The Tor Browser: ipc/ipdl/test/cxx/TestJSON.cpp@8bccb770b82d

     1 #include "TestJSON.h"

     3 #include "IPDLUnitTests.h"      // fail etc.

     5 #define test_assert(_cond, _msg) \

     6     if (!(_cond)) fail(_msg)

     8 namespace mozilla {

     9 namespace _ipdltest {

    11 static nsString

    12 String(const char* const str)

    13 {

    14     return NS_ConvertUTF8toUTF16(str);

    15 }

    17 static void

    18 Array123(InfallibleTArray<JSONVariant>& a123)

    19 {

    20     a123.AppendElement(1);  a123.AppendElement(2);  a123.AppendElement(3);

    22     test_assert(a123 == a123, "operator== is broken");

    23 }

    25 template<class HandleT>

    26 JSONVariant

    27 MakeTestVariant(HandleT* handle)

    28 {

    29     // In JS syntax:

    30     //

    31     //   return [

    32     //     undefined, null, true, 1.25, "test string",

    33     //     handle,

    34     //     [ 1, 2, 3 ],

    35     //     { "undefined" : undefined,

    36     //       "null"      : null,

    37     //       "true"      : true,

    38     //       "1.25"      : 1.25,

    39     //       "string"    : "string"

    40     //       "handle"    : handle,

    41     //       "array"     : [ 1, 2, 3 ]

    42     //     }

    43     //   ]

    44     //

    45     InfallibleTArray<JSONVariant> outer;

    47     outer.AppendElement(void_t());

    48     outer.AppendElement(null_t());

    49     outer.AppendElement(true);

    50     outer.AppendElement(1.25);

    51     outer.AppendElement(String("test string"));

    53     outer.AppendElement(handle);

    55     InfallibleTArray<JSONVariant> tmp;

    56     Array123(tmp);

    57     outer.AppendElement(tmp);

    59     InfallibleTArray<KeyValue> obj;

    60     obj.AppendElement(KeyValue(String("undefined"), void_t()));

    61     obj.AppendElement(KeyValue(String("null"), null_t()));

    62     obj.AppendElement(KeyValue(String("true"), true));

    63     obj.AppendElement(KeyValue(String("1.25"), 1.25));

    64     obj.AppendElement(KeyValue(String("string"), String("value")));

    65     obj.AppendElement(KeyValue(String("handle"), handle));

    66     InfallibleTArray<JSONVariant> tmp2;

    67     Array123(tmp2);

    68     obj.AppendElement(KeyValue(String("array"), tmp2));

    70     outer.AppendElement(obj);

    72     test_assert(outer == outer, "operator== is broken");

    74     return JSONVariant(outer);

    75 }

    77 //-----------------------------------------------------------------------------

    78 // parent

    80 void

    81 TestJSONParent::Main()

    82 {

    83     if (!SendStart())

    84         fail("sending Start");

    85 }

    88 bool

    89 TestJSONParent::RecvTest(const JSONVariant& i,

    90                          JSONVariant* o)

    91 {

    92     test_assert(i == i, "operator== is broken");

    93     test_assert(i == MakeTestVariant(mKid), "inparam mangled en route");

    95     *o = i;

    97     test_assert(i == *o, "operator= is broken");

    99     return true;

   100 }

   103 //-----------------------------------------------------------------------------

   104 // child

   106 bool

   107 TestJSONChild::RecvStart()

   108 {

   109     if (!SendPTestHandleConstructor())

   110         fail("sending Handle ctor");

   112     JSONVariant i(MakeTestVariant(mKid));

   113     test_assert(i == i, "operator== is broken");

   114     test_assert(i == MakeTestVariant(mKid), "copy ctor is broken");

   116     JSONVariant o;

   117     if (!SendTest(i, &o))

   118         fail("sending Test");

   120     test_assert(i == o, "round-trip mangled input data");

   121     test_assert(o == MakeTestVariant(mKid), "outparam mangled en route");

   123     Close();

   124     return true;

   125 }

   128 } // namespace _ipdltest

   129 } // namespace mozilla

The Tor Browser / file revision