From 0e5eb3f35c67c066289ac5eb804dc6a0833a2f30 Mon Sep 17 00:00:00 2001 From: Thad House Date: Fri, 19 Jan 2024 22:24:54 -0800 Subject: [PATCH] [wpiutil] Fix DynamicStruct string handling (#6253) Dynamic structs had a few major issues. In C++, if the string was the last definition in the schema, attempting to set a string would trigger an assertion. This has been fixed Setting a string value could truncate the string actually stored in the struct, if the definition was shorter than the string to set. There was no way to detect if this case occurred. The set string function now returns a bool if the string was fully written or not. Reading a string that had a value shorter than the schema definition would result in embedded trailing nulls in the string. This would make comparing string equality basically impossible, as those embedded nulls count for the length of the string. The above truncating didn't take into account UTF8 code points. This means a truncation could happen in the middle of a unicode character. Depending on the language this had different behavior, but unpaired code points are problematic to detect in any case. On the decoding side, detect if a split UTF8 code point has occurred by the writer, and if so just ignore it and treat it as not part of the string. Doing this on the receive side means a newer receive side is all that is needed to fix this, which is generally a better option then requiring all senders to update. Actual DynamicStruct instances have 0 units tests for them. Added a bunch of unit tests around strings to ensure things work properly. --- wpiutil/CMakeLists.txt | 3 + .../wpi/first/util/struct/DynamicStruct.java | 57 +++++- .../main/native/cpp/struct/DynamicStruct.cpp | 65 ++++++- .../native/include/wpi/struct/DynamicStruct.h | 11 +- .../first/util/struct/DynamicStructTest.java | 117 ++++++++++++ .../native/cpp/struct/DynamicStructTest.cpp | 173 ++++++++++++++++++ 6 files changed, 413 insertions(+), 13 deletions(-) diff --git a/wpiutil/CMakeLists.txt b/wpiutil/CMakeLists.txt index a3f6f1935b..e7fcb6da30 100644 --- a/wpiutil/CMakeLists.txt +++ b/wpiutil/CMakeLists.txt @@ -270,4 +270,7 @@ if(WITH_TESTS) wpilib_add_test(wpiutil src/test/native/cpp) target_link_libraries(wpiutil_test wpiutil gmock_main wpiutil_testlib) + if(MSVC) + target_compile_options(wpiutil_test PRIVATE /utf-8) + endif() endif() diff --git a/wpiutil/src/main/java/edu/wpi/first/util/struct/DynamicStruct.java b/wpiutil/src/main/java/edu/wpi/first/util/struct/DynamicStruct.java index 1f9fdc379a..de8350e8d2 100644 --- a/wpiutil/src/main/java/edu/wpi/first/util/struct/DynamicStruct.java +++ b/wpiutil/src/main/java/edu/wpi/first/util/struct/DynamicStruct.java @@ -378,6 +378,7 @@ public final class DynamicStruct { * @throws IllegalArgumentException if field is not a member of this struct * @throws IllegalStateException if struct descriptor is invalid */ + @SuppressWarnings({"PMD.CollapsibleIfStatements", "PMD.AvoidDeeplyNestedIfStmts"}) public String getStringField(StructFieldDescriptor field) { if (field.getType() != StructFieldType.kChar) { throw new UnsupportedOperationException("field is not char type"); @@ -390,7 +391,56 @@ public final class DynamicStruct { } byte[] bytes = new byte[field.m_arraySize]; m_data.position(field.m_offset).get(bytes, 0, field.m_arraySize); - return new String(bytes, StandardCharsets.UTF_8); + // Find last non zero character + int stringLength = bytes.length; + for (; stringLength > 0; stringLength--) { + if (bytes[stringLength - 1] != 0) { + break; + } + } + // If string is all zeroes, its empty and return an empty string. + if (stringLength == 0) { + return ""; + } + // Check if the end of the string is in the middle of a continuation byte or + // not. + if ((bytes[stringLength - 1] & 0x80) != 0) { + // This is a UTF8 continuation byte. Make sure its valid. + // Walk back until initial byte is found + int utf8StartByte = stringLength; + for (; utf8StartByte > 0; utf8StartByte--) { + if ((bytes[utf8StartByte - 1] & 0x40) != 0) { + // Having 2nd bit set means start byte + break; + } + } + if (utf8StartByte == 0) { + // This case means string only contains continuation bytes + return ""; + } + utf8StartByte--; + // Check if its a 2, 3, or 4 byte + byte checkByte = bytes[utf8StartByte]; + if ((checkByte & 0xE0) == 0xC0) { + // 2 byte, need 1 more byte + if (utf8StartByte != stringLength - 2) { + stringLength = utf8StartByte; + } + } else if ((checkByte & 0xF0) == 0xE0) { + // 3 byte, need 2 more bytes + if (utf8StartByte != stringLength - 3) { + stringLength = utf8StartByte; + } + } else if ((checkByte & 0xF8) == 0xF0) { + // 4 byte, need 3 more bytes + if (utf8StartByte != stringLength - 4) { + stringLength = utf8StartByte; + } + } + // If we get here, the string is either completely garbage or fine. + } + + return new String(bytes, 0, stringLength, StandardCharsets.UTF_8); } /** @@ -398,11 +448,12 @@ public final class DynamicStruct { * * @param field field descriptor * @param value field value + * @return true if the full value fit in the struct, false if truncated * @throws UnsupportedOperationException if field is not char type * @throws IllegalArgumentException if field is not a member of this struct * @throws IllegalStateException if struct descriptor is invalid */ - public void setStringField(StructFieldDescriptor field, String value) { + public boolean setStringField(StructFieldDescriptor field, String value) { if (field.getType() != StructFieldType.kChar) { throw new UnsupportedOperationException("field is not char type"); } @@ -414,10 +465,12 @@ public final class DynamicStruct { } ByteBuffer bb = StandardCharsets.UTF_8.encode(value); int len = Math.min(bb.remaining(), field.m_arraySize); + boolean copiedFull = len == bb.remaining(); m_data.position(field.m_offset).put(bb.limit(len)); for (int i = len; i < field.m_arraySize; i++) { m_data.put((byte) 0); } + return copiedFull; } /** diff --git a/wpiutil/src/main/native/cpp/struct/DynamicStruct.cpp b/wpiutil/src/main/native/cpp/struct/DynamicStruct.cpp index 7ae9271ae0..8d43f53744 100644 --- a/wpiutil/src/main/native/cpp/struct/DynamicStruct.cpp +++ b/wpiutil/src/main/native/cpp/struct/DynamicStruct.cpp @@ -349,16 +349,75 @@ void MutableDynamicStruct::SetData(std::span data) { std::copy(data.begin(), data.begin() + m_desc->GetSize(), m_data.begin()); } -void MutableDynamicStruct::SetStringField(const StructFieldDescriptor* field, +std::string_view DynamicStruct::GetStringField( + const StructFieldDescriptor* field) const { + assert(field->m_type == StructFieldType::kChar); + assert(field->m_parent == m_desc); + assert(m_desc->IsValid()); + // Find last non zero character + size_t stringLength; + for (stringLength = field->m_arraySize; stringLength > 0; stringLength--) { + if (m_data[field->m_offset + stringLength - 1] != 0) { + break; + } + } + // If string is all zeroes, its empty and return an empty string. + if (stringLength == 0) { + return ""; + } + // Check if the end of the string is in the middle of a continuation byte or + // not. + if ((m_data[field->m_offset + stringLength - 1] & 0x80) != 0) { + // This is a UTF8 continuation byte. Make sure its valid. + // Walk back until initial byte is found + size_t utf8StartByte = stringLength; + for (; utf8StartByte > 0; utf8StartByte--) { + if ((m_data[field->m_offset + utf8StartByte - 1] & 0x40) != 0) { + // Having 2nd bit set means start byte + break; + } + } + if (utf8StartByte == 0) { + // This case means string only contains continuation bytes + return ""; + } + utf8StartByte--; + // Check if its a 2, 3, or 4 byte + uint8_t checkByte = m_data[field->m_offset + utf8StartByte]; + if ((checkByte & 0xE0) == 0xC0) { + // 2 byte, need 1 more byte + if (utf8StartByte != stringLength - 2) { + stringLength = utf8StartByte; + } + } else if ((checkByte & 0xF0) == 0xE0) { + // 3 byte, need 2 more bytes + if (utf8StartByte != stringLength - 3) { + stringLength = utf8StartByte; + } + } else if ((checkByte & 0xF8) == 0xF0) { + // 4 byte, need 3 more bytes + if (utf8StartByte != stringLength - 4) { + stringLength = utf8StartByte; + } + } + // If we get here, the string is either completely garbage or fine. + } + return {reinterpret_cast(&m_data[field->m_offset]), + stringLength}; +} + +bool MutableDynamicStruct::SetStringField(const StructFieldDescriptor* field, std::string_view value) { assert(field->m_type == StructFieldType::kChar); assert(field->m_parent == m_desc); assert(m_desc->IsValid()); size_t len = (std::min)(field->m_arraySize, value.size()); + bool copiedFull = len == value.size(); std::copy(value.begin(), value.begin() + len, reinterpret_cast(&m_data[field->m_offset])); - std::fill(&m_data[field->m_offset + len], - &m_data[field->m_offset + field->m_arraySize], 0); + auto toFill = m_data.subspan(field->m_offset + len, field->m_arraySize - len); + std::fill(toFill.begin(), toFill.end(), 0); + return copiedFull; } void MutableDynamicStruct::SetStructField(const StructFieldDescriptor* field, diff --git a/wpiutil/src/main/native/include/wpi/struct/DynamicStruct.h b/wpiutil/src/main/native/include/wpi/struct/DynamicStruct.h index 4254090110..f49db2514e 100644 --- a/wpiutil/src/main/native/include/wpi/struct/DynamicStruct.h +++ b/wpiutil/src/main/native/include/wpi/struct/DynamicStruct.h @@ -472,13 +472,7 @@ class DynamicStruct { * @param field field descriptor * @return field value */ - std::string_view GetStringField(const StructFieldDescriptor* field) const { - assert(field->m_type == StructFieldType::kChar); - assert(field->m_parent == m_desc); - assert(m_desc->IsValid()); - return {reinterpret_cast(&m_data[field->m_offset]), - field->m_arraySize}; - } + std::string_view GetStringField(const StructFieldDescriptor* field) const; /** * Gets the value of a struct field. @@ -610,8 +604,9 @@ class MutableDynamicStruct : public DynamicStruct { * * @param field field descriptor * @param value field value + * @return true if the full value fit in the struct, false if truncated */ - void SetStringField(const StructFieldDescriptor* field, + bool SetStringField(const StructFieldDescriptor* field, std::string_view value); /** diff --git a/wpiutil/src/test/java/edu/wpi/first/util/struct/DynamicStructTest.java b/wpiutil/src/test/java/edu/wpi/first/util/struct/DynamicStructTest.java index 9e77c80aee..78a8127f43 100644 --- a/wpiutil/src/test/java/edu/wpi/first/util/struct/DynamicStructTest.java +++ b/wpiutil/src/test/java/edu/wpi/first/util/struct/DynamicStructTest.java @@ -18,6 +18,7 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +@SuppressWarnings("AvoidEscapedUnicodeCharacters") class DynamicStructTest { @SuppressWarnings("MemberName") private StructDescriptorDatabase db; @@ -387,4 +388,120 @@ class DynamicStructTest { assertNotNull(field.getStruct()); } } + + @Test + void testStringAllZeros() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[32]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertEquals("", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTrip() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[32]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertTrue(dynamic.setStringField(field, "abc")); + assertEquals("abc", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTripEmbeddedNull() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[32]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertTrue(dynamic.setStringField(field, "ab\0c")); + assertEquals("ab\0c", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTripStringTooLong() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[2]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertFalse(dynamic.setStringField(field, "abc")); + assertEquals("ab", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTripPartial2ByteUtf8() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[2]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertFalse(dynamic.setStringField(field, "a\u0234")); + assertEquals("a", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTrip2ByteUtf8() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[3]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertTrue(dynamic.setStringField(field, "a\u0234")); + assertEquals("a\u0234", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTripPartial3ByteUtf8FirstByte() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[2]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertFalse(dynamic.setStringField(field, "a\u1234")); + assertEquals("a", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTripPartial3ByteUtf8SecondByte() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[3]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertFalse(dynamic.setStringField(field, "a\u1234")); + assertEquals("a", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTrip3ByteUtf8() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[4]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertTrue(dynamic.setStringField(field, "a\u1234")); + assertEquals("a\u1234", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTripPartial4ByteUtf8FirstByte() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[2]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertFalse(dynamic.setStringField(field, "a\uD83D\uDC00")); + assertEquals("a", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTripPartial4ByteUtf8SecondByte() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[3]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertFalse(dynamic.setStringField(field, "a\uD83D\uDC00")); + assertEquals("a", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTripPartial4ByteUtf8ThirdByte() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[4]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertFalse(dynamic.setStringField(field, "a\uD83D\uDC00")); + assertEquals("a", dynamic.getStringField(field)); + } + + @Test + void testStringRoundTrip4ByteUtf8() { + var desc = assertDoesNotThrow(() -> db.add("test", "char a[5]")); + var dynamic = DynamicStruct.allocate(desc); + var field = desc.findFieldByName("a"); + assertTrue(dynamic.setStringField(field, "a\uD83D\uDC00")); + assertEquals("a\uD83D\uDC00", dynamic.getStringField(field)); + } } diff --git a/wpiutil/src/test/native/cpp/struct/DynamicStructTest.cpp b/wpiutil/src/test/native/cpp/struct/DynamicStructTest.cpp index d5d21d17b6..b0d43ffd06 100644 --- a/wpiutil/src/test/native/cpp/struct/DynamicStructTest.cpp +++ b/wpiutil/src/test/native/cpp/struct/DynamicStructTest.cpp @@ -269,6 +269,179 @@ TEST_F(DynamicStructTest, DuplicateFieldName) { ASSERT_EQ(err, "duplicate field a"); } +TEST_F(DynamicStructTest, StringAllZeros) { + auto desc = db.Add("test", "char a[32]", &err); + uint8_t data[32]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_EQ(dynamic.GetStringField(field), ""); +} + +TEST_F(DynamicStructTest, StringRoundTrip) { + auto desc = db.Add("test", "char a[32]", &err); + uint8_t data[32]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_TRUE(dynamic.SetStringField(field, "abc")); + EXPECT_EQ(dynamic.GetStringField(field), "abc"); +} + +TEST_F(DynamicStructTest, StringRoundTripEmbeddedNull) { + auto desc = db.Add("test", "char a[32]", &err); + uint8_t data[32]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + std::string check{"ab\0c", 4}; + ASSERT_EQ(check.size(), 4u); + EXPECT_TRUE(dynamic.SetStringField(field, check)); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, check); + EXPECT_EQ(4u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTripTooLong) { + auto desc = db.Add("test", "char a[2]", &err); + uint8_t data[2]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_FALSE(dynamic.SetStringField(field, "abc")); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "ab"); + EXPECT_EQ(2u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTripPartial2ByteUtf8) { + auto desc = db.Add("test", "char a[2]", &err); + uint8_t data[2]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_FALSE(dynamic.SetStringField(field, "a\u0234")); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "a"); + EXPECT_EQ(1u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTrip2ByteUtf8) { + auto desc = db.Add("test", "char a[3]", &err); + uint8_t data[3]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_TRUE(dynamic.SetStringField(field, "a\u0234")); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "a\u0234"); + EXPECT_EQ(3u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTrip3ByteUtf8) { + auto desc = db.Add("test", "char a[4]", &err); + uint8_t data[4]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_TRUE(dynamic.SetStringField(field, "a\u1234")); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "a\u1234"); + EXPECT_EQ(4u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTrip3ByteUtf8PartialFirstByte) { + auto desc = db.Add("test", "char a[2]", &err); + uint8_t data[2]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_FALSE(dynamic.SetStringField(field, "a\u1234")); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "a"); + EXPECT_EQ(1u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTrip3ByteUtf8PartialSecondByte) { + auto desc = db.Add("test", "char a[3]", &err); + uint8_t data[3]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_FALSE(dynamic.SetStringField(field, "a\u1234")); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "a"); + EXPECT_EQ(1u, get.size()); +} + +// MSVC and GCC do surrogate pairs differently. +// Manually construct the 4 byte string +static constexpr char buffer[] = { + static_cast(0x61), static_cast(0xf0), static_cast(0x9f), + static_cast(0x90), static_cast(0x80), static_cast(0x00)}; +static constexpr std::string_view fourByteUtf8String{buffer}; + +TEST_F(DynamicStructTest, StringRoundTrip4ByteUtf8) { + auto desc = db.Add("test", "char a[5]", &err); + uint8_t data[5]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_TRUE(dynamic.SetStringField(field, fourByteUtf8String)); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, fourByteUtf8String); + EXPECT_EQ(5u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTrip4ByteUtf8PartialFirstByte) { + auto desc = db.Add("test", "char a[2]", &err); + uint8_t data[2]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_FALSE(dynamic.SetStringField(field, fourByteUtf8String)); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "a"); + EXPECT_EQ(1u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTrip4ByteUtf8PartialSecondByte) { + auto desc = db.Add("test", "char a[3]", &err); + uint8_t data[3]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_FALSE(dynamic.SetStringField(field, fourByteUtf8String)); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "a"); + EXPECT_EQ(1u, get.size()); +} + +TEST_F(DynamicStructTest, StringRoundTrip4ByteUtf8PartialThirdByte) { + auto desc = db.Add("test", "char a[4]", &err); + uint8_t data[4]; + std::memset(data, 0, sizeof(data)); + ASSERT_EQ(desc->GetSize(), sizeof(data) / sizeof(data[0])); + wpi::MutableDynamicStruct dynamic{desc, data}; + auto field = desc->FindFieldByName("a"); + EXPECT_FALSE(dynamic.SetStringField(field, fourByteUtf8String)); + auto get = dynamic.GetStringField(field); + EXPECT_EQ(get, "a"); + EXPECT_EQ(1u, get.size()); +} + struct SimpleTestParam { const char* schema; size_t size;