// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors // Licensed under the MIT License: // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. #define CAPNP_PRIVATE #include "layout.h" #include "message.h" #include "arena.h" #include <kj/compat/gtest.h> #if CAPNP_DEBUG_TYPES namespace kj { template <typename T, typename U> String KJ_STRINGIFY(kj::Quantity<T, U> value) { return kj::str(value / kj::unit<kj::Quantity<T, U>>()); } } #endif namespace capnp { namespace _ { // private namespace { TEST(WireFormat, SimpleRawDataStruct) { AlignedData<2> data = {{ // Struct ref, offset = 1, dataSize = 1, pointerCount = 0 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, // Content for the data section. 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }}; StructReader reader = PointerReader::getRootUnchecked(data.words).getStruct(nullptr); EXPECT_EQ(0xefcdab8967452301ull, reader.getDataField<uint64_t>(0 * ELEMENTS)); EXPECT_EQ(0u, reader.getDataField<uint64_t>(1 * ELEMENTS)); EXPECT_EQ(0x67452301u, reader.getDataField<uint32_t>(0 * ELEMENTS)); EXPECT_EQ(0xefcdab89u, reader.getDataField<uint32_t>(1 * ELEMENTS)); EXPECT_EQ(0u, reader.getDataField<uint32_t>(2 * ELEMENTS)); EXPECT_EQ(0x2301u, reader.getDataField<uint16_t>(0 * ELEMENTS)); EXPECT_EQ(0x6745u, reader.getDataField<uint16_t>(1 * ELEMENTS)); EXPECT_EQ(0xab89u, reader.getDataField<uint16_t>(2 * ELEMENTS)); EXPECT_EQ(0xefcdu, reader.getDataField<uint16_t>(3 * ELEMENTS)); EXPECT_EQ(0u, reader.getDataField<uint16_t>(4 * ELEMENTS)); EXPECT_EQ(321u ^ 0xefcdab8967452301ull, reader.getDataField<uint64_t>(0 * ELEMENTS, 321u)); EXPECT_EQ(321u ^ 0x67452301u, reader.getDataField<uint32_t>(0 * ELEMENTS, 321u)); EXPECT_EQ(321u ^ 0x2301u, reader.getDataField<uint16_t>(0 * ELEMENTS, 321u)); EXPECT_EQ(321u, reader.getDataField<uint64_t>(1 * ELEMENTS, 321u)); EXPECT_EQ(321u, reader.getDataField<uint32_t>(2 * ELEMENTS, 321u)); EXPECT_EQ(321u, reader.getDataField<uint16_t>(4 * ELEMENTS, 321u)); // Bits EXPECT_TRUE (reader.getDataField<bool>(0 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(1 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(2 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(3 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(4 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(5 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(6 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(7 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>( 8 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>( 9 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(10 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(11 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(12 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>(13 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(14 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(15 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>(63 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(64 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>(0 * ELEMENTS, false)); EXPECT_FALSE(reader.getDataField<bool>(1 * ELEMENTS, false)); EXPECT_TRUE (reader.getDataField<bool>(63 * ELEMENTS, false)); EXPECT_FALSE(reader.getDataField<bool>(64 * ELEMENTS, false)); EXPECT_FALSE(reader.getDataField<bool>(0 * ELEMENTS, true)); EXPECT_TRUE (reader.getDataField<bool>(1 * ELEMENTS, true)); EXPECT_FALSE(reader.getDataField<bool>(63 * ELEMENTS, true)); EXPECT_TRUE (reader.getDataField<bool>(64 * ELEMENTS, true)); } static const AlignedData<2> SUBSTRUCT_DEFAULT = {{0,0,0,0,1,0,0,0, 0,0,0,0,0,0,0,0}}; static const AlignedData<2> STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT = {{0,0,0,0,1,0,0,0, 0,0,0,0,0,0,0,0}}; static constexpr StructSize STRUCTLIST_ELEMENT_SIZE(1 * WORDS, 1 * POINTERS); static void setupStruct(StructBuilder builder) { builder.setDataField<uint64_t>(0 * ELEMENTS, 0x1011121314151617ull); builder.setDataField<uint32_t>(2 * ELEMENTS, 0x20212223u); builder.setDataField<uint16_t>(6 * ELEMENTS, 0x3031u); builder.setDataField<uint8_t>(14 * ELEMENTS, 0x40u); builder.setDataField<bool>(120 * ELEMENTS, false); builder.setDataField<bool>(121 * ELEMENTS, false); builder.setDataField<bool>(122 * ELEMENTS, true); builder.setDataField<bool>(123 * ELEMENTS, false); builder.setDataField<bool>(124 * ELEMENTS, true); builder.setDataField<bool>(125 * ELEMENTS, true); builder.setDataField<bool>(126 * ELEMENTS, true); builder.setDataField<bool>(127 * ELEMENTS, false); { StructBuilder subStruct = builder.getPointerField(0 * POINTERS).initStruct( StructSize(1 * WORDS, 0 * POINTERS)); subStruct.setDataField<uint32_t>(0 * ELEMENTS, 123); } { ListBuilder list = builder.getPointerField(1 * POINTERS) .initList(ElementSize::FOUR_BYTES, 3 * ELEMENTS); EXPECT_EQ(3 * ELEMENTS, list.size()); list.setDataElement<int32_t>(0 * ELEMENTS, 200); list.setDataElement<int32_t>(1 * ELEMENTS, 201); list.setDataElement<int32_t>(2 * ELEMENTS, 202); } { ListBuilder list = builder.getPointerField(2 * POINTERS).initStructList( 4 * ELEMENTS, STRUCTLIST_ELEMENT_SIZE); EXPECT_EQ(4 * ELEMENTS, list.size()); for (int i = 0; i < 4; i++) { StructBuilder element = list.getStructElement(i * ELEMENTS); element.setDataField<int32_t>(0 * ELEMENTS, 300 + i); element.getPointerField(0 * POINTERS) .initStruct(StructSize(1 * WORDS, 0 * POINTERS)) .setDataField<int32_t>(0 * ELEMENTS, 400 + i); } } { ListBuilder list = builder.getPointerField(3 * POINTERS) .initList(ElementSize::POINTER, 5 * ELEMENTS); EXPECT_EQ(5 * ELEMENTS, list.size()); for (uint i = 0; i < 5; i++) { ListBuilder element = list.getPointerElement(i * ELEMENTS) .initList(ElementSize::TWO_BYTES, (i + 1) * ELEMENTS); EXPECT_EQ((i + 1) * ELEMENTS, element.size()); for (uint j = 0; j <= i; j++) { element.setDataElement<uint16_t>(j * ELEMENTS, 500 + j); } } } } static void checkStruct(StructBuilder builder) { EXPECT_EQ(0x1011121314151617ull, builder.getDataField<uint64_t>(0 * ELEMENTS)); EXPECT_EQ(0x20212223u, builder.getDataField<uint32_t>(2 * ELEMENTS)); EXPECT_EQ(0x3031u, builder.getDataField<uint16_t>(6 * ELEMENTS)); EXPECT_EQ(0x40u, builder.getDataField<uint8_t>(14 * ELEMENTS)); EXPECT_FALSE(builder.getDataField<bool>(120 * ELEMENTS)); EXPECT_FALSE(builder.getDataField<bool>(121 * ELEMENTS)); EXPECT_TRUE (builder.getDataField<bool>(122 * ELEMENTS)); EXPECT_FALSE(builder.getDataField<bool>(123 * ELEMENTS)); EXPECT_TRUE (builder.getDataField<bool>(124 * ELEMENTS)); EXPECT_TRUE (builder.getDataField<bool>(125 * ELEMENTS)); EXPECT_TRUE (builder.getDataField<bool>(126 * ELEMENTS)); EXPECT_FALSE(builder.getDataField<bool>(127 * ELEMENTS)); { StructBuilder subStruct = builder.getPointerField(0 * POINTERS).getStruct( StructSize(1 * WORDS, 0 * POINTERS), SUBSTRUCT_DEFAULT.words); EXPECT_EQ(123u, subStruct.getDataField<uint32_t>(0 * ELEMENTS)); } { ListBuilder list = builder.getPointerField(1 * POINTERS) .getList(ElementSize::FOUR_BYTES, nullptr); ASSERT_EQ(3 * ELEMENTS, list.size()); EXPECT_EQ(200, list.getDataElement<int32_t>(0 * ELEMENTS)); EXPECT_EQ(201, list.getDataElement<int32_t>(1 * ELEMENTS)); EXPECT_EQ(202, list.getDataElement<int32_t>(2 * ELEMENTS)); } { ListBuilder list = builder.getPointerField(2 * POINTERS) .getStructList(STRUCTLIST_ELEMENT_SIZE, nullptr); ASSERT_EQ(4 * ELEMENTS, list.size()); for (int i = 0; i < 4; i++) { StructBuilder element = list.getStructElement(i * ELEMENTS); EXPECT_EQ(300 + i, element.getDataField<int32_t>(0 * ELEMENTS)); EXPECT_EQ(400 + i, element.getPointerField(0 * POINTERS) .getStruct(StructSize(1 * WORDS, 0 * POINTERS), STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT.words) .getDataField<int32_t>(0 * ELEMENTS)); } } { ListBuilder list = builder.getPointerField(3 * POINTERS).getList(ElementSize::POINTER, nullptr); ASSERT_EQ(5 * ELEMENTS, list.size()); for (uint i = 0; i < 5; i++) { ListBuilder element = list.getPointerElement(i * ELEMENTS) .getList(ElementSize::TWO_BYTES, nullptr); ASSERT_EQ((i + 1) * ELEMENTS, element.size()); for (uint j = 0; j <= i; j++) { EXPECT_EQ(500u + j, element.getDataElement<uint16_t>(j * ELEMENTS)); } } } } static void checkStruct(StructReader reader) { EXPECT_EQ(0x1011121314151617ull, reader.getDataField<uint64_t>(0 * ELEMENTS)); EXPECT_EQ(0x20212223u, reader.getDataField<uint32_t>(2 * ELEMENTS)); EXPECT_EQ(0x3031u, reader.getDataField<uint16_t>(6 * ELEMENTS)); EXPECT_EQ(0x40u, reader.getDataField<uint8_t>(14 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(120 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(121 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>(122 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(123 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>(124 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>(125 * ELEMENTS)); EXPECT_TRUE (reader.getDataField<bool>(126 * ELEMENTS)); EXPECT_FALSE(reader.getDataField<bool>(127 * ELEMENTS)); { StructReader subStruct = reader.getPointerField(0 * POINTERS) .getStruct(SUBSTRUCT_DEFAULT.words); EXPECT_EQ(123u, subStruct.getDataField<uint32_t>(0 * ELEMENTS)); } { ListReader list = reader.getPointerField(1 * POINTERS).getList(ElementSize::FOUR_BYTES, nullptr); ASSERT_EQ(3 * ELEMENTS, list.size()); EXPECT_EQ(200, list.getDataElement<int32_t>(0 * ELEMENTS)); EXPECT_EQ(201, list.getDataElement<int32_t>(1 * ELEMENTS)); EXPECT_EQ(202, list.getDataElement<int32_t>(2 * ELEMENTS)); } { ListReader list = reader.getPointerField(2 * POINTERS) .getList(ElementSize::INLINE_COMPOSITE, nullptr); ASSERT_EQ(4 * ELEMENTS, list.size()); for (int i = 0; i < 4; i++) { StructReader element = list.getStructElement(i * ELEMENTS); EXPECT_EQ(300 + i, element.getDataField<int32_t>(0 * ELEMENTS)); EXPECT_EQ(400 + i, element.getPointerField(0 * POINTERS) .getStruct(STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT.words) .getDataField<int32_t>(0 * ELEMENTS)); } } { ListReader list = reader.getPointerField(3 * POINTERS).getList(ElementSize::POINTER, nullptr); ASSERT_EQ(5 * ELEMENTS, list.size()); for (uint i = 0; i < 5; i++) { ListReader element = list.getPointerElement(i * ELEMENTS) .getList(ElementSize::TWO_BYTES, nullptr); ASSERT_EQ((i + 1) * ELEMENTS, element.size()); for (uint j = 0; j <= i; j++) { EXPECT_EQ(500u + j, element.getDataElement<uint16_t>(j * ELEMENTS)); } } } } TEST(WireFormat, StructRoundTrip_OneSegment) { MallocMessageBuilder message; BuilderArena arena(&message); auto allocation = arena.allocate(1 * WORDS); SegmentBuilder* segment = allocation.segment; word* rootLocation = allocation.words; StructBuilder builder = PointerBuilder::getRoot(segment, nullptr, rootLocation) .initStruct(StructSize(2 * WORDS, 4 * POINTERS)); setupStruct(builder); // word count: // 1 root pointer // 6 root struct // 1 sub message // 2 3-element int32 list // 13 struct list // 1 tag // 12 4x struct // 1 data section // 1 pointer section // 1 sub-struct // 11 list list // 5 pointers to sub-lists // 6 sub-lists (4x 1 word, 1x 2 words) // ----- // 34 kj::ArrayPtr<const kj::ArrayPtr<const word>> segments = arena.getSegmentsForOutput(); ASSERT_EQ(1u, segments.size()); EXPECT_EQ(34u, segments[0].size()); checkStruct(builder); checkStruct(builder.asReader()); checkStruct(PointerReader::getRootUnchecked(segment->getStartPtr()).getStruct(nullptr)); checkStruct(PointerReader::getRoot(segment, nullptr, segment->getStartPtr(), 4) .getStruct(nullptr)); } TEST(WireFormat, StructRoundTrip_OneSegmentPerAllocation) { MallocMessageBuilder message(0, AllocationStrategy::FIXED_SIZE); BuilderArena arena(&message); auto allocation = arena.allocate(1 * WORDS); SegmentBuilder* segment = allocation.segment; word* rootLocation = allocation.words; StructBuilder builder = PointerBuilder::getRoot(segment, nullptr, rootLocation) .initStruct(StructSize(2 * WORDS, 4 * POINTERS)); setupStruct(builder); // Verify that we made 15 segments. kj::ArrayPtr<const kj::ArrayPtr<const word>> segments = arena.getSegmentsForOutput(); ASSERT_EQ(15u, segments.size()); // Check that each segment has the expected size. Recall that the first word of each segment will // actually be a pointer to the first thing allocated within that segment. EXPECT_EQ( 1u, segments[ 0].size()); // root ref EXPECT_EQ( 7u, segments[ 1].size()); // root struct EXPECT_EQ( 2u, segments[ 2].size()); // sub-struct EXPECT_EQ( 3u, segments[ 3].size()); // 3-element int32 list EXPECT_EQ(10u, segments[ 4].size()); // struct list EXPECT_EQ( 2u, segments[ 5].size()); // struct list substruct 1 EXPECT_EQ( 2u, segments[ 6].size()); // struct list substruct 2 EXPECT_EQ( 2u, segments[ 7].size()); // struct list substruct 3 EXPECT_EQ( 2u, segments[ 8].size()); // struct list substruct 4 EXPECT_EQ( 6u, segments[ 9].size()); // list list EXPECT_EQ( 2u, segments[10].size()); // list list sublist 1 EXPECT_EQ( 2u, segments[11].size()); // list list sublist 2 EXPECT_EQ( 2u, segments[12].size()); // list list sublist 3 EXPECT_EQ( 2u, segments[13].size()); // list list sublist 4 EXPECT_EQ( 3u, segments[14].size()); // list list sublist 5 checkStruct(builder); checkStruct(builder.asReader()); checkStruct(PointerReader::getRoot(segment, nullptr, segment->getStartPtr(), 4) .getStruct(nullptr)); } TEST(WireFormat, StructRoundTrip_MultipleSegmentsWithMultipleAllocations) { MallocMessageBuilder message(8, AllocationStrategy::FIXED_SIZE); BuilderArena arena(&message); auto allocation = arena.allocate(1 * WORDS); SegmentBuilder* segment = allocation.segment; word* rootLocation = allocation.words; StructBuilder builder = PointerBuilder::getRoot(segment, nullptr, rootLocation) .initStruct(StructSize(2 * WORDS, 4 * POINTERS)); setupStruct(builder); // Verify that we made 6 segments. kj::ArrayPtr<const kj::ArrayPtr<const word>> segments = arena.getSegmentsForOutput(); ASSERT_EQ(6u, segments.size()); // Check that each segment has the expected size. Recall that each object will be prefixed by an // extra word if its parent is in a different segment. EXPECT_EQ( 8u, segments[0].size()); // root ref + struct + sub EXPECT_EQ( 3u, segments[1].size()); // 3-element int32 list EXPECT_EQ(10u, segments[2].size()); // struct list EXPECT_EQ( 8u, segments[3].size()); // struct list substructs EXPECT_EQ( 8u, segments[4].size()); // list list + sublist 1,2 EXPECT_EQ( 7u, segments[5].size()); // list list sublist 3,4,5 checkStruct(builder); checkStruct(builder.asReader()); checkStruct(PointerReader::getRoot(segment, nullptr, segment->getStartPtr(), 4) .getStruct(nullptr)); } inline bool isNan(float f) { return f != f; } inline bool isNan(double f) { return f != f; } TEST(WireFormat, NanPatching) { EXPECT_EQ(0x7fc00000u, mask(kj::nan(), 0)); EXPECT_TRUE(isNan(unmask<float>(0x7fc00000u, 0))); EXPECT_TRUE(isNan(unmask<float>(0x7fc00001u, 0))); EXPECT_TRUE(isNan(unmask<float>(0x7fc00005u, 0))); EXPECT_EQ(0x7fc00000u, mask(unmask<float>(0x7fc00000u, 0), 0)); EXPECT_EQ(0x7ff8000000000000ull, mask((double)kj::nan(), 0)); EXPECT_TRUE(isNan(unmask<double>(0x7ff8000000000000ull, 0))); EXPECT_TRUE(isNan(unmask<double>(0x7ff8000000000001ull, 0))); EXPECT_TRUE(isNan(unmask<double>(0x7ff8000000000005ull, 0))); EXPECT_EQ(0x7ff8000000000000ull, mask(unmask<double>(0x7ff8000000000000ull, 0), 0)); } } // namespace } // namespace _ (private) } // namespace capnp