| # Copyright 2015 The TensorFlow Authors. All Rights Reserved. |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # ============================================================================== |
| """Tests for tensorflow.kernels.logging_ops.""" |
| |
| from __future__ import absolute_import |
| from __future__ import division |
| from __future__ import print_function |
| |
| |
| from tensorflow.python.eager import context |
| from tensorflow.python.framework import constant_op |
| from tensorflow.python.framework import test_util |
| from tensorflow.python.ops import array_ops |
| from tensorflow.python.ops import math_ops |
| from tensorflow.python.ops import string_ops |
| from tensorflow.python.ops import variables |
| from tensorflow.python.platform import test |
| from tensorflow.python.util import compat |
| |
| |
| class StringFormatOpTest(test.TestCase): |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorOneDim(self): |
| with self.test_session(): |
| tensor = math_ops.range(10) |
| format_output = string_ops.string_format("{}", tensor) |
| out = self.evaluate(format_output) |
| expected = "[0 1 2 ... 7 8 9]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| with self.test_session(): |
| tensor = math_ops.range(10) |
| format_output = string_ops.string_format("{}", [tensor]) |
| out = self.evaluate(format_output) |
| expected = "[0 1 2 ... 7 8 9]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneVariableScalar(self): |
| with self.test_session(): |
| var = variables.Variable(3.34) |
| format_output = string_ops.string_format("{}", [var]) |
| if not context.executing_eagerly(): |
| variables.global_variables_initializer().run() |
| out = self.evaluate(format_output) |
| expected = "3.34" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneVariableOneDim(self): |
| with self.test_session(): |
| var = variables.Variable(math_ops.range(10)) |
| format_output = string_ops.string_format("{}", [var]) |
| if not context.executing_eagerly(): |
| variables.global_variables_initializer().run() |
| out = self.evaluate(format_output) |
| expected = "[0 1 2 ... 7 8 9]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatTwoVariablesWithAssignAdd(self): |
| with self.test_session(): |
| var_one = variables.Variable(2.14) |
| plus_one = var_one.assign_add(1.0) |
| var_two = variables.Variable(math_ops.range(10)) |
| format_output = string_ops.string_format("{}, {}", [var_one, var_two]) |
| if not context.executing_eagerly(): |
| variables.global_variables_initializer().run() |
| self.evaluate(plus_one) |
| out = self.evaluate(format_output) |
| expected = "3.14, [0 1 2 ... 7 8 9]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorOneDimFloat(self): |
| with self.test_session(): |
| tensor = constant_op.constant([0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7]) |
| format_output = string_ops.string_format("{}", tensor) |
| out = self.evaluate(format_output) |
| expected = "[0 0.1 0.2 ... 0.5 0.6 0.7]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorOneDimMatchesSummarize(self): |
| with self.test_session(): |
| tensor = math_ops.range(6) |
| format_output = string_ops.string_format("{}", tensor, summarize=3) |
| out = self.evaluate(format_output) |
| expected = "[0 1 2 3 4 5]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorOneDimVarySummarize(self): |
| with self.test_session(): |
| tensor = math_ops.range(6) |
| format_output = string_ops.string_format("{}", tensor, summarize=-1) |
| out = self.evaluate(format_output) |
| expected = "[0 1 2 3 4 5]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| with self.test_session(): |
| tensor = math_ops.range(6) |
| format_output = string_ops.string_format("{}", tensor, summarize=1) |
| out = self.evaluate(format_output) |
| expected = "[0 ... 5]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| with self.test_session(): |
| tensor = math_ops.range(6) |
| format_output = string_ops.string_format("{}", tensor, summarize=2) |
| out = self.evaluate(format_output) |
| expected = "[0 1 ... 4 5]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| with self.test_session(): |
| tensor = math_ops.range(6) |
| format_output = string_ops.string_format("{}", tensor, summarize=10) |
| out = self.evaluate(format_output) |
| expected = "[0 1 2 3 4 5]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorOneDimAlmostSummarize(self): |
| with self.test_session(): |
| tensor = math_ops.range(5) |
| format_output = string_ops.string_format("{}", tensor, summarize=3) |
| out = self.evaluate(format_output) |
| expected = "[0 1 2 3 4]" |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorTwoDimLessThanSummarize(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(4), [2, 2]) |
| format_output = string_ops.string_format("{}", tensor, summarize=3) |
| out = self.evaluate(format_output) |
| expected = ("[[0 1]\n" |
| " [2 3]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorTwoDim(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(100), [10, 10]) |
| format_output = string_ops.string_format("{}", tensor) |
| out = self.evaluate(format_output) |
| expected = ("[[0 1 2 ... 7 8 9]\n" |
| " [10 11 12 ... 17 18 19]\n" |
| " [20 21 22 ... 27 28 29]\n" |
| " ...\n" |
| " [70 71 72 ... 77 78 79]\n" |
| " [80 81 82 ... 87 88 89]\n" |
| " [90 91 92 ... 97 98 99]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorTwoDimSummarizeTwo(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(100), [10, 10]) |
| format_output = string_ops.string_format("{}", tensor, summarize=2) |
| out = self.evaluate(format_output) |
| expected = ("[[0 1 ... 8 9]\n" |
| " [10 11 ... 18 19]\n" |
| " ...\n" |
| " [80 81 ... 88 89]\n" |
| " [90 91 ... 98 99]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorThreeDim(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(1000), [10, 10, 10]) |
| format_output = string_ops.string_format("{}", tensor) |
| out = self.evaluate(format_output) |
| expected = ("[[[0 1 2 ... 7 8 9]\n" |
| " [10 11 12 ... 17 18 19]\n" |
| " [20 21 22 ... 27 28 29]\n" |
| " ...\n" |
| " [70 71 72 ... 77 78 79]\n" |
| " [80 81 82 ... 87 88 89]\n" |
| " [90 91 92 ... 97 98 99]]\n" |
| "\n" |
| " [[100 101 102 ... 107 108 109]\n" |
| " [110 111 112 ... 117 118 119]\n" |
| " [120 121 122 ... 127 128 129]\n" |
| " ...\n [170 171 172 ... 177 178 179]\n" |
| " [180 181 182 ... 187 188 189]\n" |
| " [190 191 192 ... 197 198 199]]\n" |
| "\n" |
| " [[200 201 202 ... 207 208 209]\n" |
| " [210 211 212 ... 217 218 219]\n" |
| " [220 221 222 ... 227 228 229]\n" |
| " ...\n" |
| " [270 271 272 ... 277 278 279]\n" |
| " [280 281 282 ... 287 288 289]\n" |
| " [290 291 292 ... 297 298 299]]\n" |
| "\n" |
| " ...\n" |
| "\n" |
| " [[700 701 702 ... 707 708 709]\n" |
| " [710 711 712 ... 717 718 719]\n" |
| " [720 721 722 ... 727 728 729]\n" |
| " ...\n" |
| " [770 771 772 ... 777 778 779]\n" |
| " [780 781 782 ... 787 788 789]\n" |
| " [790 791 792 ... 797 798 799]]\n" |
| "\n" |
| " [[800 801 802 ... 807 808 809]\n" |
| " [810 811 812 ... 817 818 819]\n" |
| " [820 821 822 ... 827 828 829]\n" |
| " ...\n" |
| " [870 871 872 ... 877 878 879]\n" |
| " [880 881 882 ... 887 888 889]\n" |
| " [890 891 892 ... 897 898 899]]\n" |
| "\n" |
| " [[900 901 902 ... 907 908 909]\n" |
| " [910 911 912 ... 917 918 919]\n" |
| " [920 921 922 ... 927 928 929]\n" |
| " ...\n" |
| " [970 971 972 ... 977 978 979]\n" |
| " [980 981 982 ... 987 988 989]\n" |
| " [990 991 992 ... 997 998 999]]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorTemplatePrefix(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(100), [10, 10]) |
| format_output = string_ops.string_format("tensor summary: {}", tensor) |
| out = self.evaluate(format_output) |
| expected = ("tensor summary: [[0 1 2 ... 7 8 9]\n" |
| " [10 11 12 ... 17 18 19]\n" |
| " [20 21 22 ... 27 28 29]\n" |
| " ...\n" |
| " [70 71 72 ... 77 78 79]\n" |
| " [80 81 82 ... 87 88 89]\n" |
| " [90 91 92 ... 97 98 99]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorTemplatePrefixAndSuffix(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(100), [10, 10]) |
| format_output = string_ops.string_format("tensor summary: {}, suffix", |
| tensor) |
| out = self.evaluate(format_output) |
| expected = ("tensor summary: [[0 1 2 ... 7 8 9]\n" |
| " [10 11 12 ... 17 18 19]\n" |
| " [20 21 22 ... 27 28 29]\n" |
| " ...\n" |
| " [70 71 72 ... 77 78 79]\n" |
| " [80 81 82 ... 87 88 89]\n" |
| " [90 91 92 ... 97 98 99]], suffix") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatOneTensorTemplateSuffix(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(100), [10, 10]) |
| format_output = string_ops.string_format("{}, suffix", tensor) |
| out = self.evaluate(format_output) |
| expected = ("[[0 1 2 ... 7 8 9]\n" |
| " [10 11 12 ... 17 18 19]\n" |
| " [20 21 22 ... 27 28 29]\n" |
| " ...\n" |
| " [70 71 72 ... 77 78 79]\n" |
| " [80 81 82 ... 87 88 89]\n" |
| " [90 91 92 ... 97 98 99]], suffix") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatNoTensor(self): |
| with self.test_session(): |
| format_output = string_ops.string_format("No tensor.", ()) |
| out = self.evaluate(format_output) |
| expected = "No tensor." |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatMultiTensor(self): |
| with self.test_session(): |
| tensor_one = array_ops.reshape(math_ops.range(100), [10, 10]) |
| tensor_two = tensor_one * 10 |
| format_output = string_ops.string_format("One: {},\nTwo: {}", |
| (tensor_one, tensor_two)) |
| out = self.evaluate(format_output) |
| expected = ("One: [[0 1 2 ... 7 8 9]\n" |
| " [10 11 12 ... 17 18 19]\n" |
| " [20 21 22 ... 27 28 29]\n" |
| " ...\n" |
| " [70 71 72 ... 77 78 79]\n" |
| " [80 81 82 ... 87 88 89]\n" |
| " [90 91 92 ... 97 98 99]],\n" |
| "Two: [[0 10 20 ... 70 80 90]\n" |
| " [100 110 120 ... 170 180 190]\n" |
| " [200 210 220 ... 270 280 290]\n" |
| " ...\n" |
| " [700 710 720 ... 770 780 790]\n" |
| " [800 810 820 ... 870 880 890]\n" |
| " [900 910 920 ... 970 980 990]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatSummarizeOne(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(100), [10, 10]) |
| format_output = string_ops.string_format("tensor summary: {}", tensor, |
| summarize=1) |
| out = self.evaluate(format_output) |
| expected = ("tensor summary: [[0 ... 9]\n" |
| " ...\n" |
| " [90 ... 99]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatSummarizeTwo(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(100), [10, 10]) |
| format_output = string_ops.string_format("tensor summary: {}", tensor, |
| summarize=2) |
| out = self.evaluate(format_output) |
| expected = ("tensor summary: [[0 1 ... 8 9]\n" |
| " [10 11 ... 18 19]\n" |
| " ...\n" |
| " [80 81 ... 88 89]\n" |
| " [90 91 ... 98 99]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testFormatPlaceholder(self): |
| with self.test_session(): |
| tensor = array_ops.reshape(math_ops.range(100), [10, 10]) |
| format_output = string_ops.string_format("tensor summary: %t%", tensor, |
| placeholder="%t%") |
| out = self.evaluate(format_output) |
| expected = ("tensor summary: [[0 1 2 ... 7 8 9]\n" |
| " [10 11 12 ... 17 18 19]\n" |
| " [20 21 22 ... 27 28 29]\n" |
| " ...\n" |
| " [70 71 72 ... 77 78 79]\n" |
| " [80 81 82 ... 87 88 89]\n" |
| " [90 91 92 ... 97 98 99]]") |
| self.assertEqual(compat.as_text(out), expected) |
| |
| @test_util.run_in_graph_and_eager_modes() |
| def testTensorCountMustMatchPlaceholderCount(self): |
| with self.test_session(): |
| with self.assertRaisesRegexp( |
| ValueError, r"2 placeholder\(s\) in template does not match 1 " |
| r"tensor\(s\) provided as input"): |
| tensor = math_ops.range(10) |
| format_output = string_ops.string_format("{} {}", tensor) |
| self.evaluate(format_output) |
| with self.test_session(): |
| with self.assertRaisesRegexp( |
| ValueError, r"2 placeholder\(s\) in template does not match 1 " |
| r"tensor\(s\) provided as input"): |
| tensor = math_ops.range(10) |
| format_output = string_ops.string_format("{} {}", [tensor]) |
| self.evaluate(format_output) |
| with self.test_session(): |
| with self.assertRaisesRegexp( |
| ValueError, r"1 placeholder\(s\) in template does not match 2 " |
| r"tensor\(s\) provided as input"): |
| tensor = math_ops.range(10) |
| format_output = string_ops.string_format("{}", (tensor, tensor)) |
| self.evaluate(format_output) |
| |
| |
| if __name__ == "__main__": |
| test.main() |
