1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/ipc/ipdl/test/cxx/TestDataStructures.cpp Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,985 @@
1.4 +#include "TestDataStructures.h"
1.5 +
1.6 +#include "mozilla/unused.h"
1.7 +
1.8 +#include "IPDLUnitTests.h" // fail etc.
1.9 +
1.10 +typedef InfallibleTArray<nsIntRegion> RegionArray;
1.11 +
1.12 +namespace mozilla {
1.13 +namespace _ipdltest {
1.14 +
1.15 +static const uint32_t nactors = 10;
1.16 +
1.17 +#define test_assert(_cond, _msg) \
1.18 + if (!(_cond)) fail(_msg)
1.19 +
1.20 +template<typename T>
1.21 +static void
1.22 +assert_arrays_equal(const InfallibleTArray<T>& a, const InfallibleTArray<T>& b)
1.23 +{
1.24 + test_assert(a == b, "arrays equal");
1.25 +}
1.26 +
1.27 +inline static TestDataStructuresSub&
1.28 +Cast(PTestDataStructuresSubParent* a)
1.29 +{
1.30 + return *static_cast<TestDataStructuresSub*>(a);
1.31 +}
1.32 +
1.33 +inline static TestDataStructuresSub&
1.34 +Cast(PTestDataStructuresSubChild* a)
1.35 +{
1.36 + return *static_cast<TestDataStructuresSub*>(a);
1.37 +}
1.38 +
1.39 +//-----------------------------------------------------------------------------
1.40 +// parent
1.41 +
1.42 +TestDataStructuresParent::TestDataStructuresParent()
1.43 +{
1.44 + MOZ_COUNT_CTOR(TestDataStructuresParent);
1.45 +}
1.46 +
1.47 +TestDataStructuresParent::~TestDataStructuresParent()
1.48 +{
1.49 + MOZ_COUNT_DTOR(TestDataStructuresParent);
1.50 +}
1.51 +
1.52 +void
1.53 +TestDataStructuresParent::Main()
1.54 +{
1.55 + for (uint32_t i = 0; i < nactors; ++i)
1.56 + if (!SendPTestDataStructuresSubConstructor(i))
1.57 + fail("can't alloc actor");
1.58 +
1.59 + if (!SendStart())
1.60 + fail("can't send Start()");
1.61 +}
1.62 +
1.63 +bool
1.64 +TestDataStructuresParent::DeallocPTestDataStructuresSubParent(PTestDataStructuresSubParent* actor)
1.65 +{
1.66 + test_assert(Cast(actor).mI == Cast(mKids[0]).mI,
1.67 + "dtor sent to wrong actor");
1.68 + mKids.RemoveElementAt(0);
1.69 + delete actor;
1.70 + if (mKids.Length() > 0)
1.71 + return true;
1.72 +
1.73 + return true;
1.74 +}
1.75 +
1.76 +bool TestDataStructuresParent::RecvTest1(
1.77 + const InfallibleTArray<int>& ia,
1.78 + InfallibleTArray<int>* oa)
1.79 +{
1.80 + test_assert(5 == ia.Length(), "wrong length");
1.81 + for (int i = 0; i < 5; ++i)
1.82 + test_assert(i == ia[i], "wrong value");
1.83 +
1.84 + *oa = ia;
1.85 +
1.86 + return true;
1.87 +}
1.88 +
1.89 +bool TestDataStructuresParent::RecvTest2(
1.90 + const InfallibleTArray<PTestDataStructuresSubParent*>& i1,
1.91 + InfallibleTArray<PTestDataStructuresSubParent*>* o1)
1.92 +{
1.93 + test_assert(nactors == i1.Length(), "wrong #actors");
1.94 + for (uint32_t i = 0; i < i1.Length(); ++i)
1.95 + test_assert(i == Cast(i1[i]).mI, "wrong mI value");
1.96 + *o1 = i1;
1.97 + return true;
1.98 +}
1.99 +
1.100 +bool TestDataStructuresParent::RecvTest3(
1.101 + const IntDouble& i1,
1.102 + const IntDouble& i2,
1.103 + IntDouble* o1,
1.104 + IntDouble* o2)
1.105 +{
1.106 + test_assert(42 == i1.get_int(), "wrong value");
1.107 + test_assert(4.0 == i2.get_double(), "wrong value");
1.108 +
1.109 + *o1 = i1;
1.110 + *o2 = i2;
1.111 +
1.112 + return true;
1.113 +}
1.114 +
1.115 +bool TestDataStructuresParent::RecvTest4(
1.116 + const InfallibleTArray<IntDouble>& i1,
1.117 + InfallibleTArray<IntDouble>* o1)
1.118 +{
1.119 + test_assert(4 == i1.Length(), "wrong length");
1.120 + test_assert(1 == i1[0].get_int(), "wrong value");
1.121 + test_assert(2.0 == i1[1].get_double(), "wrong value");
1.122 + test_assert(3 == i1[2].get_int(), "wrong value");
1.123 + test_assert(4.0 == i1[3].get_double(), "wrong value");
1.124 +
1.125 + *o1 = i1;
1.126 +
1.127 + return true;
1.128 +}
1.129 +
1.130 +bool TestDataStructuresParent::RecvTest5(
1.131 + const IntDoubleArrays& i1,
1.132 + const IntDoubleArrays& i2,
1.133 + const IntDoubleArrays& i3,
1.134 + IntDoubleArrays* o1,
1.135 + IntDoubleArrays* o2,
1.136 + IntDoubleArrays* o3)
1.137 +{
1.138 + test_assert(42 == i1.get_int(), "wrong value");
1.139 +
1.140 + const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
1.141 + test_assert(3 == i2a.Length(), "wrong length");
1.142 + test_assert(1 == i2a[0], "wrong value");
1.143 + test_assert(2 == i2a[1], "wrong value");
1.144 + test_assert(3 == i2a[2], "wrong value");
1.145 +
1.146 + const InfallibleTArray<double>& i3a = i3.get_ArrayOfdouble();
1.147 + test_assert(3 == i3a.Length(), "wrong length");
1.148 + test_assert(1.0 == i3a[0], "wrong value");
1.149 + test_assert(2.0 == i3a[1], "wrong value");
1.150 + test_assert(3.0 == i3a[2], "wrong value");
1.151 +
1.152 + *o1 = i1;
1.153 + *o2 = i2a;
1.154 + *o3 = i3a;
1.155 +
1.156 + return true;
1.157 +}
1.158 +
1.159 +bool
1.160 +TestDataStructuresParent::RecvTest7_0(const ActorWrapper& i1,
1.161 + ActorWrapper* o1)
1.162 +{
1.163 + if (i1.actorChild() != nullptr)
1.164 + fail("child side actor should always be null");
1.165 +
1.166 + if (i1.actorParent() != mKids[0])
1.167 + fail("should have got back same actor on parent side");
1.168 +
1.169 + o1->actorParent() = mKids[0];
1.170 + // malicious behavior
1.171 + o1->actorChild() =
1.172 + reinterpret_cast<PTestDataStructuresSubChild*>(0xdeadbeef);
1.173 + return true;
1.174 +}
1.175 +
1.176 +bool TestDataStructuresParent::RecvTest6(
1.177 + const InfallibleTArray<IntDoubleArrays>& i1,
1.178 + InfallibleTArray<IntDoubleArrays>* o1)
1.179 +{
1.180 + test_assert(3 == i1.Length(), "wrong length");
1.181 +
1.182 + IntDoubleArrays id1(i1[0]);
1.183 + test_assert(42 == id1.get_int(), "wrong value");
1.184 +
1.185 + InfallibleTArray<int> i2a(i1[1].get_ArrayOfint());
1.186 + test_assert(3 == i2a.Length(), "wrong length");
1.187 + test_assert(1 == i2a[0], "wrong value");
1.188 + test_assert(2 == i2a[1], "wrong value");
1.189 + test_assert(3 == i2a[2], "wrong value");
1.190 +
1.191 + InfallibleTArray<double> i3a(i1[2].get_ArrayOfdouble());
1.192 + test_assert(3 == i3a.Length(), "wrong length");
1.193 + test_assert(1.0 == i3a[0], "wrong value");
1.194 + test_assert(2.0 == i3a[1], "wrong value");
1.195 + test_assert(3.0 == i3a[2], "wrong value");
1.196 +
1.197 + o1->AppendElement(id1);
1.198 + o1->AppendElement(IntDoubleArrays(i2a));
1.199 + o1->AppendElement(IntDoubleArrays(i3a));
1.200 +
1.201 + return true;
1.202 +}
1.203 +
1.204 +bool TestDataStructuresParent::RecvTest7(
1.205 + const Actors& i1,
1.206 + const Actors& i2,
1.207 + const Actors& i3,
1.208 + Actors* o1,
1.209 + Actors* o2,
1.210 + Actors* o3)
1.211 +{
1.212 + test_assert(42 == i1.get_int(), "wrong value");
1.213 +
1.214 + InfallibleTArray<int> i2a(i2.get_ArrayOfint());
1.215 + test_assert(3 == i2a.Length(), "wrong length");
1.216 + test_assert(1 == i2a[0], "wrong value");
1.217 + test_assert(2 == i2a[1], "wrong value");
1.218 + test_assert(3 == i2a[2], "wrong value");
1.219 +
1.220 + assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
1.221 +
1.222 + *o1 = 42;
1.223 + *o2 = i2a;
1.224 + *o3 = mKids;
1.225 +
1.226 + return true;
1.227 +}
1.228 +
1.229 +bool TestDataStructuresParent::RecvTest8(
1.230 + const InfallibleTArray<Actors>& i1,
1.231 + InfallibleTArray<Actors>* o1)
1.232 +{
1.233 + test_assert(3 == i1.Length(), "wrong length");
1.234 + test_assert(42 == i1[0].get_int(), "wrong value");
1.235 +
1.236 + const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
1.237 + test_assert(3 == i2a.Length(), "wrong length");
1.238 + test_assert(1 == i2a[0], "wrong value");
1.239 + test_assert(2 == i2a[1], "wrong value");
1.240 + test_assert(3 == i2a[2], "wrong value");
1.241 +
1.242 + assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
1.243 +
1.244 + *o1 = i1;
1.245 +
1.246 + return true;
1.247 +}
1.248 +
1.249 +bool TestDataStructuresParent::RecvTest9(
1.250 + const Unions& i1,
1.251 + const Unions& i2,
1.252 + const Unions& i3,
1.253 + const Unions& i4,
1.254 + Unions* o1,
1.255 + Unions* o2,
1.256 + Unions* o3,
1.257 + Unions* o4)
1.258 +{
1.259 + test_assert(42 == i1.get_int(), "wrong value");
1.260 +
1.261 + const InfallibleTArray<int>& i2a = i2.get_ArrayOfint();
1.262 + test_assert(3 == i2a.Length(), "wrong length");
1.263 + test_assert(1 == i2a[0], "wrong value");
1.264 + test_assert(2 == i2a[1], "wrong value");
1.265 + test_assert(3 == i2a[2], "wrong value");
1.266 +
1.267 + assert_arrays_equal(mKids, i3.get_ArrayOfPTestDataStructuresSubParent());
1.268 +
1.269 + const InfallibleTArray<PTestDataStructuresSubParent*>& i4a =
1.270 + i4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
1.271 + assert_arrays_equal(mKids, i4a);
1.272 +
1.273 + *o1 = i1;
1.274 + *o2 = i2;
1.275 + *o3 = i3;
1.276 + *o4 = i4;
1.277 +
1.278 + return true;
1.279 +}
1.280 +
1.281 +bool TestDataStructuresParent::RecvTest10(
1.282 + const InfallibleTArray<Unions>& i1,
1.283 + InfallibleTArray<Unions>* o1)
1.284 +{
1.285 + test_assert(42 == i1[0].get_int(), "wrong value");
1.286 +
1.287 + const InfallibleTArray<int>& i2a = i1[1].get_ArrayOfint();
1.288 + test_assert(3 == i2a.Length(), "wrong length");
1.289 + test_assert(1 == i2a[0], "wrong value");
1.290 + test_assert(2 == i2a[1], "wrong value");
1.291 + test_assert(3 == i2a[2], "wrong value");
1.292 +
1.293 + assert_arrays_equal(mKids, i1[2].get_ArrayOfPTestDataStructuresSubParent());
1.294 +
1.295 + const InfallibleTArray<PTestDataStructuresSubParent*>& i4a =
1.296 + i1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubParent();
1.297 + assert_arrays_equal(mKids, i4a);
1.298 +
1.299 + *o1 = i1;
1.300 +
1.301 + return true;
1.302 +}
1.303 +
1.304 +bool TestDataStructuresParent::RecvTest11(
1.305 + const SIntDouble& i,
1.306 + SIntDouble* o)
1.307 +{
1.308 + test_assert(1 == i.i(), "wrong value");
1.309 + test_assert(2.0 == i.d(), "wrong value");
1.310 + *o = i;
1.311 + return true;
1.312 +}
1.313 +
1.314 +bool TestDataStructuresParent::RecvTest12(
1.315 + const SIntDoubleArrays& i,
1.316 + SIntDoubleArrays* o)
1.317 +{
1.318 + InfallibleTArray<int> ai;
1.319 + ai.AppendElement(1);
1.320 + ai.AppendElement(2);
1.321 + ai.AppendElement(3);
1.322 +
1.323 + InfallibleTArray<double> ad;
1.324 + ad.AppendElement(.5);
1.325 + ad.AppendElement(1.0);
1.326 + ad.AppendElement(2.0);
1.327 +
1.328 + test_assert(42 == i.i(), "wrong value");
1.329 + assert_arrays_equal(ai, i.ai());
1.330 + assert_arrays_equal(ad, i.ad());
1.331 +
1.332 + *o = i;
1.333 +
1.334 + return true;
1.335 +}
1.336 +
1.337 +bool TestDataStructuresParent::RecvTest13(
1.338 + const SActors& i,
1.339 + SActors* o)
1.340 +{
1.341 + InfallibleTArray<int> ai;
1.342 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.343 +
1.344 + test_assert(42 == i.i(), "wrong value");
1.345 + assert_arrays_equal(ai, i.ai());
1.346 + assert_arrays_equal(mKids, i.apParent());
1.347 +
1.348 + *o = i;
1.349 +
1.350 + return true;
1.351 +}
1.352 +
1.353 +bool TestDataStructuresParent::RecvTest14(
1.354 + const Structs& i,
1.355 + Structs* o)
1.356 +{
1.357 + InfallibleTArray<int> ai;
1.358 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.359 +
1.360 + test_assert(42 == i.i(), "wrong value");
1.361 + assert_arrays_equal(ai, i.ai());
1.362 + assert_arrays_equal(mKids, i.apParent());
1.363 +
1.364 + const SActors& ia = i.aa()[0];
1.365 + test_assert(42 == ia.i(), "wrong value");
1.366 + assert_arrays_equal(ai, ia.ai());
1.367 + assert_arrays_equal(mKids, ia.apParent());
1.368 +
1.369 + *o = i;
1.370 +
1.371 + return true;
1.372 +}
1.373 +
1.374 +bool TestDataStructuresParent::RecvTest15(
1.375 + const WithStructs& i1,
1.376 + const WithStructs& i2,
1.377 + const WithStructs& i3,
1.378 + const WithStructs& i4,
1.379 + const WithStructs& i5,
1.380 + WithStructs* o1,
1.381 + WithStructs* o2,
1.382 + WithStructs* o3,
1.383 + WithStructs* o4,
1.384 + WithStructs* o5)
1.385 +{
1.386 + InfallibleTArray<int> ai;
1.387 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.388 +
1.389 + test_assert(i1 == int(42), "wrong value");
1.390 + assert_arrays_equal(i2.get_ArrayOfint(), ai);
1.391 + assert_arrays_equal(i3.get_ArrayOfPTestDataStructuresSubParent(), mKids);
1.392 +
1.393 + const SActors& ia = i4.get_ArrayOfSActors()[0];
1.394 + test_assert(42 == ia.i(), "wrong value");
1.395 + assert_arrays_equal(ai, ia.ai());
1.396 + assert_arrays_equal(mKids, ia.apParent());
1.397 +
1.398 + const Structs& is = i5.get_ArrayOfStructs()[0];
1.399 + test_assert(42 == is.i(), "wrong value");
1.400 + assert_arrays_equal(ai, is.ai());
1.401 + assert_arrays_equal(mKids, is.apParent());
1.402 +
1.403 + const SActors& isa = is.aa()[0];
1.404 + test_assert(42 == isa.i(), "wrong value");
1.405 + assert_arrays_equal(ai, isa.ai());
1.406 + assert_arrays_equal(mKids, isa.apParent());
1.407 +
1.408 + *o1 = i1;
1.409 + *o2 = i2;
1.410 + *o3 = i3;
1.411 + *o4 = i4;
1.412 + *o5 = i5;
1.413 +
1.414 + return true;
1.415 +}
1.416 +
1.417 +bool TestDataStructuresParent::RecvTest16(
1.418 + const WithUnions& i,
1.419 + WithUnions* o)
1.420 +{
1.421 + test_assert(i.i() == 42, "wrong value");
1.422 +
1.423 + InfallibleTArray<int> ai;
1.424 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.425 + assert_arrays_equal(ai, i.ai());
1.426 +
1.427 + assert_arrays_equal(i.apParent(), mKids);
1.428 +
1.429 + assert_arrays_equal(mKids, i.aa()[0].get_ArrayOfPTestDataStructuresSubParent());
1.430 +
1.431 + const InfallibleTArray<Unions>& iau = i.au();
1.432 + test_assert(iau[0] == 42, "wrong value");
1.433 + assert_arrays_equal(ai, iau[1].get_ArrayOfint());
1.434 + assert_arrays_equal(mKids, iau[2].get_ArrayOfPTestDataStructuresSubParent());
1.435 + assert_arrays_equal(mKids,
1.436 + iau[3].get_ArrayOfActors()[0]
1.437 + .get_ArrayOfPTestDataStructuresSubParent());
1.438 +
1.439 + *o = i;
1.440 +
1.441 + return true;
1.442 +}
1.443 +
1.444 +bool TestDataStructuresParent::RecvTest17(const InfallibleTArray<Op>& sa)
1.445 +{
1.446 + test_assert(sa.Length() == 1 && Op::TSetAttrs == sa[0].type(),
1.447 + "wrong value");
1.448 + return true;
1.449 +}
1.450 +
1.451 +bool TestDataStructuresParent::RecvTest18(const RegionArray& ra)
1.452 +{
1.453 + for (RegionArray::index_type i = 0; i < ra.Length(); ++i) {
1.454 + nsIntRegionRectIterator it(ra[i]);
1.455 + // if |ra| has been realloc()d and given a different allocator
1.456 + // chunk, this next line will nondeterministically crash or
1.457 + // iloop
1.458 + while (const nsIntRect* sr = it.Next()) unused << sr;
1.459 + }
1.460 +
1.461 + return true;
1.462 +}
1.463 +
1.464 +//-----------------------------------------------------------------------------
1.465 +// child
1.466 +
1.467 +TestDataStructuresChild::TestDataStructuresChild()
1.468 +{
1.469 + MOZ_COUNT_CTOR(TestDataStructuresChild);
1.470 +}
1.471 +
1.472 +TestDataStructuresChild::~TestDataStructuresChild()
1.473 +{
1.474 + MOZ_COUNT_DTOR(TestDataStructuresChild);
1.475 +}
1.476 +
1.477 +bool
1.478 +TestDataStructuresChild::RecvStart()
1.479 +{
1.480 + puts("[TestDataStructuresChild] starting");
1.481 +
1.482 + Test1();
1.483 + Test2();
1.484 + Test3();
1.485 + Test4();
1.486 + Test5();
1.487 + Test6();
1.488 + Test7_0();
1.489 + Test7();
1.490 + Test8();
1.491 + Test9();
1.492 + Test10();
1.493 + Test11();
1.494 + Test12();
1.495 + Test13();
1.496 + Test14();
1.497 + Test15();
1.498 + Test16();
1.499 + Test17();
1.500 + if (OtherProcess() != 0) {
1.501 + //FIXME/bug 703317 allocation of nsIntRegion uses a global
1.502 + //region pool which breaks threads
1.503 + Test18();
1.504 + }
1.505 +
1.506 + for (uint32_t i = 0; i < nactors; ++i)
1.507 + if (!PTestDataStructuresSubChild::Send__delete__(mKids[i]))
1.508 + fail("can't send dtor");
1.509 +
1.510 + Close();
1.511 +
1.512 + return true;
1.513 +}
1.514 +
1.515 +void
1.516 +TestDataStructuresChild::Test1()
1.517 +{
1.518 + InfallibleTArray<int> ia;
1.519 +
1.520 + for (int i = 0; i < 5; ++i)
1.521 + ia.AppendElement(i);
1.522 +
1.523 + InfallibleTArray<int> oa;
1.524 + if (!SendTest1(ia, &oa))
1.525 + fail("can't send Test1");
1.526 +
1.527 + assert_arrays_equal(ia, oa);
1.528 +
1.529 + printf(" passed %s\n", __FUNCTION__);
1.530 +}
1.531 +
1.532 +void
1.533 +TestDataStructuresChild::Test2()
1.534 +{
1.535 + InfallibleTArray<PTestDataStructuresSubChild*> oa;
1.536 + if (!SendTest2(mKids, &oa))
1.537 + fail("can't send Test2");
1.538 + assert_arrays_equal(mKids, oa);
1.539 +
1.540 + printf(" passed %s\n", __FUNCTION__);
1.541 +}
1.542 +
1.543 +void
1.544 +TestDataStructuresChild::Test3()
1.545 +{
1.546 + int i1i = 42;
1.547 + double i2d = 4.0;
1.548 + IntDouble i1(i1i);
1.549 + IntDouble i2(i2d);
1.550 + IntDouble o1, o2;
1.551 +
1.552 + SendTest3(i1, i2, &o1, &o2);
1.553 +
1.554 + test_assert(i1i == o1.get_int(), "wrong value");
1.555 + test_assert(i2d == o2.get_double(), "wrong value");
1.556 +
1.557 + printf(" passed %s\n", __FUNCTION__);
1.558 +}
1.559 +
1.560 +void
1.561 +TestDataStructuresChild::Test4()
1.562 +{
1.563 + InfallibleTArray<IntDouble> i1;
1.564 + i1.AppendElement(IntDouble(int(1)));
1.565 + i1.AppendElement(IntDouble(2.0));
1.566 + i1.AppendElement(IntDouble(int(3)));
1.567 + i1.AppendElement(IntDouble(4.0));
1.568 +
1.569 + InfallibleTArray<IntDouble> o1;
1.570 + if (!SendTest4(i1, &o1))
1.571 + fail("can't send Test4");
1.572 +
1.573 + // TODO Union::operator==()
1.574 + test_assert(i1.Length() == o1.Length(), "wrong length");
1.575 + test_assert(1 == o1[0].get_int(), "wrong value");
1.576 + test_assert(2.0 == o1[1].get_double(), "wrong value");
1.577 + test_assert(3 == o1[2].get_int(), "wrong value");
1.578 + test_assert(4.0 == o1[3].get_double(), "wrong value");
1.579 +
1.580 + printf(" passed %s\n", __FUNCTION__);
1.581 +}
1.582 +
1.583 +void
1.584 +TestDataStructuresChild::Test5()
1.585 +{
1.586 + IntDoubleArrays i1(int(42));
1.587 + InfallibleTArray<int> i2;
1.588 + i2.AppendElement(1); i2.AppendElement(2); i2.AppendElement(3);
1.589 + InfallibleTArray<double> i3;
1.590 + i3.AppendElement(1.0); i3.AppendElement(2.0); i3.AppendElement(3.0);
1.591 +
1.592 + IntDoubleArrays o1, o2, o3;
1.593 + if (!SendTest5(i1, IntDoubleArrays(i2), IntDoubleArrays(i3),
1.594 + &o1, &o2, &o3))
1.595 + fail("can't send Test5");
1.596 +
1.597 + test_assert(42 == o1.get_int(), "wrong value");
1.598 + assert_arrays_equal(i2, o2.get_ArrayOfint());
1.599 + assert_arrays_equal(i3, o3.get_ArrayOfdouble());
1.600 +
1.601 + printf(" passed %s\n", __FUNCTION__);
1.602 +}
1.603 +
1.604 +void
1.605 +TestDataStructuresChild::Test6()
1.606 +{
1.607 + IntDoubleArrays id1(int(42));
1.608 + InfallibleTArray<int> id2;
1.609 + id2.AppendElement(1); id2.AppendElement(2); id2.AppendElement(3);
1.610 + InfallibleTArray<double> id3;
1.611 + id3.AppendElement(1.0); id3.AppendElement(2.0); id3.AppendElement(3.0);
1.612 +
1.613 + InfallibleTArray<IntDoubleArrays> i1;
1.614 + i1.AppendElement(id1);
1.615 + i1.AppendElement(IntDoubleArrays(id2));
1.616 + i1.AppendElement(IntDoubleArrays(id3));
1.617 +
1.618 + InfallibleTArray<IntDoubleArrays> o1;
1.619 + if (!SendTest6(i1, &o1))
1.620 + fail("can't send Test6");
1.621 +
1.622 + test_assert(3 == o1.Length(), "wrong length");
1.623 + IntDoubleArrays od1(o1[0]);
1.624 + InfallibleTArray<int> od2(o1[1].get_ArrayOfint());
1.625 + InfallibleTArray<double> od3(o1[2].get_ArrayOfdouble());
1.626 +
1.627 + test_assert(42 == od1.get_int(), "wrong value");
1.628 + assert_arrays_equal(id2, od2);
1.629 + assert_arrays_equal(id3, od3);
1.630 +
1.631 + printf(" passed %s\n", __FUNCTION__);
1.632 +}
1.633 +
1.634 +void
1.635 +TestDataStructuresChild::Test7_0()
1.636 +{
1.637 + ActorWrapper iaw;
1.638 + if (iaw.actorChild() != nullptr || iaw.actorParent() != nullptr)
1.639 + fail("actor members should be null initially");
1.640 +
1.641 + iaw.actorChild() = mKids[0];
1.642 + if (iaw.actorParent() != nullptr)
1.643 + fail("parent should be null on child side after set");
1.644 +
1.645 + ActorWrapper oaw;
1.646 + if (!SendTest7_0(iaw, &oaw))
1.647 + fail("sending Test7_0");
1.648 +
1.649 + if (oaw.actorParent() != nullptr)
1.650 + fail("parent accessor on actor-struct members should always be null in child");
1.651 +
1.652 + if (oaw.actorChild() != mKids[0])
1.653 + fail("should have got back same child-side actor");
1.654 +}
1.655 +
1.656 +void
1.657 +TestDataStructuresChild::Test7()
1.658 +{
1.659 + Actors i1(42);
1.660 + InfallibleTArray<int> i2a;
1.661 + i2a.AppendElement(1); i2a.AppendElement(2); i2a.AppendElement(3);
1.662 +
1.663 + Actors o1, o2, o3;
1.664 + if (!SendTest7(i1, Actors(i2a), Actors(mKids), &o1, &o2, &o3))
1.665 + fail("can't send Test7");
1.666 +
1.667 + test_assert(42 == o1.get_int(), "wrong value");
1.668 + assert_arrays_equal(i2a, o2.get_ArrayOfint());
1.669 + assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
1.670 +
1.671 + printf(" passed %s\n", __FUNCTION__);
1.672 +}
1.673 +
1.674 +void
1.675 +TestDataStructuresChild::Test8()
1.676 +{
1.677 + Actors i1e(42);
1.678 + InfallibleTArray<int> i2a;
1.679 + i2a.AppendElement(1); i2a.AppendElement(2); i2a.AppendElement(3);
1.680 +
1.681 + InfallibleTArray<Actors> i1;
1.682 + i1.AppendElement(i1e);
1.683 + i1.AppendElement(i2a);
1.684 + i1.AppendElement(mKids);
1.685 +
1.686 + InfallibleTArray<Actors> o1;
1.687 + if (!SendTest8(i1, &o1))
1.688 + fail("can't send Test8");
1.689 +
1.690 + test_assert(3 == o1.Length(), "wrong length");
1.691 + test_assert(42 == o1[0].get_int(), "wrong value");
1.692 + assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
1.693 + assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
1.694 +
1.695 + printf(" passed %s\n", __FUNCTION__);
1.696 +}
1.697 +
1.698 +void
1.699 +TestDataStructuresChild::Test9()
1.700 +{
1.701 + Unions i1(int(42));
1.702 +
1.703 + InfallibleTArray<int> i2a;
1.704 + i2a.AppendElement(1);
1.705 + i2a.AppendElement(2);
1.706 + i2a.AppendElement(3);
1.707 +
1.708 + InfallibleTArray<Actors> i4a;
1.709 + i4a.AppendElement(mKids);
1.710 +
1.711 + Unions o1, o2, o3, o4;
1.712 + if (!SendTest9(i1, Unions(i2a), Unions(mKids), Unions(i4a),
1.713 + &o1, &o2, &o3, &o4))
1.714 + fail("can't send Test9");
1.715 +
1.716 + test_assert(42 == o1.get_int(), "wrong value");
1.717 + assert_arrays_equal(i2a, o2.get_ArrayOfint());
1.718 + assert_arrays_equal(mKids, o3.get_ArrayOfPTestDataStructuresSubChild());
1.719 + assert_arrays_equal(
1.720 + mKids,
1.721 + o4.get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
1.722 +
1.723 + printf(" passed %s\n", __FUNCTION__);
1.724 +}
1.725 +
1.726 +void
1.727 +TestDataStructuresChild::Test10()
1.728 +{
1.729 + Unions i1a(int(42));
1.730 +
1.731 + InfallibleTArray<int> i2a;
1.732 + i2a.AppendElement(1);
1.733 + i2a.AppendElement(2);
1.734 + i2a.AppendElement(3);
1.735 +
1.736 + InfallibleTArray<Actors> i4a;
1.737 + i4a.AppendElement(mKids);
1.738 +
1.739 + InfallibleTArray<Unions> i1;
1.740 + i1.AppendElement(i1a);
1.741 + i1.AppendElement(Unions(i2a));
1.742 + i1.AppendElement(Unions(mKids));
1.743 + i1.AppendElement(Unions(i4a));
1.744 +
1.745 + InfallibleTArray<Unions> o1;
1.746 + if (!SendTest10(i1, &o1))
1.747 + fail("can't send Test10");
1.748 +
1.749 + test_assert(4 == o1.Length(), "wrong length");
1.750 + test_assert(42 == o1[0].get_int(), "wrong value");
1.751 + assert_arrays_equal(i2a, o1[1].get_ArrayOfint());
1.752 + assert_arrays_equal(mKids, o1[2].get_ArrayOfPTestDataStructuresSubChild());
1.753 + assert_arrays_equal(
1.754 + mKids,
1.755 + o1[3].get_ArrayOfActors()[0].get_ArrayOfPTestDataStructuresSubChild());
1.756 +
1.757 + printf(" passed %s\n", __FUNCTION__);
1.758 +}
1.759 +
1.760 +void
1.761 +TestDataStructuresChild::Test11()
1.762 +{
1.763 + SIntDouble i(1, 2.0);
1.764 + SIntDouble o;
1.765 +
1.766 + if (!SendTest11(i, &o))
1.767 + fail("sending Test11");
1.768 +
1.769 + test_assert(1 == o.i() && 2.0 == o.d(), "wrong values");
1.770 +
1.771 + printf(" passed %s\n", __FUNCTION__);
1.772 +}
1.773 +
1.774 +void
1.775 +TestDataStructuresChild::Test12()
1.776 +{
1.777 + InfallibleTArray<int> ai;
1.778 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.779 +
1.780 + InfallibleTArray<double> ad;
1.781 + ad.AppendElement(.5); ad.AppendElement(1.0); ad.AppendElement(2.0);
1.782 +
1.783 + SIntDoubleArrays i(42, ai, ad);
1.784 + SIntDoubleArrays o;
1.785 +
1.786 + if (!SendTest12(i, &o))
1.787 + fail("sending Test12");
1.788 +
1.789 + test_assert(42 == o.i(), "wrong value");
1.790 + assert_arrays_equal(ai, o.ai());
1.791 + assert_arrays_equal(ad, o.ad());
1.792 +
1.793 + printf(" passed %s\n", __FUNCTION__);
1.794 +}
1.795 +
1.796 +void
1.797 +TestDataStructuresChild::Test13()
1.798 +{
1.799 + InfallibleTArray<int> ai;
1.800 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.801 +
1.802 + SActors i;
1.803 + i.i() = 42;
1.804 + i.ai() = ai;
1.805 + i.apChild() = mKids;
1.806 +
1.807 + SActors o;
1.808 + if (!SendTest13(i, &o))
1.809 + fail("can't send Test13");
1.810 +
1.811 + test_assert(42 == o.i(), "wrong value");
1.812 + assert_arrays_equal(ai, o.ai());
1.813 + assert_arrays_equal(mKids, o.apChild());
1.814 +
1.815 + printf(" passed %s\n", __FUNCTION__);
1.816 +}
1.817 +
1.818 +void
1.819 +TestDataStructuresChild::Test14()
1.820 +{
1.821 + InfallibleTArray<int> ai;
1.822 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.823 +
1.824 + SActors ia;
1.825 + ia.i() = 42;
1.826 + ia.ai() = ai;
1.827 + ia.apChild() = mKids;
1.828 + InfallibleTArray<SActors> aa; aa.AppendElement(ia);
1.829 +
1.830 + Structs i;
1.831 + i.i() = 42;
1.832 + i.ai() = ai;
1.833 + i.apChild() = mKids;
1.834 + i.aa() = aa;
1.835 +
1.836 + Structs o;
1.837 + if (!SendTest14(i, &o))
1.838 + fail("can't send Test14");
1.839 +
1.840 + test_assert(42 == o.i(), "wrong value");
1.841 + assert_arrays_equal(ai, o.ai());
1.842 + assert_arrays_equal(mKids, o.apChild());
1.843 +
1.844 + const SActors& os = o.aa()[0];
1.845 + test_assert(42 == os.i(), "wrong value");
1.846 + assert_arrays_equal(ai, os.ai());
1.847 + assert_arrays_equal(mKids, os.apChild());
1.848 +
1.849 + printf(" passed %s\n", __FUNCTION__);
1.850 +}
1.851 +
1.852 +void
1.853 +TestDataStructuresChild::Test15()
1.854 +{
1.855 + InfallibleTArray<int> ai;
1.856 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.857 +
1.858 + SActors ia;
1.859 + ia.i() = 42;
1.860 + ia.ai() = ai;
1.861 + ia.apChild() = mKids;
1.862 + InfallibleTArray<SActors> iaa; iaa.AppendElement(ia);
1.863 +
1.864 + Structs is;
1.865 + is.i() = 42;
1.866 + is.ai() = ai;
1.867 + is.apChild() = mKids;
1.868 + is.aa() = iaa;
1.869 + InfallibleTArray<Structs> isa; isa.AppendElement(is);
1.870 +
1.871 + WithStructs o1, o2, o3, o4, o5;
1.872 + if (!SendTest15(WithStructs(42),
1.873 + WithStructs(ai),
1.874 + WithStructs(mKids),
1.875 + WithStructs(iaa),
1.876 + WithStructs(isa),
1.877 + &o1, &o2, &o3, &o4, &o5))
1.878 + fail("sending Test15");
1.879 +
1.880 + test_assert(o1 == int(42), "wrong value");
1.881 + assert_arrays_equal(o2.get_ArrayOfint(), ai);
1.882 + assert_arrays_equal(o3.get_ArrayOfPTestDataStructuresSubChild(), mKids);
1.883 +
1.884 + const SActors& oa = o4.get_ArrayOfSActors()[0];
1.885 + test_assert(42 == oa.i(), "wrong value");
1.886 + assert_arrays_equal(ai, oa.ai());
1.887 + assert_arrays_equal(mKids, oa.apChild());
1.888 +
1.889 + const Structs& os = o5.get_ArrayOfStructs()[0];
1.890 + test_assert(42 == os.i(), "wrong value");
1.891 + assert_arrays_equal(ai, os.ai());
1.892 + assert_arrays_equal(mKids, os.apChild());
1.893 +
1.894 + const SActors& osa = os.aa()[0];
1.895 + test_assert(42 == osa.i(), "wrong value");
1.896 + assert_arrays_equal(ai, osa.ai());
1.897 + assert_arrays_equal(mKids, osa.apChild());
1.898 +
1.899 + printf(" passed %s\n", __FUNCTION__);
1.900 +}
1.901 +
1.902 +void
1.903 +TestDataStructuresChild::Test16()
1.904 +{
1.905 + WithUnions i;
1.906 +
1.907 + i.i() = 42;
1.908 +
1.909 + InfallibleTArray<int> ai;
1.910 + ai.AppendElement(1); ai.AppendElement(2); ai.AppendElement(3);
1.911 + i.ai() = ai;
1.912 +
1.913 + i.apChild() = mKids;
1.914 +
1.915 + InfallibleTArray<Actors> iaa;
1.916 + iaa.AppendElement(mKids);
1.917 + i.aa() = iaa;
1.918 +
1.919 + InfallibleTArray<Unions> iau;
1.920 + iau.AppendElement(int(42));
1.921 + iau.AppendElement(ai);
1.922 + iau.AppendElement(mKids);
1.923 + iau.AppendElement(iaa);
1.924 + i.au() = iau;
1.925 +
1.926 + WithUnions o;
1.927 + if (!SendTest16(i, &o))
1.928 + fail("sending Test16");
1.929 +
1.930 + test_assert(42 == o.i(), "wrong value");
1.931 + assert_arrays_equal(o.ai(), ai);
1.932 + assert_arrays_equal(o.apChild(), mKids);
1.933 +
1.934 + const Actors& oaa = o.aa()[0];
1.935 + assert_arrays_equal(oaa.get_ArrayOfPTestDataStructuresSubChild(), mKids);
1.936 +
1.937 + const InfallibleTArray<Unions>& oau = o.au();
1.938 + test_assert(oau[0] == 42, "wrong value");
1.939 + assert_arrays_equal(oau[1].get_ArrayOfint(), ai);
1.940 + assert_arrays_equal(oau[2].get_ArrayOfPTestDataStructuresSubChild(),
1.941 + mKids);
1.942 + assert_arrays_equal(oau[3].get_ArrayOfActors()[0]
1.943 + .get_ArrayOfPTestDataStructuresSubChild(),
1.944 + mKids);
1.945 +
1.946 + printf(" passed %s\n", __FUNCTION__);
1.947 +}
1.948 +
1.949 +void
1.950 +TestDataStructuresChild::Test17()
1.951 +{
1.952 + Attrs attrs;
1.953 + attrs.common() = CommonAttrs(true);
1.954 + attrs.specific() = BarAttrs(1.0f);
1.955 +
1.956 + InfallibleTArray<Op> ops;
1.957 + ops.AppendElement(SetAttrs(nullptr, mKids[0], attrs));
1.958 +
1.959 + if (!SendTest17(ops))
1.960 + fail("sending Test17");
1.961 +
1.962 + printf(" passed %s\n", __FUNCTION__);
1.963 +}
1.964 +
1.965 +void
1.966 +TestDataStructuresChild::Test18()
1.967 +{
1.968 + const int nelements = 1000;
1.969 + RegionArray ra;
1.970 + // big enough to hopefully force a realloc to a different chunk of
1.971 + // memory on the receiving side, if the workaround isn't working
1.972 + // correctly. But SetCapacity() here because we don't want to
1.973 + // crash on the sending side.
1.974 + ra.SetCapacity(nelements);
1.975 + for (int i = 0; i < nelements; ++i) {
1.976 + nsIntRegion r;
1.977 + r = r.Or(nsIntRect(0, 0, 10, 10), nsIntRect(10, 10, 10, 10));
1.978 + ra.AppendElement(r);
1.979 + }
1.980 +
1.981 + if (!SendTest18(ra))
1.982 + fail("sending Test18");
1.983 +
1.984 + printf(" passed %s\n", __FUNCTION__);
1.985 +}
1.986 +
1.987 +} // namespace _ipdltest
1.988 +} // namespace mozilla
