any-test.c++ 15.4 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

22
#include "any.h"
23
#include "message.h"
24
#include <kj/compat/gtest.h>
25 26 27 28 29 30
#include "test-util.h"

namespace capnp {
namespace _ {  // private
namespace {

31
TEST(Any, AnyPointer) {
32
  MallocMessageBuilder builder;
33
  auto root = builder.getRoot<test::TestAnyPointer>();
34

35 36 37
  initTestMessage(root.getAnyPointerField().initAs<TestAllTypes>());
  checkTestMessage(root.getAnyPointerField().getAs<TestAllTypes>());
  checkTestMessage(root.asReader().getAnyPointerField().getAs<TestAllTypes>());
38

39 40 41
  root.getAnyPointerField().setAs<Text>("foo");
  EXPECT_EQ("foo", root.getAnyPointerField().getAs<Text>());
  EXPECT_EQ("foo", root.asReader().getAnyPointerField().getAs<Text>());
42

43 44 45
  root.getAnyPointerField().setAs<Data>(data("foo"));
  EXPECT_EQ(data("foo"), root.getAnyPointerField().getAs<Data>());
  EXPECT_EQ(data("foo"), root.asReader().getAnyPointerField().getAs<Data>());
46 47

  {
48
    root.getAnyPointerField().setAs<List<uint32_t>>({123, 456, 789});
49 50

    {
51
      List<uint32_t>::Builder list = root.getAnyPointerField().getAs<List<uint32_t>>();
52 53 54 55 56 57 58
      ASSERT_EQ(3u, list.size());
      EXPECT_EQ(123u, list[0]);
      EXPECT_EQ(456u, list[1]);
      EXPECT_EQ(789u, list[2]);
    }

    {
59
      List<uint32_t>::Reader list = root.asReader().getAnyPointerField().getAs<List<uint32_t>>();
60 61 62 63 64 65 66 67
      ASSERT_EQ(3u, list.size());
      EXPECT_EQ(123u, list[0]);
      EXPECT_EQ(456u, list[1]);
      EXPECT_EQ(789u, list[2]);
    }
  }

  {
68
    root.getAnyPointerField().setAs<List<Text>>({"foo", "bar"});
69 70

    {
71
      List<Text>::Builder list = root.getAnyPointerField().getAs<List<Text>>();
72 73 74 75 76 77
      ASSERT_EQ(2u, list.size());
      EXPECT_EQ("foo", list[0]);
      EXPECT_EQ("bar", list[1]);
    }

    {
78
      List<Text>::Reader list = root.asReader().getAnyPointerField().getAs<List<Text>>();
79 80 81 82 83 84 85 86
      ASSERT_EQ(2u, list.size());
      EXPECT_EQ("foo", list[0]);
      EXPECT_EQ("bar", list[1]);
    }
  }

  {
    {
87
      List<TestAllTypes>::Builder list = root.getAnyPointerField().initAs<List<TestAllTypes>>(2);
88 89 90 91 92
      ASSERT_EQ(2u, list.size());
      initTestMessage(list[0]);
    }

    {
93
      List<TestAllTypes>::Builder list = root.getAnyPointerField().getAs<List<TestAllTypes>>();
94 95 96 97 98 99
      ASSERT_EQ(2u, list.size());
      checkTestMessage(list[0]);
      checkTestMessageAllZero(list[1]);
    }

    {
100 101
      List<TestAllTypes>::Reader list =
          root.asReader().getAnyPointerField().getAs<List<TestAllTypes>>();
102 103 104 105 106 107 108
      ASSERT_EQ(2u, list.size());
      checkTestMessage(list[0]);
      checkTestMessageAllZero(list[1]);
    }
  }
}

109 110 111 112 113 114 115 116
TEST(Any, AnyStruct) {
  MallocMessageBuilder builder;
  auto root = builder.getRoot<test::TestAnyPointer>();

  initTestMessage(root.getAnyPointerField().initAs<TestAllTypes>());
  checkTestMessage(root.getAnyPointerField().getAs<TestAllTypes>());
  checkTestMessage(root.asReader().getAnyPointerField().getAs<TestAllTypes>());

117 118 119 120 121
  auto allTypes = root.getAnyPointerField().getAs<AnyStruct>().as<TestAllTypes>();
  auto allTypesReader = root.getAnyPointerField().getAs<AnyStruct>().asReader().as<TestAllTypes>();
  allTypes.setInt32Field(100);
  EXPECT_EQ(100, allTypes.getInt32Field());
  EXPECT_EQ(100, allTypesReader.getInt32Field());
122

123 124 125 126 127 128 129 130 131 132
  EXPECT_EQ(48, root.getAnyPointerField().getAs<AnyStruct>().getDataSection().size());
  EXPECT_EQ(20, root.getAnyPointerField().getAs<AnyStruct>().getPointerSection().size());

  EXPECT_EQ(48, root.getAnyPointerField().asReader().getAs<AnyStruct>().getDataSection().size());
  EXPECT_EQ(20, root.getAnyPointerField().asReader().getAs<AnyStruct>().getPointerSection().size());

  auto b = toAny(root.getAnyPointerField().getAs<TestAllTypes>());
  EXPECT_EQ(48, b.getDataSection().size());
  EXPECT_EQ(20, b.getPointerSection().size());

133
#if !_MSC_VER  // TODO(msvc): ICE on the necessary constructor; see any.h.
134 135 136
  b = root.getAnyPointerField().getAs<TestAllTypes>();
  EXPECT_EQ(48, b.getDataSection().size());
  EXPECT_EQ(20, b.getPointerSection().size());
137
#endif
138

139 140 141 142 143 144 145 146
  auto r = toAny(root.getAnyPointerField().getAs<TestAllTypes>().asReader());
  EXPECT_EQ(48, r.getDataSection().size());
  EXPECT_EQ(20, r.getPointerSection().size());

  r = toAny(root.getAnyPointerField().getAs<TestAllTypes>()).asReader();
  EXPECT_EQ(48, r.getDataSection().size());
  EXPECT_EQ(20, r.getPointerSection().size());

147
#if !_MSC_VER  // TODO(msvc): ICE on the necessary constructor; see any.h.
148 149 150
  r = root.getAnyPointerField().getAs<TestAllTypes>().asReader();
  EXPECT_EQ(48, r.getDataSection().size());
  EXPECT_EQ(20, r.getPointerSection().size());
151
#endif
152

153 154 155
  {
    MallocMessageBuilder b2;
    auto root2 = b2.getRoot<test::TestAnyPointer>();
156 157
    auto sb = root2.getAnyPointerField().initAsAnyStruct(
        r.getDataSection().size() / 8, r.getPointerSection().size());
158 159 160 161 162 163 164

    EXPECT_EQ(48, sb.getDataSection().size());
    EXPECT_EQ(20, sb.getPointerSection().size());

    // TODO: is there a higher-level API for this?
    memcpy(sb.getDataSection().begin(), r.getDataSection().begin(), r.getDataSection().size());
  }
165 166 167 168 169 170 171 172 173 174 175 176 177 178

  {
    auto ptrs = r.getPointerSection();
    EXPECT_EQ("foo", ptrs[0].getAs<Text>());
    EXPECT_EQ("bar", kj::heapString(ptrs[1].getAs<Data>().asChars()));
    EXPECT_EQ("xyzzy", ptrs[15].getAs<List<Text>>()[1]);
  }

  {
    auto ptrs = b.getPointerSection();
    EXPECT_EQ("foo", ptrs[0].getAs<Text>());
    EXPECT_EQ("bar", kj::heapString(ptrs[1].getAs<Data>().asChars()));
    EXPECT_EQ("xyzzy", ptrs[15].getAs<List<Text>>()[1]);
  }
179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
}

TEST(Any, AnyList) {
  MallocMessageBuilder builder;
  auto root = builder.getRoot<test::TestAnyPointer>();
  List<TestAllTypes>::Builder b = root.getAnyPointerField().initAs<List<TestAllTypes>>(2);
  initTestMessage(b[0]);

  auto ptr = root.getAnyPointerField().getAs<AnyList>();

  EXPECT_EQ(2, ptr.size());
  EXPECT_EQ(48, ptr.as<List<AnyStruct>>()[0].getDataSection().size());
  EXPECT_EQ(20, ptr.as<List<AnyStruct>>()[0].getPointerSection().size());

  auto readPtr = root.getAnyPointerField().asReader().getAs<AnyList>();

  EXPECT_EQ(2, readPtr.size());
  EXPECT_EQ(48, readPtr.as<List<AnyStruct>>()[0].getDataSection().size());
  EXPECT_EQ(20, readPtr.as<List<AnyStruct>>()[0].getPointerSection().size());

  auto alb = toAny(root.getAnyPointerField().getAs<List<TestAllTypes>>());
  EXPECT_EQ(2, alb.size());
  EXPECT_EQ(48, alb.as<List<AnyStruct>>()[0].getDataSection().size());
  EXPECT_EQ(20, alb.as<List<AnyStruct>>()[0].getPointerSection().size());

204
#if !_MSC_VER  // TODO(msvc): ICE on the necessary constructor; see any.h.
205 206 207 208
  alb = root.getAnyPointerField().getAs<List<TestAllTypes>>();
  EXPECT_EQ(2, alb.size());
  EXPECT_EQ(48, alb.as<List<AnyStruct>>()[0].getDataSection().size());
  EXPECT_EQ(20, alb.as<List<AnyStruct>>()[0].getPointerSection().size());
209
#endif
210

211 212 213 214 215 216 217 218 219 220
  auto alr = toAny(root.getAnyPointerField().getAs<List<TestAllTypes>>().asReader());
  EXPECT_EQ(2, alr.size());
  EXPECT_EQ(48, alr.as<List<AnyStruct>>()[0].getDataSection().size());
  EXPECT_EQ(20, alr.as<List<AnyStruct>>()[0].getPointerSection().size());

  alr = toAny(root.getAnyPointerField().getAs<List<TestAllTypes>>()).asReader();
  EXPECT_EQ(2, alr.size());
  EXPECT_EQ(48, alr.as<List<AnyStruct>>()[0].getDataSection().size());
  EXPECT_EQ(20, alr.as<List<AnyStruct>>()[0].getPointerSection().size());

221
#if !_MSC_VER  // TODO(msvc): ICE on the necessary constructor; see any.h.
222 223 224 225
  alr = root.getAnyPointerField().getAs<List<TestAllTypes>>().asReader();
  EXPECT_EQ(2, alr.size());
  EXPECT_EQ(48, alr.as<List<AnyStruct>>()[0].getDataSection().size());
  EXPECT_EQ(20, alr.as<List<AnyStruct>>()[0].getPointerSection().size());
226
#endif
227 228
}

229 230 231 232
TEST(Any, AnyStructListCapInSchema) {
  MallocMessageBuilder builder;
  auto root = builder.getRoot<test::TestAnyOthers>();

233 234 235 236 237
  {
    initTestMessage(root.initAnyStructFieldAs<TestAllTypes>());
    AnyStruct::Builder anyStruct = root.getAnyStructField();
    checkTestMessage(anyStruct.as<TestAllTypes>());
    checkTestMessage(anyStruct.asReader().as<TestAllTypes>());
238 239 240 241 242 243 244 245 246

    EXPECT_TRUE(root.hasAnyStructField());
    auto orphan = root.disownAnyStructField();
    checkTestMessage(orphan.getReader().as<TestAllTypes>());
    EXPECT_FALSE(root.hasAnyStructField());

    root.adoptAnyStructField(kj::mv(orphan));
    EXPECT_TRUE(root.hasAnyStructField());
    checkTestMessage(root.getAnyStructField().as<TestAllTypes>());
247 248 249 250 251 252 253 254 255 256
  }

  {
    List<int>::Builder list = root.initAnyListFieldAs<List<int>>(3);
    list.set(0, 123);
    list.set(1, 456);
    list.set(2, 789);

    AnyList::Builder anyList = root.getAnyListField();
    checkList(anyList.as<List<int>>(), {123, 456, 789});
257 258 259 260 261 262 263 264 265

    EXPECT_TRUE(root.hasAnyListField());
    auto orphan = root.disownAnyListField();
    checkList(orphan.getReader().as<List<int>>(), {123, 456, 789});
    EXPECT_FALSE(root.hasAnyListField());

    root.adoptAnyListField(kj::mv(orphan));
    EXPECT_TRUE(root.hasAnyListField());
    checkList(root.getAnyListField().as<List<int>>(), {123, 456, 789});
266 267
  }

268
#if !CAPNP_LITE
269
  // This portion of the test relies on a Client, not present in lite-mode.
270 271 272 273 274 275 276 277 278 279 280 281
  {
    kj::EventLoop loop;
    kj::WaitScope waitScope(loop);
    int callCount = 0;
    root.setCapabilityField(kj::heap<TestInterfaceImpl>(callCount));
    Capability::Client client = root.getCapabilityField();
    auto req = client.castAs<test::TestInterface>().fooRequest();
    req.setI(123);
    req.setJ(true);
    req.send().wait(waitScope);
    EXPECT_EQ(1, callCount);
  }
282
#endif
283 284
}

285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
KJ_TEST("Builder::isStruct() does not corrupt segment pointer") {
  MallocMessageBuilder builder(1); // small first segment
  auto root = builder.getRoot<AnyPointer>();

  // Do a lot of allocations so that there is likely a segment with a decent
  // amount of free space.
  initTestMessage(root.initAs<test::TestAllTypes>());

  // This will probably get allocated in a segment that still has room for the
  // Data allocation below.
  root.initAs<test::TestAllTypes>();

  // At one point, this caused root.builder.segment to point to the segment
  // where the struct is allocated, rather than segment where the root pointer
  // lives, i.e. segment zero.
  EXPECT_TRUE(root.isStruct());

  // If root.builder.segment points to the wrong segment and that segment has free
  // space, then this triggers a DREQUIRE failure in WirePointer::setKindAndTarget().
  root.initAs<Data>(1);
}
306 307 308 309

TEST(Any, Equals) {
  MallocMessageBuilder builderA;
  auto rootA = builderA.getRoot<test::TestAllTypes>();
310
  auto anyA = builderA.getRoot<AnyPointer>();
311 312 313 314
  initTestMessage(rootA);

  MallocMessageBuilder builderB;
  auto rootB = builderB.getRoot<test::TestAllTypes>();
315
  auto anyB = builderB.getRoot<AnyPointer>();
316 317
  initTestMessage(rootB);

318
  EXPECT_EQ(Equality::EQUAL, anyA.equals(anyB));
319 320

  rootA.setBoolField(false);
321
  EXPECT_EQ(Equality::NOT_EQUAL, anyA.equals(anyB));
322 323

  rootB.setBoolField(false);
324
  EXPECT_EQ(Equality::EQUAL, anyA.equals(anyB));
325 326

  rootB.setEnumField(test::TestEnum::GARPLY);
327
  EXPECT_EQ(Equality::NOT_EQUAL, anyA.equals(anyB));
328 329

  rootA.setEnumField(test::TestEnum::GARPLY);
330
  EXPECT_EQ(Equality::EQUAL, anyA.equals(anyB));
331 332

  rootA.getStructField().setTextField("buzz");
333
  EXPECT_EQ(Equality::NOT_EQUAL, anyA.equals(anyB));
334 335

  rootB.getStructField().setTextField("buzz");
336
  EXPECT_EQ(Equality::EQUAL, anyA.equals(anyB));
337 338

  rootA.initVoidList(3);
339
  EXPECT_EQ(Equality::NOT_EQUAL, anyA.equals(anyB));
340 341

  rootB.initVoidList(3);
342
  EXPECT_EQ(Equality::EQUAL, anyA.equals(anyB));
343 344

  rootA.getBoolList().set(2, true);
345
  EXPECT_EQ(Equality::NOT_EQUAL, anyA.equals(anyB));
346 347

  rootB.getBoolList().set(2, true);
348
  EXPECT_EQ(Equality::EQUAL, anyA.equals(anyB));
349 350

  rootB.getStructList()[1].setTextField("my NEW structlist 2");
351
  EXPECT_EQ(Equality::NOT_EQUAL, anyA.equals(anyB));
352 353

  rootA.getStructList()[1].setTextField("my NEW structlist 2");
354
  EXPECT_EQ(Equality::EQUAL, anyA.equals(anyB));
355 356
}

357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379
KJ_TEST("Bit list with nonzero pad bits") {
  AlignedData<2> segment1 = {{
      0x01, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, // eleven bit-sized elements
      0xee, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // twelfth bit is set!
  }};
  kj::ArrayPtr<const word> segments1[1] = {
    kj::arrayPtr(segment1.words, 2)
  };
  SegmentArrayMessageReader message1(kj::arrayPtr(segments1, 1));

  AlignedData<2> segment2 = {{
      0x01, 0x00, 0x00, 0x00, 0x59, 0x00, 0x00, 0x00, // eleven bit-sized elements
      0xee, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // twelfth bit is not set
  }};
  kj::ArrayPtr<const word> segments2[1] = {
    kj::arrayPtr(segment2.words, 2)
  };
  SegmentArrayMessageReader message2(kj::arrayPtr(segments2, 1));

  // Should be equal, despite nonzero padding.
  KJ_ASSERT(message1.getRoot<AnyList>() == message2.getRoot<AnyList>());
}

380
KJ_TEST("Pointer list unequal to struct list") {
381
  AlignedData<1> segment1 = {{
382 383 384 385
      // list with zero pointer-sized elements
      0x01, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
  }};
  kj::ArrayPtr<const word> segments1[1] = {
386
    kj::arrayPtr(segment1.words, 1)
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404
  };
  SegmentArrayMessageReader message1(kj::arrayPtr(segments1, 1));

  AlignedData<2> segment2 = {{
      // struct list of length zero
      0x01, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,

      // struct list tag, zero elements
      0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  }};
  kj::ArrayPtr<const word> segments2[1] = {
    kj::arrayPtr(segment2.words, 2)
  };
  SegmentArrayMessageReader message2(kj::arrayPtr(segments2, 1));

  EXPECT_EQ(Equality::NOT_EQUAL, message1.getRoot<AnyList>().equals(message2.getRoot<AnyList>()));
}

405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436
KJ_TEST("Truncating non-null pointer fields does not preserve equality") {
  AlignedData<3> segment1 = {{
      // list with one data word and one pointer field
      0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00,

      // data word
      0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,

      // non-null pointer to zero-sized struct
      0xfc, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
  }};
  kj::ArrayPtr<const word> segments1[1] = {
    kj::arrayPtr(segment1.words, 3)
  };
  SegmentArrayMessageReader message1(kj::arrayPtr(segments1, 1));

  AlignedData<2> segment2 = {{
      // list with one data word and zero pointers
      0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,

      // data word
      0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab, 0xab,
  }};
  kj::ArrayPtr<const word> segments2[1] = {
    kj::arrayPtr(segment2.words, 2)
  };
  SegmentArrayMessageReader message2(kj::arrayPtr(segments2, 1));

  EXPECT_EQ(Equality::NOT_EQUAL,
            message1.getRoot<AnyPointer>().equals(message2.getRoot<AnyPointer>()));
}

437 438 439
}  // namespace
}  // namespace _ (private)
}  // namespace capnp