automated-tests/src/dali-toolkit-unmanaged/utc-Dali-JsonParser.cpp

   1 //
   2 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.0 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 #include <iostream>
  18 #include <stdlib.h>
  19 #include <dali-toolkit-test-suite-utils.h>
  20 #include <dali-toolkit/dali-toolkit.h>
  21 #include <dali-toolkit/public-api/builder/json-parser.h>
  22
  23 using namespace Dali;
  24 using namespace Dali::Toolkit;
  25
  26 void utc_json_parser_startup(void)
  27 {
  28   test_return_value = TET_UNDEF;
  29 }
  30
  31 void utc_json_parser_cleanup(void)
  32 {
  33   test_return_value = TET_PASS;
  34 }
  35
  36 namespace
  37 {
  38
  39 std::string ReplaceQuotes(const std::string &in_s)
  40 {
  41   std::string s(in_s);
  42   // wrong as no embedded quote but had regex link problems
  43   std::replace(s.begin(), s.end(), '\'', '"');
  44   return s;
  45 }
  46
  47 void CompareTrees(const TreeNode& a, const TreeNode& b)
  48 {
  49   DALI_TEST_CHECK( a.GetType() == b.GetType() );
  50
  51   DALI_TEST_CHECK( a.Size() == b.Size() );
  52
  53   if( a.GetName() )
  54   {
  55     DALI_TEST_CHECK( std::string( a.GetName() ) == std::string( b.GetName() ) );
  56   }
  57
  58   DALI_TEST_CHECK( a.HasSubstitution() == b.HasSubstitution() );
  59
  60   switch( a.GetType() )
  61   {
  62     case TreeNode::OBJECT:
  63     case TreeNode::ARRAY:
  64     {
  65       for( TreeNode::ConstIterator aiter = a.CBegin(), biter = b.CBegin();
  66            aiter != a.CEnd() && biter != b.CEnd(); ++aiter, ++biter )
  67       {
  68         CompareTrees( (*aiter).second, (*biter).second );
  69       }
  70       break;
  71     }
  72     case TreeNode::STRING:
  73     {
  74       DALI_TEST_CHECK( std::string( a.GetString() ) == std::string( b.GetString() ) );
  75       break;
  76     }
  77     case TreeNode::FLOAT:
  78     {
  79       DALI_TEST_CHECK( a.GetFloat() == b.GetFloat() );
  80       break;
  81     }
  82     case TreeNode::INTEGER:
  83     {
  84       DALI_TEST_CHECK( a.GetInteger() == b.GetInteger());
  85       break;
  86     }
  87     case TreeNode::BOOLEAN:
  88     {
  89       DALI_TEST_CHECK( a.GetBoolean() == b.GetBoolean() );
  90       break;
  91     }
  92   }
  93 }
  94
  95
  96 }
  97
  98
  99 int UtcDaliJsonParserMethod01(void)
 100 {
 101   ToolkitTestApplication application;
 102
 103   tet_infoline("JSON basic test");
 104
 105   std::string s1( ReplaceQuotes(
 106 "{ \
 107   'string':'value2', \
 108   'integer':2, \
 109   'float':2.0, \
 110   'boolean':true, \
 111   'nil':null, \
 112   'array':[1,2,3], \
 113   'object':{'key':'value'} \
 114 }"));
 115
 116   JsonParser parser = JsonParser::New();
 117
 118   parser.Parse( s1 );
 119
 120   if(parser.ParseError())
 121   {
 122     std::cout << "Error: " << parser.GetErrorDescription() << std::endl;
 123     std::cout << "   at: " << parser.GetErrorLineNumber() << "(" << parser.GetErrorPosition() << ")" << std::endl;
 124   }
 125
 126   DALI_TEST_CHECK(!parser.ParseError());
 127
 128   const TreeNode* root = parser.GetRoot();
 129
 130   DALI_TEST_CHECK(root);
 131
 132   DALI_TEST_CHECK(root->Size());
 133
 134   TreeNode::ConstIterator iter = root->CBegin();
 135   DALI_TEST_CHECK(iter != root->CEnd());
 136
 137   const TreeNode* node = NULL;
 138
 139   node = &((*iter).second);
 140   DALI_TEST_CHECK(node);
 141   DALI_TEST_CHECK(node->GetType() == TreeNode::STRING);
 142   DALI_TEST_CHECK(std::string((*iter).first) == std::string("string"));
 143   DALI_TEST_CHECK(std::string(node->GetString()) == std::string("value2"));
 144
 145   ++iter;
 146   DALI_TEST_CHECK(iter != root->CEnd());
 147   node = &((*iter).second);
 148   DALI_TEST_CHECK(node);
 149   DALI_TEST_CHECK(node->GetType() == TreeNode::INTEGER);
 150   DALI_TEST_CHECK(std::string((*iter).first) == std::string("integer"));
 151   DALI_TEST_CHECK(node->GetInteger() == 2);
 152
 153   ++iter;
 154   DALI_TEST_CHECK(iter != root->CEnd());
 155   node = &((*iter).second);
 156   DALI_TEST_CHECK(node);
 157   DALI_TEST_CHECK(node->GetType() == TreeNode::FLOAT);
 158   DALI_TEST_CHECK(std::string((*iter).first) == std::string("float"));
 159   DALI_TEST_CHECK(node->GetFloat() == 2.0);
 160
 161   ++iter;
 162   DALI_TEST_CHECK(iter != root->CEnd());
 163   node = &((*iter).second);
 164   DALI_TEST_CHECK(node);
 165   DALI_TEST_CHECK(node->GetType() == TreeNode::BOOLEAN);
 166   DALI_TEST_CHECK(std::string((*iter).first) == std::string("boolean"));
 167   DALI_TEST_CHECK(node->GetBoolean());
 168
 169   ++iter;
 170   DALI_TEST_CHECK(iter != root->CEnd());
 171   node = &((*iter).second);
 172   DALI_TEST_CHECK(node);
 173   DALI_TEST_CHECK(node->GetType() == TreeNode::IS_NULL);
 174   DALI_TEST_CHECK(std::string((*iter).first) == std::string("nil"));
 175
 176   ++iter;
 177   DALI_TEST_CHECK(iter != root->CEnd());
 178   node = &((*iter).second);
 179   DALI_TEST_CHECK(node);
 180   DALI_TEST_CHECK(node->GetType() == TreeNode::ARRAY);
 181   DALI_TEST_CHECK(node->Size() == 3);
 182   TreeNode::ConstIterator iterArray = node->CBegin();
 183
 184   DALI_TEST_CHECK(iterArray != node->CEnd());
 185   DALI_TEST_CHECK( ((*iterArray).second).GetType() == TreeNode::INTEGER);
 186   DALI_TEST_CHECK( (*iterArray).first == NULL );
 187   DALI_TEST_CHECK( ((*iterArray).second).GetInteger() == 1);
 188
 189   ++iterArray;
 190   DALI_TEST_CHECK(iterArray != node->CEnd());
 191   DALI_TEST_CHECK( ((*iterArray).second).GetType() == TreeNode::INTEGER);
 192   DALI_TEST_CHECK( (*iterArray).first == NULL );
 193   DALI_TEST_CHECK( ((*iterArray).second).GetInteger() == 2);
 194
 195   ++iterArray;
 196   DALI_TEST_CHECK(iterArray != node->CEnd());
 197   DALI_TEST_CHECK( ((*iterArray).second).GetType() == TreeNode::INTEGER);
 198   DALI_TEST_CHECK( (*iterArray).first == NULL );
 199   DALI_TEST_CHECK( ((*iterArray).second).GetInteger() == 3);
 200
 201   ++iter;
 202   DALI_TEST_CHECK(iter != root->CEnd());
 203   node = &((*iter).second);
 204   DALI_TEST_CHECK(node);
 205   DALI_TEST_CHECK(node->GetType() == TreeNode::OBJECT);
 206   DALI_TEST_CHECK(node->Size() == 1);
 207
 208   TreeNode::ConstIterator iterObject = node->CBegin();
 209   DALI_TEST_CHECK(iterObject != node->CEnd());
 210   DALI_TEST_CHECK( ((*iterObject).second).GetType() == TreeNode::STRING);
 211   DALI_TEST_CHECK( std::string((*iterObject).first) == std::string("key" ));
 212   DALI_TEST_CHECK( std::string(((*iterObject).second).GetString()) == std::string("value"));
 213
 214   tet_result(TET_PASS);
 215   END_TEST;
 216 }
 217
 218 int UtcDaliJsonParserMethod02(void)
 219 {
 220   ToolkitTestApplication application;
 221
 222   tet_infoline("JSON Comments");
 223
 224   std::string s1( ReplaceQuotes("         \
 225 // some comments with empty line above  \n\
 226 {                                         \
 227   // inline comments                    \n\
 228   'key':'value', // endline comments    \n\
 229   // more inline comments               \n\
 230   'key2':'value2'                         \
 231 }                                         \
 232 "));
 233
 234   JsonParser parser = JsonParser::New();
 235
 236   parser.Parse( s1 );
 237
 238   if(parser.ParseError())
 239   {
 240     std::cout << "Error: " << parser.GetErrorDescription() << std::endl;
 241     std::cout << "   at: " << parser.GetErrorLineNumber() << "(" << parser.GetErrorPosition() << ")" << std::endl;
 242   }
 243
 244   DALI_TEST_CHECK(!parser.ParseError());
 245
 246   const TreeNode* root = parser.GetRoot();
 247
 248   DALI_TEST_CHECK(root);
 249
 250   DALI_TEST_CHECK(root->Size());
 251
 252   const TreeNode& node = (*root->CBegin()).second;
 253
 254   DALI_TEST_CHECK(node.GetType() == TreeNode::STRING);
 255
 256   DALI_TEST_CHECK(node.GetString() == std::string("value"));
 257
 258   DALI_TEST_CHECK((*root->CBegin()).first == std::string("key"));
 259
 260   tet_result(TET_PASS);
 261   END_TEST;
 262 }
 263
 264
 265 int UtcDaliJsonParserMethod03(void)
 266 {
 267   ToolkitTestApplication application;
 268
 269   tet_infoline("JSON Empty line comment");
 270
 271   std::string s1( ReplaceQuotes(
 272 "/*\n" \
 273 "c comment\n" \
 274 "*/"\
 275 "// next empty line comment\n"\
 276 "//\n"\
 277 "{\n"\
 278 "  'key':'value'\n"\
 279 "}\n"\
 280 ));
 281
 282   JsonParser parser = JsonParser::New();
 283
 284   parser.Parse( s1 );
 285
 286   if(parser.ParseError())
 287   {
 288     std::cout << "Error: " << parser.GetErrorDescription() << std::endl;
 289     std::cout << "   at: " << parser.GetErrorLineNumber() << "(" << parser.GetErrorPosition() << ")" << std::endl;
 290   }
 291
 292   DALI_TEST_CHECK(!parser.ParseError());
 293
 294   const TreeNode* root = parser.GetRoot();
 295
 296   DALI_TEST_CHECK(root);
 297
 298   DALI_TEST_CHECK(root->Size());
 299
 300   const TreeNode& node = (*root->CBegin()).second;
 301
 302   DALI_TEST_CHECK(node.GetType() == TreeNode::STRING);
 303
 304   DALI_TEST_CHECK(node.GetString() == std::string("value"));
 305
 306   DALI_TEST_CHECK((*root->CBegin()).first == std::string("key"));
 307
 308   tet_result(TET_PASS);
 309   END_TEST;
 310 }
 311
 312 int UtcDaliJsonParserMethod04(void)
 313 {
 314   ToolkitTestApplication application;
 315
 316   tet_infoline("JSON Merge");
 317
 318   std::string s1( ReplaceQuotes("                                       \
 319 {                                                                       \
 320   'animations':                                                         \
 321   {                                                                     \
 322     'bump':                                                             \
 323     {                                                                   \
 324       'properties':                                                     \
 325       [                                                                 \
 326         {                                                               \
 327           'actor':'bump-image',                                         \
 328           'property':'uLightPosition',                                  \
 329           'value':[0.8, 0.0, -1.5],                                     \
 330           'alpha-function': 'BOUNCE',                                   \
 331           'time-period': { 'duration': 2.5 }                            \
 332         }                                                               \
 333       ]                                                                 \
 334     }                                                                   \
 335   }                                                                     \
 336 }                                                                       \
 337 "));
 338
 339   std::string s2( ReplaceQuotes("                                       \
 340 {                                                                       \
 341   'animations':                                                         \
 342   {                                                                     \
 343     'bump':                                                             \
 344     {                                                                   \
 345       'duration': 5.0,                                                  \
 346       'loop': true,                                                     \
 347       'end-action':'DISCARD'                                            \
 348     }                                                                   \
 349   }                                                                     \
 350 }                                                                       \
 351 "));
 352
 353   JsonParser parser = JsonParser::New();
 354
 355   parser.Parse( s1 );
 356
 357   if(parser.ParseError())
 358   {
 359     std::cout << "Error: " << parser.GetErrorDescription() << std::endl;
 360     std::cout << "   at: " << parser.GetErrorLineNumber() << "(" << parser.GetErrorPosition() << ")" << std::endl;
 361   }
 362   DALI_TEST_CHECK(!parser.ParseError());
 363
 364   parser.Parse( s2 );
 365
 366   if(parser.ParseError())
 367   {
 368     std::cout << "Error: " << parser.GetErrorDescription() << std::endl;
 369     std::cout << "   at: " << parser.GetErrorLineNumber() << "(" << parser.GetErrorPosition() << ")" << std::endl;
 370   }
 371
 372   DALI_TEST_CHECK(!parser.ParseError());
 373
 374   const TreeNode* root = parser.GetRoot();
 375   DALI_TEST_CHECK(root);
 376
 377   const TreeNode *node = root->Find("bump");
 378   DALI_TEST_CHECK(node);
 379
 380   DALI_TEST_CHECK(static_cast<int>(node->Size()) == 4);
 381
 382   DALI_TEST_CHECK( node->GetChild("duration") );
 383   DALI_TEST_CHECK( node->GetChild("loop") );
 384   DALI_TEST_CHECK( node->GetChild("properties") );
 385
 386
 387   tet_result(TET_PASS);
 388   END_TEST;
 389 }
 390
 391 int UtcDaliJsonParserMethod05(void)
 392 {
 393   ToolkitTestApplication application;
 394
 395   tet_infoline("JSON Pack & Write");
 396
 397   std::string s1( ReplaceQuotes("                                       \
 398 {                                                                       \
 399   'animations':                                                         \
 400   {                                                                     \
 401     'bump':                                                             \
 402     {                                                                   \
 403       'properties':                                                     \
 404       [                                                                 \
 405         {                                                               \
 406           'actor':'bump-image',                                         \
 407           'property':'uLightPosition',                                  \
 408           'value':[0.8, 0.0, -1.5],                                     \
 409           'alpha-function': 'BOUNCE',                                   \
 410           'time-period': { 'duration': 2.5 }                            \
 411         }                                                               \
 412       ]                                                                 \
 413     }                                                                   \
 414   }                                                                     \
 415 }                                                                       \
 416 "));
 417
 418   JsonParser parser = JsonParser::New();
 419
 420   parser.Parse( s1 );
 421
 422   if(parser.ParseError())
 423   {
 424     std::cout << "Error: " << parser.GetErrorDescription() << std::endl;
 425     std::cout << "   at: " << parser.GetErrorLineNumber() << "(" << parser.GetErrorPosition() << ")" << std::endl;
 426   }
 427   DALI_TEST_CHECK(!parser.ParseError());
 428
 429   std::stringstream a;
 430   parser.Write(a, 2);
 431
 432   parser.Pack();
 433
 434   std::stringstream b;
 435   parser.Write(b, 2);
 436
 437   DALI_TEST_CHECK( a.str() == b.str() );
 438
 439   tet_result(TET_PASS);
 440   END_TEST;
 441 }
 442
 443 namespace
 444 {
 445
 446 static const int NUMBER_OK_TESTS = 36;
 447 const char *TEST_OK[NUMBER_OK_TESTS] = {
 448   "{ 'hex': '\u0123\u4567\u89AB\uCDEF\uabcd\uef4A' }",
 449   "{ 'special': '`1~!@#$%^&*()_+-={:[,]}|;.</>?' }",
 450   "{ 'slash': '/ & \' }",
 451   "{'object with 1 member':['array with 1 element']}",
 452   "[{}, [], -42, true, false, null]",
 453   "{ 'integer': 1234567890 }",
 454   "{ 'integer': 1234567890 }",
 455   "{ 'real': -9876.543210 }",
 456   "{ 'e': 0.123456789e-12 }",
 457   "{ 'E': 1.234567890E+34 }",
 458   "{ '':  23456789012E66 }",
 459   "{ 'zero': 0 }",
 460   "{ 'one': 1 }",
 461   "{ 'space': ' ' }",
 462   "{ 'backslash': '\' }",
 463   "{ 'controls': '\\b\\f\\n\\r\\t' }",
 464   "{ 'alpha': 'abcdefghijklmnopqrstuvwyz' }",
 465   "{ 'ALPHA': 'ABCDEFGHIJKLMNOPQRSTUVWYZ' }",
 466   "{ 'digit': '0123456789' }",
 467   "{ '0123456789': 'digit' }",
 468   "{ 'true': true }",
 469   "{ 'false': false }",
 470   "{ 'null': null }",
 471   "{ 'array':[  ] }",
 472   "{ 'object':{  } }",
 473   "{ 'address': '1 Communication Centre. South Street' }",
 474   "{ 'url': 'http://www.JSON.org/' }",
 475   "{ 'comment': '// /* <!-- --' }",
 476   "{ '# -- --> */': ' ' }",
 477   "{ ' s p a c e d ' :[1,2 , 3,4 , 5        ,          6           ,7        ]}",
 478   "{ 'compact':[1,2,3,4,5,6,7]}",
 479   "{ 'quotes': '&#34; \\u0022 %22 0x22 034 &#x22;' }",
 480   "{ '\\uCAFE\\uBABE\\uAB98\\uFCDE\\ubcda\\uef4A\\b\\f\\n\\r\\t`1~!@#$%^&*()_+-=[]{}|;:': 'A key can be any string'}",
 481   "[ 0.5 ,98.6, 99.44,1066,1e1,0.1e1,1e-1,1e00,2e+00,2e-00, 'rosebud']",
 482   "{'JSON Test Pattern pass3': { 'The outermost value': 'must be an object or array.', 'In this test': 'It is an object.' } }",
 483   "[[[[[[[[[[[[[[[[[[['Not too deep']]]]]]]]]]]]]]]]]]]",
 484 };
 485 }
 486
 487
 488 int UtcDaliJsonParserMethod06(void)
 489 {
 490   ToolkitTestApplication application;
 491
 492   tet_infoline("JSON Parse Success");
 493
 494   JsonParser parser = JsonParser::New();
 495
 496   for(int i = 0; i < NUMBER_OK_TESTS; ++i)
 497   {
 498     parser = JsonParser::New();
 499
 500     parser.Parse( ReplaceQuotes(TEST_OK[i]) );
 501
 502     if(parser.ParseError())
 503     {
 504       tet_printf("Valid JSON parse test %d Failed", i);
 505       tet_printf("%s", ReplaceQuotes(TEST_OK[i]).c_str());
 506
 507       tet_printf("JSON Error %d:%d: %s (%d)", parser.GetErrorLineNumber(), parser.GetErrorColumn(), parser.GetErrorDescription().c_str(), parser.GetErrorPosition());
 508     }
 509
 510     DALI_TEST_CHECK(!parser.ParseError());
 511   }
 512
 513   tet_result(TET_PASS);
 514   END_TEST;
 515 }
 516
 517 namespace
 518 {
 519
 520 static const int NUMBER_FAIL_TESTS = 34;
 521 const char *TEST_FAIL[] = {
 522   "[' tab\t   character  \t in\t string   ']",
 523   "['Extra close']]",
 524   "['Colon instead of comma': false]",
 525   "{'Numbers cannot have leading zeroes': 013}",
 526   "['Bad value', truth]",
 527   "['Illegal backslash escape: \017']",
 528   "['Bad value', truth]['Illegal backslash escape: \017']",
 529   "{'Comma instead if closing brace': true,",
 530   "{'Double colon':: null}",
 531   "{'Extra comma': true,}",
 532   "['Unclosed array'",
 533   "{'Illegal invocation': alert()}",
 534   "{'Missing colon' null}",
 535   "[0e]",
 536   "{unquoted_key: 'keys must be quoted'}",
 537   "'A JSON payload should be an object or array, not a string.'",
 538   "[\naked]",
 539   "{'Illegal expression': 1 + 2}",
 540   "{'Extra value after close': true} 'misplaced quoted value'",
 541   "[0e+]",
 542   "[+23456789012E66]",
 543   "['extra comma',]",
 544   "['Comma after the close'],",
 545   "['double extra comma',,]",
 546   "['Illegal backslash escape: \x15']",
 547   "['line\nbreak']",
 548   "{'Comma instead of colon', null}",
 549   "['mismatch'}",
 550   "['line\nbreak']",
 551   "[0e+-1]",
 552   "{'Numbers cannot be hex': 0x14}",
 553   "[   , '<-- missing value']",
 554   "[{'no comma':1} {'b:2}]",
 555   "{'extra comma':1,}",
 556 };
 557 }
 558
 559 int UtcDaliJsonParserMethod07(void)
 560 {
 561   ToolkitTestApplication application;
 562
 563   tet_infoline("JSON Fail");
 564
 565   JsonParser parser = JsonParser::New();
 566
 567   for(int i = 0; i < NUMBER_FAIL_TESTS; ++i)
 568   {
 569     parser = JsonParser::New();
 570
 571     parser.Parse( ReplaceQuotes(TEST_FAIL[i]) );
 572
 573     if(!parser.ParseError())
 574     {
 575       tet_printf("Invalid JSON parse test %d Failed", i);
 576       tet_printf("%s", ReplaceQuotes(TEST_FAIL[i]).c_str());
 577       tet_printf("JSON Error %d:%d %s (%s)", parser.GetErrorLineNumber(), parser.GetErrorColumn(),
 578                  parser.GetErrorDescription().c_str(), parser.GetErrorPosition());
 579     }
 580
 581     DALI_TEST_CHECK(parser.ParseError());
 582   }
 583
 584
 585   parser = JsonParser::New();
 586
 587   parser.Parse( "['single quote']" );
 588
 589   if(!parser.ParseError())
 590   {
 591     tet_printf("['single quote']");
 592   }
 593
 594   DALI_TEST_CHECK(parser.ParseError());
 595
 596   tet_result(TET_PASS);
 597   END_TEST;
 598 }
 599
 600 int UtcDaliJsonParserMethod08(void)
 601 {
 602   ToolkitTestApplication application;
 603
 604   tet_infoline("JSON error reporting");
 605
 606   std::string s1( ReplaceQuotes("\
 607 {                                         \n\
 608   'float':,],                             \n\
 609 }                                         \n\
 610 "));
 611
 612   JsonParser parser = JsonParser::New();
 613
 614   parser.Parse( s1 );
 615
 616   DALI_TEST_CHECK(parser.ParseError());
 617
 618   DALI_TEST_CHECK(1  == parser.GetErrorLineNumber());
 619   DALI_TEST_CHECK(53 == parser.GetErrorPosition());
 620   DALI_TEST_CHECK(11 == parser.GetErrorColumn());
 621
 622   tet_result(TET_PASS);
 623   END_TEST;
 624 }
 625
 626 int UtcDaliJsonParserMethod09(void)
 627 {
 628   ToolkitTestApplication application;
 629
 630   tet_infoline("JSON Pack()");
 631
 632   std::string s1( ReplaceQuotes("\
 633 {                                         \
 634   'string':'value2',                      \
 635   'integer':2,                            \
 636   'float':2.3,                            \
 637   'boolean':true,                         \
 638   'nil':null,                             \
 639   'array':[1,2,3],                        \
 640   'object':{'key':'value'}                \
 641 }                                         \
 642 "));
 643
 644   JsonParser parser = JsonParser::New();
 645
 646   parser.Parse( s1 );
 647
 648   std::stringstream ss1;
 649   parser.Write(ss1, 2);
 650
 651   parser.Pack(); // Pack() moves strings
 652
 653   std::stringstream ss2;
 654   parser.Write(ss2, 2);
 655
 656   DALI_TEST_CHECK(ss1.str() == ss2.str());
 657
 658   tet_result(TET_PASS);
 659   END_TEST;
 660 }
 661
 662 int UtcDaliJsonParserMethod10(void)
 663 {
 664   ToolkitTestApplication application;
 665
 666   tet_infoline("JSON empty data");
 667
 668   std::string s1( "" );
 669
 670   JsonParser parser = JsonParser::New();
 671
 672   parser.Parse( s1 );
 673
 674   DALI_TEST_CHECK(parser.ParseError());
 675
 676   tet_result(TET_PASS);
 677   END_TEST;
 678 }
 679
 680 int UtcDaliJsonParserMethod11(void)
 681 {
 682   ToolkitTestApplication application;
 683   tet_infoline("JSON tree copy");
 684
 685   std::string s1( ReplaceQuotes("                                       \
 686 {                                                                       \
 687   'animations':                                                         \
 688   {                                                                     \
 689     'bump':                                                             \
 690     {                                                                   \
 691       'properties':                                                     \
 692       [                                                                 \
 693         {                                                               \
 694           'actor':'bump-image',                                         \
 695           'property':'uLightPosition',                                  \
 696           'value':[0.8, 0.0, -1.5],                                     \
 697           'alpha-function': 'BOUNCE',                                   \
 698           'time-period': { 'duration': 2.5 }                            \
 699         }                                                               \
 700       ]                                                                 \
 701     }                                                                   \
 702   }                                                                     \
 703 }                                                                       \
 704 "));
 705
 706   JsonParser parser = JsonParser::New();
 707
 708   parser.Parse( s1 );
 709
 710   JsonParser parser2 = JsonParser::New(*parser.GetRoot());
 711
 712   DALI_TEST_CHECK(parser.GetRoot());
 713   DALI_TEST_CHECK(parser2.GetRoot());
 714
 715   CompareTrees( *parser.GetRoot(), *parser2.GetRoot() );
 716
 717   tet_result(TET_PASS);
 718   END_TEST;
 719 }