1 /* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15
16 #include "tensorflow/lite/micro/micro_string.h"
17
18 #include "tensorflow/lite/micro/testing/micro_test.h"
19
20 TF_LITE_MICRO_TESTS_BEGIN
21
TF_LITE_MICRO_TEST(FormatPositiveIntShouldMatchExpected)22 TF_LITE_MICRO_TEST(FormatPositiveIntShouldMatchExpected) {
23 const int kBufferLen = 32;
24 char buffer[kBufferLen];
25 const char golden[] = "Int: 55";
26 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Int: %d", 55);
27 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
28 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
29 }
30
TF_LITE_MICRO_TEST(FormatNegativeIntShouldMatchExpected)31 TF_LITE_MICRO_TEST(FormatNegativeIntShouldMatchExpected) {
32 const int kBufferLen = 32;
33 char buffer[kBufferLen];
34 const char golden[] = "Int: -55";
35 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Int: %d", -55);
36 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
37 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
38 }
39
TF_LITE_MICRO_TEST(FormatUnsignedIntShouldMatchExpected)40 TF_LITE_MICRO_TEST(FormatUnsignedIntShouldMatchExpected) {
41 const int kBufferLen = 32;
42 char buffer[kBufferLen];
43 const char golden[] = "UInt: 12345";
44 int bytes_written = MicroSnprintf(buffer, kBufferLen, "UInt: %u", 12345);
45 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
46 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
47 }
48
TF_LITE_MICRO_TEST(FormatHexShouldMatchExpected)49 TF_LITE_MICRO_TEST(FormatHexShouldMatchExpected) {
50 const int kBufferLen = 32;
51 char buffer[kBufferLen];
52 const char golden[] = "Hex: 0x12345";
53 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Hex: %x", 0x12345);
54 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
55 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
56 }
57
TF_LITE_MICRO_TEST(FormatFloatShouldMatchExpected)58 TF_LITE_MICRO_TEST(FormatFloatShouldMatchExpected) {
59 const int kBufferLen = 32;
60 char buffer[kBufferLen];
61 const char golden[] = "Float: 1.0*2^4";
62 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Float: %f", 16.);
63 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
64 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
65 }
66
TF_LITE_MICRO_TEST(BadlyFormattedStringShouldProduceReasonableString)67 TF_LITE_MICRO_TEST(BadlyFormattedStringShouldProduceReasonableString) {
68 const int kBufferLen = 32;
69 char buffer[kBufferLen];
70 const char golden[] = "Test Badly % formated % string";
71 int bytes_written =
72 MicroSnprintf(buffer, kBufferLen, "Test Badly %% formated %% string%");
73 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
74 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
75 }
76
TF_LITE_MICRO_TEST(IntFormatOverrunShouldTruncate)77 TF_LITE_MICRO_TEST(IntFormatOverrunShouldTruncate) {
78 const int kBufferLen = 8;
79 char buffer[kBufferLen];
80 const char golden[] = "Int: ";
81 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Int: %d", 12345);
82 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
83 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
84 }
85
TF_LITE_MICRO_TEST(UnsignedIntFormatOverrunShouldTruncate)86 TF_LITE_MICRO_TEST(UnsignedIntFormatOverrunShouldTruncate) {
87 const int kBufferLen = 8;
88 char buffer[kBufferLen];
89 const char golden[] = "UInt: ";
90 int bytes_written = MicroSnprintf(buffer, kBufferLen, "UInt: %u", 12345);
91 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
92 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
93 }
94
TF_LITE_MICRO_TEST(HexFormatOverrunShouldTruncate)95 TF_LITE_MICRO_TEST(HexFormatOverrunShouldTruncate) {
96 const int kBufferLen = 8;
97 char buffer[kBufferLen];
98 const char golden[] = "Hex: ";
99 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Hex: %x", 0x12345);
100 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
101 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
102 }
103
TF_LITE_MICRO_TEST(FloatFormatOverrunShouldTruncate)104 TF_LITE_MICRO_TEST(FloatFormatOverrunShouldTruncate) {
105 const int kBufferLen = 12;
106 char buffer[kBufferLen];
107 const char golden[] = "Float: ";
108 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Float: %x", 12345.);
109 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
110 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
111 }
112
TF_LITE_MICRO_TEST(FloatFormatShouldPrintFractionCorrectly)113 TF_LITE_MICRO_TEST(FloatFormatShouldPrintFractionCorrectly) {
114 const int kBufferLen = 24;
115 char buffer[kBufferLen];
116 const char golden[] = "Float: 1.0625*2^0";
117 // Add small offset to float value to account for float rounding error.
118 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Float: %f", 1.0625001);
119 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
120 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
121 }
122
TF_LITE_MICRO_TEST(FloatFormatShouldPrintFractionCorrectlyNoLeadingZeros)123 TF_LITE_MICRO_TEST(FloatFormatShouldPrintFractionCorrectlyNoLeadingZeros) {
124 const int kBufferLen = 24;
125 char buffer[kBufferLen];
126 const char golden[] = "Float: 1.6332993*2^-1";
127 int bytes_written = MicroSnprintf(buffer, kBufferLen, "Float: %f", 0.816650);
128 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
129 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
130 }
131
TF_LITE_MICRO_TEST(StringFormatOverrunShouldTruncate)132 TF_LITE_MICRO_TEST(StringFormatOverrunShouldTruncate) {
133 const int kBufferLen = 10;
134 char buffer[kBufferLen];
135 const char golden[] = "String: h";
136 int bytes_written =
137 MicroSnprintf(buffer, kBufferLen, "String: %s", "hello world");
138 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
139 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
140 }
141
TF_LITE_MICRO_TEST(StringFormatWithExactOutputSizeOverrunShouldTruncate)142 TF_LITE_MICRO_TEST(StringFormatWithExactOutputSizeOverrunShouldTruncate) {
143 const int kBufferLen = 10;
144 char buffer[kBufferLen];
145 const char golden[] = "format st";
146 int bytes_written = MicroSnprintf(buffer, kBufferLen, "format str");
147 TF_LITE_MICRO_EXPECT_EQ(static_cast<int>(sizeof(golden)), bytes_written);
148 TF_LITE_MICRO_EXPECT_STRING_EQ(golden, buffer);
149 }
150
151 TF_LITE_MICRO_TESTS_END
152