layout-test.c++ 17 KB
Newer Older
Kenton Varda's avatar
Kenton Varda committed
1 2
// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
// Licensed under the MIT License:
3
//
Kenton Varda's avatar
Kenton Varda committed
4 5 6 7 8 9
// 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:
10
//
Kenton Varda's avatar
Kenton Varda committed
11 12
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
13
//
Kenton Varda's avatar
Kenton Varda committed
14 15 16 17 18 19 20
// 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.
21

Kenton Varda's avatar
Kenton Varda committed
22
#define CAPNP_PRIVATE
23
#include "layout.h"
Kenton Varda's avatar
Kenton Varda committed
24
#include "message.h"
25
#include "arena.h"
26
#include <kj/compat/gtest.h>
27

28 29
#if CAPNP_DEBUG_TYPES
namespace kj {
Kenton Varda's avatar
Kenton Varda committed
30
  template <typename T, typename U>
31 32
  String KJ_STRINGIFY(kj::Quantity<T, U> value) {
    return kj::str(value / kj::unit<kj::Quantity<T, U>>());
Kenton Varda's avatar
Kenton Varda committed
33 34
  }
}
35
#endif
Kenton Varda's avatar
Kenton Varda committed
36

37
namespace capnp {
38
namespace _ {  // private
39 40
namespace {

Kenton Varda's avatar
Kenton Varda committed
41 42
TEST(WireFormat, SimpleRawDataStruct) {
  AlignedData<2> data = {{
43
    // Struct ref, offset = 1, dataSize = 1, pointerCount = 0
44
    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
45
    // Content for the data section.
Kenton Varda's avatar
Kenton Varda committed
46 47
    0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef
  }};
48

Kenton Varda's avatar
Kenton Varda committed
49
  StructReader reader = PointerReader::getRootUnchecked(data.words).getStruct(nullptr);
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

  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));
65 66 67 68 69
  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
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
  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));

91 92
  EXPECT_TRUE (reader.getDataField<bool>(0 * ELEMENTS, false));
  EXPECT_FALSE(reader.getDataField<bool>(1 * ELEMENTS, false));
Kenton Varda's avatar
Kenton Varda committed
93
  EXPECT_TRUE (reader.getDataField<bool>(63 * ELEMENTS, false));
94
  EXPECT_FALSE(reader.getDataField<bool>(64 * ELEMENTS, false));
95 96 97 98
  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));
99 100
}

101
static const AlignedData<2> SUBSTRUCT_DEFAULT = {{0,0,0,0,1,0,0,0,  0,0,0,0,0,0,0,0}};
102
static const AlignedData<2> STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT =
103
    {{0,0,0,0,1,0,0,0,  0,0,0,0,0,0,0,0}};
104

105
static constexpr StructSize STRUCTLIST_ELEMENT_SIZE(1 * WORDS, 1 * POINTERS);
106

Kenton Varda's avatar
Kenton Varda committed
107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
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);

  {
122
    StructBuilder subStruct = builder.getPointerField(0 * POINTERS).initStruct(
123
        StructSize(1 * WORDS, 0 * POINTERS));
Kenton Varda's avatar
Kenton Varda committed
124 125 126 127
    subStruct.setDataField<uint32_t>(0 * ELEMENTS, 123);
  }

  {
128
    ListBuilder list = builder.getPointerField(1 * POINTERS)
129
        .initList(ElementSize::FOUR_BYTES, 3 * ELEMENTS);
Kenton Varda's avatar
Kenton Varda committed
130 131 132 133 134 135 136
    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);
  }

  {
137 138
    ListBuilder list = builder.getPointerField(2 * POINTERS).initStructList(
        4 * ELEMENTS, STRUCTLIST_ELEMENT_SIZE);
Kenton Varda's avatar
Kenton Varda committed
139 140
    EXPECT_EQ(4 * ELEMENTS, list.size());
    for (int i = 0; i < 4; i++) {
Kenton Varda's avatar
Kenton Varda committed
141
      StructBuilder element = list.getStructElement(i * ELEMENTS);
Kenton Varda's avatar
Kenton Varda committed
142
      element.setDataField<int32_t>(0 * ELEMENTS, 300 + i);
143
      element.getPointerField(0 * POINTERS)
144
             .initStruct(StructSize(1 * WORDS, 0 * POINTERS))
Kenton Varda's avatar
Kenton Varda committed
145 146 147 148 149
             .setDataField<int32_t>(0 * ELEMENTS, 400 + i);
    }
  }

  {
150
    ListBuilder list = builder.getPointerField(3 * POINTERS)
151
                              .initList(ElementSize::POINTER, 5 * ELEMENTS);
Kenton Varda's avatar
Kenton Varda committed
152 153
    EXPECT_EQ(5 * ELEMENTS, list.size());
    for (uint i = 0; i < 5; i++) {
154
      ListBuilder element = list.getPointerElement(i * ELEMENTS)
155
                                .initList(ElementSize::TWO_BYTES, (i + 1) * ELEMENTS);
Kenton Varda's avatar
Kenton Varda committed
156 157 158 159 160 161 162 163
      EXPECT_EQ((i + 1) * ELEMENTS, element.size());
      for (uint j = 0; j <= i; j++) {
        element.setDataElement<uint16_t>(j * ELEMENTS, 500 + j);
      }
    }
  }
}

164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
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));

  {
179
    StructBuilder subStruct = builder.getPointerField(0 * POINTERS).getStruct(
180
        StructSize(1 * WORDS, 0 * POINTERS), SUBSTRUCT_DEFAULT.words);
181 182 183 184
    EXPECT_EQ(123u, subStruct.getDataField<uint32_t>(0 * ELEMENTS));
  }

  {
185
    ListBuilder list = builder.getPointerField(1 * POINTERS)
186
                              .getList(ElementSize::FOUR_BYTES, nullptr);
187 188 189 190 191 192 193
    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));
  }

  {
194 195
    ListBuilder list = builder.getPointerField(2 * POINTERS)
                              .getStructList(STRUCTLIST_ELEMENT_SIZE, nullptr);
196 197
    ASSERT_EQ(4 * ELEMENTS, list.size());
    for (int i = 0; i < 4; i++) {
Kenton Varda's avatar
Kenton Varda committed
198
      StructBuilder element = list.getStructElement(i * ELEMENTS);
199 200
      EXPECT_EQ(300 + i, element.getDataField<int32_t>(0 * ELEMENTS));
      EXPECT_EQ(400 + i,
201
          element.getPointerField(0 * POINTERS)
202
                 .getStruct(StructSize(1 * WORDS, 0 * POINTERS),
203 204
                            STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT.words)
                 .getDataField<int32_t>(0 * ELEMENTS));
205 206 207 208
    }
  }

  {
209
    ListBuilder list = builder.getPointerField(3 * POINTERS).getList(ElementSize::POINTER, nullptr);
210 211
    ASSERT_EQ(5 * ELEMENTS, list.size());
    for (uint i = 0; i < 5; i++) {
212
      ListBuilder element = list.getPointerElement(i * ELEMENTS)
213
                                .getList(ElementSize::TWO_BYTES, nullptr);
214 215 216 217 218 219 220 221
      ASSERT_EQ((i + 1) * ELEMENTS, element.size());
      for (uint j = 0; j <= i; j++) {
        EXPECT_EQ(500u + j, element.getDataElement<uint16_t>(j * ELEMENTS));
      }
    }
  }
}

Kenton Varda's avatar
Kenton Varda committed
222
static void checkStruct(StructReader reader) {
223 224 225 226 227 228 229 230 231 232 233 234
  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));
Kenton Varda's avatar
Kenton Varda committed
235 236

  {
237 238
    StructReader subStruct = reader.getPointerField(0 * POINTERS)
                                   .getStruct(SUBSTRUCT_DEFAULT.words);
239
    EXPECT_EQ(123u, subStruct.getDataField<uint32_t>(0 * ELEMENTS));
Kenton Varda's avatar
Kenton Varda committed
240 241 242
  }

  {
243
    ListReader list = reader.getPointerField(1 * POINTERS).getList(ElementSize::FOUR_BYTES, nullptr);
Kenton Varda's avatar
Kenton Varda committed
244 245 246 247 248 249 250
    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));
  }

  {
251
    ListReader list = reader.getPointerField(2 * POINTERS)
252
                            .getList(ElementSize::INLINE_COMPOSITE, nullptr);
Kenton Varda's avatar
Kenton Varda committed
253 254
    ASSERT_EQ(4 * ELEMENTS, list.size());
    for (int i = 0; i < 4; i++) {
255 256
      StructReader element = list.getStructElement(i * ELEMENTS);
      EXPECT_EQ(300 + i, element.getDataField<int32_t>(0 * ELEMENTS));
Kenton Varda's avatar
Kenton Varda committed
257
      EXPECT_EQ(400 + i,
258 259 260
          element.getPointerField(0 * POINTERS)
                 .getStruct(STRUCTLIST_ELEMENT_SUBSTRUCT_DEFAULT.words)
                 .getDataField<int32_t>(0 * ELEMENTS));
Kenton Varda's avatar
Kenton Varda committed
261 262 263 264
    }
  }

  {
265
    ListReader list = reader.getPointerField(3 * POINTERS).getList(ElementSize::POINTER, nullptr);
Kenton Varda's avatar
Kenton Varda committed
266 267
    ASSERT_EQ(5 * ELEMENTS, list.size());
    for (uint i = 0; i < 5; i++) {
268
      ListReader element = list.getPointerElement(i * ELEMENTS)
269
                               .getList(ElementSize::TWO_BYTES, nullptr);
Kenton Varda's avatar
Kenton Varda committed
270 271 272 273 274 275 276 277
      ASSERT_EQ((i + 1) * ELEMENTS, element.size());
      for (uint j = 0; j <= i; j++) {
        EXPECT_EQ(500u + j, element.getDataElement<uint16_t>(j * ELEMENTS));
      }
    }
  }
}

278
TEST(WireFormat, StructRoundTrip_OneSegment) {
279
  MallocMessageBuilder message;
280
  BuilderArena arena(&message);
281 282 283
  auto allocation = arena.allocate(1 * WORDS);
  SegmentBuilder* segment = allocation.segment;
  word* rootLocation = allocation.words;
Kenton Varda's avatar
Kenton Varda committed
284

Kenton Varda's avatar
Kenton Varda committed
285
  StructBuilder builder = PointerBuilder::getRoot(segment, rootLocation)
286
      .initStruct(StructSize(2 * WORDS, 4 * POINTERS));
Kenton Varda's avatar
Kenton Varda committed
287 288 289
  setupStruct(builder);

  // word count:
290
  //    1  root pointer
Kenton Varda's avatar
Kenton Varda committed
291 292 293 294 295 296
  //    6  root struct
  //    1  sub message
  //    2  3-element int32 list
  //   13  struct list
  //         1 tag
  //        12 4x struct
297 298
  //           1 data section
  //           1 pointer section
Kenton Varda's avatar
Kenton Varda committed
299 300
  //           1 sub-struct
  //   11  list list
301
  //         5 pointers to sub-lists
Kenton Varda's avatar
Kenton Varda committed
302 303 304
  //         6 sub-lists (4x 1 word, 1x 2 words)
  // -----
  //   34
305
  kj::ArrayPtr<const kj::ArrayPtr<const word>> segments = arena.getSegmentsForOutput();
306 307
  ASSERT_EQ(1u, segments.size());
  EXPECT_EQ(34u, segments[0].size());
Kenton Varda's avatar
Kenton Varda committed
308

309
  checkStruct(builder);
Kenton Varda's avatar
Kenton Varda committed
310
  checkStruct(builder.asReader());
Kenton Varda's avatar
Kenton Varda committed
311 312
  checkStruct(PointerReader::getRootUnchecked(segment->getStartPtr()).getStruct(nullptr));
  checkStruct(PointerReader::getRoot(segment, segment->getStartPtr(), 4).getStruct(nullptr));
Kenton Varda's avatar
Kenton Varda committed
313 314
}

315
TEST(WireFormat, StructRoundTrip_OneSegmentPerAllocation) {
316
  MallocMessageBuilder message(0, AllocationStrategy::FIXED_SIZE);
317
  BuilderArena arena(&message);
318 319 320
  auto allocation = arena.allocate(1 * WORDS);
  SegmentBuilder* segment = allocation.segment;
  word* rootLocation = allocation.words;
Kenton Varda's avatar
Kenton Varda committed
321

Kenton Varda's avatar
Kenton Varda committed
322
  StructBuilder builder = PointerBuilder::getRoot(segment, rootLocation)
323
      .initStruct(StructSize(2 * WORDS, 4 * POINTERS));
Kenton Varda's avatar
Kenton Varda committed
324 325
  setupStruct(builder);

Kenton Varda's avatar
Kenton Varda committed
326
  // Verify that we made 15 segments.
327
  kj::ArrayPtr<const kj::ArrayPtr<const word>> segments = arena.getSegmentsForOutput();
328
  ASSERT_EQ(15u, segments.size());
Kenton Varda's avatar
Kenton Varda committed
329

Kenton Varda's avatar
Kenton Varda committed
330
  // Check that each segment has the expected size.  Recall that the first word of each segment will
331
  // actually be a pointer to the first thing allocated within that segment.
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
  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
Kenton Varda's avatar
Kenton Varda committed
347

348
  checkStruct(builder);
Kenton Varda's avatar
Kenton Varda committed
349
  checkStruct(builder.asReader());
Kenton Varda's avatar
Kenton Varda committed
350
  checkStruct(PointerReader::getRoot(segment, segment->getStartPtr(), 4).getStruct(nullptr));
351 352 353
}

TEST(WireFormat, StructRoundTrip_MultipleSegmentsWithMultipleAllocations) {
354
  MallocMessageBuilder message(8, AllocationStrategy::FIXED_SIZE);
355
  BuilderArena arena(&message);
356 357 358
  auto allocation = arena.allocate(1 * WORDS);
  SegmentBuilder* segment = allocation.segment;
  word* rootLocation = allocation.words;
359

Kenton Varda's avatar
Kenton Varda committed
360
  StructBuilder builder = PointerBuilder::getRoot(segment, rootLocation)
361
      .initStruct(StructSize(2 * WORDS, 4 * POINTERS));
362 363 364
  setupStruct(builder);

  // Verify that we made 6 segments.
365
  kj::ArrayPtr<const kj::ArrayPtr<const word>> segments = arena.getSegmentsForOutput();
366
  ASSERT_EQ(6u, segments.size());
367 368 369

  // 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.
370 371 372 373 374 375
  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
376 377 378

  checkStruct(builder);
  checkStruct(builder.asReader());
Kenton Varda's avatar
Kenton Varda committed
379
  checkStruct(PointerReader::getRoot(segment, segment->getStartPtr(), 4).getStruct(nullptr));
Kenton Varda's avatar
Kenton Varda committed
380 381
}

382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
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));
}

398
}  // namespace
399
}  // namespace _ (private)
400
}  // namespace capnp