netSerial

     1 #include <stdlib.h>
     2 #include <stdio.h>
     3 #include <string.h>
     4 
     5 #define ck_assert_str_eq(a,b) a;b;
     6 #define ck_assert_str_ne(a,b) a;b;
     7 #define ck_assert_ptr_eq(a,b) a;b;
     8 #define ck_assert_ptr_ne(a,b) a;b;
     9 #define ck_assert_uint_eq(a,b) a;b;
    10 #define ck_assert_uint_ne(a,b) a;b;
    11 #define ck_assert_int_eq(a,b) a;b;
    12 #define ck_assert_int_ne(a,b) a;b;
    13 #define ck_assert(a) a;
    14 
    15 
    16 #include "libsheepyObject.h"
    17 #include "netSerial.h"
    18 
    19 int argc; char **argv;
    20 
    21 /* enable/disable logging */
    22 /* #undef pLog */
    23 /* #define pLog(...) */
    24 
    25 
    26 void topT(void) {
    27 
    28   // STEPS
    29   // init
    30   // init allocate
    31   // terminate
    32   // allocate
    33   // string
    34   // duplicate
    35 
    36   createNetSerial(n);
    37   createNetSerial(ds);
    38   char *s;
    39   smallBytest *B;
    40   createSmallDict(d);
    41   createSmallArray(a);
    42 
    43   // empty smallBytes
    44   initiateG(&B);
    45   pushBufferG(B, NULL, 1);
    46   // store garbage data in empty smallBytes
    47   B->B->data = 0;
    48   ck_assert_ptr_eq(getTopTypeG(&ds), NULL);
    49   deserialG(&ds, B);
    50   // nothing should deserialized
    51   ck_assert_ptr_eq(getTopTypeG(&ds), NULL);
    52   terminateG(B);
    53 
    54   // undefined
    55   undefinedt *oU = allocUndefined();
    56   setTopNFreeG(&n, (baset *)oU);
    57   B = serialG(&n);
    58   s = sToString((smallt *) B->B);
    59   ck_assert_str_eq(s, "[0x00]");
    60   free(s);
    61   deserialG(&ds, B);
    62   s = toStringG(&ds);
    63   ck_assert_str_eq(s, "null");
    64   free(s);
    65   terminateG(B);
    66   freeManyG(&n, &ds);
    67 
    68   // bool
    69   setTopG(&n, TRUE);
    70   B = serialG(&n);
    71   s = sToString((smallt *) B->B);
    72   ck_assert_str_eq(s, "[0x11]");
    73   free(s);
    74   deserialG(&ds, B);
    75   s = toStringG(&ds);
    76   ck_assert_str_eq(s, "true");
    77   free(s);
    78   terminateG(B);
    79   freeManyG(&n, &ds);
    80 
    81   // double
    82   setTopG(&n, 1.2);
    83   B = serialG(&n);
    84   logI("len %u", lenG(B));
    85   logSI("%s", toHexSepS(getValG(B), lenG(B), " "));
    86   s = sToString((smallt *) B->B);
    87   ck_assert_str_eq(s, "[0x03,0x33,0x33,0x33,0x33,0x33,0x33,0xf3,0x3f]");
    88   free(s);
    89   deserialG(&ds, B);
    90   s = toStringG(&ds);
    91   ck_assert_str_eq(s, "1.200000e+00");
    92   free(s);
    93   terminateG(B);
    94   freeManyG(&n, &ds);
    95 
    96   // TODO test with 0x8000000000000000 and 0x7FFFFFFFFFFFFFFF
    97   // 64 bit int test with bit 63 set
    98   setTopG(&n, -8030967404224553996);
    99   B = serialG(&n);
   100   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   101   s = sToString((smallt *) B->B);
   102   ck_assert_str_eq(s, "[0xf4,0x82,0xd2,0x8b,0xc7,0xb7,0xd2,0xbb,0xee,0x1b]");
   103   free(s);
   104   deserialG(&ds, B);
   105   s = toStringG(&ds);
   106   logVarG(s);
   107   ck_assert_str_eq(s, "-8030967404224553996");
   108   free(s);
   109   terminateG(B);
   110   freeManyG(&n, &ds);
   111 
   112   // 64 bit int test large positive value
   113   setTopG(&n, 12000000000UL);
   114   B = serialG(&n);
   115   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   116   s = sToString((smallt *) B->B);
   117   ck_assert_str_eq(s, "[0x84,0x80,0xbc,0xc1,0x96,0x0b]");
   118   free(s);
   119   deserialG(&ds, B);
   120   s = toStringG(&ds);
   121   logVarG(s);
   122   ck_assert_str_eq(s, "12000000000");
   123   free(s);
   124   terminateG(B);
   125   freeManyG(&n, &ds);
   126 
   127   // int
   128   setTopG(&n, 120);
   129   B = serialG(&n);
   130   logI("len %u", lenG(B));
   131   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   132   s = sToString((smallt *) B->B);
   133   ck_assert_str_eq(s, "[0x84,0x1e]");
   134   free(s);
   135   deserialG(&ds, B);
   136   s = toStringG(&ds);
   137   ck_assert_str_eq(s, "120");
   138   free(s);
   139   terminateG(B);
   140   freeManyG(&n, &ds);
   141 
   142   // string
   143   setTopG(&n, "string");
   144   B = serialG(&n);
   145   logI("len %u", lenG(B));
   146   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   147   s = sToString((smallt *) B->B);
   148   ck_assert_str_eq(s, "[0x05,0x73,0x74,0x72,0x69,0x6e,0x67,0x00]");
   149   free(s);
   150   deserialG(&ds, B);
   151   s = toStringG(&ds);
   152   ck_assert_str_eq(s, "string");
   153   free(s);
   154   terminateG(B);
   155   freeManyG(&n, &ds);
   156 
   157   // dict
   158   setG(&d, "k", 4);
   159   setTopG(&n, &d);
   160   B = serialG(&n);
   161   logI("len %u", lenG(B));
   162   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   163   s = sToString((smallt *) B->B);
   164   ck_assert_str_eq(s, "[0x4e,0x01,0x6b,0x00,0x08]");
   165   free(s);
   166   deserialG(&ds, B);
   167   s = toStringG(&ds);
   168   ck_assert_str_eq(s, "{\"k\":4}");
   169   free(s);
   170   terminateG(B);
   171   freeManyG(&n, &ds);
   172 
   173   // array
   174   pushG(&a, "k");
   175   pushG(&a, 4);
   176   setTopG(&n, &a);
   177   B = serialG(&n);
   178   logI("len %u", lenG(B));
   179   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   180   s = sToString((smallt *) B->B);
   181   ck_assert_str_eq(s, "[0x26,0x45,0x6b,0x00,0x08]");
   182   free(s);
   183   deserialG(&ds, B);
   184   s = toStringG(&ds);
   185   ck_assert_str_eq(s, "[\"k\",4]");
   186   free(s);
   187   terminateG(B);
   188   freeManyG(&n, &ds);
   189 
   190 }
   191 
   192 
   193 
   194 void uniformDictT(void) {
   195 
   196   // STEPS
   197   // init
   198   // init allocate
   199   // terminate
   200   // allocate
   201   // string
   202   // duplicate
   203 
   204   createNetSerial(n);
   205   createNetSerial(ds);
   206   char *s;
   207   smallBytest *B;
   208   createSmallDict(d);
   209   createSmallDict(dd);
   210   createSmallArray(a);
   211 
   212   // undefined
   213   undefinedt *oU = allocUndefined();
   214   setG(&d, "0", oU);
   215   setG(&d, "1", oU);
   216   setG(&d, "2", oU);
   217   setG(&d, "3", oU);
   218   setG(&d, "4", oU);
   219   setNFreeG(&d, "5", oU);
   220   setTopG(&n, &d);
   221   B = serialG(&n);
   222   logI("len %u", lenG(B));
   223   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   224   s = sToString((smallt *) B->B);
   225   ck_assert_str_eq(s, "[0x0e,0x06,0x30,0x00,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x35,0x00]");
   226   free(s);
   227   deserialG(&ds, B);
   228   s = toStringG(&ds);
   229   ck_assert_str_eq(s, "{\"0\":null,\"1\":null,\"2\":null,\"3\":null,\"4\":null,\"5\":null}");
   230   free(s);
   231   terminateG(B);
   232   freeManyG(&n, &ds);
   233 
   234   // empty dict
   235   initiateG(&d);
   236   setTopG(&n, &d);
   237   B = serialG(&n);
   238   logI("len %u", lenG(B));
   239   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   240   s = sToString((smallt *) B->B);
   241   ck_assert_str_eq(s, "[0x0e,0x00]");
   242   free(s);
   243   deserialG(&ds, B);
   244   s = toStringG(&ds);
   245   ck_assert_str_eq(s, "{}");
   246   free(s);
   247   terminateG(B);
   248   freeManyG(&n, &ds);
   249 
   250   // bool
   251   initiateG(&d);
   252   setG(&d, "0", TRUE);
   253   setG(&d, "1", TRUE);
   254   setG(&d, "2", TRUE);
   255   setG(&d, "3", TRUE);
   256   setTopG(&n, &d);
   257   B = serialG(&n);
   258   logI("len %u", lenG(B));
   259   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   260   s = sToString((smallt *) B->B);
   261   ck_assert_str_eq(s, "[0x1e,0x04,0x30,0x00,0x0f,0x31,0x00,0x32,0x00,0x33,0x00]");
   262   free(s);
   263   deserialG(&ds, B);
   264   s = toStringG(&ds);
   265   ck_assert_str_eq(s, "{\"0\":true,\"1\":true,\"2\":true,\"3\":true}");
   266   free(s);
   267   terminateG(B);
   268   freeManyG(&n, &ds);
   269 
   270   // 9 bools
   271   initiateG(&d);
   272   setG(&d, "0", TRUE);
   273   setG(&d, "1", TRUE);
   274   setG(&d, "2", TRUE);
   275   setG(&d, "3", TRUE);
   276   setG(&d, "4", TRUE);
   277   setG(&d, "5", TRUE);
   278   setG(&d, "6", TRUE);
   279   setG(&d, "7", TRUE);
   280   setG(&d, "8", TRUE);
   281   setTopG(&n, &d);
   282   B = serialG(&n);
   283   logI("len %u", lenG(B));
   284   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   285   s = sToString((smallt *) B->B);
   286   ck_assert_str_eq(s, "[0x1e,0x09,0x30,0x00,0xff,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x35,0x00,0x36,0x00,0x37,0x00,0x38,0x00,0x01]");
   287   free(s);
   288   deserialG(&ds, B);
   289   s = toStringG(&ds);
   290   ck_assert_str_eq(s, "{\"0\":true,\"1\":true,\"2\":true,\"3\":true,\"4\":true,\"5\":true,\"6\":true,\"7\":true,\"8\":true}");
   291   free(s);
   292   terminateG(B);
   293   freeManyG(&n, &ds);
   294 
   295 
   296   // double
   297   initiateG(&d);
   298   setG(&d, "0", 1.1);
   299   setG(&d, "1", 2.2);
   300   setG(&d, "2", 3.3);
   301   setTopG(&n, &d);
   302   B = serialG(&n);
   303   logI("len %u", lenG(B));
   304   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   305   s = sToString((smallt *) B->B);
   306   ck_assert_str_eq(s, "[0x3e,0x03,0x30,0x00,0x9a,0x99,0x99,0x99,0x99,0x99,0xf1,0x3f,0x31,0x00,0x9a,0x99,0x99,0x99,0x99,0x99,0x01,0x40,0x32,0x00,0x66,0x66,0x66,0x66,0x66,0x66,0x0a,0x40]");
   307   free(s);
   308   deserialG(&ds, B);
   309   s = toStringG(&ds);
   310   ck_assert_str_eq(s, "{\"0\":1.100000e+00,\"1\":2.200000e+00,\"2\":3.300000e+00}");
   311   free(s);
   312   terminateG(B);
   313   freeManyG(&n, &ds);
   314 
   315   // int
   316   initiateG(&d);
   317   setG(&d, "0", 1);
   318   setG(&d, "1", 2);
   319   setTopG(&n, &d);
   320   B = serialG(&n);
   321   logI("len %u", lenG(B));
   322   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   323   s = sToString((smallt *) B->B);
   324   ck_assert_str_eq(s, "[0x4e,0x02,0x30,0x00,0x02,0x31,0x00,0x04]");
   325   free(s);
   326   deserialG(&ds, B);
   327   s = toStringG(&ds);
   328   ck_assert_str_eq(s, "{\"0\":1,\"1\":2}");
   329   free(s);
   330   terminateG(B);
   331   freeManyG(&n, &ds);
   332 
   333   // string
   334   initiateG(&d);
   335   setG(&d, "0", "a");
   336   setG(&d, "1", "A");
   337   setG(&d, "2", "z");
   338   setTopG(&n, &d);
   339   B = serialG(&n);
   340   logI("len %u", lenG(B));
   341   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   342   s = sToString((smallt *) B->B);
   343   ck_assert_str_eq(s, "[0x5e,0x03,0x30,0x00,0x61,0x00,0x31,0x00,0x41,0x00,0x32,0x00,0x7a,0x00]");
   344   free(s);
   345   deserialG(&ds, B);
   346   s = toStringG(&ds);
   347   ck_assert_str_eq(s, "{\"0\":\"a\",\"1\":\"A\",\"2\":\"z\"}");
   348   free(s);
   349   terminateG(B);
   350   freeManyG(&n, &ds);
   351 
   352   // dict
   353   initiateG(&d);
   354   setG(&dd, "9", "z");
   355   setG(&dd, "1", 1);
   356   setG(&d, "0", &dd);
   357   initiateG(&dd);
   358   setG(&dd, "Z", "-");
   359   setG(&dd, "A", 234);
   360   setG(&d, "1", &dd);
   361   setTopG(&n, &d);
   362   logVarG(&n);
   363   B = serialG(&n);
   364   logI("len %u", lenG(B));
   365   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   366   s = sToString((smallt *) B->B);
   367   ck_assert_str_eq(s, "[0x2e,0x02,0x30,0x00,0x02,0x39,0x00,0x45,0x7a,0x00,0x31,0x00,0x02,0x31,0x00,0x02,0x5a,0x00,0x45,0x2d,0x00,0x41,0x00,0xd4,0x03]");
   368   free(s);
   369   deserialG(&ds, B);
   370   s = toStringG(&ds);
   371   ck_assert_str_eq(s, "{\"0\":{\"9\":\"z\",\"1\":1},\"1\":{\"Z\":\"-\",\"A\":234}}");
   372   free(s);
   373   terminateG(B);
   374   freeManyG(&n, &ds);
   375 
   376   // uniform dict
   377   initiateG(&dd);
   378   initiateG(&d);
   379   setG(&dd, "9", 1);
   380   setG(&dd, "1", 2);
   381   setG(&d, "0", &dd);
   382   initiateG(&dd);
   383   setG(&dd, "Z", "-");
   384   setG(&dd, "A", "+");
   385   setG(&d, "1", &dd);
   386   setTopG(&n, &d);
   387   logVarG(&n);
   388   B = serialG(&n);
   389   logI("len %u", lenG(B));
   390   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   391   s = sToString((smallt *) B->B);
   392   ck_assert_str_eq(s, "[0xee,0x02,0x30,0x00,0x24,0x39,0x00,0x02,0x31,0x00,0x04,0x31,0x00,0x25,0x5a,0x00,0x2d,0x00,0x41,0x00,0x2b,0x00]");
   393   free(s);
   394   deserialG(&ds, B);
   395   s = toStringG(&ds);
   396   ck_assert_str_eq(s, "{\"0\":{\"9\":1,\"1\":2},\"1\":{\"Z\":\"-\",\"A\":\"+\"}}");
   397   free(s);
   398   terminateG(B);
   399   freeManyG(&n, &ds);
   400 
   401   // array
   402   initiateG(&d);
   403   pushG(&a, "k");
   404   pushG(&a, 4);
   405   setG(&d, "0", &a);
   406   setTopG(&n, &d);
   407   B = serialG(&n);
   408   logI("len %u", lenG(B));
   409   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   410   s = sToString((smallt *) B->B);
   411   ck_assert_str_eq(s, "[0x6e,0x01,0x30,0x00,0x02,0x45,0x6b,0x00,0x08]");
   412   free(s);
   413   deserialG(&ds, B);
   414   s = toStringG(&ds);
   415   ck_assert_str_eq(s, "{\"0\":[\"k\",4]}");
   416   free(s);
   417   terminateG(B);
   418   freeManyG(&n, &ds);
   419 
   420   // uniform array
   421   initiateG(&d);
   422   initiateG(&a);
   423   pushG(&a, 1);
   424   pushG(&a, 2);
   425   pushG(&a, 3);
   426   pushG(&a, 4);
   427   setG(&d, "0", &a);
   428   setTopG(&n, &d);
   429   B = serialG(&n);
   430   logI("len %u", lenG(B));
   431   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   432   s = sToString((smallt *) B->B);
   433   ck_assert_str_eq(s, "[0xfe,0x01,0x30,0x00,0x44,0x02,0x04,0x06,0x08]");
   434   free(s);
   435   deserialG(&ds, B);
   436   s = toStringG(&ds);
   437   ck_assert_str_eq(s, "{\"0\":[1,2,3,4]}");
   438   free(s);
   439   terminateG(B);
   440   freeManyG(&n, &ds);
   441 
   442   // smallBytes
   443   initiateG(&d);
   444   createSmallBytes(b);
   445   createSmallBytes(b1);
   446   pushG(&b, 1);
   447   pushG(&b, 2);
   448   pushG(&b, 3);
   449   pushG(&b, 4);
   450   pushG(&b1, 5);
   451   pushG(&b1, 6);
   452   pushG(&b1, 7);
   453   setG(&d, "0", &b);
   454   setG(&d, "1", &b1);
   455   setTopG(&n, &d);
   456   B = serialG(&n);
   457   logI("len %u", lenG(B));
   458   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   459   s = sToString((smallt *) B->B);
   460   ck_assert_str_eq(s, "[0x7e,0x02,0x30,0x00,0x04,0x01,0x02,0x03,0x04,0x31,0x00,0x03,0x05,0x06,0x07]");
   461   free(s);
   462   deserialG(&ds, B);
   463   s = toStringG(&ds);
   464   ck_assert_str_eq(s, "{"_"0"_":[0x01,0x02,0x03,0x04],"_"1"_":[0x05,0x06,0x07]}");
   465   free(s);
   466   terminateG(B);
   467   freeManyG(&n, &ds);
   468 
   469 }
   470 
   471 
   472 // uniformArray
   473 void uniformArrayT(void) {
   474 
   475   // STEPS
   476   // init
   477   // init allocate
   478   // terminate
   479   // allocate
   480   // string
   481   // duplicate
   482 
   483   createNetSerial(n);
   484   createNetSerial(ds);
   485   char *s;
   486   smallBytest *B;
   487   createSmallArray(A);
   488   createSmallDict(dd);
   489   createSmallArray(a);
   490 
   491   // undefined
   492   undefinedt *oU = allocUndefined();
   493   pushG(&A, oU);
   494   pushG(&A, oU);
   495   pushG(&A, oU);
   496   pushG(&A, oU);
   497   pushG(&A, oU);
   498   pushNFreeG(&A, oU);
   499   setTopG(&n, &A);
   500   B = serialG(&n);
   501   logI("len %u", lenG(B));
   502   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   503   s = sToString((smallt *) B->B);
   504   ck_assert_str_eq(s, "[0x0f,0x06]");
   505   free(s);
   506   deserialG(&ds, B);
   507   s = toStringG(&ds);
   508   ck_assert_str_eq(s, "[null,null,null,null,null,null]");
   509   free(s);
   510   terminateG(B);
   511   freeManyG(&n, &ds);
   512 
   513   // empty dict
   514   initiateG(&A);
   515   setTopG(&n, &A);
   516   B = serialG(&n);
   517   logI("len %u", lenG(B));
   518   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   519   s = sToString((smallt *) B->B);
   520   ck_assert_str_eq(s, "[0x0f,0x00]");
   521   free(s);
   522   deserialG(&ds, B);
   523   s = toStringG(&ds);
   524   ck_assert_str_eq(s, "[]");
   525   free(s);
   526   terminateG(B);
   527   freeManyG(&n, &ds);
   528 
   529   // bool
   530   initiateG(&A);
   531   pushG(&A, TRUE);
   532   pushG(&A, TRUE);
   533   pushG(&A, TRUE);
   534   pushG(&A, TRUE);
   535   setTopG(&n, &A);
   536   B = serialG(&n);
   537   logI("len %u", lenG(B));
   538   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   539   s = sToString((smallt *) B->B);
   540   ck_assert_str_eq(s, "[0x1f,0x04,0x0f]");
   541   free(s);
   542   deserialG(&ds, B);
   543   s = toStringG(&ds);
   544   ck_assert_str_eq(s, "[true,true,true,true]");
   545   free(s);
   546   terminateG(B);
   547   freeManyG(&n, &ds);
   548 
   549   // double
   550   initiateG(&A);
   551   pushG(&A, 1.1);
   552   pushG(&A, 2.2);
   553   pushG(&A, 3.3);
   554   setTopG(&n, &A);
   555   B = serialG(&n);
   556   logI("len %u", lenG(B));
   557   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   558   s = sToString((smallt *) B->B);
   559   ck_assert_str_eq(s, "[0x3f,0x03,0x9a,0x99,0x99,0x99,0x99,0x99,0xf1,0x3f,0x9a,0x99,0x99,0x99,0x99,0x99,0x01,0x40,0x66,0x66,0x66,0x66,0x66,0x66,0x0a,0x40]");
   560   free(s);
   561   deserialG(&ds, B);
   562   s = toStringG(&ds);
   563   ck_assert_str_eq(s, "[1.100000e+00,2.200000e+00,3.300000e+00]");
   564   free(s);
   565   terminateG(B);
   566   freeManyG(&n, &ds);
   567 
   568   // int
   569   initiateG(&A);
   570   pushG(&A, 1);
   571   pushG(&A, 2);
   572   setTopG(&n, &A);
   573   B = serialG(&n);
   574   logI("len %u", lenG(B));
   575   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   576   s = sToString((smallt *) B->B);
   577   ck_assert_str_eq(s, "[0x4f,0x02,0x02,0x04]");
   578   free(s);
   579   deserialG(&ds, B);
   580   s = toStringG(&ds);
   581   ck_assert_str_eq(s, "[1,2]");
   582   free(s);
   583   terminateG(B);
   584   freeManyG(&n, &ds);
   585 
   586   // string
   587   initiateG(&A);
   588   pushG(&A, "a");
   589   pushG(&A, "A");
   590   pushG(&A, "z");
   591   setTopG(&n, &A);
   592   B = serialG(&n);
   593   logI("len %u", lenG(B));
   594   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   595   s = sToString((smallt *) B->B);
   596   ck_assert_str_eq(s, "[0x5f,0x03,0x61,0x00,0x41,0x00,0x7a,0x00]");
   597   free(s);
   598   deserialG(&ds, B);
   599   s = toStringG(&ds);
   600   ck_assert_str_eq(s, "[\"a\",\"A\",\"z\"]");
   601   free(s);
   602   terminateG(B);
   603   freeManyG(&n, &ds);
   604 
   605   // dict
   606   initiateG(&A);
   607   setG(&dd, "9", "z");
   608   setG(&dd, "1", 1);
   609   pushG(&A, &dd);
   610   initiateG(&dd);
   611   setG(&dd, "Z", "-");
   612   setG(&dd, "A", 234);
   613   pushG(&A, &dd);
   614   setTopG(&n, &A);
   615   logVarG(&n);
   616   B = serialG(&n);
   617   logI("len %u", lenG(B));
   618   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   619   s = sToString((smallt *) B->B);
   620   ck_assert_str_eq(s, "[0x2f,0x02,0x02,0x39,0x00,0x45,0x7a,0x00,0x31,0x00,0x02,0x02,0x5a,0x00,0x45,0x2d,0x00,0x41,0x00,0xd4,0x03]");
   621   free(s);
   622   deserialG(&ds, B);
   623   s = toStringG(&ds);
   624   ck_assert_str_eq(s, "[{\"9\":\"z\",\"1\":1},{\"Z\":\"-\",\"A\":234}]");
   625   free(s);
   626   terminateG(B);
   627   freeManyG(&n, &ds);
   628 
   629   // uniform dict
   630   initiateG(&dd);
   631   initiateG(&A);
   632   setG(&dd, "9", 1);
   633   setG(&dd, "1", 2);
   634   pushG(&A, &dd);
   635   initiateG(&dd);
   636   setG(&dd, "Z", "-");
   637   setG(&dd, "A", "+");
   638   pushG(&A, &dd);
   639   setTopG(&n, &A);
   640   logVarG(&n);
   641   B = serialG(&n);
   642   logI("len %u", lenG(B));
   643   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   644   s = sToString((smallt *) B->B);
   645   ck_assert_str_eq(s, "[0xef,0x02,0x24,0x39,0x00,0x02,0x31,0x00,0x04,0x25,0x5a,0x00,0x2d,0x00,0x41,0x00,0x2b,0x00]");
   646   free(s);
   647   deserialG(&ds, B);
   648   s = toStringG(&ds);
   649   ck_assert_str_eq(s, "[{\"9\":1,\"1\":2},{\"Z\":\"-\",\"A\":\"+\"}]");
   650   free(s);
   651   terminateG(B);
   652   freeManyG(&n, &ds);
   653 
   654   // array
   655   initiateG(&A);
   656   pushG(&a, "k");
   657   pushG(&a, 4);
   658   pushG(&A, &a);
   659   setTopG(&n, &A);
   660   B = serialG(&n);
   661   logI("len %u", lenG(B));
   662   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   663   s = sToString((smallt *) B->B);
   664   ck_assert_str_eq(s, "[0x6f,0x01,0x02,0x45,0x6b,0x00,0x08]");
   665   free(s);
   666   deserialG(&ds, B);
   667   s = toStringG(&ds);
   668   ck_assert_str_eq(s, "[[\"k\",4]]");
   669   free(s);
   670   terminateG(B);
   671   freeManyG(&n, &ds);
   672 
   673   initiateG(&A);
   674   initiateG(&a);
   675   pushG(&a, 1);
   676   pushG(&a, 2);
   677   pushG(&a, 3);
   678   pushG(&a, 4);
   679   pushG(&A, &a);
   680   setTopG(&n, &A);
   681   B = serialG(&n);
   682   logI("len %u", lenG(B));
   683   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   684   s = sToString((smallt *) B->B);
   685   ck_assert_str_eq(s, "[0xff,0x01,0x44,0x02,0x04,0x06,0x08]");
   686   free(s);
   687   deserialG(&ds, B);
   688   s = toStringG(&ds);
   689   ck_assert_str_eq(s, "[[1,2,3,4]]");
   690   free(s);
   691   terminateG(B);
   692   freeManyG(&n, &ds);
   693 
   694   // many bools in uniform array
   695   parseG(&n, "[true,true,true,true,true,true,true,true,false,true]");
   696   logVarG(&n);
   697   B = serialG(&n);
   698   logI("len %u", lenG(B));
   699   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   700   s = sToString((smallt *) B->B);
   701   ck_assert_str_eq(s, "[0x1f,0x0a,0xff,0x02]");
   702   free(s);
   703   deserialG(&ds, B);
   704   s = toStringG(&ds);
   705   ck_assert_str_eq(s, "[true,true,true,true,true,true,true,true,false,true]");
   706   free(s);
   707   terminateG(B);
   708   freeManyG(&n, &ds);
   709 
   710   // smallBytes
   711   initiateG(&A);
   712   createSmallBytes(b);
   713   pushG(&b, 1);
   714   pushG(&b, 2);
   715   pushG(&b, 3);
   716   pushG(&b, 4);
   717   pushG(&b, 5);
   718   pushG(&b, 6);
   719   pushG(&A, &b);
   720   initiateG(&b);
   721   pushG(&b, 7);
   722   pushG(&b, 8);
   723   pushG(&b, 9);
   724   pushG(&b, 10);
   725   pushG(&b, 11);
   726   pushG(&b, 12);
   727   pushG(&A, &b);
   728   setTopG(&n, &A);
   729   logVarG(&n);
   730   B = serialG(&n);
   731   logI("len %u", lenG(B));
   732   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   733   s = sToString((smallt *) B->B);
   734   ck_assert_str_eq(s, "[0x7f,0x02,0x06,0x01,0x02,0x03,0x04,0x05,0x06,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c]");
   735   free(s);
   736   deserialG(&ds, B);
   737   s = toStringG(&ds);
   738   ck_assert_str_eq(s, "[[0x01,0x02,0x03,0x04,0x05,0x06],[0x07,0x08,0x09,0x0a,0x0b,0x0c]]");
   739   free(s);
   740   terminateG(B);
   741   freeManyG(&n, &ds);
   742 
   743 }
   744 
   745 
   746 // dict with values, dict, array, uniforms, packed test high/low nibbles
   747 void dictT(void) {
   748 
   749   // STEPS
   750   // init
   751   // init allocate
   752   // terminate
   753   // allocate
   754   // string
   755   // duplicate
   756 
   757   createNetSerial(n);
   758   createNetSerial(ds);
   759   char *s;
   760   smallBytest *B;
   761   createSmallDict(d);
   762   createSmallDict(dd);
   763   createSmallArray(a);
   764 
   765   // dict with a deleted element (empty with dict->count == 1)
   766   initiateG(&d);
   767   setG(&d, "0", NULL);
   768   delElemG(&d, "0");
   769   setTopG(&n, &d);
   770   logVarG(&n);
   771   B = serialG(&n);
   772   logI("len %u", lenG(B));
   773   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   774   s = sToString((smallt *) B->B);
   775   ck_assert_str_eq(s, "[0x0e,0x00]");
   776   free(s);
   777   deserialG(&ds, B);
   778   s = toStringG(&ds);
   779   ck_assert_str_eq(s, "{}");
   780   free(s);
   781   terminateG(B);
   782   freeManyG(&n, &ds);
   783 
   784   // null and uniform dict
   785   initiateG(&d);
   786   setG(&d, "0", NULL);
   787   initiateG(&dd);
   788   setG(&dd, "Z", "-");
   789   setG(&dd, "A", "+");
   790   setG(&d, "1", &dd);
   791   setTopG(&n, &d);
   792   logVarG(&n);
   793   B = serialG(&n);
   794   logI("len %u", lenG(B));
   795   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   796   s = sToString((smallt *) B->B);
   797   ck_assert_str_eq(s, "[0x22,0x30,0x00,0xe0,0x31,0x00,0x25,0x5a,0x00,0x2d,0x00,0x41,0x00,0x2b,0x00]");
   798   free(s);
   799   deserialG(&ds, B);
   800   s = toStringG(&ds);
   801   ck_assert_str_eq(s, "{\"0\":null,\"1\":{\"Z\":\"-\",\"A\":\"+\"}}");
   802   free(s);
   803   terminateG(B);
   804   freeManyG(&n, &ds);
   805 
   806   // null and dict
   807   initiateG(&d);
   808   setG(&d, "0", NULL);
   809   initiateG(&dd);
   810   setG(&dd, "Z", "-");
   811   setG(&dd, "A", 1);
   812   setG(&d, "1", &dd);
   813   setTopG(&n, &d);
   814   logVarG(&n);
   815   B = serialG(&n);
   816   logI("len %u", lenG(B));
   817   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   818   s = sToString((smallt *) B->B);
   819   ck_assert_str_eq(s, "[0x22,0x30,0x00,0x20,0x31,0x00,0x02,0x5a,0x00,0x45,0x2d,0x00,0x41,0x00,0x02]");
   820   free(s);
   821   deserialG(&ds, B);
   822   s = toStringG(&ds);
   823   ck_assert_str_eq(s, "{\"0\":null,\"1\":{\"Z\":\"-\",\"A\":1}}");
   824   free(s);
   825   terminateG(B);
   826   freeManyG(&n, &ds);
   827 
   828   // bool and uniform dict
   829   initiateG(&d);
   830   setG(&d, "0", TRUE);
   831   initiateG(&dd);
   832   setG(&dd, "Z", "-");
   833   setG(&dd, "A", "+");
   834   setG(&d, "1", &dd);
   835   setTopG(&n, &d);
   836   logVarG(&n);
   837   B = serialG(&n);
   838   logI("len %u", lenG(B));
   839   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   840   s = sToString((smallt *) B->B);
   841   ck_assert_str_eq(s, "[0x22,0x30,0x00,0x11,0x31,0x00,0x5e,0x02,0x5a,0x00,0x2d,0x00,0x41,0x00,0x2b,0x00]");
   842   free(s);
   843   deserialG(&ds, B);
   844   s = toStringG(&ds);
   845   ck_assert_str_eq(s, "{\"0\":true,\"1\":{\"Z\":\"-\",\"A\":\"+\"}}");
   846   free(s);
   847   terminateG(B);
   848   freeManyG(&n, &ds);
   849 
   850   // null element and uniform array
   851   initiateG(&d);
   852   setG(&d, "1", NULL);
   853   initiateG(&a);
   854   pushG(&a, 1);
   855   pushG(&a, 2);
   856   pushG(&a, 3);
   857   pushG(&a, 4);
   858   setG(&d, "0", &a);
   859   setTopG(&n, &d);
   860   logVarG(&n);
   861   B = serialG(&n);
   862   logI("len %u", lenG(B));
   863   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   864   s = sToString((smallt *) B->B);
   865   ck_assert_str_eq(s, "[0x22,0x31,0x00,0xf0,0x30,0x00,0x44,0x02,0x04,0x06,0x08]");
   866   free(s);
   867   deserialG(&ds, B);
   868   s = toStringG(&ds);
   869   ck_assert_str_eq(s, "{\"1\":null,\"0\":[1,2,3,4]}");
   870   free(s);
   871   terminateG(B);
   872   freeManyG(&n, &ds);
   873 
   874   // uniform array high nibble
   875   initiateG(&d);
   876   setG(&d, "1", TRUE);
   877   initiateG(&a);
   878   pushG(&a, 1);
   879   pushG(&a, 2);
   880   pushG(&a, 3);
   881   pushG(&a, 4);
   882   setG(&d, "0", &a);
   883   setTopG(&n, &d);
   884   logVarG(&n);
   885   B = serialG(&n);
   886   logI("len %u", lenG(B));
   887   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   888   s = sToString((smallt *) B->B);
   889   ck_assert_str_eq(s, "[0x22,0x31,0x00,0x11,0x30,0x00,0x4f,0x04,0x02,0x04,0x06,0x08]");
   890   free(s);
   891   deserialG(&ds, B);
   892   s = toStringG(&ds);
   893   ck_assert_str_eq(s, "{\"1\":true,\"0\":[1,2,3,4]}");
   894   free(s);
   895   terminateG(B);
   896   freeManyG(&n, &ds);
   897 
   898   // uniform array in high nibble
   899   initiateG(&d);
   900   setG(&d, "1", "1");
   901   initiateG(&a);
   902   pushG(&a, 1);
   903   pushG(&a, 2);
   904   pushG(&a, 3);
   905   pushG(&a, 4);
   906   setG(&d, "0", &a);
   907   setTopG(&n, &d);
   908   logVarG(&n);
   909   B = serialG(&n);
   910   logI("len %u", lenG(B));
   911   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   912   s = sToString((smallt *) B->B);
   913   ck_assert_str_eq(s, "[0x22,0x31,0x00,0xf5,0x31,0x00,0x30,0x00,0x44,0x02,0x04,0x06,0x08]");
   914   free(s);
   915   deserialG(&ds, B);
   916   s = toStringG(&ds);
   917   ck_assert_str_eq(s, "{\"1\":\"1\",\"0\":[1,2,3,4]}");
   918   free(s);
   919   terminateG(B);
   920   freeManyG(&n, &ds);
   921 
   922   // low and high nibble undefined
   923   parseG(&n, "{"_"0"_":null,"_"1"_":null, "_"2"_":1}");
   924   logVarG(&n);
   925   B = serialG(&n);
   926   logI("len %u", lenG(B));
   927   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   928   s = sToString((smallt *) B->B);
   929   ck_assert_str_eq(s, "[0x32,0x30,0x00,0x00,0x31,0x00,0x32,0x00,0x24]");
   930   free(s);
   931   deserialG(&ds, B);
   932   s = toStringG(&ds);
   933   ck_assert_str_eq(s, "{\"0\":null,\"1\":null,\"2\":1}");
   934   free(s);
   935   terminateG(B);
   936   freeManyG(&n, &ds);
   937 
   938   // low and high nibble bool
   939   parseG(&n, "{"_"z"_":null,"_"0"_":true,"_"1"_":true, "_"2"_":true, "_"3"_":true"_"4"_":true"_"5"_":true, "_"6"_":true, "_"7"_":true, "_"8"_":true, "_"9"_":true, "_"a"_":true, "_"b"_":true, "_"c"_":true, "_"d"_":true}");
   940   logVarG(&n);
   941   B = serialG(&n);
   942   logI("len %u", lenG(B));
   943   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   944   s = sToString((smallt *) B->B);
   945   ck_assert_str_eq(s, "[0xf2,0x01,0x7a,0x00,0x10,0x30,0x00,0xff,0x31,0x00,0x11,0x32,0x00,0x33,0x00,0x11,0x34,0x00,0x35,0x00,0x11,0x36,0x00,0x37,0x00,0x11,0x38,0x00,0x3f,0x39,0x00,0x11,0x61,0x00,0x62,0x00,0x11,0x63,0x00,0x64,0x00,0x01]");
   946   free(s);
   947   deserialG(&ds, B);
   948   s = toStringG(&ds);
   949   ck_assert_str_eq(s, "{\"z\":null,\"0\":true,\"1\":true,\"2\":true,\"3\":true,\"4\":true,\"5\":true,\"6\":true,\"7\":true,\"8\":true,\"9\":true,\"a\":true,\"b\":true,\"c\":true,\"d\":true}");
   950   free(s);
   951   terminateG(B);
   952   freeManyG(&n, &ds);
   953 
   954   // low and high nibble bool - deserialDict ctx->nibble == lowNbl and ctx->boolShift == 8
   955   parseG(&n, "{"_"z"_":null,"_"0"_":true,"_"1"_":true, "_"2"_":true, "_"3"_":true, "_"4"_":true, "_"5"_":true, "_"6"_":true, "_"7"_":true, \"Z\": null, "_"8"_":true, "_"9"_":true, "_"a"_":true, "_"b"_":true, "_"c"_":true, "_"d"_":true}");
   956   logVarG(&n);
   957   B = serialG(&n);
   958   logI("len %u", lenG(B));
   959   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   960   s = sToString((smallt *) B->B);
   961   ck_assert_str_eq(s, "[0x82,0x02,0x7a,0x00,0x10,0x30,0x00,0xff,0x31,0x00,0x11,0x32,0x00,0x33,0x00,0x11,0x34,0x00,0x35,0x00,0x11,0x36,0x00,0x37,0x00,0x01,0x5a,0x00,0x38,0x00,0xf1,0x39,0x00,0x11,0x61,0x00,0x62,0x00,0x11,0x63,0x00,0x03,0x64,0x00,0x01]");
   962   free(s);
   963   deserialG(&ds, B);
   964   s = toStringG(&ds);
   965   ck_assert_str_eq(s, "{\"z\":null,\"0\":true,\"1\":true,\"2\":true,\"3\":true,\"4\":true,\"5\":true,\"6\":true,\"7\":true,\"Z\":null,\"8\":true,\"9\":true,\"a\":true,\"b\":true,\"c\":true,\"d\":true}");
   966   free(s);
   967   terminateG(B);
   968   freeManyG(&n, &ds);
   969 
   970   // dict in dict
   971   parseG(&n, "{"_"0"_":{\"0\":true}, "_"2"_":{\"0\":false},\"z\":null}");
   972   logVarG(&n);
   973   B = serialG(&n);
   974   logI("len %u", lenG(B));
   975   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   976   s = sToString((smallt *) B->B);
   977   ck_assert_str_eq(s, "[0x32,0x30,0x00,0x1e,0x01,0x30,0x00,0x01,0x32,0x00,0x1e,0x01,0x30,0x00,0x7a,0x00,0x00]");
   978   free(s);
   979   deserialG(&ds, B);
   980   s = toStringG(&ds);
   981   ck_assert_str_eq(s, "{\"0\":{\"0\":true},\"2\":{\"0\":false},\"z\":null}");
   982   free(s);
   983   terminateG(B);
   984   freeManyG(&n, &ds);
   985 
   986 
   987   // low and high nibble double
   988   parseG(&n, "{"_"0"_":0.0, "_"2"_":2.0,\"z\":null}");
   989   logVarG(&n);
   990   B = serialG(&n);
   991   logI("len %u", lenG(B));
   992   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
   993   s = sToString((smallt *) B->B);
   994   ck_assert_str_eq(s, "[0x32,0x30,0x00,0x33,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x7a,0x00,0x00]");
   995   free(s);
   996   deserialG(&ds, B);
   997   s = toStringG(&ds);
   998   ck_assert_str_eq(s, "{\"0\":0.000000e+00,\"2\":2.000000e+00,\"z\":null}");
   999   free(s);
  1000   terminateG(B);
  1001   freeManyG(&n, &ds);
  1002 
  1003   // high nibble string
  1004   parseG(&n, "{"_"0"_":null, "_"2"_":\"2.0\",\"z\":null}");
  1005   logVarG(&n);
  1006   B = serialG(&n);
  1007   logI("len %u", lenG(B));
  1008   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1009   s = sToString((smallt *) B->B);
  1010   ck_assert_str_eq(s, "[0x32,0x30,0x00,0x50,0x32,0x00,0x32,0x2e,0x30,0x00,0x7a,0x00,0x00]");
  1011   free(s);
  1012   deserialG(&ds, B);
  1013   s = toStringG(&ds);
  1014   ck_assert_str_eq(s, "{\"0\":null,\"2\":\"2.0\",\"z\":null}");
  1015   free(s);
  1016   terminateG(B);
  1017   freeManyG(&n, &ds);
  1018 
  1019   // array in dict
  1020   parseG(&n, "{"_"0"_":null, "_"2"_":[1,2],\"z\":[true,3]}");
  1021   logVarG(&n);
  1022   B = serialG(&n);
  1023   logI("len %u", lenG(B));
  1024   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1025   s = sToString((smallt *) B->B);
  1026   ck_assert_str_eq(s, "[0x32,0x30,0x00,0xf0,0x32,0x00,0x24,0x02,0x04,0x7a,0x00,0x26,0x11,0x64]");
  1027   free(s);
  1028   deserialG(&ds, B);
  1029   s = toStringG(&ds);
  1030   ck_assert_str_eq(s, "{\"0\":null,\"2\":[1,2],\"z\":[true,3]}");
  1031   free(s);
  1032   terminateG(B);
  1033   freeManyG(&n, &ds);
  1034 
  1035 
  1036 
  1037   // packed dicts
  1038   parseG(&n, "{"_"0"_":{},"_"1"_":{}, "_"2"_":{}, "_"3"_":{}, "_"4"_":{}, "_"5"_": 1}");
  1039   logVarG(&n);
  1040   B = serialG(&n);
  1041   logI("len %u", lenG(B));
  1042   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1043   s = sToString((smallt *) B->B);
  1044   ck_assert_str_eq(s, "[0x62,0x30,0x00,0x58,0x00,0x31,0x00,0x00,0x32,0x00,0x00,0x33,0x00,0x00,0x34,0x00,0x00,0x35,0x00,0x24]");
  1045   free(s);
  1046   deserialG(&ds, B);
  1047   s = toStringG(&ds);
  1048   ck_assert_str_eq(s, "{\"0\":{},\"1\":{},\"2\":{},\"3\":{},\"4\":{},\"5\":1}");
  1049   free(s);
  1050   terminateG(B);
  1051   freeManyG(&n, &ds);
  1052 
  1053   parseG(&n, "{"_"0"_":{"_"0"_":null,"_"1"_":1},"_"1"_":{"_"0"_":"_"0"_","_"1"_":1}, "_"2"_":{"_"0"_":"_"0"_","_"1"_":1}, "_"3"_":{"_"0"_":"_"0"_","_"1"_":1}, "_"4"_":{"_"0"_":"_"0"_","_"1"_":1}, "_"5"_": 1}");
  1054   logVarG(&n);
  1055   B = serialG(&n);
  1056   logI("len %u", lenG(B));
  1057   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1058   s = sToString((smallt *) B->B);
  1059   ck_assert_str_eq(s, "[0x62,0x30,0x00,0x58,0x02,0x30,0x00,0x40,0x31,0x00,0x02,0x31,0x00,0x02,0x30,0x00,0x45,0x30,0x00,0x31,0x00,0x02,0x32,0x00,0x02,0x30,0x00,0x45,0x30,0x00,0x31,0x00,0x02,0x33,0x00,0x02,0x30,0x00,0x45,0x30,0x00,0x31,0x00,0x02,0x34,0x00,0x02,0x30,0x00,0x45,0x30,0x00,0x31,0x00,0x02,0x35,0x00,0x24]");
  1060   free(s);
  1061   deserialG(&ds, B);
  1062   s = toStringG(&ds);
  1063   ck_assert_str_eq(s, "{\"0\":{\"0\":null,\"1\":1},\"1\":{\"0\":\"0\",\"1\":1},\"2\":{\"0\":\"0\",\"1\":1},\"3\":{\"0\":\"0\",\"1\":1},\"4\":{\"0\":\"0\",\"1\":1},\"5\":1}");
  1064   free(s);
  1065   terminateG(B);
  1066   freeManyG(&n, &ds);
  1067 
  1068   // high nibble packed dicts
  1069   parseG(&n, "{\"a\": null,"_"0"_":{},"_"1"_":{}, "_"2"_":{}, "_"3"_":{}, "_"4"_":{}, "_"5"_": 1}");
  1070   logVarG(&n);
  1071   B = serialG(&n);
  1072   logI("len %u", lenG(B));
  1073   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1074   s = sToString((smallt *) B->B);
  1075   ck_assert_str_eq(s, "[0x72,0x61,0x00,0x80,0x30,0x00,0x05,0x00,0x31,0x00,0x00,0x32,0x00,0x00,0x33,0x00,0x00,0x34,0x00,0x00,0x35,0x00,0x24]");
  1076   free(s);
  1077   deserialG(&ds, B);
  1078   s = toStringG(&ds);
  1079   ck_assert_str_eq(s, "{\"a\":null,\"0\":{},\"1\":{},\"2\":{},\"3\":{},\"4\":{},\"5\":1}");
  1080   free(s);
  1081   terminateG(B);
  1082   freeManyG(&n, &ds);
  1083 
  1084 
  1085   // packed doubles
  1086   parseG(&n, "{"_"0"_":0.0,"_"1"_":1.0, "_"2"_":2.0, "_"3"_":3.0, "_"4"_":4.0, "_"5"_": null}");
  1087   logVarG(&n);
  1088   B = serialG(&n);
  1089   logI("len %u", lenG(B));
  1090   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1091   s = sToString((smallt *) B->B);
  1092   ck_assert_str_eq(s, "[0x62,0x30,0x00,0x59,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x31,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x33,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x40,0x34,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x40,0x35,0x00,0x00]");
  1093   free(s);
  1094   deserialG(&ds, B);
  1095   s = toStringG(&ds);
  1096   ck_assert_str_eq(s, "{\"0\":0.000000e+00,\"1\":1.000000e+00,\"2\":2.000000e+00,\"3\":3.000000e+00,\"4\":4.000000e+00,\"5\":null}");
  1097   free(s);
  1098   terminateG(B);
  1099   freeManyG(&n, &ds);
  1100 
  1101   // high nibble packed doubles
  1102   parseG(&n, "{\"a\": null, "_"0"_":0.0,"_"1"_":1.0, "_"2"_":2.0, "_"3"_":3.0, "_"4"_":4.0, "_"5"_": null}");
  1103   logVarG(&n);
  1104   B = serialG(&n);
  1105   logI("len %u", lenG(B));
  1106   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1107   s = sToString((smallt *) B->B);
  1108   ck_assert_str_eq(s, "[0x72,0x61,0x00,0x90,0x30,0x00,0x05,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x31,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f,0x32,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x33,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x40,0x34,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x40,0x35,0x00,0x00]");
  1109   free(s);
  1110   deserialG(&ds, B);
  1111   s = toStringG(&ds);
  1112   ck_assert_str_eq(s, "{\"a\":null,\"0\":0.000000e+00,\"1\":1.000000e+00,\"2\":2.000000e+00,\"3\":3.000000e+00,\"4\":4.000000e+00,\"5\":null}");
  1113   free(s);
  1114   terminateG(B);
  1115   freeManyG(&n, &ds);
  1116 
  1117 
  1118   // packed ints
  1119   parseG(&n, "{\"1\":1,\"2\":2,\"3\":3,\"4\":4,\"Z\":\"l\"}");
  1120   logVarG(&n);
  1121   B = serialG(&n);
  1122   logI("len %u", lenG(B));
  1123   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1124   s = sToString((smallt *) B->B);
  1125   ck_assert_str_eq(s, "[0x52,0x31,0x00,0x4a,0x02,0x32,0x00,0x04,0x33,0x00,0x06,0x34,0x00,0x08,0x5a,0x00,0x05,0x6c,0x00]");
  1126   free(s);
  1127   deserialG(&ds, B);
  1128   s = toStringG(&ds);
  1129   ck_assert_str_eq(s, "{\"1\":1,\"2\":2,\"3\":3,\"4\":4,\"Z\":\"l\"}");
  1130   free(s);
  1131   terminateG(B);
  1132   freeManyG(&n, &ds);
  1133 
  1134   // high nibble packed ints
  1135   parseG(&n, "{\"0\":null,\"1\":1,\"2\":2,\"3\":3,\"4\":4,\"Z\":\"l\"}");
  1136   logVarG(&n);
  1137   B = serialG(&n);
  1138   logI("len %u", lenG(B));
  1139   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1140   s = sToString((smallt *) B->B);
  1141   ck_assert_str_eq(s, "[0x62,0x30,0x00,0xa0,0x31,0x00,0x04,0x02,0x32,0x00,0x04,0x33,0x00,0x06,0x34,0x00,0x08,0x5a,0x00,0x05,0x6c,0x00]");
  1142   free(s);
  1143   deserialG(&ds, B);
  1144   s = toStringG(&ds);
  1145   ck_assert_str_eq(s, "{\"0\":null,\"1\":1,\"2\":2,\"3\":3,\"4\":4,\"Z\":\"l\"}");
  1146   free(s);
  1147   terminateG(B);
  1148   freeManyG(&n, &ds);
  1149 
  1150 
  1151   // packed strings
  1152   parseG(&n, "{\"1\":\"1\",\"2\":\"2\",\"3\":\"3\",\"4\":\"4\",\"Z\":null}");
  1153   logVarG(&n);
  1154   B = serialG(&n);
  1155   logI("len %u", lenG(B));
  1156   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1157   s = sToString((smallt *) B->B);
  1158   ck_assert_str_eq(s, "[0x52,0x31,0x00,0x4b,0x31,0x00,0x32,0x00,0x32,0x00,0x33,0x00,0x33,0x00,0x34,0x00,0x34,0x00,0x5a,0x00,0x00]");
  1159   free(s);
  1160   deserialG(&ds, B);
  1161   s = toStringG(&ds);
  1162   ck_assert_str_eq(s, "{\"1\":\"1\",\"2\":\"2\",\"3\":\"3\",\"4\":\"4\",\"Z\":null}");
  1163   free(s);
  1164   terminateG(B);
  1165   freeManyG(&n, &ds);
  1166 
  1167   // high nibble packed strings
  1168   parseG(&n, "{\"0\":null,\"1\":\"1\",\"2\":\"2\",\"3\":\"3\",\"4\":\"4\",\"Z\":null}");
  1169   logVarG(&n);
  1170   B = serialG(&n);
  1171   logI("len %u", lenG(B));
  1172   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1173   s = sToString((smallt *) B->B);
  1174   ck_assert_str_eq(s, "[0x62,0x30,0x00,0xb0,0x31,0x00,0x04,0x31,0x00,0x32,0x00,0x32,0x00,0x33,0x00,0x33,0x00,0x34,0x00,0x34,0x00,0x5a,0x00,0x00]");
  1175   free(s);
  1176   deserialG(&ds, B);
  1177   s = toStringG(&ds);
  1178   ck_assert_str_eq(s, "{\"0\":null,\"1\":\"1\",\"2\":\"2\",\"3\":\"3\",\"4\":\"4\",\"Z\":null}");
  1179   free(s);
  1180   terminateG(B);
  1181   freeManyG(&n, &ds);
  1182 
  1183   // packed arrays
  1184   parseG(&n, "{\"1\":[],\"2\":[1],\"3\":[\"3r\"],\"4\":[true],\"Z\":null}");
  1185   logVarG(&n);
  1186   B = serialG(&n);
  1187   logI("len %u", lenG(B));
  1188   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1189   s = sToString((smallt *) B->B);
  1190   ck_assert_str_eq(s, "[0x52,0x31,0x00,0x4c,0x00,0x32,0x00,0x01,0x24,0x33,0x00,0x01,0x15,0x33,0x72,0x00,0x34,0x00,0x01,0x01,0x5a,0x00,0x00]");
  1191   free(s);
  1192   deserialG(&ds, B);
  1193   s = toStringG(&ds);
  1194   ck_assert_str_eq(s, "{\"1\":[],\"2\":[1],\"3\":[\"3r\"],\"4\":[true],\"Z\":null}");
  1195   free(s);
  1196   terminateG(B);
  1197   freeManyG(&n, &ds);
  1198 
  1199   // high nibble packed arrays
  1200   parseG(&n, "{\"0\":null,\"1\":[],\"2\":[1],\"3\":[\"3r\"],\"4\":[true],\"Z\":null}");
  1201   logVarG(&n);
  1202   B = serialG(&n);
  1203   logI("len %u", lenG(B));
  1204   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1205   s = sToString((smallt *) B->B);
  1206   ck_assert_str_eq(s, "[0x62,0x30,0x00,0xc0,0x31,0x00,0x04,0x00,0x32,0x00,0x01,0x24,0x33,0x00,0x01,0x15,0x33,0x72,0x00,0x34,0x00,0x01,0x01,0x5a,0x00,0x00]");
  1207   free(s);
  1208   deserialG(&ds, B);
  1209   s = toStringG(&ds);
  1210   ck_assert_str_eq(s, "{\"0\":null,\"1\":[],\"2\":[1],\"3\":[\"3r\"],\"4\":[true],\"Z\":null}");
  1211   free(s);
  1212   terminateG(B);
  1213   freeManyG(&n, &ds);
  1214 
  1215   // smallBytes
  1216   parseG(&n, "{"_"0"_":null,"_"z"_":[true,3]}");
  1217   createSmallBytes(b);
  1218   pushG(&b, 1);
  1219   pushG(&b, 2);
  1220   pushG(&b, 3);
  1221   pushG(&b, 4);
  1222   pushG(&b, 5);
  1223   pushG(&b, 6);
  1224   setG(&n, "bytes", &b);
  1225   logVarG(&n);
  1226   B = serialG(&n);
  1227   logI("len %u", lenG(B));
  1228   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1229   s = sToString((smallt *) B->B);
  1230   ck_assert_str_eq(s, "[0x32,0x30,0x00,0x60,0x7a,0x00,0x02,0x11,0x64,0x62,0x79,0x74,0x65,0x73,0x00,0x67,0x01,0x02,0x03,0x04,0x05,0x06]");
  1231   free(s);
  1232   deserialG(&ds, B);
  1233   s = toStringG(&ds);
  1234   ck_assert_str_eq(s, "{"_"0"_":null,"_"z"_":[true,3],"_"bytes"_":[0x01,0x02,0x03,0x04,0x05,0x06]}");
  1235   free(s);
  1236   terminateG(B);
  1237   freeManyG(&n, &ds);
  1238 
  1239   parseG(&n, "{"_"0"_":null,"_"z"_":[true,3],"_"1"_":null}");
  1240   initiateG(&b);
  1241   pushG(&b, 1);
  1242   pushG(&b, 2);
  1243   pushG(&b, 3);
  1244   pushG(&b, 4);
  1245   pushG(&b, 5);
  1246   pushG(&b, 6);
  1247   setG(&n, "bytes", &b);
  1248   logVarG(&n);
  1249   B = serialG(&n);
  1250   logI("len %u", lenG(B));
  1251   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1252   s = sToString((smallt *) B->B);
  1253   ck_assert_str_eq(s, "[0x42,0x30,0x00,0x60,0x7a,0x00,0x02,0x11,0x64,0x31,0x00,0x70,0x62,0x79,0x74,0x65,0x73,0x00,0x06,0x01,0x02,0x03,0x04,0x05,0x06]");
  1254   free(s);
  1255   deserialG(&ds, B);
  1256   s = toStringG(&ds);
  1257   ck_assert_str_eq(s, "{"_"0"_":null,"_"z"_":[true,3],"_"1"_":null,"_"bytes"_":[0x01,0x02,0x03,0x04,0x05,0x06]}");
  1258   free(s);
  1259   terminateG(B);
  1260   freeManyG(&n, &ds);
  1261 
  1262 }
  1263 
  1264 
  1265 // array with values, dict, array, uniforms, packed test high/low nibbles
  1266 void arrayT(void) {
  1267 
  1268   // STEPS
  1269   // init
  1270   // init allocate
  1271   // terminate
  1272   // allocate
  1273   // string
  1274   // duplicate
  1275 
  1276   createNetSerial(n);
  1277   createNetSerial(ds);
  1278   char *s;
  1279   smallBytest *B;
  1280   createSmallArray(A);
  1281   createSmallArray(a);
  1282 
  1283   // null and uniform array
  1284   initiateG(&A);
  1285   pushG(&A, NULL);
  1286   initiateG(&a);
  1287   pushG(&a, 1);
  1288   pushG(&a, 2);
  1289   pushG(&a, 3);
  1290   pushG(&a, 4);
  1291   pushG(&A, &a);
  1292   setTopG(&n, &A);
  1293   logVarG(&n);
  1294   B = serialG(&n);
  1295   logI("len %u", lenG(B));
  1296   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1297   s = sToString((smallt *) B->B);
  1298   ck_assert_str_eq(s, "[0x26,0xf0,0x44,0x02,0x04,0x06,0x08]");
  1299   free(s);
  1300   deserialG(&ds, B);
  1301   s = toStringG(&ds);
  1302   //ck_assert_str_eq(s, "[null,null]");
  1303   ck_assert_str_eq(s, "[null,[1,2,3,4]]");
  1304   free(s);
  1305   terminateG(B);
  1306   freeManyG(&n, &ds);
  1307 
  1308   // uniform array in high low
  1309   initiateG(&A);
  1310   pushG(&A, FALSE);
  1311   initiateG(&a);
  1312   pushG(&a, 1);
  1313   pushG(&a, 2);
  1314   pushG(&a, 3);
  1315   pushG(&a, 4);
  1316   pushG(&A, &a);
  1317   setTopG(&n, &A);
  1318   logVarG(&n);
  1319   B = serialG(&n);
  1320   logI("len %u", lenG(B));
  1321   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1322   s = sToString((smallt *) B->B);
  1323   ck_assert_str_eq(s, "[0x26,0x01,0x4f,0x04,0x02,0x04,0x06,0x08]");
  1324   free(s);
  1325   deserialG(&ds, B);
  1326   s = toStringG(&ds);
  1327   //ck_assert_str_eq(s, "[null,null]");
  1328   ck_assert_str_eq(s, "[false,[1,2,3,4]]");
  1329   free(s);
  1330   terminateG(B);
  1331   freeManyG(&n, &ds);
  1332 
  1333   // uniform array in high nibble
  1334   initiateG(&A);
  1335   pushG(&A, "1");
  1336   initiateG(&a);
  1337   pushG(&a, 1);
  1338   pushG(&a, 2);
  1339   pushG(&a, 3);
  1340   pushG(&a, 4);
  1341   pushG(&A, &a);
  1342   setTopG(&n, &A);
  1343   logVarG(&n);
  1344   B = serialG(&n);
  1345   logI("len %u", lenG(B));
  1346   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1347   s = sToString((smallt *) B->B);
  1348   ck_assert_str_eq(s, "[0x26,0xf5,0x31,0x00,0x44,0x02,0x04,0x06,0x08]");
  1349   free(s);
  1350   deserialG(&ds, B);
  1351   s = toStringG(&ds);
  1352   ck_assert_str_eq(s, "[\"1\",[1,2,3,4]]");
  1353   free(s);
  1354   terminateG(B);
  1355   freeManyG(&n, &ds);
  1356 
  1357   // high nibble array
  1358   parseG(&n, "[null, [1,null]]");
  1359   logVarG(&n);
  1360   B = serialG(&n);
  1361   logI("len %u", lenG(B));
  1362   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1363   s = sToString((smallt *) B->B);
  1364   ck_assert_str_eq(s, "[0x26,0x60,0x02,0x24,0x00]");
  1365   free(s);
  1366   deserialG(&ds, B);
  1367   s = toStringG(&ds);
  1368   ck_assert_str_eq(s, "[null,[1,null]]");
  1369   free(s);
  1370   terminateG(B);
  1371   freeManyG(&n, &ds);
  1372 
  1373   // low and high undefined
  1374   parseG(&n, "[null,null,1]");
  1375   logVarG(&n);
  1376   B = serialG(&n);
  1377   logI("len %u", lenG(B));
  1378   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1379   s = sToString((smallt *) B->B);
  1380   ck_assert_str_eq(s, "[0x36,0x00,0x24]");
  1381   free(s);
  1382   deserialG(&ds, B);
  1383   s = toStringG(&ds);
  1384   ck_assert_str_eq(s, "[null,null,1]");
  1385   free(s);
  1386   terminateG(B);
  1387   freeManyG(&n, &ds);
  1388 
  1389   // low and high nibble bool
  1390   parseG(&n, "[null,true,false,false,true,true,false,true,false,true,true,true,true,true]");
  1391   logVarG(&n);
  1392   B = serialG(&n);
  1393   logI("len %u", lenG(B));
  1394   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1395   s = sToString((smallt *) B->B);
  1396   ck_assert_str_eq(s, "[0xe6,0x01,0x10,0x59,0x11,0x11,0x11,0x11,0x1f,0x11,0x11]");
  1397   free(s);
  1398   deserialG(&ds, B);
  1399   s = toStringG(&ds);
  1400   ck_assert_str_eq(s, "[null,true,false,false,true,true,false,true,false,true,true,true,true,true]");
  1401   free(s);
  1402   terminateG(B);
  1403   freeManyG(&n, &ds);
  1404 
  1405   // low and high nibble bool - ctx->boolOffset != 0 ctx->nibble == lowNbl ctx->boolShift == 8
  1406   parseG(&n, "[true,false,false,true,null,true,false,true,false,true,true,true,true,true]");
  1407   logVarG(&n);
  1408   B = serialG(&n);
  1409   logI("len %u", lenG(B));
  1410   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1411   s = sToString((smallt *) B->B);
  1412   ck_assert_str_eq(s, "[0xe6,0x01,0x91,0x11,0x01,0x51,0x11,0x11,0x1f,0x11,0x11]");
  1413   free(s);
  1414   deserialG(&ds, B);
  1415   s = toStringG(&ds);
  1416   ck_assert_str_eq(s, "[true,false,false,true,null,true,false,true,false,true,true,true,true,true]");
  1417   free(s);
  1418   terminateG(B);
  1419   freeManyG(&n, &ds);
  1420 
  1421 
  1422   // dict in array
  1423   parseG(&n, "[{\"0\":null,\"1\":1},{\"2\":2},{\"3\":3},null]");
  1424   logVarG(&n);
  1425   B = serialG(&n);
  1426   logI("len %u", lenG(B));
  1427   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1428   s = sToString((smallt *) B->B);
  1429   ck_assert_str_eq(s, "[0x46,0x22,0x30,0x00,0x40,0x31,0x00,0x02,0x4e,0x01,0x32,0x00,0x04,0x4e,0x01,0x33,0x00,0x06,0x00]");
  1430   free(s);
  1431   deserialG(&ds, B);
  1432   s = toStringG(&ds);
  1433   ck_assert_str_eq(s, "[{\"0\":null,\"1\":1},{\"2\":2},{\"3\":3},null]");
  1434   free(s);
  1435   terminateG(B);
  1436   freeManyG(&n, &ds);
  1437 
  1438   // double in array
  1439   parseG(&n, "[1.0,2.0,null]");
  1440   logVarG(&n);
  1441   B = serialG(&n);
  1442   logI("len %u", lenG(B));
  1443   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1444   s = sToString((smallt *) B->B);
  1445   ck_assert_str_eq(s, "[0x36,0x33,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00]");
  1446   free(s);
  1447   deserialG(&ds, B);
  1448   s = toStringG(&ds);
  1449   ck_assert_str_eq(s, "[1.000000e+00,2.000000e+00,null]");
  1450   free(s);
  1451   terminateG(B);
  1452   freeManyG(&n, &ds);
  1453 
  1454   // int in array
  1455   parseG(&n, "[1,2,null]");
  1456   logVarG(&n);
  1457   B = serialG(&n);
  1458   logI("len %u", lenG(B));
  1459   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1460   s = sToString((smallt *) B->B);
  1461   ck_assert_str_eq(s, "[0x36,0x24,0x44,0x00]");
  1462   free(s);
  1463   deserialG(&ds, B);
  1464   s = toStringG(&ds);
  1465   ck_assert_str_eq(s, "[1,2,null]");
  1466   free(s);
  1467   terminateG(B);
  1468   freeManyG(&n, &ds);
  1469 
  1470   // string in array
  1471   parseG(&n, "[\"1\",\"2\",null]");
  1472   logVarG(&n);
  1473   B = serialG(&n);
  1474   logI("len %u", lenG(B));
  1475   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1476   s = sToString((smallt *) B->B);
  1477   ck_assert_str_eq(s, "[0x36,0x55,0x31,0x00,0x32,0x00,0x00]");
  1478   free(s);
  1479   deserialG(&ds, B);
  1480   s = toStringG(&ds);
  1481   ck_assert_str_eq(s, "[\"1\",\"2\",null]");
  1482   free(s);
  1483   terminateG(B);
  1484   freeManyG(&n, &ds);
  1485 
  1486   // array in array
  1487   parseG(&n, "[[],[1,2],null]");
  1488   logVarG(&n);
  1489   B = serialG(&n);
  1490   logI("len %u", lenG(B));
  1491   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1492   s = sToString((smallt *) B->B);
  1493   ck_assert_str_eq(s, "[0x36,0x0f,0x00,0x4f,0x02,0x02,0x04,0x00]");
  1494   free(s);
  1495   deserialG(&ds, B);
  1496   s = toStringG(&ds);
  1497   ck_assert_str_eq(s, "[[],[1,2],null]");
  1498   free(s);
  1499   terminateG(B);
  1500   freeManyG(&n, &ds);
  1501 
  1502 
  1503   // packed dicts
  1504   parseG(&n, "[{\"1\":1},{\"2\":2},{\"3\":3},{\"4\":4},null]");
  1505   logVarG(&n);
  1506   B = serialG(&n);
  1507   logI("len %u", lenG(B));
  1508   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1509   s = sToString((smallt *) B->B);
  1510   ck_assert_str_eq(s, "[0x56,0x48,0x01,0x31,0x00,0x24,0x01,0x32,0x00,0x44,0x01,0x33,0x00,0x64,0x01,0x34,0x00,0x84,0x01,0x00]");
  1511   free(s);
  1512   deserialG(&ds, B);
  1513   s = toStringG(&ds);
  1514   ck_assert_str_eq(s, "[{\"1\":1},{\"2\":2},{\"3\":3},{\"4\":4},null]");
  1515   free(s);
  1516   terminateG(B);
  1517   freeManyG(&n, &ds);
  1518 
  1519   // high nibble packed dicts
  1520   parseG(&n, "[null,{\"1\":1},{\"2\":2},{\"3\":3},{\"4\":4},null]");
  1521   logVarG(&n);
  1522   B = serialG(&n);
  1523   logI("len %u", lenG(B));
  1524   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1525   s = sToString((smallt *) B->B);
  1526   ck_assert_str_eq(s, "[0x66,0x80,0x04,0x01,0x31,0x00,0x24,0x01,0x32,0x00,0x44,0x01,0x33,0x00,0x64,0x01,0x34,0x00,0x84,0x01,0x00]");
  1527   free(s);
  1528   deserialG(&ds, B);
  1529   s = toStringG(&ds);
  1530   ck_assert_str_eq(s, "[null,{\"1\":1},{\"2\":2},{\"3\":3},{\"4\":4},null]");
  1531   free(s);
  1532   terminateG(B);
  1533   freeManyG(&n, &ds);
  1534 
  1535   // packed doubles
  1536   parseG(&n, "[1.0,2.0,3.0,4.0,null]");
  1537   logVarG(&n);
  1538   B = serialG(&n);
  1539   logI("len %u", lenG(B));
  1540   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1541   s = sToString((smallt *) B->B);
  1542   ck_assert_str_eq(s, "[0x56,0x49,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x40,0x00]");
  1543   free(s);
  1544   deserialG(&ds, B);
  1545   s = toStringG(&ds);
  1546   ck_assert_str_eq(s, "[1.000000e+00,2.000000e+00,3.000000e+00,4.000000e+00,null]");
  1547   free(s);
  1548   terminateG(B);
  1549   freeManyG(&n, &ds);
  1550 
  1551   // high nibble packed doubles
  1552   parseG(&n, "[null,1.0,2.0,3.0,4.0,null]");
  1553   logVarG(&n);
  1554   B = serialG(&n);
  1555   logI("len %u", lenG(B));
  1556   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1557   s = sToString((smallt *) B->B);
  1558   ck_assert_str_eq(s, "[0x66,0x90,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0x40,0x00,0x00,0x00,0x00,0x00,0x00,0x10,0x40,0x00]");
  1559   free(s);
  1560   deserialG(&ds, B);
  1561   s = toStringG(&ds);
  1562   ck_assert_str_eq(s, "[null,1.000000e+00,2.000000e+00,3.000000e+00,4.000000e+00,null]");
  1563   free(s);
  1564   terminateG(B);
  1565   freeManyG(&n, &ds);
  1566 
  1567   // packed ints
  1568   parseG(&n, "[1,2,3,4,null]");
  1569   logVarG(&n);
  1570   B = serialG(&n);
  1571   logI("len %u", lenG(B));
  1572   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1573   s = sToString((smallt *) B->B);
  1574   ck_assert_str_eq(s, "[0x56,0x4a,0x02,0x04,0x06,0x08,0x00]");
  1575   free(s);
  1576   deserialG(&ds, B);
  1577   s = toStringG(&ds);
  1578   ck_assert_str_eq(s, "[1,2,3,4,null]");
  1579   free(s);
  1580   terminateG(B);
  1581   freeManyG(&n, &ds);
  1582 
  1583   // high nibble packed ints
  1584   parseG(&n, "[null,1,2,3,4,null]");
  1585   logVarG(&n);
  1586   B = serialG(&n);
  1587   logI("len %u", lenG(B));
  1588   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1589   s = sToString((smallt *) B->B);
  1590   ck_assert_str_eq(s, "[0x66,0xa0,0x04,0x02,0x04,0x06,0x08,0x00]");
  1591   free(s);
  1592   deserialG(&ds, B);
  1593   s = toStringG(&ds);
  1594   ck_assert_str_eq(s, "[null,1,2,3,4,null]");
  1595   free(s);
  1596   terminateG(B);
  1597   freeManyG(&n, &ds);
  1598 
  1599   // packed strings
  1600   parseG(&n, "[\"1\",\"2\",\"3\",\"4\",null]");
  1601   logVarG(&n);
  1602   B = serialG(&n);
  1603   logI("len %u", lenG(B));
  1604   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1605   s = sToString((smallt *) B->B);
  1606   ck_assert_str_eq(s, "[0x56,0x4b,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x00]");
  1607   free(s);
  1608   deserialG(&ds, B);
  1609   s = toStringG(&ds);
  1610   ck_assert_str_eq(s, "[\"1\",\"2\",\"3\",\"4\",null]");
  1611   free(s);
  1612   terminateG(B);
  1613   freeManyG(&n, &ds);
  1614 
  1615   // high nibble packed strings
  1616   parseG(&n, "[null,\"1\",\"2\",\"3\",\"4\",null]");
  1617   logVarG(&n);
  1618   B = serialG(&n);
  1619   logI("len %u", lenG(B));
  1620   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1621   s = sToString((smallt *) B->B);
  1622   ck_assert_str_eq(s, "[0x66,0xb0,0x04,0x31,0x00,0x32,0x00,0x33,0x00,0x34,0x00,0x00]");
  1623   free(s);
  1624   deserialG(&ds, B);
  1625   s = toStringG(&ds);
  1626   ck_assert_str_eq(s, "[null,\"1\",\"2\",\"3\",\"4\",null]");
  1627   free(s);
  1628   terminateG(B);
  1629   freeManyG(&n, &ds);
  1630 
  1631   // packed arrays
  1632   parseG(&n, "[[1],[2],[3],[4],null]");
  1633   logVarG(&n);
  1634   B = serialG(&n);
  1635   logI("len %u", lenG(B));
  1636   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1637   s = sToString((smallt *) B->B);
  1638   ck_assert_str_eq(s, "[0x56,0x4c,0x01,0x24,0x01,0x44,0x01,0x64,0x01,0x84,0x01,0x00]");
  1639   free(s);
  1640   deserialG(&ds, B);
  1641   s = toStringG(&ds);
  1642   ck_assert_str_eq(s, "[[1],[2],[3],[4],null]");
  1643   free(s);
  1644   terminateG(B);
  1645   freeManyG(&n, &ds);
  1646 
  1647   // high nibble packed arrays
  1648   parseG(&n, "[null,[1],[2],[3],[4],null]");
  1649   logVarG(&n);
  1650   B = serialG(&n);
  1651   logI("len %u", lenG(B));
  1652   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1653   s = sToString((smallt *) B->B);
  1654   ck_assert_str_eq(s, "[0x66,0xc0,0x04,0x01,0x24,0x01,0x44,0x01,0x64,0x01,0x84,0x01,0x00]");
  1655   free(s);
  1656   deserialG(&ds, B);
  1657   s = toStringG(&ds);
  1658   ck_assert_str_eq(s, "[null,[1],[2],[3],[4],null]");
  1659   free(s);
  1660   terminateG(B);
  1661   freeManyG(&n, &ds);
  1662 
  1663   // smallBytes
  1664   parseG(&n, "[1,2,null]");
  1665   createSmallBytes(b);
  1666   pushG(&b, 1);
  1667   pushG(&b, 2);
  1668   pushG(&b, 3);
  1669   pushG(&b, 4);
  1670   pushG(&b, 5);
  1671   pushG(&b, 6);
  1672   pushG(&n, &b);
  1673   logVarG(&n);
  1674   B = serialG(&n);
  1675   logI("len %u", lenG(B));
  1676   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1677   s = sToString((smallt *) B->B);
  1678   ck_assert_str_eq(s, "[0x46,0x24,0x44,0x70,0x06,0x01,0x02,0x03,0x04,0x05,0x06]");
  1679   free(s);
  1680   deserialG(&ds, B);
  1681   s = toStringG(&ds);
  1682   ck_assert_str_eq(s, "[1,2,null,[0x01,0x02,0x03,0x04,0x05,0x06]]");
  1683   free(s);
  1684   terminateG(B);
  1685   freeManyG(&n, &ds);
  1686 
  1687   parseG(&n, "[1,2]");
  1688   initiateG(&b);
  1689   pushG(&b, 1);
  1690   pushG(&b, 2);
  1691   pushG(&b, 3);
  1692   pushG(&b, 4);
  1693   pushG(&b, 5);
  1694   pushG(&b, 6);
  1695   pushG(&n, &b);
  1696   logVarG(&n);
  1697   B = serialG(&n);
  1698   logI("len %u", lenG(B));
  1699   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1700   s = sToString((smallt *) B->B);
  1701   ck_assert_str_eq(s, "[0x36,0x24,0x44,0x67,0x01,0x02,0x03,0x04,0x05,0x06]");
  1702   free(s);
  1703   deserialG(&ds, B);
  1704   s = toStringG(&ds);
  1705   ck_assert_str_eq(s, "[1,2,[0x01,0x02,0x03,0x04,0x05,0x06]]");
  1706   free(s);
  1707   terminateG(B);
  1708   freeManyG(&n, &ds);
  1709 
  1710 }
  1711 
  1712 
  1713 void variousT(void) {
  1714 
  1715   createNetSerial(n);
  1716   createNetSerial(ds);
  1717   char *s;
  1718   smallBytest *B;
  1719 
  1720 
  1721   // array dict int bool string
  1722   parseG(&n, "[0, \"asd\", {\"rpc\":\"ds\", \"id\":1, \"p\":true}, [true, \"user\", [[false,\"name\",1], [true, \"name2\", 12340], [false, \"zxc\", 234]]]]");
  1723   logVarG(&n);
  1724   B = serialG(&n);
  1725   logI("len %u", lenG(B));
  1726   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1727   s = sToString((smallt *) B->B);
  1728   ck_assert_str_eq(s, "[0x46,0x04,0x25,0x61,0x73,0x64,0x00,0x03,0x72,0x70,0x63,0x00,0x45,0x64,0x73,0x00,0x69,0x64,0x00,0x02,0x70,0x00,0xb1,0x36,0x51,0x75,0x73,0x65,0x72,0x00,0x6f,0x03,0x03,0x51,0x6e,0x61,0x6d,0x65,0x00,0x24,0x03,0x51,0x6e,0x61,0x6d,0x65,0x32,0x00,0x84,0x8d,0x18,0x03,0x01,0x45,0x7a,0x78,0x63,0x00,0xd4,0x03]");
  1729   free(s);
  1730   deserialG(&ds, B);
  1731   s = toStringG(&ds);
  1732   ck_assert_str_eq(s, "[0,\"asd\",{\"rpc\":\"ds\",\"id\":1,\"p\":true},[true,\"user\",[[false,\"name\",1],[true,\"name2\",12340],[false,\"zxc\",234]]]]");
  1733   free(s);
  1734   terminateG(B);
  1735   freeManyG(&n, &ds);
  1736 
  1737   parseG(&n, "[[{a:1}, null, {a:1}, {a:1}]]");
  1738   logVarG(&n);
  1739   B = serialG(&n);
  1740   logI("len %u", lenG(B));
  1741   logSI("%s",toHexSepS(getValG(B), lenG(B), " "));
  1742   s = sToString((smallt *) B->B);
  1743   ck_assert_str_eq(s, "[0x6f,0x01,0x04,0x4e,0x01,0x61,0x00,0x02,0xe0,0x14,0x61,0x00,0x02,0x4e,0x01,0x61,0x00,0x02]");
  1744   free(s);
  1745   deserialG(&ds, B);
  1746   s = toStringG(&ds);
  1747   ck_assert_str_eq(s, "[[{\"a\":1},null,{\"a\":1},{\"a\":1}]]");
  1748   free(s);
  1749   terminateG(B);
  1750   freeManyG(&n, &ds);
  1751 
  1752 }
  1753 
  1754 
  1755 int main(int n, char**v) {
  1756 
  1757 initLibsheepy(v[0]);
  1758 setLogMode(LOG_FUNC);
  1759 
  1760 topT();
  1761 uniformDictT();
  1762 uniformArrayT();
  1763 dictT();
  1764 arrayT();
  1765 variousT();
  1766 }