1 /* Copyright 2016 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 #include "tensorflow/core/example/feature_util.h"
16
17 #include <string>
18 #include <vector>
19
20 #include "absl/strings/string_view.h"
21 #include "tensorflow/core/example/example.pb.h"
22 #include "tensorflow/core/platform/test.h"
23 #include "tensorflow/core/platform/types.h"
24
25 namespace tensorflow {
26 namespace {
27
28 const float kTolerance = 1e-5;
29
TEST(GetFeatureValuesInt64Test,ReadsASingleValue)30 TEST(GetFeatureValuesInt64Test, ReadsASingleValue) {
31 Example example;
32 (*example.mutable_features()->mutable_feature())["tag"]
33 .mutable_int64_list()
34 ->add_value(42);
35
36 auto tag = GetFeatureValues<protobuf_int64>("tag", example);
37
38 ASSERT_EQ(1, tag.size());
39 EXPECT_EQ(42, tag.Get(0));
40 }
41
TEST(GetFeatureValuesInt64Test,ReadsASingleValueFromFeature)42 TEST(GetFeatureValuesInt64Test, ReadsASingleValueFromFeature) {
43 Feature feature;
44 feature.mutable_int64_list()->add_value(42);
45
46 auto values = GetFeatureValues<protobuf_int64>(feature);
47
48 ASSERT_EQ(1, values.size());
49 EXPECT_EQ(42, values.Get(0));
50 }
51
TEST(GetFeatureValuesInt64Test,WritesASingleValue)52 TEST(GetFeatureValuesInt64Test, WritesASingleValue) {
53 Example example;
54
55 GetFeatureValues<protobuf_int64>("tag", &example)->Add(42);
56
57 ASSERT_EQ(1,
58 example.features().feature().at("tag").int64_list().value_size());
59 EXPECT_EQ(42, example.features().feature().at("tag").int64_list().value(0));
60 }
61
TEST(GetFeatureValuesInt64Test,WritesASingleValueToFeature)62 TEST(GetFeatureValuesInt64Test, WritesASingleValueToFeature) {
63 Feature feature;
64
65 GetFeatureValues<protobuf_int64>(&feature)->Add(42);
66
67 ASSERT_EQ(1, feature.int64_list().value_size());
68 EXPECT_EQ(42, feature.int64_list().value(0));
69 }
70
TEST(GetFeatureValuesInt64Test,CheckUntypedFieldExistence)71 TEST(GetFeatureValuesInt64Test, CheckUntypedFieldExistence) {
72 Example example;
73 ASSERT_FALSE(HasFeature("tag", example));
74
75 GetFeatureValues<protobuf_int64>("tag", &example)->Add(0);
76
77 EXPECT_TRUE(HasFeature("tag", example));
78 }
79
TEST(GetFeatureValuesInt64Test,CheckTypedFieldExistence)80 TEST(GetFeatureValuesInt64Test, CheckTypedFieldExistence) {
81 Example example;
82
83 GetFeatureValues<float>("tag", &example)->Add(3.14);
84 ASSERT_FALSE(HasFeature<protobuf_int64>("tag", example));
85
86 GetFeatureValues<protobuf_int64>("tag", &example)->Add(42);
87
88 EXPECT_TRUE(HasFeature<protobuf_int64>("tag", example));
89 auto tag_ro = GetFeatureValues<protobuf_int64>("tag", example);
90 ASSERT_EQ(1, tag_ro.size());
91 EXPECT_EQ(42, tag_ro.Get(0));
92 }
93
TEST(GetFeatureValuesInt64Test,CopyIterableToAField)94 TEST(GetFeatureValuesInt64Test, CopyIterableToAField) {
95 Example example;
96 std::vector<int> values{1, 2, 3};
97
98 std::copy(values.begin(), values.end(),
99 protobuf::RepeatedFieldBackInserter(
100 GetFeatureValues<protobuf_int64>("tag", &example)));
101
102 auto tag_ro = GetFeatureValues<protobuf_int64>("tag", example);
103 ASSERT_EQ(3, tag_ro.size());
104 EXPECT_EQ(1, tag_ro.Get(0));
105 EXPECT_EQ(2, tag_ro.Get(1));
106 EXPECT_EQ(3, tag_ro.Get(2));
107 }
108
TEST(GetFeatureValuesFloatTest,ReadsASingleValueFromFeature)109 TEST(GetFeatureValuesFloatTest, ReadsASingleValueFromFeature) {
110 Feature feature;
111 feature.mutable_float_list()->add_value(3.14);
112
113 auto values = GetFeatureValues<float>(feature);
114
115 ASSERT_EQ(1, values.size());
116 EXPECT_NEAR(3.14, values.Get(0), kTolerance);
117 }
118
TEST(GetFeatureValuesFloatTest,ReadsASingleValue)119 TEST(GetFeatureValuesFloatTest, ReadsASingleValue) {
120 Example example;
121 (*example.mutable_features()->mutable_feature())["tag"]
122 .mutable_float_list()
123 ->add_value(3.14);
124
125 auto tag = GetFeatureValues<float>("tag", example);
126
127 ASSERT_EQ(1, tag.size());
128 EXPECT_NEAR(3.14, tag.Get(0), kTolerance);
129 }
130
TEST(GetFeatureValuesFloatTest,WritesASingleValueToFeature)131 TEST(GetFeatureValuesFloatTest, WritesASingleValueToFeature) {
132 Feature feature;
133
134 GetFeatureValues<float>(&feature)->Add(3.14);
135
136 ASSERT_EQ(1, feature.float_list().value_size());
137 EXPECT_NEAR(3.14, feature.float_list().value(0), kTolerance);
138 }
139
TEST(GetFeatureValuesFloatTest,WritesASingleValue)140 TEST(GetFeatureValuesFloatTest, WritesASingleValue) {
141 Example example;
142
143 GetFeatureValues<float>("tag", &example)->Add(3.14);
144
145 ASSERT_EQ(1,
146 example.features().feature().at("tag").float_list().value_size());
147 EXPECT_NEAR(3.14,
148 example.features().feature().at("tag").float_list().value(0),
149 kTolerance);
150 }
151
TEST(GetFeatureValuesFloatTest,CheckTypedFieldExistence)152 TEST(GetFeatureValuesFloatTest, CheckTypedFieldExistence) {
153 Example example;
154
155 GetFeatureValues<protobuf_int64>("tag", &example)->Add(42);
156 ASSERT_FALSE(HasFeature<float>("tag", example));
157
158 GetFeatureValues<float>("tag", &example)->Add(3.14);
159
160 EXPECT_TRUE(HasFeature<float>("tag", example));
161 auto tag_ro = GetFeatureValues<float>("tag", example);
162 ASSERT_EQ(1, tag_ro.size());
163 EXPECT_NEAR(3.14, tag_ro.Get(0), kTolerance);
164 }
165
TEST(GetFeatureValuesFloatTest,CheckTypedFieldExistenceForDeprecatedMethod)166 TEST(GetFeatureValuesFloatTest, CheckTypedFieldExistenceForDeprecatedMethod) {
167 Example example;
168
169 GetFeatureValues<protobuf_int64>("tag", &example)->Add(42);
170 ASSERT_FALSE(ExampleHasFeature<float>("tag", example));
171
172 GetFeatureValues<float>("tag", &example)->Add(3.14);
173
174 EXPECT_TRUE(ExampleHasFeature<float>("tag", example));
175 auto tag_ro = GetFeatureValues<float>("tag", example);
176 ASSERT_EQ(1, tag_ro.size());
177 EXPECT_NEAR(3.14, tag_ro.Get(0), kTolerance);
178 }
179
TEST(GetFeatureValuesStringTest,ReadsASingleValueFromFeature)180 TEST(GetFeatureValuesStringTest, ReadsASingleValueFromFeature) {
181 Feature feature;
182 feature.mutable_bytes_list()->add_value("FOO");
183
184 auto values = GetFeatureValues<std::string>(feature);
185
186 ASSERT_EQ(1, values.size());
187 EXPECT_EQ("FOO", values.Get(0));
188 }
189
TEST(GetFeatureValuesStringTest,ReadsASingleValue)190 TEST(GetFeatureValuesStringTest, ReadsASingleValue) {
191 Example example;
192 (*example.mutable_features()->mutable_feature())["tag"]
193 .mutable_bytes_list()
194 ->add_value("FOO");
195
196 auto tag = GetFeatureValues<std::string>("tag", example);
197
198 ASSERT_EQ(1, tag.size());
199 EXPECT_EQ("FOO", tag.Get(0));
200 }
201
TEST(GetFeatureValuesStringTest,WritesASingleValueToFeature)202 TEST(GetFeatureValuesStringTest, WritesASingleValueToFeature) {
203 Feature feature;
204
205 *GetFeatureValues<std::string>(&feature)->Add() = "FOO";
206
207 ASSERT_EQ(1, feature.bytes_list().value_size());
208 EXPECT_EQ("FOO", feature.bytes_list().value(0));
209 }
210
TEST(GetFeatureValuesStringTest,WritesASingleValue)211 TEST(GetFeatureValuesStringTest, WritesASingleValue) {
212 Example example;
213
214 *GetFeatureValues<std::string>("tag", &example)->Add() = "FOO";
215
216 ASSERT_EQ(1,
217 example.features().feature().at("tag").bytes_list().value_size());
218 EXPECT_EQ("FOO",
219 example.features().feature().at("tag").bytes_list().value(0));
220 }
221
TEST(GetFeatureValuesStringTest,CheckTypedFieldExistence)222 TEST(GetFeatureValuesStringTest, CheckTypedFieldExistence) {
223 Example example;
224
225 GetFeatureValues<protobuf_int64>("tag", &example)->Add(42);
226 ASSERT_FALSE(HasFeature<std::string>("tag", example));
227
228 *GetFeatureValues<std::string>("tag", &example)->Add() = "FOO";
229
230 EXPECT_TRUE(HasFeature<std::string>("tag", example));
231 auto tag_ro = GetFeatureValues<std::string>("tag", example);
232 ASSERT_EQ(1, tag_ro.size());
233 EXPECT_EQ("FOO", tag_ro.Get(0));
234 }
235
TEST(AppendFeatureValuesTest,FloatValuesFromContainer)236 TEST(AppendFeatureValuesTest, FloatValuesFromContainer) {
237 Example example;
238
239 std::vector<double> values{1.1, 2.2, 3.3};
240 AppendFeatureValues(values, "tag", &example);
241
242 auto tag_ro = GetFeatureValues<float>("tag", example);
243 ASSERT_EQ(3, tag_ro.size());
244 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
245 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
246 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
247 }
248
TEST(AppendFeatureValuesTest,FloatValuesFromContainerWithStringViewKey)249 TEST(AppendFeatureValuesTest, FloatValuesFromContainerWithStringViewKey) {
250 Example example;
251
252 std::vector<double> values{1.1, 2.2, 3.3};
253 absl::string_view key("tag");
254 AppendFeatureValues(values, key, &example);
255
256 auto tag_ro = GetFeatureValues<float>("tag", example);
257 ASSERT_EQ(3, tag_ro.size());
258 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
259 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
260 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
261 }
262
TEST(AppendFeatureValuesTest,FloatValuesUsingInitializerList)263 TEST(AppendFeatureValuesTest, FloatValuesUsingInitializerList) {
264 Example example;
265
266 AppendFeatureValues({1.1, 2.2, 3.3}, "tag", &example);
267
268 auto tag_ro = GetFeatureValues<float>("tag", example);
269 ASSERT_EQ(3, tag_ro.size());
270 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
271 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
272 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
273 }
274
TEST(AppendFeatureValuesTest,FloatValuesUsingInitializerListWithStringViewKey)275 TEST(AppendFeatureValuesTest,
276 FloatValuesUsingInitializerListWithStringViewKey) {
277 Example example;
278 absl::string_view key("tag");
279 AppendFeatureValues({1.1, 2.2, 3.3}, key, &example);
280
281 auto tag_ro = GetFeatureValues<float>("tag", example);
282 ASSERT_EQ(3, tag_ro.size());
283 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
284 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
285 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
286 }
287
TEST(AppendFeatureValuesTest,FloatValuesUsingIterators)288 TEST(AppendFeatureValuesTest, FloatValuesUsingIterators) {
289 Example example;
290 std::vector<double> values{1.1, 2.2, 3.3};
291 AppendFeatureValues(values.begin(), values.end(), "tag", &example);
292
293 auto tag_ro = GetFeatureValues<float>("tag", example);
294 ASSERT_EQ(3, tag_ro.size());
295 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
296 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
297 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
298 }
299
TEST(AppendFeatureValuesTest,FloatValuesUsingIteratorsWithStringViewKey)300 TEST(AppendFeatureValuesTest, FloatValuesUsingIteratorsWithStringViewKey) {
301 Example example;
302 absl::string_view key("tag");
303 std::vector<double> values{1.1, 2.2, 3.3};
304 AppendFeatureValues(values.begin(), values.end(), key, &example);
305
306 auto tag_ro = GetFeatureValues<float>("tag", example);
307 ASSERT_EQ(3, tag_ro.size());
308 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
309 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
310 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
311 }
312
TEST(SetFeatureValuesTest,FloatValuesUsingInitializerList)313 TEST(SetFeatureValuesTest, FloatValuesUsingInitializerList) {
314 Example example;
315
316 // The first set of values should be overwritten by the second.
317 AppendFeatureValues({1.1, 2.2, 3.3}, "tag", &example);
318 SetFeatureValues({10.1, 20.2, 30.3}, "tag", &example);
319
320 auto tag_ro = GetFeatureValues<float>("tag", example);
321 ASSERT_EQ(3, tag_ro.size());
322 EXPECT_NEAR(10.1, tag_ro.Get(0), kTolerance);
323 EXPECT_NEAR(20.2, tag_ro.Get(1), kTolerance);
324 EXPECT_NEAR(30.3, tag_ro.Get(2), kTolerance);
325 }
326
TEST(SetFeatureValuesTest,ContainerOfStringView)327 TEST(SetFeatureValuesTest, ContainerOfStringView) {
328 Example example;
329
330 std::vector<std::string> values = {"hello", "world"};
331 std::vector<absl::string_view> values_string_view(values.begin(),
332 values.end());
333
334 SetFeatureValues(values_string_view, "tag", &example);
335
336 auto tag_ro = GetFeatureValues<std::string>("tag", example);
337 ASSERT_EQ(tag_ro.size(), 2);
338 EXPECT_EQ(tag_ro.Get(0), "hello");
339 EXPECT_EQ(tag_ro.Get(1), "world");
340 }
341
TEST(AppendFeatureValuesTest,Int64ValuesUsingInitializerList)342 TEST(AppendFeatureValuesTest, Int64ValuesUsingInitializerList) {
343 Example example;
344
345 std::vector<protobuf_int64> values{1, 2, 3};
346 AppendFeatureValues(values, "tag", &example);
347
348 auto tag_ro = GetFeatureValues<protobuf_int64>("tag", example);
349 ASSERT_EQ(3, tag_ro.size());
350 EXPECT_EQ(1, tag_ro.Get(0));
351 EXPECT_EQ(2, tag_ro.Get(1));
352 EXPECT_EQ(3, tag_ro.Get(2));
353 }
354
TEST(AppendFeatureValuesTest,StringValuesUsingInitializerList)355 TEST(AppendFeatureValuesTest, StringValuesUsingInitializerList) {
356 Example example;
357
358 AppendFeatureValues({"FOO", "BAR", "BAZ"}, "tag", &example);
359
360 auto tag_ro = GetFeatureValues<std::string>("tag", example);
361 ASSERT_EQ(3, tag_ro.size());
362 EXPECT_EQ("FOO", tag_ro.Get(0));
363 EXPECT_EQ("BAR", tag_ro.Get(1));
364 EXPECT_EQ("BAZ", tag_ro.Get(2));
365 }
366
TEST(AppendFeatureValuesTest,StringVariablesUsingInitializerList)367 TEST(AppendFeatureValuesTest, StringVariablesUsingInitializerList) {
368 Example example;
369
370 string string1("FOO");
371 string string2("BAR");
372 string string3("BAZ");
373
374 AppendFeatureValues({string1, string2, string3}, "tag", &example);
375
376 auto tag_ro = GetFeatureValues<std::string>("tag", example);
377 ASSERT_EQ(3, tag_ro.size());
378 EXPECT_EQ("FOO", tag_ro.Get(0));
379 EXPECT_EQ("BAR", tag_ro.Get(1));
380 EXPECT_EQ("BAZ", tag_ro.Get(2));
381 }
382
TEST(AppendFeatureValuesTest,StringViewVariablesUsingInitializerList)383 TEST(AppendFeatureValuesTest, StringViewVariablesUsingInitializerList) {
384 Example example;
385
386 AppendFeatureValues({absl::string_view("FOO"), absl::string_view("BAR"),
387 absl::string_view("BAZ")},
388 "tag", &example);
389
390 auto tag_ro = GetFeatureValues<std::string>("tag", example);
391 ASSERT_EQ(3, tag_ro.size());
392 EXPECT_EQ("FOO", tag_ro.Get(0));
393 EXPECT_EQ("BAR", tag_ro.Get(1));
394 EXPECT_EQ("BAZ", tag_ro.Get(2));
395 }
396
TEST(AppendFeatureValuesTest,StringViewVariablesUsingIterators)397 TEST(AppendFeatureValuesTest, StringViewVariablesUsingIterators) {
398 Example example;
399
400 std::vector<absl::string_view> strings;
401 strings.push_back("FOO");
402 strings.push_back("BAR");
403 strings.push_back("BAZ");
404
405 AppendFeatureValues(strings.begin(), strings.end(), "tag", &example);
406
407 auto tag_ro = GetFeatureValues<std::string>("tag", example);
408 ASSERT_EQ(3, tag_ro.size());
409 EXPECT_EQ("FOO", tag_ro.Get(0));
410 EXPECT_EQ("BAR", tag_ro.Get(1));
411 EXPECT_EQ("BAZ", tag_ro.Get(2));
412 }
413
TEST(GetFeatureTest,WritesAVectorToFeature)414 TEST(GetFeatureTest, WritesAVectorToFeature) {
415 Example example;
416
417 Feature* feature = GetFeature("tag", &example);
418 AppendFeatureValues<float>({1.1, 2.2, 3.3}, feature);
419
420 auto tag_ro = GetFeatureValues<float>("tag", example);
421
422 ASSERT_EQ(3, tag_ro.size());
423 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
424 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
425 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
426 }
427
TEST(GetFeatureTest,ReadsAVectorFromFeature)428 TEST(GetFeatureTest, ReadsAVectorFromFeature) {
429 Example example;
430
431 AppendFeatureValues<float>({1.1, 2.2, 3.3}, "tag", &example);
432
433 const Feature& feature = GetFeature("tag", example);
434 auto tag_ro = GetFeatureValues<float>(feature);
435
436 ASSERT_EQ(3, tag_ro.size());
437 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
438 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
439 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
440 }
441
TEST(SequenceExampleTest,ReadsASingleValueFromContext)442 TEST(SequenceExampleTest, ReadsASingleValueFromContext) {
443 SequenceExample se;
444 (*se.mutable_context()->mutable_feature())["tag"]
445 .mutable_int64_list()
446 ->add_value(42);
447
448 auto values = GetFeatureValues<protobuf_int64>("tag", se.context());
449
450 ASSERT_EQ(1, values.size());
451 EXPECT_EQ(42, values.Get(0));
452 }
453
TEST(SequenceExampleTest,WritesASingleValueToContext)454 TEST(SequenceExampleTest, WritesASingleValueToContext) {
455 SequenceExample se;
456
457 GetFeatureValues<protobuf_int64>("tag", se.mutable_context())->Add(42);
458
459 ASSERT_EQ(1, se.context().feature().at("tag").int64_list().value_size());
460 EXPECT_EQ(42, se.context().feature().at("tag").int64_list().value(0));
461 }
462
TEST(SequenceExampleTest,AppendFeatureValuesToContextSingleArg)463 TEST(SequenceExampleTest, AppendFeatureValuesToContextSingleArg) {
464 SequenceExample se;
465
466 AppendFeatureValues({1.1, 2.2, 3.3}, "tag", se.mutable_context());
467
468 auto tag_ro = GetFeatureValues<float>("tag", se.context());
469 ASSERT_EQ(3, tag_ro.size());
470 EXPECT_NEAR(1.1, tag_ro.Get(0), kTolerance);
471 EXPECT_NEAR(2.2, tag_ro.Get(1), kTolerance);
472 EXPECT_NEAR(3.3, tag_ro.Get(2), kTolerance);
473 }
474
TEST(SequenceExampleTest,CheckTypedFieldExistence)475 TEST(SequenceExampleTest, CheckTypedFieldExistence) {
476 SequenceExample se;
477
478 GetFeatureValues<float>("tag", se.mutable_context())->Add(3.14);
479 ASSERT_FALSE(HasFeature<protobuf_int64>("tag", se.context()));
480
481 GetFeatureValues<protobuf_int64>("tag", se.mutable_context())->Add(42);
482
483 EXPECT_TRUE(HasFeature<protobuf_int64>("tag", se.context()));
484 auto tag_ro = GetFeatureValues<protobuf_int64>("tag", se.context());
485 ASSERT_EQ(1, tag_ro.size());
486 EXPECT_EQ(42, tag_ro.Get(0));
487 }
488
TEST(SequenceExampleTest,ReturnsExistingFeatureLists)489 TEST(SequenceExampleTest, ReturnsExistingFeatureLists) {
490 SequenceExample se;
491 (*se.mutable_feature_lists()->mutable_feature_list())["tag"]
492 .mutable_feature()
493 ->Add();
494
495 auto feature = GetFeatureList("tag", se);
496
497 ASSERT_EQ(1, feature.size());
498 }
499
TEST(SequenceExampleTest,CreatesNewFeatureLists)500 TEST(SequenceExampleTest, CreatesNewFeatureLists) {
501 SequenceExample se;
502
503 GetFeatureList("tag", &se)->Add();
504
505 EXPECT_EQ(1, se.feature_lists().feature_list().at("tag").feature_size());
506 }
507
TEST(SequenceExampleTest,CheckFeatureListExistence)508 TEST(SequenceExampleTest, CheckFeatureListExistence) {
509 SequenceExample se;
510 ASSERT_FALSE(HasFeatureList("tag", se));
511
512 GetFeatureList("tag", &se)->Add();
513
514 ASSERT_TRUE(HasFeatureList("tag", se));
515 }
516
TEST(SequenceExampleTest,AppendFeatureValuesWithInitializerList)517 TEST(SequenceExampleTest, AppendFeatureValuesWithInitializerList) {
518 SequenceExample se;
519
520 AppendFeatureValues({1, 2, 3}, "ids", se.mutable_context());
521 AppendFeatureValues({"cam1-0", "cam2-0"},
522 GetFeatureList("images", &se)->Add());
523 AppendFeatureValues({"cam1-1", "cam2-2"},
524 GetFeatureList("images", &se)->Add());
525 SequenceExample expected_proto;
526 protobuf::TextFormat::ParseFromString(
527 "context {\n"
528 " feature {\n"
529 " key: \"ids\"\n"
530 " value {\n"
531 " int64_list {\n"
532 " value: 1\n"
533 " value: 2\n"
534 " value: 3\n"
535 " }\n"
536 " }\n"
537 " }\n"
538 "}\n"
539 "feature_lists {\n"
540 " feature_list {\n"
541 " key: \"images\"\n"
542 " value {\n"
543 " feature {\n"
544 " bytes_list {\n"
545 " value: \"cam1-0\"\n"
546 " value: \"cam2-0\"\n"
547 " }\n"
548 " }\n"
549 " feature {\n"
550 " bytes_list {\n"
551 " value: \"cam1-1\"\n"
552 " value: \"cam2-2\"\n"
553 " }\n"
554 " }\n"
555 " }\n"
556 " }\n"
557 "}\n",
558 &expected_proto);
559 EXPECT_EQ(se.DebugString(), expected_proto.DebugString());
560 }
561
TEST(SequenceExampleTest,AppendFeatureValuesWithVectors)562 TEST(SequenceExampleTest, AppendFeatureValuesWithVectors) {
563 SequenceExample se;
564
565 std::vector<float> readings{1.0, 2.5, 5.0};
566 AppendFeatureValues(readings, GetFeatureList("movie_ratings", &se)->Add());
567
568 SequenceExample expected_proto;
569 protobuf::TextFormat::ParseFromString(
570 "feature_lists {\n"
571 " feature_list {\n"
572 " key: \"movie_ratings\"\n"
573 " value {\n"
574 " feature {\n"
575 " float_list {\n"
576 " value: 1\n"
577 " value: 2.5\n"
578 " value: 5\n"
579 " }\n"
580 " }\n"
581 " }\n"
582 " }\n"
583 "}\n",
584 &expected_proto);
585 EXPECT_EQ(se.DebugString(), expected_proto.DebugString());
586 }
587
TEST(SequenceExampleTest,SetContextFeatureValuesWithInitializerList)588 TEST(SequenceExampleTest, SetContextFeatureValuesWithInitializerList) {
589 SequenceExample se;
590
591 // The first set of values should be overwritten by the second.
592 SetFeatureValues({101, 102, 103}, "ids", se.mutable_context());
593 SetFeatureValues({1, 2, 3}, "ids", se.mutable_context());
594
595 // These values should be appended without overwriting.
596 AppendFeatureValues({4, 5, 6}, "ids", se.mutable_context());
597
598 SequenceExample expected_proto;
599 protobuf::TextFormat::ParseFromString(
600 "context {\n"
601 " feature {\n"
602 " key: \"ids\"\n"
603 " value {\n"
604 " int64_list {\n"
605 " value: 1\n"
606 " value: 2\n"
607 " value: 3\n"
608 " value: 4\n"
609 " value: 5\n"
610 " value: 6\n"
611 " }\n"
612 " }\n"
613 " }\n"
614 "}\n",
615 &expected_proto);
616 EXPECT_EQ(se.DebugString(), expected_proto.DebugString());
617 }
618
TEST(SequenceExampleTest,SetFeatureValuesWithInitializerList)619 TEST(SequenceExampleTest, SetFeatureValuesWithInitializerList) {
620 SequenceExample se;
621
622 // The first set of values should be overwritten by the second.
623 AppendFeatureValues({1, 2, 3}, "ids", se.mutable_context());
624 SetFeatureValues({4, 5, 6}, "ids", se.mutable_context());
625
626 // Two distinct features are added to the same feature list, so both will
627 // coexist in the output.
628 AppendFeatureValues({"cam1-0", "cam2-0"},
629 GetFeatureList("images", &se)->Add());
630 SetFeatureValues({"cam1-1", "cam2-1"}, GetFeatureList("images", &se)->Add());
631
632 // The first set of values should be overwritten by the second.
633 AppendFeatureValues({"cam1-0", "cam2-0"},
634 GetFeatureList("more-images", &se)->Add());
635 SetFeatureValues({"cam1-1", "cam2-1"},
636 GetFeatureList("more-images", &se)->Mutable(0));
637
638 SequenceExample expected_proto;
639 protobuf::TextFormat::ParseFromString(
640 "context {\n"
641 " feature {\n"
642 " key: \"ids\"\n"
643 " value {\n"
644 " int64_list {\n"
645 " value: 4\n"
646 " value: 5\n"
647 " value: 6\n"
648 " }\n"
649 " }\n"
650 " }\n"
651 "}\n"
652 "feature_lists {\n"
653 " feature_list {\n"
654 " key: \"images\"\n"
655 " value {\n"
656 " feature {\n"
657 " bytes_list {\n"
658 " value: \"cam1-0\"\n"
659 " value: \"cam2-0\"\n"
660 " }\n"
661 " }\n"
662 " feature {\n"
663 " bytes_list {\n"
664 " value: \"cam1-1\"\n"
665 " value: \"cam2-1\"\n"
666 " }\n"
667 " }\n"
668 " }\n"
669 " }\n"
670 " feature_list {\n"
671 " key: \"more-images\"\n"
672 " value {\n"
673 " feature {\n"
674 " bytes_list {\n"
675 " value: \"cam1-1\"\n"
676 " value: \"cam2-1\"\n"
677 " }\n"
678 " }\n"
679 " }\n"
680 " }\n"
681 "}\n",
682 &expected_proto);
683 EXPECT_EQ(se.DebugString(), expected_proto.DebugString());
684 }
685
686 } // namespace
687 } // namespace tensorflow
688