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

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