| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <fuchsia/example/fostr/cpp/fidl.h> |
| #include <fuchsia/example/fostr2/cpp/fidl.h> |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async-loop/default.h> |
| |
| #include <sstream> |
| |
| #include <gtest/gtest.h> |
| #include <src/lib/fostr/fidl/fuchsia/example/fostr/formatting.h> |
| #include <src/lib/fostr/fidl/fuchsia/example/fostr2/formatting.h> |
| |
| #include "fuchsia/example/fostr/cpp/fidl.h" |
| #include "lib/fidl/cpp/vector.h" |
| #include "src/lib/fostr/fidl_types.h" |
| #include "src/lib/fsl/handles/object_info.h" |
| |
| namespace fostr { |
| namespace { |
| |
| #define EXPECT_FIDL_TO_FORMAT_AS(Value, Expected) \ |
| do { \ |
| std::ostringstream os; \ |
| os << (Value); \ |
| EXPECT_EQ(Expected, os.str()); \ |
| } while (0) |
| |
| // Matches string |value| from an istream. |
| std::istream& operator>>(std::istream& is, const std::string& value) { |
| std::string str(value.size(), '\0'); |
| |
| if (!is.read(&str[0], value.size()) || value != str) { |
| return is; |
| } |
| |
| // Required to set eofbit as appropriate. |
| is.peek(); |
| |
| return is; |
| } |
| |
| TEST(FidlTypes, UnionEmpty) { |
| fuchsia::example::fostr::MyUnion u; |
| EXPECT_FIDL_TO_FORMAT_AS(u, "<empty union>"); |
| } |
| |
| TEST(FidlTypes, UnionSet) { |
| fuchsia::example::fostr::MyUnion u; |
| u.set_i(5); |
| EXPECT_FIDL_TO_FORMAT_AS(u, "i 5"); |
| } |
| |
| TEST(FidlTypes, XunionEmpty) { |
| using fidl::operator<<; |
| |
| fuchsia::example::fostr::MyXunion xu; |
| |
| EXPECT_FIDL_TO_FORMAT_AS(xu, "<empty union>"); |
| } |
| |
| TEST(FidlTypes, XunionSet) { |
| using fidl::operator<<; |
| |
| fuchsia::example::fostr::MyXunion xu; |
| xu.set_i(5); |
| |
| EXPECT_FIDL_TO_FORMAT_AS(xu, "i 5"); |
| } |
| |
| TEST(FidlTypes, XunionSetWithUint8) { |
| using fidl::operator<<; |
| |
| fuchsia::example::fostr::MyXunion xu; |
| xu.set_my_uint8(5); |
| |
| EXPECT_FIDL_TO_FORMAT_AS(xu, "my_uint8 5"); |
| } |
| |
| TEST(FidlTypes, XunionSetWithInt8) { |
| using fidl::operator<<; |
| |
| fuchsia::example::fostr::MyXunion xu; |
| xu.set_my_int8(-5); |
| |
| EXPECT_FIDL_TO_FORMAT_AS(xu, "my_int8 -5"); |
| } |
| |
| TEST(FidlTypes, Array) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::array<std::string, 2> utensil_array; |
| utensil_array[0] = "knife"; |
| utensil_array[1] = "spork"; |
| |
| os << Indent << "utensil:" << Formatted(utensil_array); |
| |
| EXPECT_EQ( |
| "utensil:" |
| "\n [0] knife" |
| "\n [1] spork", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, ArrayOfInt32) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::array<int32_t, 2> arr; |
| arr[0] = 5; |
| arr[1] = 6; |
| os << Indent << "arr: " << Formatted(arr); |
| EXPECT_EQ( |
| "arr: " |
| "\n [0] 5" |
| "\n [1] 6", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, ArrayOfFloat) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::array<float, 2> arr; |
| arr[0] = 5.5f; |
| arr[1] = 6.6f; |
| os << Indent << "arr: " << Formatted(arr); |
| EXPECT_EQ( |
| "arr: " |
| "\n [0] 5.5" |
| "\n [1] 6.6", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, ArrayOfArrays) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| |
| std::array<int32_t, 3> left; |
| std::array<int32_t, 3> right; |
| left[0] = 4; |
| left[1] = 5; |
| left[2] = 6; |
| right[0] = 7; |
| right[1] = 8; |
| right[2] = 9; |
| |
| std::array<std::array<int32_t, 3>, 2> arr; |
| arr[0] = left; |
| arr[1] = right; |
| os << Indent << "arr: " << Formatted(arr); |
| EXPECT_EQ( |
| "arr: " |
| "\n [0]:" |
| "\n [0] 4" |
| "\n [1] 5" |
| "\n [2] 6" |
| "\n [1]:" |
| "\n [0] 7" |
| "\n [1] 8" |
| "\n [2] 9", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, ArrayOfArraysEmpty) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| |
| std::array<std::array<int32_t, 3>, 0> arr; |
| os << Indent << "arr: " << Formatted(arr); |
| EXPECT_EQ("arr: <empty>", os.str()); |
| } |
| |
| TEST(FidlTypes, ArrayOfUint8) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::array<uint8_t, 10> small_array; |
| std::array<uint8_t, 255> medium_array; |
| std::array<uint8_t, 265> large_array; |
| for (uint8_t i = 0; i < 10; ++i) { |
| small_array[i] = i; |
| large_array[i] = i; |
| } |
| for (uint8_t i = 0; i < 255; ++i) { |
| medium_array[i] = i; |
| large_array[i + 10] = i; |
| } |
| |
| os << Indent << "small:" << Formatted(small_array) << fostr::NewLine |
| << "medium:" << Formatted(medium_array) << fostr::NewLine |
| << "large:" << Formatted(large_array); |
| |
| EXPECT_EQ( |
| "small:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 " |
| ".......... " |
| "\n medium:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f " |
| "................" |
| "\n 0010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f " |
| "................" |
| "\n 0020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f " |
| "!\"#$%&'()*+,-./" |
| "\n 0030 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f " |
| "0123456789:;<=>?" |
| "\n 0040 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f " |
| "@ABCDEFGHIJKLMNO" |
| "\n 0050 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f " |
| "PQRSTUVWXYZ[\\]^_" |
| "\n 0060 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f " |
| "`abcdefghijklmno" |
| "\n 0070 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f " |
| "pqrstuvwxyz{|}~." |
| "\n 0080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f " |
| "................" |
| "\n 0090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f " |
| "................" |
| "\n 00a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af " |
| "................" |
| "\n 00b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf " |
| "................" |
| "\n 00c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf " |
| "................" |
| "\n 00d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df " |
| "................" |
| "\n 00e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef " |
| "................" |
| "\n 00f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe " |
| "............... " |
| "\n large:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 " |
| "................" |
| "\n 0010 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 " |
| "................" |
| "\n 0020 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 " |
| ".......... !\"#$%" |
| "\n 0030 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 " |
| "&'()*+,-./012345" |
| "\n (truncated, 265 bytes total)", |
| |
| os.str()); |
| } |
| |
| TEST(FidlTypes, ArrayOfInt8) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::array<int8_t, 10> small_array; |
| std::array<int8_t, 255> medium_array; |
| std::array<int8_t, 265> large_array; |
| for (uint8_t i = 0; i < 10; ++i) { |
| small_array[i] = static_cast<int8_t>(i); |
| large_array[i] = static_cast<int8_t>(i); |
| } |
| for (uint8_t i = 0; i < 255; ++i) { |
| medium_array[i] = static_cast<int8_t>(i); |
| large_array[i + 10] = static_cast<int8_t>(i); |
| } |
| |
| os << Indent << "small:" << Formatted(small_array) << fostr::NewLine |
| << "medium:" << Formatted(medium_array) << fostr::NewLine |
| << "large:" << Formatted(large_array); |
| |
| EXPECT_EQ( |
| "small:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 " |
| ".......... " |
| "\n medium:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f " |
| "................" |
| "\n 0010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f " |
| "................" |
| "\n 0020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f " |
| "!\"#$%&'()*+,-./" |
| "\n 0030 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f " |
| "0123456789:;<=>?" |
| "\n 0040 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f " |
| "@ABCDEFGHIJKLMNO" |
| "\n 0050 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f " |
| "PQRSTUVWXYZ[\\]^_" |
| "\n 0060 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f " |
| "`abcdefghijklmno" |
| "\n 0070 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f " |
| "pqrstuvwxyz{|}~." |
| "\n 0080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f " |
| "................" |
| "\n 0090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f " |
| "................" |
| "\n 00a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af " |
| "................" |
| "\n 00b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf " |
| "................" |
| "\n 00c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf " |
| "................" |
| "\n 00d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df " |
| "................" |
| "\n 00e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef " |
| "................" |
| "\n 00f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe " |
| "............... " |
| "\n large:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 " |
| "................" |
| "\n 0010 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 " |
| "................" |
| "\n 0020 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 " |
| ".......... !\"#$%" |
| "\n 0030 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 " |
| "&'()*+,-./012345" |
| "\n (truncated, 265 bytes total)", |
| |
| os.str()); |
| } |
| |
| TEST(FidlTypes, VectorPtr) { |
| std::ostringstream os; |
| fidl::VectorPtr<std::string> null_vector; |
| fidl::VectorPtr<std::string> empty_vector; |
| fidl::VectorPtr<std::string> utensil_vector; |
| empty_vector.emplace(); |
| utensil_vector.emplace({"knife", "spork"}); |
| |
| os << fostr::Indent << "null:" << null_vector << ", empty:" << empty_vector |
| << ", utensil:" << utensil_vector; |
| |
| EXPECT_EQ( |
| "null:<null>, empty:<empty>, utensil:" |
| "\n [0] knife" |
| "\n [1] spork", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, VectorPtrOfUint8) { |
| std::ostringstream os; |
| fidl::VectorPtr<uint8_t> null_vector; |
| fidl::VectorPtr<uint8_t> empty_vector; |
| fidl::VectorPtr<uint8_t> small_vector; |
| fidl::VectorPtr<uint8_t> medium_vector; |
| fidl::VectorPtr<uint8_t> large_vector; |
| empty_vector.emplace(); |
| small_vector.emplace(); |
| medium_vector.emplace(); |
| large_vector.emplace(); |
| for (uint8_t i = 0; i < 10; ++i) { |
| small_vector->push_back(i); |
| large_vector->push_back(i); |
| } |
| for (uint8_t i = 0; i < 255; ++i) { |
| medium_vector->push_back(i); |
| large_vector->push_back(i); |
| } |
| |
| os << fostr::Indent << "null:" << null_vector << ", empty:" << empty_vector << fostr::NewLine |
| << "small:" << small_vector << fostr::NewLine << "medium:" << medium_vector << fostr::NewLine |
| << "large:" << large_vector; |
| |
| EXPECT_EQ( |
| "null:<null>, empty:<empty>" |
| "\n small:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 " |
| ".......... " |
| "\n medium:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f " |
| "................" |
| "\n 0010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f " |
| "................" |
| "\n 0020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f " |
| "!\"#$%&'()*+,-./" |
| "\n 0030 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f " |
| "0123456789:;<=>?" |
| "\n 0040 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f " |
| "@ABCDEFGHIJKLMNO" |
| "\n 0050 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f " |
| "PQRSTUVWXYZ[\\]^_" |
| "\n 0060 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f " |
| "`abcdefghijklmno" |
| "\n 0070 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f " |
| "pqrstuvwxyz{|}~." |
| "\n 0080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f " |
| "................" |
| "\n 0090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f " |
| "................" |
| "\n 00a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af " |
| "................" |
| "\n 00b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf " |
| "................" |
| "\n 00c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf " |
| "................" |
| "\n 00d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df " |
| "................" |
| "\n 00e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef " |
| "................" |
| "\n 00f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe " |
| "............... " |
| "\n large:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 " |
| "................" |
| "\n 0010 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 " |
| "................" |
| "\n 0020 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 " |
| ".......... !\"#$%" |
| "\n 0030 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 " |
| "&'()*+,-./012345" |
| "\n (truncated, 265 bytes total)", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, VectorPtrOfInt8) { |
| std::ostringstream os; |
| fidl::VectorPtr<int8_t> null_vector; |
| fidl::VectorPtr<int8_t> empty_vector; |
| fidl::VectorPtr<int8_t> small_vector; |
| fidl::VectorPtr<int8_t> medium_vector; |
| fidl::VectorPtr<int8_t> large_vector; |
| empty_vector.emplace(); |
| small_vector.emplace(); |
| medium_vector.emplace(); |
| large_vector.emplace(); |
| for (uint8_t i = 0; i < 10; ++i) { |
| small_vector->push_back(static_cast<int8_t>(i)); |
| large_vector->push_back(static_cast<int8_t>(i)); |
| } |
| for (uint8_t i = 0; i < 255; ++i) { |
| medium_vector->push_back(static_cast<int8_t>(i)); |
| large_vector->push_back(static_cast<int8_t>(i)); |
| } |
| |
| os << fostr::Indent << "null:" << null_vector << ", empty:" << empty_vector << fostr::NewLine |
| << "small:" << small_vector << fostr::NewLine << "medium:" << medium_vector << fostr::NewLine |
| << "large:" << large_vector; |
| |
| EXPECT_EQ( |
| "null:<null>, empty:<empty>" |
| "\n small:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 " |
| ".......... " |
| "\n medium:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f " |
| "................" |
| "\n 0010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f " |
| "................" |
| "\n 0020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f " |
| "!\"#$%&'()*+,-./" |
| "\n 0030 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f " |
| "0123456789:;<=>?" |
| "\n 0040 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f " |
| "@ABCDEFGHIJKLMNO" |
| "\n 0050 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f " |
| "PQRSTUVWXYZ[\\]^_" |
| "\n 0060 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f " |
| "`abcdefghijklmno" |
| "\n 0070 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f " |
| "pqrstuvwxyz{|}~." |
| "\n 0080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f " |
| "................" |
| "\n 0090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f " |
| "................" |
| "\n 00a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af " |
| "................" |
| "\n 00b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf " |
| "................" |
| "\n 00c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf " |
| "................" |
| "\n 00d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df " |
| "................" |
| "\n 00e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef " |
| "................" |
| "\n 00f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe " |
| "............... " |
| "\n large:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 " |
| "................" |
| "\n 0010 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 " |
| "................" |
| "\n 0020 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 " |
| ".......... !\"#$%" |
| "\n 0030 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 " |
| "&'()*+,-./012345" |
| "\n (truncated, 265 bytes total)", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, StdVector) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::vector<std::string> empty_vector; |
| std::vector<std::string> utensil_vector = {"knife", "spork"}; |
| |
| // The fostr::NewLine was added to repro https://fxbug.dev/42160365 and test for regressions. |
| os << fostr::Indent << fostr::NewLine << "empty:" << Formatted(empty_vector) |
| << ", utensil:" << Formatted(utensil_vector); |
| |
| EXPECT_EQ( |
| "\n empty:<empty>, utensil:" |
| "\n [0] knife" |
| "\n [1] spork", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, StdVectorOfVectors) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::vector<std::vector<std::string>> empty_vector; |
| std::vector<std::vector<std::string>> utensil_vector = { |
| {"knife", "spork"}, {}, {"runcible spoon"}}; |
| |
| // The fostr::NewLine was added to repro https://fxbug.dev/42160365 and test for regressions. |
| os << fostr::Indent << fostr::NewLine << "empty:" << Formatted(empty_vector) |
| << ", utensil:" << Formatted(utensil_vector); |
| |
| EXPECT_EQ( |
| "\n empty:<empty>, utensil:" |
| "\n [0] " |
| "\n [0] knife" |
| "\n [1] spork" |
| "\n [1] <empty>" |
| "\n [2] " |
| "\n [0] runcible spoon", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, StdVectorOfUint8) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::vector<uint8_t> empty_vector; |
| std::vector<uint8_t> small_vector; |
| std::vector<uint8_t> medium_vector; |
| std::vector<uint8_t> large_vector; |
| for (uint8_t i = 0; i < 10; ++i) { |
| small_vector.push_back(i); |
| large_vector.push_back(i); |
| } |
| for (uint8_t i = 0; i < 255; ++i) { |
| medium_vector.push_back(i); |
| large_vector.push_back(i); |
| } |
| |
| os << fostr::Indent << "empty:" << Formatted(empty_vector) << fostr::NewLine |
| << "small:" << Formatted(small_vector) << fostr::NewLine |
| << "medium:" << Formatted(medium_vector) << fostr::NewLine |
| << "large:" << Formatted(large_vector); |
| |
| EXPECT_EQ( |
| "empty:<empty>" |
| "\n small:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 " |
| ".......... " |
| "\n medium:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f " |
| "................" |
| "\n 0010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f " |
| "................" |
| "\n 0020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f " |
| "!\"#$%&'()*+,-./" |
| "\n 0030 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f " |
| "0123456789:;<=>?" |
| "\n 0040 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f " |
| "@ABCDEFGHIJKLMNO" |
| "\n 0050 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f " |
| "PQRSTUVWXYZ[\\]^_" |
| "\n 0060 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f " |
| "`abcdefghijklmno" |
| "\n 0070 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f " |
| "pqrstuvwxyz{|}~." |
| "\n 0080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f " |
| "................" |
| "\n 0090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f " |
| "................" |
| "\n 00a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af " |
| "................" |
| "\n 00b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf " |
| "................" |
| "\n 00c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf " |
| "................" |
| "\n 00d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df " |
| "................" |
| "\n 00e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef " |
| "................" |
| "\n 00f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe " |
| "............... " |
| "\n large:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 " |
| "................" |
| "\n 0010 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 " |
| "................" |
| "\n 0020 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 " |
| ".......... !\"#$%" |
| "\n 0030 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 " |
| "&'()*+,-./012345" |
| "\n (truncated, 265 bytes total)", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, StdVectorOfInt8) { |
| using fidl::operator<<; |
| std::ostringstream os; |
| std::vector<int8_t> empty_vector; |
| std::vector<int8_t> small_vector; |
| std::vector<int8_t> medium_vector; |
| std::vector<int8_t> large_vector; |
| for (uint8_t i = 0; i < 10; ++i) { |
| small_vector.push_back(static_cast<int8_t>(i)); |
| large_vector.push_back(static_cast<int8_t>(i)); |
| } |
| for (uint8_t i = 0; i < 255; ++i) { |
| medium_vector.push_back(static_cast<int8_t>(i)); |
| large_vector.push_back(static_cast<int8_t>(i)); |
| } |
| |
| os << fostr::Indent << "empty:" << Formatted(empty_vector) << fostr::NewLine |
| << "small:" << Formatted(small_vector) << fostr::NewLine |
| << "medium:" << Formatted(medium_vector) << fostr::NewLine |
| << "large:" << Formatted(large_vector); |
| |
| EXPECT_EQ( |
| "empty:<empty>" |
| "\n small:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 " |
| ".......... " |
| "\n medium:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f " |
| "................" |
| "\n 0010 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f " |
| "................" |
| "\n 0020 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f " |
| "!\"#$%&'()*+,-./" |
| "\n 0030 30 31 32 33 34 35 36 37 38 39 3a 3b 3c 3d 3e 3f " |
| "0123456789:;<=>?" |
| "\n 0040 40 41 42 43 44 45 46 47 48 49 4a 4b 4c 4d 4e 4f " |
| "@ABCDEFGHIJKLMNO" |
| "\n 0050 50 51 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e 5f " |
| "PQRSTUVWXYZ[\\]^_" |
| "\n 0060 60 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f " |
| "`abcdefghijklmno" |
| "\n 0070 70 71 72 73 74 75 76 77 78 79 7a 7b 7c 7d 7e 7f " |
| "pqrstuvwxyz{|}~." |
| "\n 0080 80 81 82 83 84 85 86 87 88 89 8a 8b 8c 8d 8e 8f " |
| "................" |
| "\n 0090 90 91 92 93 94 95 96 97 98 99 9a 9b 9c 9d 9e 9f " |
| "................" |
| "\n 00a0 a0 a1 a2 a3 a4 a5 a6 a7 a8 a9 aa ab ac ad ae af " |
| "................" |
| "\n 00b0 b0 b1 b2 b3 b4 b5 b6 b7 b8 b9 ba bb bc bd be bf " |
| "................" |
| "\n 00c0 c0 c1 c2 c3 c4 c5 c6 c7 c8 c9 ca cb cc cd ce cf " |
| "................" |
| "\n 00d0 d0 d1 d2 d3 d4 d5 d6 d7 d8 d9 da db dc dd de df " |
| "................" |
| "\n 00e0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 ea eb ec ed ee ef " |
| "................" |
| "\n 00f0 f0 f1 f2 f3 f4 f5 f6 f7 f8 f9 fa fb fc fd fe " |
| "............... " |
| "\n large:" |
| "\n 0000 00 01 02 03 04 05 06 07 08 09 00 01 02 03 04 05 " |
| "................" |
| "\n 0010 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15 " |
| "................" |
| "\n 0020 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 " |
| ".......... !\"#$%" |
| "\n 0030 26 27 28 29 2a 2b 2c 2d 2e 2f 30 31 32 33 34 35 " |
| "&'()*+,-./012345" |
| "\n (truncated, 265 bytes total)", |
| os.str()); |
| } |
| |
| TEST(FidlTypes, UnboundBinding) { |
| std::ostringstream os; |
| fuchsia::example::fostr::ExampleProtocol* impl = nullptr; |
| fidl::Binding<fuchsia::example::fostr::ExampleProtocol> binding(impl); |
| |
| os << binding; |
| EXPECT_EQ("<not bound>", os.str()); |
| } |
| |
| TEST(FidlTypes, Binding) { |
| async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread); |
| |
| std::ostringstream os; |
| fuchsia::example::fostr::ExampleProtocol* impl = nullptr; |
| fidl::Binding<fuchsia::example::fostr::ExampleProtocol> binding(impl); |
| auto interface_handle = binding.NewBinding(); |
| |
| os << binding; |
| |
| std::istringstream is(os.str()); |
| zx_koid_t koid; |
| zx_koid_t related_koid; |
| is >> "koid 0x" >> std::hex >> koid >> " <-> 0x" >> related_koid; |
| |
| EXPECT_TRUE(is && is.eof()); |
| EXPECT_EQ(fsl::GetKoid(binding.channel().get()), koid); |
| EXPECT_EQ(fsl::GetKoid(interface_handle.channel().get()), related_koid); |
| } |
| |
| TEST(FidlTypes, UnboundInterfaceHandle) { |
| std::ostringstream os; |
| fidl::InterfaceHandle<fuchsia::example::fostr::ExampleProtocol> interface_handle; |
| |
| os << interface_handle; |
| EXPECT_EQ("<not valid>", os.str()); |
| } |
| |
| TEST(FidlTypes, InterfaceHandle) { |
| async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread); |
| |
| std::ostringstream os; |
| fuchsia::example::fostr::ExampleProtocol* impl = nullptr; |
| fidl::Binding<fuchsia::example::fostr::ExampleProtocol> binding(impl); |
| auto interface_handle = binding.NewBinding(); |
| |
| os << interface_handle; |
| |
| std::istringstream is(os.str()); |
| zx_koid_t koid; |
| zx_koid_t related_koid; |
| is >> "koid 0x" >> std::hex >> koid >> " <-> 0x" >> related_koid; |
| |
| EXPECT_TRUE(is && is.eof()); |
| EXPECT_EQ(fsl::GetKoid(interface_handle.channel().get()), koid); |
| EXPECT_EQ(fsl::GetKoid(binding.channel().get()), related_koid); |
| } |
| |
| TEST(FidlTypes, UnboundInterfacePtr) { |
| std::ostringstream os; |
| fidl::InterfacePtr<fuchsia::example::fostr::ExampleProtocol> interface_ptr; |
| |
| os << interface_ptr; |
| EXPECT_EQ("<not bound>", os.str()); |
| } |
| |
| TEST(FidlTypes, InterfacePtr) { |
| async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread); |
| |
| std::ostringstream os; |
| fidl::InterfacePtr<fuchsia::example::fostr::ExampleProtocol> interface_ptr; |
| auto interface_request = interface_ptr.NewRequest(); |
| |
| os << interface_ptr; |
| |
| std::istringstream is(os.str()); |
| zx_koid_t koid; |
| zx_koid_t related_koid; |
| is >> "koid 0x" >> std::hex >> koid >> " <-> 0x" >> related_koid; |
| |
| EXPECT_TRUE(is && is.eof()); |
| EXPECT_EQ(fsl::GetKoid(interface_ptr.channel().get()), koid); |
| EXPECT_EQ(fsl::GetKoid(interface_request.channel().get()), related_koid); |
| } |
| |
| TEST(FidlTypes, InvalidInterfaceRequest) { |
| std::ostringstream os; |
| fidl::InterfaceRequest<fuchsia::example::fostr::ExampleProtocol> interface_request; |
| |
| os << interface_request; |
| EXPECT_EQ("<not valid>", os.str()); |
| } |
| |
| TEST(FidlTypes, InterfaceRequest) { |
| async::Loop loop(&kAsyncLoopConfigAttachToCurrentThread); |
| |
| std::ostringstream os; |
| fidl::InterfacePtr<fuchsia::example::fostr::ExampleProtocol> interface_ptr; |
| auto interface_request = interface_ptr.NewRequest(); |
| |
| os << interface_request; |
| |
| std::istringstream is(os.str()); |
| zx_koid_t koid; |
| zx_koid_t related_koid; |
| is >> "koid 0x" >> std::hex >> koid >> " <-> 0x" >> related_koid; |
| |
| EXPECT_TRUE(is && is.eof()); |
| EXPECT_EQ(fsl::GetKoid(interface_request.channel().get()), koid); |
| EXPECT_EQ(fsl::GetKoid(interface_ptr.channel().get()), related_koid); |
| } |
| |
| TEST(FidlTypes, BitsFormatting) { |
| using namespace fuchsia::example::fostr; |
| |
| EXPECT_FIDL_TO_FORMAT_AS(static_cast<ExampleBits>(0), "<empty bits>"); |
| EXPECT_FIDL_TO_FORMAT_AS(ExampleBits::A, "a"); |
| EXPECT_FIDL_TO_FORMAT_AS(ExampleBits::B, "b"); |
| EXPECT_FIDL_TO_FORMAT_AS(ExampleBits::C, "c"); |
| EXPECT_FIDL_TO_FORMAT_AS(ExampleBits::A | ExampleBits::C, "a|c"); |
| EXPECT_FIDL_TO_FORMAT_AS(~ExampleBits::C, "a|b"); |
| } |
| |
| TEST(FidlTypes, EnumFormatting) { |
| using namespace fuchsia::example::fostr; |
| |
| EXPECT_FIDL_TO_FORMAT_AS(ExampleEnum::FOO, "foo"); |
| EXPECT_FIDL_TO_FORMAT_AS(ExampleEnum::BAR_BAZ, "bar baz"); |
| EXPECT_FIDL_TO_FORMAT_AS(static_cast<ExampleEnum>(999), "<invalid enum value: 999>"); |
| } |
| |
| TEST(FidlTypes, StructFormatting) { |
| using namespace fuchsia::example::fostr; |
| |
| MyXunion xu; |
| xu.set_b(false); |
| |
| fidl::VectorPtr<int32_t> nums{std::vector<int32_t>{}}; |
| for (int32_t i = 0; i < 3; ++i) { |
| nums->push_back(static_cast<int32_t>(i)); |
| } |
| |
| MyStruct my_struct; |
| my_struct.nums = std::move(nums); |
| my_struct.foo = "hello there"; |
| my_struct.bar = std::move(xu); |
| my_struct.my_uint8 = 5; |
| my_struct.my_int8 = -6; |
| |
| EXPECT_FIDL_TO_FORMAT_AS(my_struct, R"( |
| nums: |
| [0] 0 |
| [1] 1 |
| [2] 2 |
| foo: hello there |
| bar: b 0 |
| my_uint8: 5 |
| my_int8: -6)"); |
| } |
| |
| TEST(FidlTypes, TableFormatting) { |
| using namespace fuchsia::example::fostr; |
| |
| SimpleTable table; |
| EXPECT_FIDL_TO_FORMAT_AS(table, "<empty table>"); |
| |
| table.set_x(false); |
| table.set_z(34); |
| table.set_my_uint8(5); |
| table.set_my_int8(-6); |
| EXPECT_FIDL_TO_FORMAT_AS(table, R"( |
| x: 0 |
| z: 34 |
| my_uint8: 5 |
| my_int8: -6)"); |
| } |
| |
| // Tests that fb/79996 has not regressed. |
| TEST(FidlTypes, ExternalOptionals) { |
| using namespace fuchsia::example::fostr; |
| using namespace fuchsia::example::fostr2; |
| |
| MyStruct2 struct2; |
| EXPECT_FIDL_TO_FORMAT_AS(struct2, "\n optional_external_value: <null>"); |
| |
| struct2.optional_external_value = std::make_unique<MyStruct>(); |
| EXPECT_FIDL_TO_FORMAT_AS(struct2, R"( |
| optional_external_value: |
| nums: <null> |
| foo: |
| bar: <empty union> |
| my_uint8: 0 |
| my_int8: 0)"); |
| } |
| |
| } // namespace |
| } // namespace fostr |
