NewLang Project
Yet another programm language
Loading...
Searching...
No Matches
run_test.cpp
Go to the documentation of this file.
1//#ifdef BUILD_UNITTEST
2//
3//#include "warning_push.h"
4//#include <gtest/gtest.h>
5//
6//#include <torch/torch.h>
7//#include <ATen/ATen.h>
8//#include "warning_pop.h"
9//
10//
11//#include "parser.h"
12//
13//#include <signal.h>
14//
15//#include "builtin.h"
16//#include "runtime.h"
17//#include "context.h"
18//#include "jit.h"
19//
20//using namespace newlang;
21//
22//TEST(Run, Simple) {
23// JIT * jit = JIT::ReCreate();
24// ASSERT_TRUE(jit);
25//
26// ObjPtr res = jit->Run("123");
27// ASSERT_TRUE(res);
28// ASSERT_STREQ("123", res->toString().c_str());
29// ASSERT_EQ(1, jit->m_main_ast->m_block.size());
30//
31// res = jit->Run("123.456");
32// ASSERT_TRUE(res);
33// ASSERT_STREQ("123.456", res->toString().c_str());
34// ASSERT_EQ(2, jit->m_main_ast->m_block.size());
35//
36// res = jit->Run("'123.456'");
37// ASSERT_TRUE(res);
38// ASSERT_STREQ("'123.456'", res->toString().c_str());
39// ASSERT_EQ(3, jit->m_main_ast->m_block.size());
40//
41// res = jit->Run("\"123.456\"");
42// ASSERT_TRUE(res);
43// ASSERT_STREQ("\"123.456\"", res->toString().c_str());
44// ASSERT_EQ(4, jit->m_main_ast->m_block.size());
45//
46// res = jit->Run("(,)");
47// ASSERT_TRUE(res);
48// ASSERT_STREQ("(,)", res->toString().c_str());
49// ASSERT_EQ(5, jit->m_main_ast->m_block.size());
50//
51// res = jit->Run("(123,)");
52// ASSERT_TRUE(res);
53// ASSERT_STREQ("(123,)", res->toString().c_str());
54// ASSERT_EQ(6, jit->m_main_ast->m_block.size());
55//
56// res = jit->Run("(name=123,)");
57// ASSERT_TRUE(res);
58// ASSERT_STREQ("(name=123,)", res->toString().c_str());
59// ASSERT_EQ(7, jit->m_main_ast->m_block.size());
60//
61// res = jit->Run("(name=123,):ClassName");
62// ASSERT_TRUE(res);
63// ASSERT_STREQ("(name=123,):ClassName", res->toString().c_str());
64// ASSERT_EQ(8, jit->m_main_ast->m_block.size());
65//
66// res = jit->Run("[123,]");
67// ASSERT_TRUE(res);
68// ASSERT_STREQ("[123,]:Int8", res->toString().c_str());
69// ASSERT_EQ(9, jit->m_main_ast->m_block.size());
70//
71// res = jit->Run("[123,456,]:Float32");
72// ASSERT_TRUE(res);
73// ASSERT_STREQ("[123, 456,]:Float32", res->toString().c_str());
74// ASSERT_EQ(10, jit->m_main_ast->m_block.size());
75//}
76//
317//
318//
319//static int64_t var_long = 987654321;
320//
321//static int64_t func_export(int64_t arg_long, uint8_t arg_byte) {
322// return arg_long + 2 * arg_byte;
323//}
324//
325//TEST(Eval, Assign) {
326//
327// JIT * jit = JIT::ReCreate();
328//
329// ObjPtr list = jit->Run("$?!");
330// ASSERT_STREQ("(,)", list->toString().c_str());
331//
332// ObjPtr var1 = jit->Run("var1 ::= 123");
333// ASSERT_TRUE(var1);
334// ASSERT_TRUE(var1->is_arithmetic_type());
335// ASSERT_TRUE(var1->is_integer());
336// ASSERT_TRUE(std::holds_alternative<int64_t>(var1->m_var));
337// ASSERT_EQ(var1->m_var_type_current, ObjType::Int8) << newlang::toString(var1->m_var_type_current);
338// ASSERT_EQ(var1->m_var_type_fixed, ObjType::None) << newlang::toString(var1->m_var_type_fixed);
339// ASSERT_STREQ("123", var1->toString().c_str());
340//
341// list = jit->Run("$?!");
342// ASSERT_STREQ("('var1',)", list->toString().c_str());
343//
344// ASSERT_ANY_THROW(jit->Run("var1 ::= 123"));
345//
346// ASSERT_NO_THROW(var1 = jit->Run("var1 = 100:Int8"));
347// ASSERT_EQ(var1->m_var_type_current, ObjType::Int8) << newlang::toString(var1->m_var_type_current);
348// ASSERT_EQ(var1->m_var_type_fixed, ObjType::Int8) << newlang::toString(var1->m_var_type_fixed);
349// ASSERT_STREQ("100", var1->toString().c_str());
350//
351// ASSERT_NO_THROW(var1 = jit->Run("var1 = 999"));
352// ASSERT_STREQ("999", var1->toString().c_str());
353//
354// ASSERT_NO_THROW(var1 = jit->Run("var1 = _"));
355// ASSERT_EQ(var1->getType(), ObjType::None);
356// ASSERT_STREQ("_", var1->toString().c_str());
357//
358// list = jit->Run("$?!");
359// ASSERT_STREQ("('var1',)", list->toString().c_str());
360//
361// // ASSERT_TRUE(ctx.ExecStr("var1 = "));
362// // ASSERT_TRUE(ctx.select("var1").complete());
363//
364// jit = JIT::ReCreate();
365//
366// list = jit->Run("$?!");
367// ASSERT_STREQ("(,)", list->toString().c_str());
368//
369// ObjPtr var_str;
370// ASSERT_NO_THROW(var_str = jit->Run("var_str := 'Строка'"));
371// ASSERT_TRUE(var_str);
372// ASSERT_TRUE(var_str->is_string_type());
373// ASSERT_EQ(var_str->m_var_type_current, ObjType::StrChar) << newlang::toString(var_str->m_var_type_current);
374// ASSERT_EQ(var_str->m_var_type_fixed, ObjType::String) << newlang::toString(var_str->m_var_type_fixed);
375// ASSERT_STREQ("'Строка'", var_str->toString().c_str());
376//
377// list = jit->Run("$?!");
378// ASSERT_STREQ("('var_str',)", list->toString().c_str());
379//
380// ObjPtr var_num;
381// ASSERT_NO_THROW(var_num = jit->Run("$var_num := 123.456: Single"));
382// ASSERT_TRUE(var_num);
383// ASSERT_TRUE(var_num->is_arithmetic_type());
384// ASSERT_TRUE(var_num->is_tensor_type());
385// ASSERT_EQ(var_num->m_var_type_current, ObjType::Single) << newlang::toString(var_num->m_var_type_current);
386// ASSERT_EQ(var_num->m_var_type_fixed, ObjType::Single) << newlang::toString(var_num->m_var_type_fixed);
387// ASSERT_STREQ("123.456", var_num->toString().c_str());
388//
389// list = jit->Run("$?!");
390// ASSERT_STREQ("('$var_num', 'var_str',)", list->toString().c_str());
391//
392//
393// var_long = 987654321;
394// ObjPtr var_export;
395//
396// ASSERT_ANY_THROW(jit->Run("var_export:= %var_long"));
397// ASSERT_ANY_THROW(jit->Run("var_export:= %var_long..."));
398// ASSERT_ANY_THROW(jit->Run("var_export:Int64 := %var_long:Int32 "));
399// ASSERT_ANY_THROW(jit->Run("var_export := %var_long:Int64 "));
400//
401// ASSERT_ANY_THROW(var_export = jit->Run("var_export:Int64 := %var_long..."));
402//
403// LLVMAddSymbol("var_long", &var_long);
404//
405// ASSERT_NO_THROW(var_export = jit->Run("var_export:Int64 := %var_long..."));
406//
407// ASSERT_TRUE(var_export);
408// ASSERT_TRUE(var_export->is_tensor_type()) << var_export->toString();
409// ASSERT_EQ(var_export->getType(), ObjType::Int64) << toString(var_export->getType());
410// ASSERT_STREQ("987654321", var_export->toString().c_str());
411// var_long = 123132132;
412// ASSERT_STREQ("123132132", var_export->toString().c_str());
413// var_export->SetValue_(Obj::CreateValue(59875, ObjType::None));
414// ASSERT_EQ(59875, var_long);
415//
416// list = jit->Run("$?!");
417// ASSERT_STREQ("('var_export', '$var_num', 'var_str',)", list->toString().c_str());
418//
419//
420// /*
421// * Аргументы по умолчанию для нативных функций.
422// * Функция шаблон для создания списка аргументов для встраиваемого кода,
423// * чтобы было как в C/C++ func_export(10, 20), а не func_export( (10, 20,) )
424// * + проверка компилятором, например:
425// * extern "C" _$$_func_export$( Obj &args );
426// * extern "C" _$$_func_export$_$(int64_t arg_long, uint8_t arg_byte);
427// * тогда при раскрытии EMBED {% $func_export(10, 20) %}?
428// * $func_export заменяется на _$$_func_export$_$ и компилятор будет счстлив проверкой аргументов :-)
429// */
430// ObjPtr func;
431// ASSERT_ANY_THROW(jit->Run("$func_export(arg1:Int64, arg2:Int8):Int64 := %func_export"));
432// ASSERT_ANY_THROW(jit->Run("$func_export(arg1:Int64, arg2:Int8):Int64 := %func_export..."));
433//
434// LLVMAddSymbol("func_export", (void *) &func_export);
435//
436// ASSERT_NO_THROW(func = jit->Run("$func_export(arg1:Int64, arg2:Int8):Int64 := %func_export..."));
437//
438// ASSERT_TRUE(func);
439// ASSERT_TRUE(func->is_function_type()) << func;
440// ASSERT_EQ(func->getType(), ObjType::NativeFunc);
441// ASSERT_STREQ("$func_export::(arg1:Int64, arg2:Int8):Int64{ }", func->toString().c_str());
442//
443// ObjPtr result = (*func)(200, 10);
444// ASSERT_TRUE(result);
445// ASSERT_EQ(220, result->GetValueAsInteger());
446//
447// result = (*func)(10, 10);
448// ASSERT_TRUE(result);
449// ASSERT_EQ(30, result->GetValueAsInteger());
450//
451// // result = (*func)({10, "arg2"}, {20, "arg1"});
452// // ASSERT_TRUE(result);
453// // ASSERT_EQ(40, result->GetValueAsInteger());
454//
455// // result = (*func_export)(10);
456// // ASSERT_TRUE(result);
457// // ASSERT_EQ(110, result.GetValueAsInteger());
458//
459//
460//
461// // Переполнение второго аргумента
462// // ASSERT_ANY_THROW(func_expojit->Call(&ctx, Obj::Arg(1000), Obj::Arg(1000)));
463// //
464// // list = ctx.ExecStr("$$");
465// // ASSERT_STREQ("$$=('var_str', 'var_num', 'var_export', 'func_export',)", list->toString().c_str());
466// //
467// // var_num.reset();
468// // func_export.reset();
469// //
470// // list = ctx.ExecStr("$$");
471// // ASSERT_STREQ("$$=('var_str', 'var_export',)", list->toString().c_str());
472// //
473// // // Функция возвращает словарь с именами объектов в текущем контексте
474// // ObjPtr func_eval = ctx.ExecStr("func_eval(arg1, arg2) := {$$;}");
475// // ASSERT_TRUE(func_eval);
476// // ASSERT_TRUE(func_eval->is_function_type()) << func_eval;
477// // ASSERT_EQ(func_eval->getType(), ObjType::EVAL_FUNCTION) << toString(func_eval->getType());
478// // ASSERT_STREQ("func_eval=::func_eval(arg1, arg2):={$$;}", func_eval->toString().c_str());
479// //
480// // ObjPtr result_eval = func_eval->Call(&ctx, Obj::Arg(200), Obj::Arg(10));
481// // ASSERT_TRUE(result_eval);
482// // ASSERT_STREQ("$$=('$0', 'arg1', 'arg2', 'var_str', 'var_export', 'func_eval',)", result_eval->toString().c_str());
483// //
484// // list = ctx.ExecStr("$$");
485// // ASSERT_STREQ("$$=('var_str', 'var_export', 'func_eval',)", list->toString().c_str());
486// //
487// //
488// // ObjPtr dict1 = ctx.ExecStr("(10, 2, 3, 4, )");
489// // ASSERT_TRUE(dict1);
490// // ASSERT_EQ(ObjType::Dictionary, dict1->m_var_type_current) << toString(dict1->m_var_type_current);
491// // ASSERT_EQ(ObjType::None, dict1->m_var_type_fixed) << toString(dict1->m_var_type_fixed);
492// // ASSERT_EQ(4, dict1->size());
493// // ASSERT_STREQ("(10, 2, 3, 4,)", dict1->toString().c_str());
494// //
495// // ObjPtr dict2 = ctx.ExecStr("( (10, 2, 3, 4, (1,2,), ), (10, 2, 3, 4, ),)");
496// // ASSERT_TRUE(dict2);
497// // ASSERT_EQ(ObjType::Dictionary, dict2->m_var_type_current) << toString(dict2->m_var_type_current);
498// // ASSERT_EQ(ObjType::None, dict2->m_var_type_fixed) << toString(dict2->m_var_type_fixed);
499// // ASSERT_EQ(2, dict2->size());
500// // ASSERT_STREQ("((10, 2, 3, 4, (1, 2,),), (10, 2, 3, 4,),)", dict2->toString().c_str());
501// //
502// // ObjPtr tensor = ctx.ExecStr("[1,1,0,0,]");
503// // ASSERT_TRUE(tensor);
504// // ASSERT_EQ(ObjType::Bool, tensor->m_var_type_current) << toString(tensor->m_var_type_current);
505// // ASSERT_EQ(ObjType::None, tensor->m_var_type_fixed) << toString(tensor->m_var_type_fixed);
506// // ASSERT_EQ(1, tensor->m_tensor->dim());
507// // ASSERT_EQ(4, tensor->m_tensor->size(0));
508// // ASSERT_EQ(1, tensor->index_get({0})->GetValueAsInteger());
509// // ASSERT_EQ(1, tensor->index_get({1})->GetValueAsInteger());
510// // ASSERT_EQ(0, tensor->index_get({2})->GetValueAsInteger());
511// // ASSERT_EQ(0, tensor->index_get({3})->GetValueAsInteger());
512// //
513// // ASSERT_STREQ("[1, 1, 0, 0,]:Bool", tensor->GetValueAsString().c_str());
514// //
515// // ObjPtr tensor2 = ctx.ExecStr("[222,333,3333,]");
516// // ASSERT_TRUE(tensor2);
517// // ASSERT_STREQ("[222, 333, 3333,]:Int16", tensor2->GetValueAsString().c_str());
518// //
519// // ObjPtr tensorf = ctx.ExecStr("[1.2, 0.22, 0.69,]");
520// // ASSERT_TRUE(tensorf);
521// // ASSERT_STREQ("[1.2, 0.22, 0.69,]:Float32", tensorf->GetValueAsString().c_str());
522// //
523// // ObjPtr tensor_all = ctx.ExecStr("[ [1, 1, 0, 0,], [10, 10, 0.1, 0.2,], ]");
524// // ASSERT_TRUE(tensor_all);
525// // ASSERT_EQ(ObjType::Float32, tensor_all->m_var_type_current) << toString(tensor_all->m_var_type_current);
526// // ASSERT_EQ(ObjType::None, tensor_all->m_var_type_fixed) << toString(tensor_all->m_var_type_fixed);
527// // ASSERT_EQ(2, tensor_all->m_tensor->dim()) << tensor_all->m_tensor->size(0);
528// // ASSERT_EQ(2, tensor_all->m_tensor->size(0));
529// // ASSERT_EQ(4, tensor_all->m_tensor->size(1));
530// //
531// // ASSERT_STREQ("1", tensor_all->index_get({0, 0})->GetValueAsString().c_str());
532// // ASSERT_STREQ("1", tensor_all->index_get({0, 1})->GetValueAsString().c_str());
533// // ASSERT_STREQ("0", tensor_all->index_get({0, 2})->GetValueAsString().c_str());
534// // ASSERT_STREQ("0", tensor_all->index_get({0, 3})->GetValueAsString().c_str());
535// //
536// // ASSERT_STREQ("10", tensor_all->index_get({1, 0})->GetValueAsString().c_str());
537// // ASSERT_STREQ("10", tensor_all->index_get({1, 1})->GetValueAsString().c_str());
538// // ASSERT_STREQ("0.1", tensor_all->index_get({1, 2})->GetValueAsString().c_str());
539// // ASSERT_STREQ("0.2", tensor_all->index_get({1, 3})->GetValueAsString().c_str());
540// //
541// // ASSERT_STREQ("[\n [1, 1, 0, 0,], [10, 10, 0.1, 0.2,],\n]:Float32", tensor_all->GetValueAsString().c_str());
542//}
543//
544//TEST(Run, Tensor) {
545//
546// JIT * jit = JIT::ReCreate();
547//
548// ObjPtr ddd;
549//
550// ASSERT_NO_THROW(ddd = jit->Run("(1,2,3,)"));
551// ASSERT_TRUE(ddd);
552// ASSERT_STREQ("(1, 2, 3,)", ddd->GetValueAsString().c_str()) << ddd->GetValueAsString().c_str();
553//
554// ASSERT_NO_THROW(ddd = jit->Run(":Tensor[...]( (1,2,3,) )")); // << Dump(*jit);
555// ASSERT_TRUE(ddd);
556// ASSERT_STREQ("[1, 2, 3,]:Int8", ddd->GetValueAsString().c_str()) << ddd->GetValueAsString().c_str();
557//
558//
559// ASSERT_NO_THROW(ddd = jit->Run(":Dictionary(1,2,3)"));
560// ASSERT_TRUE(ddd);
561// ASSERT_STREQ("(1, 2, 3,)", ddd->GetValueAsString().c_str()) << ddd->GetValueAsString().c_str();
562//
563// ASSERT_NO_THROW(ddd = jit->Run(":Dictionary( (1,2,3,) )"));
564// ASSERT_TRUE(ddd);
565// ASSERT_STREQ("((1, 2, 3,),)", ddd->GetValueAsString().c_str()) << ddd->GetValueAsString().c_str();
566//
567// ObjPtr tensor;
568// ASSERT_NO_THROW(tensor = jit->Run(":Tensor(1)"));
569// ASSERT_TRUE(tensor);
570// ASSERT_EQ(ObjType::Tensor, tensor->m_var_type_fixed) << toString(tensor->m_var_type_fixed);
571// ASSERT_EQ(ObjType::Bool, tensor->getType()) << toString(tensor->m_var_type_current);
572// ASSERT_EQ(0, tensor->size());
573//
574// ASSERT_STREQ("1", tensor->GetValueAsString().c_str()) << tensor->GetValueAsString().c_str();
575//
576// ASSERT_NO_THROW(tensor = jit->Run("(1,2,3,)"));
577// ASSERT_TRUE(tensor);
578// ASSERT_STREQ("(1, 2, 3,)", tensor->GetValueAsString().c_str()) << tensor->GetValueAsString().c_str();
579//
580// ASSERT_NO_THROW(tensor = jit->Run(":Tensor[...]([1,2,3,])"));
581// ASSERT_TRUE(tensor);
582// ASSERT_STREQ("[1, 2, 3,]:Int8", tensor->GetValueAsString().c_str()) << tensor->GetValueAsString().c_str();
583//
584// ASSERT_NO_THROW(tensor = jit->Run(":Int32[_]([1,])"));
585// ASSERT_TRUE(tensor);
586// ASSERT_STREQ("[1,]:Int32", tensor->GetValueAsString().c_str()) << tensor->GetValueAsString().c_str();
587//
588// ASSERT_NO_THROW(tensor = jit->Run(":Int32([1,])"));
589// ASSERT_TRUE(tensor);
590// ASSERT_STREQ("1", tensor->GetValueAsString().c_str()) << tensor->GetValueAsString().c_str();
591//
592// ObjPtr tt;
593// ASSERT_NO_THROW(tt = jit->Run(":Tensor[3]( (1,2,3,) )"));
594// ASSERT_TRUE(tt);
595// ASSERT_STREQ("[1, 2, 3,]:Int8", tt->GetValueAsString().c_str()) << tt->GetValueAsString().c_str();
596//
597// ASSERT_NO_THROW(tensor = jit->Run(":Int32[...]((1,2,3,))"));
598// ASSERT_TRUE(tensor);
599// ASSERT_STREQ("[1, 2, 3,]:Int32", tensor->GetValueAsString().c_str()) << tensor->GetValueAsString().c_str();
600//
601// ASSERT_NO_THROW(tensor = jit->Run(":Int32[2,3]((1,2,3,4,5,6,))"));
602// ASSERT_TRUE(tensor);
603//
604// EXPECT_EQ(2, tensor->m_tensor->dim());
605// EXPECT_EQ(2, tensor->m_tensor->size(0));
606// EXPECT_EQ(3, tensor->m_tensor->size(1));
607//
608// ASSERT_STREQ("[\n [1, 2, 3,], [4, 5, 6,],\n]:Int32", tensor->GetValueAsString().c_str());
609//
610// ObjPtr str;
611// ASSERT_NO_THROW(str = jit->Run(":Tensor[_]('first second')"));
612// ASSERT_TRUE(str);
613// ASSERT_STREQ("[102, 105, 114, 115, 116, 32, 115, 101, 99, 111, 110, 100,]:Int8", str->GetValueAsString().c_str());
614//
615// ASSERT_NO_THROW(tt = jit->Run(":Tensor[...]((item1='first', space=32, item3='second',))"));
616// ASSERT_TRUE(tt);
617// ASSERT_STREQ("[102, 105, 114, 115, 116, 32, 115, 101, 99, 111, 110, 100,]:Int8", tt->GetValueAsString().c_str());
618//
619// ASSERT_TRUE(str->op_equal(tt));
620//
621// ASSERT_NO_THROW(tt = jit->Run(":Int32[7,2](\"Тензор Int32 \")"));
622// ASSERT_TRUE(tt);
623// ASSERT_STREQ("[\n [1058, 1077,], [1085, 1079,], [1086, 1088,], [32, 73,], "
624// "[110, 116,], [51, 50,], [32, 32,],\n]:Int32",
625// tt->GetValueAsString().c_str());
626//
627// ASSERT_NO_THROW(tt = jit->Run(":Tensor(99)"));
628// ASSERT_TRUE(tt);
629// ASSERT_STREQ("99", tt->GetValueAsString().c_str());
630//
631// ASSERT_NO_THROW(tt = jit->Run(":Float64[10,2](0, ... )"));
632// ASSERT_TRUE(tt);
633// ASSERT_STREQ("[\n [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, 0,], [0, "
634// "0,], [0, 0,], [0, 0,], [0, 0,],\n]:Float64",
635// tt->GetValueAsString().c_str());
636//
637//}
638//
639//TEST(Run, Comprehensions) {
640//
641// JIT * jit = JIT::ReCreate();
642//
643// ASSERT_NO_THROW(jit->Run("srand(100)"));
644//
645// ObjPtr tt;
646// // Может быть раскрытие словаря, который возвращает вызов функции
647// // и может быть многократный вызов одной и той функции
648// // :Int32[3,2]( ... rand() ... )
649// Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
650// ASSERT_NO_THROW(tt = jit->Run(":Int32[3,2]( 42, ... rand() ... )"));
651// Logger::Instance()->SetLogLevel(save);
652//
653// ASSERT_TRUE(tt);
654// std::string rand_str = tt->GetValueAsString();
655// ASSERT_TRUE(50 < tt->GetValueAsString().size()) << rand_str;
656// //ASSERT_STREQ("[\n [42, 677741240,], [611911301, 516687479,], [1039653884, 807009856,],\n]:Int32", tt->GetValueAsString().c_str()) << rand_str;
657//
658//
659// ASSERT_NO_THROW(tt = jit->Run(":Int32[5,2]( ... 0..10 )"));
660// ASSERT_TRUE(tt);
661// ASSERT_STREQ("[\n [0, 1,], [2, 3,], [4, 5,], [6, 7,], [8, 9,],\n]:Int32", tt->GetValueAsString().c_str());
662//
663// ASSERT_NO_THROW(tt = jit->Run(":Float64[5,2]( 0..10 )"));
664// ASSERT_TRUE(tt);
665// ASSERT_STREQ("[\n [0, 1,], [2, 3,], [4, 5,], [6, 7,], [8, 9,],\n]:Float64", tt->GetValueAsString().c_str());
666//
667// ASSERT_NO_THROW(tt = jit->Run("0..1..0.1"));
668// ASSERT_TRUE(tt);
669// ASSERT_STREQ("0..1..0.1", tt->toString().c_str());
670//
671// ASSERT_NO_THROW(tt = jit->Run(":Tensor[_]( ... 0..0.99..0.1 )"));
672// ASSERT_TRUE(tt);
673// ASSERT_STREQ("[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,]:Float64", tt->GetValueAsString().c_str());
674//
675// // ASSERT_NO_THROW(tt = jit->Run(":Tensor( ... 0..0.99..0.1:Float32 )"));
676// // ASSERT_TRUE(tt);
677// // ASSERT_STREQ("[0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,]:Float32", tt->GetValueAsString().c_str());
678//
679// ASSERT_NO_THROW(tt = jit->Run(":Tensor[10]( 1, 2, ... )"));
680// ASSERT_TRUE(tt);
681// ASSERT_STREQ("[1, 2, 1, 2, 1, 2, 1, 2, 1, 2,]:Int8", tt->GetValueAsString().c_str());
682//
683// ASSERT_NO_THROW(tt = jit->Run(":Tensor[10]( 1, 2, ... 0 ...)"));
684// ASSERT_TRUE(tt);
685// ASSERT_STREQ("[1, 2, 0, 0, 0, 0, 0, 0, 0, 0,]:Int8", tt->GetValueAsString().c_str());
686//
687// ASSERT_NO_THROW(tt = jit->Run(":Tensor[14]( 99, 100, ... 0..5, ... )"));
688// ASSERT_TRUE(tt);
689// ASSERT_STREQ("[99, 100, 0, 1, 2, 3, 4, 99, 100, 0, 1, 2, 3, 4,]:Int8", tt->GetValueAsString().c_str());
690//
691// ObjPtr dict;
692// ASSERT_NO_THROW(dict = jit->Run(":Dictionary( ... 0..0.99..0.1 )"));
693// ASSERT_TRUE(dict);
694// ASSERT_STREQ("(0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9,)", dict->GetValueAsString().c_str());
695//
696// ASSERT_NO_THROW(dict = jit->Run(":Dictionary( ... 10..0..-1\\1 )"));
697// ASSERT_TRUE(dict);
698// ASSERT_STREQ("(10\\1, 9\\1, 8\\1, 7\\1, 6\\1, 5\\1, 4\\1, 3\\1, 2\\1, 1\\1,)", dict->GetValueAsString().c_str());
699//
700// ASSERT_NO_THROW(dict = jit->Run("dict ::= ( 1, two=2, .three=3,)"));
701// ASSERT_TRUE(dict);
702// ASSERT_STREQ("(1, two=2, three=3,)", dict->GetValueAsString().c_str());
703//
704// ObjPtr dd;
705// ASSERT_NO_THROW(dd = jit->Run(":Dictionary( 0, ... dict)"));
706// ASSERT_TRUE(dd);
707// ASSERT_STREQ("(0, 1, 2, 3,)", dd->GetValueAsString().c_str());
708//
709// ASSERT_NO_THROW(dd = jit->Run(":Dictionary( 0, ... ... dict, end=42)"));
710// ASSERT_TRUE(dd);
711// ASSERT_STREQ("(0, 1, two=2, three=3, end=42,)", dd->GetValueAsString().c_str());
712//
713//
714// ASSERT_TRUE(jit->m_diag->m_fill_remainder);
715// ASSERT_ANY_THROW(tt = jit->Run(":Tensor[16]( 99, 100, ... 0..5, ... )"));
716// jit->m_diag->m_fill_remainder = false;
717// ASSERT_NO_THROW(tt = jit->Run(":Tensor[16]( 99, 100, ... 0..5, ... )"));
718// ASSERT_TRUE(tt);
719// ASSERT_STREQ("[99, 100, 0, 1, 2, 3, 4, 99, 100, 0, 1, 2, 3, 4, 99, 100,]:Int8", tt->GetValueAsString().c_str());
720//
721//}
722//
723//
1368//
1369//TEST(Run, Iterator) {
1370//
1371// JIT * jit = JIT::ReCreate();
1372//
1373// ObjPtr dict;
1374// ASSERT_NO_THROW(dict = jit->Run("dict := ('1'=1, \"22\"=2, '333'=3, 4, \"555\"=5,)"));
1375// ASSERT_TRUE(dict);
1376// ASSERT_EQ(5, dict->size());
1377// ASSERT_EQ(1, dict->at(0).second->GetValueAsInteger());
1378// ASSERT_EQ(2, dict->at(1).second->GetValueAsInteger());
1379// ASSERT_EQ(3, dict->at(2).second->GetValueAsInteger());
1380// ASSERT_EQ(4, dict->at(3).second->GetValueAsInteger());
1381// ASSERT_EQ(5, dict->at(4).second->GetValueAsInteger());
1382// ASSERT_STREQ("1", dict->at(0).first.c_str());
1383// ASSERT_STREQ("22", dict->at(1).first.c_str());
1384// ASSERT_STREQ("333", dict->at(2).first.c_str());
1385// ASSERT_STREQ("", dict->at(3).first.c_str());
1386// ASSERT_STREQ("555", dict->at(4).first.c_str());
1387//
1388// ObjPtr dict1;
1389// ASSERT_NO_THROW(dict1 = jit->Run("dict??"));
1390// ASSERT_TRUE(dict1);
1391// ASSERT_EQ(5, dict1->size());
1392// ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
1393// ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
1394// ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
1395// ASSERT_EQ(4, dict1->at(3).second->GetValueAsInteger());
1396// ASSERT_EQ(5, dict1->at(4).second->GetValueAsInteger());
1397// ASSERT_STREQ("1", dict1->at(0).first.c_str());
1398// ASSERT_STREQ("22", dict1->at(1).first.c_str());
1399// ASSERT_STREQ("333", dict1->at(2).first.c_str());
1400// ASSERT_STREQ("", dict1->at(3).first.c_str());
1401// ASSERT_STREQ("555", dict1->at(4).first.c_str());
1402//
1403//
1404// ObjPtr iter_d = dict->IteratorMake();
1405//
1406// ASSERT_TRUE(iter_d);
1407// ASSERT_EQ(iter_d->getType(), ObjType::Iterator);
1408//
1409// ASSERT_STREQ("1", iter_d->IteratorData()->toString().c_str());
1410// ASSERT_STREQ("1", iter_d->IteratorNext(0)->toString().c_str());
1411//
1412// ASSERT_STREQ("2", iter_d->IteratorData()->toString().c_str());
1413// ASSERT_STREQ("2", iter_d->IteratorNext(0)->toString().c_str());
1414//
1415// ASSERT_STREQ("3", iter_d->IteratorData()->toString().c_str());
1416// ASSERT_STREQ("3", iter_d->IteratorNext(0)->toString().c_str());
1417//
1418// ASSERT_STREQ("4", iter_d->IteratorData()->toString().c_str());
1419// ASSERT_STREQ("4", iter_d->IteratorNext(0)->toString().c_str());
1420//
1421// ASSERT_STREQ("5", iter_d->IteratorData()->toString().c_str());
1422// ASSERT_STREQ("5", iter_d->IteratorNext(0)->toString().c_str());
1423//
1424// ASSERT_STREQ(":IteratorEnd", iter_d->IteratorData()->toString().c_str());
1425// ObjPtr iter_end = iter_d->IteratorNext(0);
1426// ASSERT_TRUE(iter_end);
1427// EXPECT_EQ(ObjType::IteratorEnd, iter_end->getType()) << newlang::toString(iter_end->getType());
1428// EXPECT_FALSE(iter_end->GetValueAsBoolean());
1429// ASSERT_STREQ(":IteratorEnd", iter_end->IteratorData()->toString().c_str());
1430//
1431// iter_end = iter_d->IteratorNext(0);
1432// ASSERT_TRUE(iter_end);
1433// ASSERT_EQ(ObjType::IteratorEnd, iter_end->getType());
1434// ASSERT_FALSE(iter_end->GetValueAsBoolean());
1435// ASSERT_STREQ(":IteratorEnd", iter_d->IteratorData()->toString().c_str());
1436//
1437//
1438// ObjPtr iter;
1439// ASSERT_NO_THROW(iter = jit->Run("it := dict?"));
1440//
1441// ASSERT_TRUE(iter);
1442// ASSERT_EQ(ObjType::Iterator, iter->getType()) << toString(iter->getType());
1443// ASSERT_TRUE(iter->m_iterator);
1444//
1445// ASSERT_TRUE(iter->m_iterator->begin() != iter->m_iterator->end());
1446// ASSERT_TRUE(*(iter->m_iterator) == iter->m_iterator->begin());
1447//
1448// ObjPtr one;
1449// ASSERT_NO_THROW(one = jit->Run("it!"));
1450// ASSERT_TRUE(one);
1451// ASSERT_EQ(1, dict->at(0).second->GetValueAsInteger());
1452//
1453// ASSERT_NO_THROW(one = jit->Run("it!"));
1454// ASSERT_TRUE(one);
1455// ASSERT_EQ(2, one->GetValueAsInteger());
1456//
1457// ASSERT_NO_THROW(one = jit->Run("@next(it)"));
1458// ASSERT_TRUE(one);
1459// ASSERT_EQ(3, one->GetValueAsInteger());
1460//
1461// ASSERT_NO_THROW(one = jit->Run("it!"));
1462// ASSERT_TRUE(one);
1463// ASSERT_EQ(4, one->GetValueAsInteger());
1464//
1465// ASSERT_NO_THROW(one = jit->Run("it!"));
1466// ASSERT_TRUE(one);
1467// ASSERT_EQ(5, one->GetValueAsInteger());
1468//
1469// ASSERT_NO_THROW(one = jit->Run("it!"));
1470// ASSERT_TRUE(one);
1471// ASSERT_EQ(ObjType::IteratorEnd, one->getType()) << one << " " << toString(one->getType());
1472//
1473// ASSERT_NO_THROW(one = jit->Run("it!"));
1474// ASSERT_TRUE(one);
1475// ASSERT_EQ(ObjType::IteratorEnd, one->getType()) << one << " " << toString(one->getType());
1476//
1477// // "@@ iter( obj, ... ) @@ ::= @@ @$obj ? (@$...) @@"
1478// // "@@ next( obj, ... ) @@ ::= @@ @$obj ! (@$...) @@"
1479// // "@@ curr( obj ) @@ ::= @@ @$obj !? @@"
1480// // "@@ first( obj ) @@ ::= @@ @$obj !! @@"
1481// // "@@ all( obj ) @@ ::= @@ @$obj ?? @@"
1482//
1483//
1484// ASSERT_TRUE(*(iter->m_iterator) == iter->m_iterator->end());
1485// ASSERT_NO_THROW(one = jit->Run("it!!"));
1486// ASSERT_TRUE(*(iter->m_iterator) != iter->m_iterator->end());
1487//
1488// ASSERT_NO_THROW(dict1 = jit->Run("it??(-3)"));
1489// ASSERT_TRUE(dict1);
1490// ASSERT_EQ(3, dict1->size());
1491// ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
1492// ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
1493// ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
1494//
1495// ObjPtr dict2;
1496// ASSERT_NO_THROW(dict2 = jit->Run("it??(-3)"));
1497// ASSERT_TRUE(dict2);
1498// ASSERT_EQ(3, dict2->size());
1499// ASSERT_EQ(4, dict2->at(0).second->GetValueAsInteger());
1500// ASSERT_EQ(5, dict2->at(1).second->GetValueAsInteger());
1501// ASSERT_EQ(ObjType::IteratorEnd, dict2->at(2).second->getType());
1502//
1503// ObjPtr dict3;
1504// ASSERT_NO_THROW(dict3 = jit->Run("it??(-3)"));
1505// ASSERT_TRUE(dict3);
1506// ASSERT_EQ(3, dict1->size());
1507// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(0).second->getType());
1508// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(1).second->getType());
1509// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(2).second->getType());
1510//
1511//
1512//
1513// ASSERT_TRUE(*(iter->m_iterator) == iter->m_iterator->end());
1514// ASSERT_NO_THROW(jit->Run("it!!"));
1515// ASSERT_TRUE(*(iter->m_iterator) != iter->m_iterator->end());
1516//
1517// ASSERT_NO_THROW(dict1 = jit->Run("it??(3)"));
1518// ASSERT_TRUE(dict1);
1519// ASSERT_EQ(3, dict1->size());
1520// ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
1521// ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
1522// ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
1523//
1524// ASSERT_NO_THROW(dict2 = jit->Run("it??(3)"));
1525// ASSERT_TRUE(dict2);
1526// ASSERT_EQ(2, dict2->size());
1527// ASSERT_EQ(4, dict2->at(0).second->GetValueAsInteger());
1528// ASSERT_EQ(5, dict2->at(1).second->GetValueAsInteger());
1529//
1530// ASSERT_NO_THROW(dict3 = jit->Run("it??(3)"));
1531// ASSERT_TRUE(dict3);
1532// ASSERT_EQ(0, dict3->size());
1533//
1534//
1535//
1536// ASSERT_TRUE(*(iter->m_iterator) == iter->m_iterator->end());
1537// ASSERT_NO_THROW(jit->Run("it!!"));
1538// ASSERT_TRUE(*(iter->m_iterator) != iter->m_iterator->end());
1539//
1540// ObjPtr flt_res;
1541// ASSERT_NO_THROW(flt_res = jit->Run("dict??('')"));
1542// ASSERT_TRUE(flt_res);
1543// ASSERT_EQ(1, flt_res->size());
1544// ASSERT_EQ(4, flt_res->at(0).second->GetValueAsInteger());
1545//
1546//
1547// ObjPtr flt1_res;
1548// ASSERT_NO_THROW(flt1_res = jit->Run("dict??('.',100)"));
1549// ASSERT_TRUE(flt1_res);
1550// ASSERT_EQ(1, flt1_res->size());
1551// ASSERT_EQ(1, flt1_res->at(0).second->GetValueAsInteger());
1552//
1553//
1554// ObjPtr flt2_res;
1555// ASSERT_NO_THROW(flt2_res = jit->Run("dict??('..',100)"));
1556// ASSERT_TRUE(flt2_res);
1557// ASSERT_EQ(1, flt2_res->size());
1558// ASSERT_EQ(2, flt2_res->at(0).second->GetValueAsInteger());
1559//
1560// ObjPtr flt3_res;
1561// ASSERT_NO_THROW(flt3_res = jit->Run("dict??('...',100)"));
1562// ASSERT_TRUE(flt3_res);
1563// ASSERT_EQ(2, flt3_res->size());
1564// ASSERT_EQ(3, flt3_res->at(0).second->GetValueAsInteger());
1565// ASSERT_EQ(5, flt3_res->at(1).second->GetValueAsInteger());
1566//
1567//
1568//
1569// ObjPtr range_test;
1570// ASSERT_NO_THROW(range_test = jit->Run("1\\1..1..-1"));
1571// ASSERT_TRUE(range_test);
1572// ASSERT_EQ(3, range_test->size());
1573// ASSERT_STREQ("1\\1", range_test->at(0).second->GetValueAsString().c_str());
1574// ASSERT_STREQ("1\\1", range_test->at(1).second->GetValueAsString().c_str());
1575// ASSERT_STREQ("-1\\1", range_test->at(2).second->GetValueAsString().c_str());
1576// ASSERT_STREQ("1\\1..1\\1..-1\\1", range_test->GetValueAsString().c_str());
1577//
1578// // ObjPtr iter_test = ctx.ExecStr("(1,'sss',(,),2,3,)??", nullptr, true);
1579// // ASSERT_TRUE(iter_test);
1580// // ASSERT_STREQ("(1, 'sss', (,), 2, 3,)", iter_test->GetValueAsString().c_str());
1581//
1582// ObjPtr iter_dict;
1583// ASSERT_NO_THROW(iter_dict = jit->Run("1..1..-1??"));
1584// ASSERT_TRUE(iter_dict);
1585// ASSERT_STREQ("(,)", iter_dict->GetValueAsString().c_str());
1586//
1587// ASSERT_NO_THROW(iter_dict = jit->Run("2..1..-1??"));
1588// ASSERT_TRUE(iter_dict);
1589// ASSERT_STREQ("(2,)", iter_dict->GetValueAsString().c_str());
1590//
1591// ASSERT_NO_THROW(iter_dict = jit->Run("3..1..-1??"));
1592// ASSERT_TRUE(iter_dict);
1593// ASSERT_STREQ("(3, 2,)", iter_dict->GetValueAsString().c_str());
1594//
1595// ASSERT_NO_THROW(iter_dict = jit->Run("3\\1..1..-1??"));
1596// ASSERT_TRUE(iter_dict);
1597// ASSERT_STREQ("(3\\1, 2\\1,)", iter_dict->GetValueAsString().c_str());
1598//
1599// ObjPtr iter_test;
1600// ASSERT_NO_THROW(iter_test = jit->Run("iter_test := 3\\1..1..-1?"));
1601// ASSERT_TRUE(iter_test);
1602// ASSERT_TRUE(iter_test->m_iterator);
1603// ASSERT_TRUE(iter_test->m_iterator->m_iter_obj);
1604// ASSERT_TRUE(iter_test->m_iterator->m_iter_obj->m_iter_range_value);
1605// ASSERT_STREQ("3\\1", iter_test->m_iterator->m_iter_obj->m_iter_range_value->GetValueAsString().c_str()) << iter_test->m_iterator->m_iter_obj->m_iter_range_value->GetValueAsString().c_str();
1606// ASSERT_EQ(iter_test->getType(), ObjType::Iterator);
1607//
1608// ObjPtr while_test;
1609//
1610// ASSERT_NO_THROW(while_test = jit->Run("[@next(iter_test)]<->{- --'EXIT'-- -}"));
1611// ASSERT_TRUE(while_test);
1612// ASSERT_TRUE(while_test->is_return()) << while_test->toString();
1613// ASSERT_STREQ(":RetMinus('EXIT')", while_test->toString().c_str()) << while_test->toString();
1614//
1615// ASSERT_NO_THROW(while_test = jit->Run("$^"));
1616// ASSERT_TRUE(while_test);
1617// ASSERT_TRUE(while_test->is_return()) << while_test->toString();
1618// ASSERT_STREQ(":RetMinus('EXIT')", while_test->toString().c_str()) << while_test->toString();
1619//
1620// ASSERT_NO_THROW(while_test = jit->Run("@latter"));
1621// ASSERT_TRUE(while_test);
1622// ASSERT_TRUE(while_test->is_return()) << while_test->toString();
1623// ASSERT_STREQ(":RetMinus('EXIT')", while_test->toString().c_str()) << while_test->toString();
1624//
1625// ASSERT_NO_THROW(while_test = jit->Run("* $^"));
1626// ASSERT_TRUE(while_test);
1627// ASSERT_TRUE(while_test->is_string_type()) << while_test->toString();
1628// ASSERT_STREQ("'EXIT'", while_test->toString().c_str()) << while_test->toString();
1629//
1630//
1631// ASSERT_NO_THROW(while_test = jit->Run("[iter_test!]<->{+ ++'PLUS'++ +}"));
1632// ASSERT_TRUE(while_test);
1633// ASSERT_TRUE(while_test->is_return()) << while_test->toString();
1634// ASSERT_STREQ(":RetPlus('PLUS')", while_test->toString().c_str()) << while_test->toString();
1635//
1636//
1637// ASSERT_NO_THROW(iter_dict = jit->Run("iter_dict := (1,2,3,)?"));
1638// ASSERT_TRUE(iter_dict);
1639// // ASSERT_TRUE(iter_dict->m_iterator->m_iter_obj->m_iter_range_value);
1640// // ASSERT_STREQ("3\\1", iter_dict->m_iterator->m_iter_obj->m_iter_range_value->GetValueAsString().c_str()) << iter_test->m_iterator->m_iter_obj->m_iter_range_value->GetValueAsString().c_str();
1641// ASSERT_EQ(iter_dict->getType(), ObjType::Iterator);
1642//
1643// ASSERT_NO_THROW(while_test = jit->Run("[iter_dict!]<->{+ ++'EXIT'++ +}"));
1644// ASSERT_TRUE(while_test);
1645// ASSERT_TRUE(while_test->is_return()) << while_test->toString();
1646// ASSERT_STREQ(":RetPlus('EXIT')", while_test->toString().c_str()) << while_test->toString();
1647//
1648// ASSERT_NO_THROW(while_test = jit->Run("$^"));
1649// ASSERT_TRUE(while_test);
1650// ASSERT_TRUE(while_test->is_return()) << while_test->toString();
1651// ASSERT_STREQ(":RetPlus('EXIT')", while_test->toString().c_str()) << while_test->toString();
1652//
1653// ASSERT_NO_THROW(while_test = jit->Run("@latter"));
1654// ASSERT_TRUE(while_test);
1655// ASSERT_TRUE(while_test->is_return()) << while_test->toString();
1656// ASSERT_STREQ(":RetPlus('EXIT')", while_test->toString().c_str()) << while_test->toString();
1657//
1658// ASSERT_NO_THROW(while_test = jit->Run("*@latter"));
1659// ASSERT_TRUE(while_test);
1660// ASSERT_TRUE(while_test->is_string_type()) << while_test->toString();
1661// ASSERT_STREQ("'EXIT'", while_test->toString().c_str()) << while_test->toString();
1662//
1663//
1664// ASSERT_NO_THROW(iter_test = jit->Run("iter_test := @iter(3\\1..1..-1)"));
1665//
1666// ObjPtr item_val;
1667// ASSERT_NO_THROW(item_val = jit->Run("@curr(iter_test)"));
1668// ASSERT_TRUE(item_val);
1669// ASSERT_STREQ("3\\1", item_val->GetValueAsString().c_str()) << iter_test->toString();
1670//
1671// ASSERT_NO_THROW(item_val = jit->Run("@next(iter_test)"));
1672// ASSERT_TRUE(item_val);
1673// ASSERT_STREQ("3\\1", item_val->GetValueAsString().c_str());
1674//
1675// ASSERT_NO_THROW(item_val = jit->Run("iter_test!?"));
1676// ASSERT_TRUE(item_val);
1677// ASSERT_STREQ("2\\1", item_val->GetValueAsString().c_str());
1678//
1679// ASSERT_NO_THROW(item_val = jit->Run("iter_test?!"));
1680// ASSERT_TRUE(item_val);
1681// ASSERT_STREQ("2\\1", item_val->GetValueAsString().c_str());
1682//
1683// ASSERT_STREQ(":Iterator", iter_test->GetValueAsString().c_str());
1684// ASSERT_TRUE(iter_test->m_iterator);
1685// ASSERT_TRUE(iter_test->m_iterator->m_iter_obj);
1686// ASSERT_STREQ("2\\1", iter_test->m_iterator->m_iter_obj->m_iter_range_value->GetValueAsString().c_str());
1687// ASSERT_STREQ("3\\1..1\\1..-1\\1", iter_test->m_iterator->m_iter_obj->GetValueAsString().c_str());
1688//
1689// ASSERT_NO_THROW(item_val = jit->Run("@next(iter_test)"));
1690// ASSERT_TRUE(item_val);
1691// ASSERT_STREQ("2\\1", item_val->GetValueAsString().c_str());
1692// ASSERT_TRUE(item_val->GetValueAsBoolean());
1693//
1694// ASSERT_STREQ(":Iterator", iter_test->GetValueAsString().c_str());
1695// ASSERT_TRUE(iter_test->m_iterator);
1696// ASSERT_TRUE(iter_test->m_iterator->m_iter_obj);
1697// ASSERT_STREQ("1\\1", iter_test->m_iterator->m_iter_obj->m_iter_range_value->GetValueAsString().c_str());
1698// ASSERT_STREQ("3\\1..1\\1..-1\\1", iter_test->m_iterator->m_iter_obj->GetValueAsString().c_str());
1699//
1700// ASSERT_NO_THROW(item_val = jit->Run("@next(iter_test)"));
1701// ASSERT_TRUE(item_val);
1702//
1703// ASSERT_STREQ(":Iterator", iter_test->GetValueAsString().c_str());
1704// ASSERT_TRUE(iter_test->m_iterator);
1705// ASSERT_TRUE(iter_test->m_iterator->m_iter_obj);
1706// ASSERT_STREQ("1\\1", iter_test->m_iterator->m_iter_obj->m_iter_range_value->GetValueAsString().c_str());
1707// ASSERT_STREQ("3\\1..1\\1..-1\\1", iter_test->m_iterator->m_iter_obj->GetValueAsString().c_str());
1708//
1709//
1710//
1711// ASSERT_TRUE(iter_test->m_iterator->m_iter_obj);
1712// ASSERT_STREQ("3\\1..1\\1..-1\\1", iter_test->m_iterator->m_iter_obj->GetValueAsString().c_str());
1713//
1714// ASSERT_STREQ(":IteratorEnd", item_val->GetValueAsString().c_str());
1715// ASSERT_FALSE(item_val->GetValueAsBoolean());
1716//
1717// ASSERT_NO_THROW(item_val = jit->Run("iter_test"));
1718// ASSERT_TRUE(item_val);
1719// ASSERT_STREQ(":Iterator", item_val->GetValueAsString().c_str());
1720//
1721// ASSERT_STREQ(":IteratorEnd", item_val->IteratorData()->GetValueAsString().c_str());
1722// ASSERT_FALSE(item_val->IteratorNext(0)->GetValueAsBoolean());
1723//
1724// ASSERT_NO_THROW(while_test = jit->Run("[iter_test?!]<->{ --'EXIT'-- }"));
1725// ASSERT_TRUE(while_test);
1726// ASSERT_STRNE("EXIT", while_test->GetValueAsString().c_str()) << while_test->GetValueAsString().c_str();
1727//
1728//
1729// ASSERT_NO_THROW(item_val = jit->Run("@first(iter_test)"));
1730// ASSERT_TRUE(item_val);
1731// ASSERT_STREQ("3\\1", item_val->GetValueAsString().c_str());
1732//
1733//
1734//}
1735//
1844//
1845//class RunTester : public ::testing::Test {
1846//protected:
1847// RuntimePtr m_rt;
1848// JIT * m_jit;
1849// ObjPtr m_result;
1850// std::string m_string;
1851//
1852// RunTester() : m_jit(JIT::ReCreate()) {
1853// }
1854//
1855// const char *Test(std::string eval, Obj *vars) {
1856// eval += ";";
1857// m_result = m_jit->Run(eval, vars);
1858// if (m_result) {
1859// m_string = m_result->GetValueAsString();
1860// return m_string.c_str();
1861// }
1862// std::cout << "Fail parsing: '" << eval << "'\n";
1863// ADD_FAILURE();
1864//
1865// return nullptr;
1866// }
1867//
1868// const char *Test(const char *eval) {
1869// Obj vars;
1870//
1871// return Test(eval, &vars);
1872// }
1873//};
1874//
1875//TEST_F(RunTester, Ops) {
1876// ASSERT_STREQ("10", Test("10"));
1877// ASSERT_STREQ("32", Test("10+22"));
1878// ASSERT_STREQ("5.1", Test("1.1+4"));
1879// ASSERT_STREQ("5.5", Test("1+4.5"));
1880//
1881// ASSERT_STREQ("10\\1", Test("10\\1"));
1882// ASSERT_STREQ("32\\1", Test("10\\1+22\\1"));
1883// ASSERT_STREQ("5\\1", Test("4\\5 + 42\\10"));
1884// ASSERT_STREQ("11\\1", Test("10\\1 + 1"));
1885// ASSERT_STREQ("4\\3", Test("1\\3 + 1"));
1886//
1887// ASSERT_STREQ("-12", Test("10 - 22"));
1888// ASSERT_STREQ("-2.9", Test("1.1 - 4"));
1889// ASSERT_STREQ("-3.5", Test("1 - 4.5"));
1890// ASSERT_STREQ("-17\\5", Test("4\\5 - 42\\10"));
1891// ASSERT_STREQ("-9\\10", Test("1\\10 - 1"));
1892// ASSERT_STREQ("-2\\3", Test("1\\3 - 1"));
1893//
1894// ASSERT_STREQ("66", Test("2 * 33"));
1895// ASSERT_STREQ("-5.5", Test("1.1 * -5"));
1896// ASSERT_STREQ("180", Test("10 * 18"));
1897// ASSERT_STREQ("66\\1", Test("2\\1 * 66\\2"));
1898// ASSERT_STREQ("-15\\1", Test("3\\1 * -5"));
1899// ASSERT_STREQ("9\\5", Test("18\\100 * 10"));
1900//
1901// ASSERT_STREQ("5", Test("10/2"));
1902// ASSERT_STREQ("5.05", Test("10.1 / 2"));
1903// ASSERT_STREQ("0.1", Test("1 / 10"));
1904// ASSERT_STREQ("0.1", Test("1.0 / 10"));
1905//
1906// ASSERT_STREQ("4\\3", Test("12\\3 / 3"));
1907// ASSERT_STREQ("1\\1", Test("5\\10 / 1\\2"));
1908// ASSERT_STREQ("1\\100", Test("1\\10 / 10"));
1909//
1910// ASSERT_STREQ("5", Test("10//2"));
1911// ASSERT_STREQ("5", Test("10.0 // 2"));
1912// ASSERT_STREQ("0", Test("1 // 10"));
1913// ASSERT_STREQ("7", Test("15 // 2"));
1914// ASSERT_STREQ("-8", Test("-15 // 2"));
1915// ASSERT_STREQ("2", Test("25 // 10"));
1916// ASSERT_STREQ("-3", Test("-25 // 10"));
1917// ASSERT_STREQ("-3", Test("-30 // 10"));
1918// ASSERT_STREQ("-4", Test("-31 // 10"));
1919//
1920// // ASSERT_STREQ("100", Test("2*20+10*5"));
1921//
1922// ASSERT_STREQ("", Test("\"\""));
1923// ASSERT_STREQ(" ", Test("\" \""));
1924// ASSERT_STREQ("строка", Test("\"\" \"строка\" "));
1925// ASSERT_STREQ("строка 222", Test("\"строка \" \"222\" "));
1926// // ASSERT_STREQ("строка строка строка ", Test("\"строка \" * 3 "));
1927//
1928// ASSERT_STREQ("100", Test("$var1:=100"));
1929// ObjPtr var1 = m_result;
1930// ASSERT_TRUE(var1);
1931// ASSERT_STREQ("('$var1',)", Test("$?!"));
1932// ASSERT_STREQ("100", Test("var1"));
1933//
1934// ObjPtr vars = Obj::CreateDict(Obj::Arg(var1, "var1"));
1935//
1936// // ASSERT_ANY_THROW(Test("$var1"));
1937// ASSERT_NO_THROW(Test("$var1", vars.get()));
1938// ASSERT_STREQ("100", Test("$var1", vars.get()));
1939//
1940// ASSERT_STREQ("20", Test("$var2:=9+11"));
1941// ObjPtr var2 = m_result;
1942// ASSERT_TRUE(var2);
1943// ASSERT_STREQ("('$var1', '$var2',)", Test("$!?"));
1944// ASSERT_STREQ("20", Test("var2"));
1945//
1946// // ASSERT_ANY_THROW(Test("$var2"));
1947// // ASSERT_ANY_THROW(Test("$var2", vars.get()));
1948// vars->push_back(Obj::Arg(var2, "var2"));
1949//
1950// ASSERT_NO_THROW(Test("$var2", vars.get()));
1951// ASSERT_STREQ("20", Test("$var2", vars.get()));
1952//
1953// ASSERT_STREQ("100", Test("var1"));
1954// ASSERT_STREQ("120", Test("var1+=var2"));
1955// ASSERT_STREQ("('$var1', '$var2',)", Test("$!?"));
1956//
1957// ASSERT_STREQ("120", Test("$var1", vars.get()));
1958//
1959// ASSERT_NO_THROW(Test("var1 := _"));
1960// ASSERT_STREQ("('$var1', '$var2',)", Test("$?!"));
1961// ASSERT_NO_THROW(Test("var2 := _"));
1962// ASSERT_STREQ("('$var1', '$var2',)", Test("$?!"));
1963//}
1964//
2231//
2232//
2233//
2234//using namespace newlang;
2235//
2236//TEST(RunTest, Empty) {
2237// Obj var;
2238// ASSERT_TRUE(var.empty());
2239// ASSERT_EQ(ObjType::None, var.getType());
2240//}
2241//
2242//TEST(RunTest, Value) {
2243// Obj var;
2244//
2245// var.SetValue_(0);
2246// ASSERT_EQ(ObjType::Bool, var.getType());
2247//
2248// var.SetValue_(1);
2249// ASSERT_EQ(ObjType::Bool, var.getType());
2250//
2251// var.SetValue_(1.0);
2252// ASSERT_EQ(ObjType::Float32, var.getType());
2253//
2254// var.SetValue_(1.0E+40);
2255// ASSERT_EQ(ObjType::Float64, var.getType());
2256//
2257// var.SetValue_(true);
2258// ASSERT_EQ(ObjType::Bool, var.getType());
2259//
2260// var.SetValue_(2);
2261// ASSERT_EQ(ObjType::Int8, var.getType());
2262//
2263// var.SetValue_(-100);
2264// ASSERT_EQ(ObjType::Int8, var.getType());
2265//
2266// var.SetValue_(1000);
2267// ASSERT_EQ(ObjType::Int16, var.getType());
2268//
2269// var.SetValue_(100000);
2270// ASSERT_EQ(ObjType::Int32, var.getType());
2271//
2272// var.SetValue_(10000000000);
2273// ASSERT_EQ(ObjType::Int64, var.getType());
2274//
2275// var.SetValue_(2.0);
2276// ASSERT_EQ(ObjType::Float32, var.getType());
2277//
2278// var.SetValue_(2.0E+40);
2279// ASSERT_EQ(ObjType::Float64, var.getType());
2280//
2281// var.SetValue_(false);
2282// ASSERT_EQ(ObjType::Bool, var.getType());
2283//}
2284//
2285//TEST(RunTest, String) {
2286// Obj var;
2287//
2288// var.SetValue_(std::string("test"));
2289// ASSERT_EQ(ObjType::StrChar, var.getType()) << toString(var.getType());
2290//
2291// Obj str1;
2292// str1.SetValue_(L"Test str");
2293// ASSERT_EQ(ObjType::StrWide, str1.getType()) << toString(str1.getType());
2294//
2295// Obj str2;
2296// str2.SetValue_(std::string("test2"));
2297// ASSERT_EQ(ObjType::StrChar, str2.getType()) << toString(str2.getType());
2298//
2299// ObjPtr str_byte = Obj::CreateString("byte");
2300// ASSERT_STREQ("byte", str_byte->GetValueAsString().c_str());
2301// ASSERT_EQ(4, str_byte->size());
2302// ASSERT_EQ(4, str_byte->m_value.size());
2303// ASSERT_STREQ("b", (*str_byte)[0].second->GetValueAsString().c_str());
2304// ASSERT_STREQ("y", (*str_byte)[1].second->GetValueAsString().c_str());
2305// ASSERT_STREQ("t", (*str_byte)[2].second->GetValueAsString().c_str());
2306// ASSERT_STREQ("e", (*str_byte)[3].second->GetValueAsString().c_str());
2307//
2308// str_byte->op_set_index(0, "B");
2309// str_byte->op_set_index(1, "Y");
2310// ASSERT_STREQ("BYte", str_byte->GetValueAsString().c_str());
2311// str_byte->op_set_index(2, "T");
2312// str_byte->op_set_index(3, "E");
2313// ASSERT_STREQ("BYTE", str_byte->GetValueAsString().c_str());
2314//
2315// ObjPtr str_char = Obj::CreateString(L"строка");
2316// ASSERT_EQ(6, str_char->size());
2317// ASSERT_EQ(6, str_char->m_string.size());
2318//
2319// ASSERT_STREQ("с", (*str_char)[0].second->GetValueAsString().c_str());
2320// ASSERT_STREQ("т", (*str_char)[1].second->GetValueAsString().c_str());
2321// ASSERT_STREQ("р", (*str_char)[2].second->GetValueAsString().c_str());
2322// ASSERT_STREQ("о", (*str_char)[3].second->GetValueAsString().c_str());
2323// ASSERT_STREQ("к", (*str_char)[4].second->GetValueAsString().c_str());
2324// ASSERT_STREQ("а", (*str_char)[5].second->GetValueAsString().c_str());
2325//
2326// str_char->op_set_index(0, "С");
2327// str_char->op_set_index(1, "Т");
2328// ASSERT_STREQ("СТрока", str_char->GetValueAsString().c_str());
2329// str_char->op_set_index(2, "Р");
2330// str_char->op_set_index(3, "О");
2331// ASSERT_STREQ("СТРОка", str_char->GetValueAsString().c_str());
2332//
2333//
2334// ObjPtr format = Obj::CreateString("{1} {2} {name}");
2335//
2336// ASSERT_ANY_THROW((*format)(););
2337// ASSERT_ANY_THROW((*format)(100););
2338//
2339// ObjPtr str3;
2340// ASSERT_NO_THROW(str3 = (*format)(Obj::Arg(-1), Obj::Arg("222"), Obj::Arg("NAME", "name")));
2341// ASSERT_STREQ("-1 222 NAME", str3->GetValueAsString().c_str());
2342//
2343// ObjPtr str4;
2344// ASSERT_NO_THROW(str4 = (*format)(Obj::Arg("value", "name"), Obj::Arg("VAL")););
2345// ASSERT_STREQ("value VAL value", str4->GetValueAsString().c_str());
2346//
2347// format = Obj::CreateString("{name}no {3} {name} {name2}");
2348// ObjPtr str5;
2349// ASSERT_NO_THROW(str5 = (*format)(Obj::Arg("value", "name"), Obj::Arg("УТФ8-УТФ8", "name2"), Obj::Arg("УТФ8", "name3")));
2350// ASSERT_STREQ("valueno УТФ8 value УТФ8-УТФ8", str5->GetValueAsString().c_str());
2351//
2352//}
2353//
2354//TEST(RunTest, StrFormat) {
2355//
2356// JIT * jit = JIT::ReCreate();
2357// ASSERT_TRUE(jit);
2358//
2359// ObjPtr str;
2360// ASSERT_NO_THROW(str = jit->Run("'{1}'('template')"));
2361// ASSERT_STREQ("template", str->GetValueAsString().c_str());
2362//
2363// ASSERT_NO_THROW(str = jit->Run("'{1} {2} {1}'('template', 'str')"));
2364// ASSERT_STREQ("template str template", str->GetValueAsString().c_str());
2365//
2366// ASSERT_NO_THROW(str = jit->Run("'{1} {2} {1} {name}'('template', name='str')"));
2367// ASSERT_STREQ("template str template str", str->GetValueAsString().c_str());
2368//
2369// ASSERT_NO_THROW(str = jit->Run("'{1} {2} {1} {name}'(333, name=0.123)"));
2370// ASSERT_STREQ("333 0.123 333 0.123", str->GetValueAsString().c_str());
2371//
2372// ASSERT_ANY_THROW(str = jit->Run("'{1} {2} {1} {name}'(333)"));
2373// ASSERT_ANY_THROW(str = jit->Run("'{1} {2} {1} {name}'(name=333)"));
2374// ASSERT_ANY_THROW(str = jit->Run("'{1} {2} {1} {name}'(333, error=333)"));
2375//
2376//
2377// ASSERT_NO_THROW(str = jit->Run("tmpl1:FmtChar := '%s'; tmpl1('template')"));
2378// ASSERT_STREQ("template", str->GetValueAsString().c_str());
2379//
2380// ASSERT_NO_THROW(str = jit->Run("tmpl2:FmtChar := '%s %s'; tmpl2('template', 'str')"));
2381// ASSERT_STREQ("template str", str->GetValueAsString().c_str());
2382//
2383//#pragma message WARNING("Wrong float argument type!")
2384// ASSERT_NO_THROW(str = jit->Run("tmpl3:FmtChar := '%d %f'; tmpl3(333, 1.123)"));
2385// ASSERT_STREQ("333 0.000000", str->GetValueAsString().c_str());
2387//
2390//}
2391//
2392//TEST(RunTest, Dict) {
2393//
2394// JIT * jit = JIT::ReCreate();
2395// ASSERT_TRUE(jit);
2396//
2397// Obj var(ObjType::Dictionary);
2398// ASSERT_TRUE(var.empty());
2399// EXPECT_ANY_THROW(var[0]);
2400//
2401// ASSERT_EQ(0, var.size());
2402// ObjPtr var2;
2403// ASSERT_NO_THROW(var2 = jit->Run("(,)"));
2404//
2405// var.push_back(Obj::CreateString("Test1"));
2406// ASSERT_EQ(1, var.size());
2407// var.push_back(Obj::CreateString("Test3"));
2408// ASSERT_EQ(2, var.size());
2409// var.insert(var.at_index_const(1), Obj::Arg(2, "2"));
2410// var.insert(var.at_index_const(0), Obj::Arg(0, "0"));
2411// ASSERT_EQ(4, var.size());
2412//
2413// ASSERT_TRUE(var[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
2414// ASSERT_TRUE(var[1].second->op_accurate(Obj::CreateString("Test1")));
2415// ASSERT_TRUE(var[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
2416// ASSERT_TRUE(var[3].second->op_accurate(Obj::CreateString(L"Test3")));
2417//
2418// ASSERT_NO_THROW(var2 = jit->Run("(0, \"Test1\", 2, 'Test3',)"));
2419//
2420// ASSERT_TRUE((*var2)[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
2421// ASSERT_TRUE((*var2)[1].second->op_accurate(Obj::CreateString("Test1")));
2422// ASSERT_TRUE((*var2)[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
2423// ASSERT_TRUE((*var2)[3].second->op_accurate(Obj::CreateString(L"Test3")));
2424//
2425// ObjPtr var3;
2426//
2427// ASSERT_NO_THROW(var3 = jit->Run("(0, \"Test1\", 2, 'Test3',)"));
2428//
2429// ASSERT_TRUE((*var3)[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
2430// ASSERT_TRUE((*var3)[1].second->op_accurate(Obj::CreateString("Test1")));
2431// ASSERT_TRUE((*var3)[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
2432// ASSERT_TRUE((*var3)[3].second->op_accurate(Obj::CreateString(L"Test3")));
2433//}
2434//
2435//TEST(RunTest, AsMap) {
2436//
2437// ObjPtr map = Obj::CreateType(ObjType::Dictionary);
2438// ASSERT_TRUE(map->empty());
2439// EXPECT_ANY_THROW((*map)["test1"]);
2440// ASSERT_EQ(0, map->size());
2441//
2442// ObjPtr temp = Obj::CreateString("Test");
2443// map->push_back(temp, "test1");
2444// map->push_back(Obj::CreateValue(100, ObjType::None), "test2");
2445// ASSERT_EQ(2, map->size());
2446// ASSERT_STREQ((*map)["test1"].second->toString().c_str(), temp->toString().c_str()) << temp->toString().c_str();
2447//
2448// ASSERT_TRUE((*map)["test2"].second);
2449// ObjPtr temp100 = Obj::CreateValue(100, ObjType::None);
2450// ASSERT_TRUE(map->exist(temp100, true));
2451//
2452// ObjPtr test2 = (*map)["test2"].second;
2453// ASSERT_TRUE(test2);
2454// ASSERT_TRUE(test2);
2455// ASSERT_STREQ("100", test2->toString().c_str());
2456//}
2457//
2458//TEST(RunTest, Eq) {
2459//
2460// ObjPtr var_int = Obj::CreateValue(100, ObjType::None);
2461// ObjPtr var_num = Obj::CreateValue(100.0, ObjType::None);
2462// ObjPtr var_str = Obj::CreateString(L"STRING");
2463// ObjPtr var_bool = Obj::CreateBool(true);
2464// ObjPtr var_empty = Obj::CreateNone();
2465//
2466// ASSERT_EQ(var_int->m_var_type_current, ObjType::Int8) << (int) var_int->getType();
2467// ASSERT_EQ(var_num->m_var_type_current, ObjType::Float32) << (int) var_num->getType();
2468// ASSERT_EQ(var_str->m_var_type_current, ObjType::StrWide) << (int) var_str->getType();
2469// ASSERT_EQ(var_bool->m_var_type_current, ObjType::Bool) << (int) var_bool->getType();
2470// ASSERT_EQ(var_empty->m_var_type_current, ObjType::None) << (int) var_empty->getType();
2471// ASSERT_TRUE(var_empty->empty()) << (int) var_empty->getType();
2472// ASSERT_FALSE(var_int->empty()) << (int) var_int->getType();
2473//
2474//
2475// ASSERT_TRUE(var_int->op_accurate(Obj::CreateValue(100, ObjType::None)));
2476// ASSERT_FALSE(var_int->op_accurate(Obj::CreateValue(111, ObjType::None)));
2477//
2478// ASSERT_TRUE(var_num->op_equal(Obj::CreateValue(100.0, ObjType::None)));
2479// ASSERT_FALSE(var_num->op_equal(Obj::CreateValue(100.0001, ObjType::None)));
2480// ASSERT_TRUE(var_num->op_accurate(Obj::CreateValue(100.0, ObjType::None)));
2481// ASSERT_FALSE(var_num->op_accurate(Obj::CreateValue(100.0001, ObjType::None)));
2482//
2483// ASSERT_TRUE(var_int->op_equal(Obj::CreateValue(100.0, ObjType::None)));
2484// ASSERT_TRUE(var_int->op_accurate(Obj::CreateValue(100.0, ObjType::None)));
2485// ASSERT_FALSE(var_int->op_equal(Obj::CreateValue(100.1, ObjType::None)));
2486// ASSERT_FALSE(var_int->op_accurate(Obj::CreateValue(100.1, ObjType::None)));
2487//
2488//
2489// ObjPtr var_int2 = Obj::CreateValue(101, ObjType::None);
2490// ObjPtr var_num2 = Obj::CreateValue(100.1, ObjType::None);
2491//
2492//
2493// ASSERT_TRUE(var_int->op_accurate(var_int));
2494// ASSERT_FALSE(var_int->op_accurate(var_int2));
2495//
2496// ASSERT_TRUE(var_num->op_accurate(var_num));
2497// ASSERT_FALSE(var_num->op_accurate(var_num2));
2498//
2499// ASSERT_TRUE(var_int->op_equal(var_num));
2500//
2501// ASSERT_FALSE(var_int->op_equal(var_num2));
2502// ASSERT_FALSE(var_num2->op_equal(var_int));
2503//
2504// ObjPtr var_bool2 = Obj::CreateBool(false);
2505//
2506// ASSERT_TRUE(var_bool->op_accurate(var_bool));
2507// ASSERT_FALSE(var_bool->op_accurate(var_bool2));
2508//
2509// ObjPtr var_str2 = Obj::CreateString("STRING2");
2510//
2511// ASSERT_TRUE(var_str->op_accurate(var_str));
2512// ASSERT_TRUE(var_str->op_accurate(Obj::CreateString("STRING")));
2513// ASSERT_FALSE(var_str->op_accurate(var_str2));
2514//
2515//
2516// ObjPtr var_empty2 = Obj::CreateNone();
2517//
2518// ASSERT_TRUE(var_empty->op_accurate(var_empty));
2519// ASSERT_TRUE(var_empty->op_accurate(var_empty2));
2520//}
2521//
2522//TEST(RunTest, Ops) {
2523//
2524// ObjPtr var_zero = Obj::CreateValue(0, ObjType::None);
2525// ASSERT_TRUE(var_zero->is_bool_type());
2526// ASSERT_TRUE(var_zero->is_arithmetic_type());
2527// ASSERT_EQ(ObjType::Bool, var_zero->m_var_type_current);
2528//
2529// ObjPtr var_bool = Obj::CreateBool(true);
2530// ASSERT_TRUE(var_bool->is_bool_type());
2531// ASSERT_TRUE(var_bool->is_arithmetic_type());
2532// ASSERT_EQ(ObjType::Bool, var_bool->m_var_type_current);
2533//
2534// ObjPtr var_char = Obj::CreateValue(100);
2535// ASSERT_TRUE(var_char->is_arithmetic_type());
2536// ASSERT_EQ(ObjType::Int8, var_char->m_var_type_current);
2537//
2538// ObjPtr var_int = Obj::CreateValue(100000);
2539// ASSERT_TRUE(var_int->is_arithmetic_type());
2540// ASSERT_EQ(ObjType::Int32, var_int->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
2541//
2542// ObjPtr var_float = Obj::CreateValue(1.0);
2543// ASSERT_TRUE(var_float->is_arithmetic_type());
2544// ASSERT_EQ(ObjType::Float32, var_float->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
2545//
2546// ObjPtr var_tensor = Obj::CreateRange(0, 10)->toType(ObjType::Int32);
2547// ASSERT_TRUE(var_tensor->is_arithmetic_type());
2548// ASSERT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
2549//
2550// var_tensor->operator*=(var_bool);
2551// ASSERT_TRUE(var_tensor->is_arithmetic_type());
2552// EXPECT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
2553//
2554// var_tensor->operator*=(var_int);
2555// ASSERT_TRUE(var_tensor->is_arithmetic_type());
2556// EXPECT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
2557//
2558// var_tensor->operator*=(var_float);
2559// ASSERT_TRUE(var_tensor->is_arithmetic_type());
2560// EXPECT_EQ(ObjType::Float32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
2561//}
2562//
2563//TEST(RunTest, Exist) {
2564//
2565// Obj var_array(ObjType::Dictionary);
2566//
2567// var_array.push_back(Obj::CreateString("item1"));
2568// var_array.push_back(Obj::CreateString("item2"));
2569//
2570// ObjPtr item = Obj::CreateString("item1");
2571// ASSERT_TRUE(var_array.exist(item, true));
2572// item->SetValue_("item2");
2573// ASSERT_TRUE(var_array.exist(item, true));
2574// item->SetValue_("item");
2575// ASSERT_FALSE(var_array.exist(item, true));
2576//
2577//
2578// Obj var_map(ObjType::Dictionary);
2579//
2580// var_map.push_back(Obj::CreateString("MAP_VALUE1"), "map1");
2581// var_map.push_back(Obj::CreateString("MAP_VALUE2"), "map2");
2582//
2583// ASSERT_TRUE(var_map[std::string("map1")].second);
2584// ASSERT_TRUE(var_map["map2"].second);
2585// ASSERT_EQ(var_map.find("map"), var_map.end());
2586//
2587//}
2588//
2589//TEST(RunTest, Intersec) {
2590//
2591// Obj var_array(ObjType::Dictionary);
2592// Obj var_array2(ObjType::Dictionary);
2593//
2594// var_array.push_back(Obj::CreateString("item1"));
2595// var_array.push_back(Obj::CreateString("item2"));
2596//
2597// ObjPtr result = var_array.op_bit_and(var_array2, true);
2598// ASSERT_TRUE(result->empty());
2599//
2600// var_array2.push_back(Obj::CreateString("item3"));
2601//
2602// result = var_array.op_bit_and(var_array2, true);
2603// ASSERT_TRUE(result->empty());
2604//
2605// var_array2.push_back(Obj::CreateString("item1"));
2606// result = var_array.op_bit_and(var_array2, true);
2607// ASSERT_FALSE(result->empty());
2608// ASSERT_EQ(1, result->size());
2609//
2610// var_array2.push_back(Obj::CreateString("item2"));
2611// result = var_array.op_bit_and(var_array2, true);
2612// ASSERT_FALSE(result->empty());
2613// ASSERT_EQ(2, result->size());
2614// //
2615// // result = Op:intersec(var_array, var_array2);
2616// // ASSERT_TRUE(Var::isEmpty(result));
2617// //
2618// //
2619// // ASSERT_TRUE(var_array.Exist(std::string("item1")));
2620// //
2621// // ASSERT_TRUE(var_array.Exist(std::string("item1")));
2622// // ASSERT_TRUE(var_array.Exist(std::string("item2")));
2623// // ASSERT_FALSE(var_array.Exist(std::string("item")));
2624// //
2625// //
2626// // Var var_map(Var::Type::MAP);
2627// //
2628// // var_map.Set("map1", "MAP1");
2629// // var_map.Set("map2", "MAP2");
2630// //
2631// // ASSERT_TRUE(var_map.Exist(std::string("map1")));
2632// // ASSERT_TRUE(var_map.Exist(std::string("map2")));
2633// // ASSERT_FALSE(var_map.Exist(std::string("map")));
2634//
2635//
2636//
2637//
2638// // Var var_object(Var::Type::OBJECT);
2639// // Var var_list(Var::Type::LIST);
2640// //
2641// // var_list.Set("map1", "MAP1");
2642// // var_map.Set("map2", "MAP2");
2643// //
2644// // ASSERT_TRUE(var_map.Exist("map1"));
2645// // ASSERT_TRUE(var_map.Exist("map2"));
2646// // ASSERT_FALSE(var_map.Exist("map"));
2647//}
2648//
2649//TEST(RunTest, Print) {
2650//
2651// RuntimePtr rt = RunTime::Init();
2652// ASSERT_TRUE(rt);
2653//
2654// ObjPtr var_int = Obj::CreateValue(100, ObjType::None);
2655// ObjPtr var_num = Obj::CreateValue(100.123, ObjType::None);
2656// ObjPtr var_str = Obj::CreateString(L"STRCHAR");
2657// ObjPtr var_strbyte = Obj::CreateString("STRBYTE");
2658// ObjPtr var_bool = Obj::CreateBool(true);
2659// ObjPtr var_empty = Obj::CreateNone();
2660//
2661// ASSERT_STREQ("100", var_int->toString().c_str()) << var_int;
2662// ASSERT_STREQ("100.123", var_num->toString().c_str()) << var_num;
2663// ASSERT_STREQ("\"STRCHAR\"", var_str->toString().c_str()) << var_str;
2664// ASSERT_STREQ("'STRBYTE'", var_strbyte->toString().c_str()) << var_strbyte;
2665// ASSERT_STREQ("1", var_bool->toString().c_str()) << var_bool;
2666// ASSERT_STREQ("_", var_empty->toString().c_str()) << var_empty;
2667//
2668// ObjPtr var_dict = Obj::CreateType(ObjType::Dictionary);
2669//
2670// ASSERT_STREQ("(,)", var_dict->toString().c_str()) << var_dict;
2671//
2672// var_dict->m_var_name = "dict";
2673// ASSERT_STREQ("dict=(,)", var_dict->toString().c_str()) << var_dict;
2674//
2675// var_dict->push_back(Obj::CreateString(L"item1"));
2676// ASSERT_STREQ("dict=(\"item1\",)", var_dict->toString().c_str()) << var_dict;
2677// var_dict->push_back(var_int);
2678// var_dict->push_back(var_bool);
2679// ASSERT_STREQ("dict=(\"item1\", 100, 1,)", var_dict->toString().c_str()) << var_dict;
2680//
2681//
2682// ObjPtr var_array = Obj::CreateDict(); //CreateTensor({1});
2683//
2684// ASSERT_STREQ("(,)", var_array->toString().c_str()) << var_array;
2685//
2686// var_array->m_var_name = "array";
2687// ASSERT_STREQ("array=(,)", var_array->toString().c_str()) << var_array;
2688//
2689// var_array->push_back(Obj::CreateString("item1"));
2690// ASSERT_STREQ("array=('item1',)", var_array->toString().c_str()) << var_array;
2691// ASSERT_NO_THROW(var_array->push_back(var_int));
2692// ASSERT_NO_THROW(var_array->push_back(var_bool));
2693// ASSERT_STREQ("array=('item1', 100, 1,)", var_array->toString().c_str()) << var_array;
2694//
2695//}
2696//
2697//TEST(RunTest, CreateFromInteger) {
2698//
2699// JIT * jit = JIT::ReCreate();
2700// ASSERT_TRUE(jit);
2701//
2702// ObjPtr var = jit->Run("123");
2703// ASSERT_TRUE(var);
2704// ASSERT_EQ(ObjType::Int8, var->getType()) << toString(var->getType());
2705// ASSERT_EQ(123, var->GetValueAsInteger());
2706//
2707// ObjPtr var2 = jit->Run("123");
2708// ASSERT_TRUE(var2);
2709// ASSERT_EQ(ObjType::Int8, var2->getType()) << toString(var2->getType());
2710// ASSERT_EQ(123, var2->GetValueAsInteger());
2711//
2712// var = jit->Run("-123");
2713// ASSERT_TRUE(var);
2714// ASSERT_EQ(ObjType::Int8, var->getType()) << toString(var->getType());
2715// ASSERT_EQ(-123, var->GetValueAsInteger());
2716//
2717// var2 = jit->Run("-123");
2718// ASSERT_TRUE(var2);
2719// ASSERT_EQ(ObjType::Int8, var2->getType()) << toString(var2->getType());
2720// ASSERT_EQ(-123, var2->GetValueAsInteger());
2721//}
2722//
2723//TEST(RunTest, CreateFromNumber) {
2724//
2725// JIT * jit = JIT::ReCreate();
2726// ASSERT_TRUE(jit);
2727//
2728// ObjPtr var = jit->Run("123.123");
2729// ASSERT_TRUE(var);
2730// ASSERT_EQ(ObjType::Float32, var->getType());
2731// ASSERT_DOUBLE_EQ(123.123, var->GetValueAsNumber());
2732//
2733// ObjPtr var2 = jit->Run("123.123");
2734// ASSERT_TRUE(var2);
2735// ASSERT_EQ(ObjType::Float32, var2->getType());
2736// ASSERT_DOUBLE_EQ(123.123, var2->GetValueAsNumber());
2737//
2738// var = jit->Run("-123.123");
2739// ASSERT_TRUE(var);
2740// ASSERT_EQ(ObjType::Float64, var->getType());
2741// ASSERT_DOUBLE_EQ(-123.123, var->GetValueAsNumber());
2742//
2743// var2 = jit->Run("-123.123E+40");
2744// ASSERT_TRUE(var2);
2745// ASSERT_EQ(ObjType::Float64, var2->getType());
2746// ASSERT_DOUBLE_EQ(-123.123E+40, var2->GetValueAsNumber());
2747//}
2748//
2749//TEST(RunTest, CreateFromString) {
2750//
2751// JIT * jit = JIT::ReCreate();
2752// ASSERT_TRUE(jit);
2753//
2754// ObjPtr var = jit->Run("\"123.123\"");
2755// ASSERT_TRUE(var);
2756// ASSERT_EQ(ObjType::StrWide, var->getType());
2757// ASSERT_STREQ("123.123", var->GetValueAsString().c_str());
2758//
2759// ObjPtr var2 = jit->Run("\"123.123\"");
2760// ASSERT_TRUE(var2);
2761// ASSERT_EQ(ObjType::StrWide, var2->getType());
2762// ASSERT_STREQ("123.123", var2->GetValueAsString().c_str());
2763//
2764// var = jit->Run("'строка'");
2765// ASSERT_TRUE(var);
2766// ASSERT_EQ(ObjType::StrChar, var->getType());
2767// ASSERT_STREQ("строка", var->GetValueAsString().c_str());
2768//
2769// var2 = jit->Run("'строка'");
2770// ASSERT_TRUE(var2);
2771// ASSERT_EQ(ObjType::StrChar, var2->getType());
2772// ASSERT_STREQ("строка", var2->GetValueAsString().c_str());
2773//}
2774//
2775//TEST(RunTest, CreateFromRational) {
2776//
2777// JIT * jit = JIT::ReCreate();
2778// ASSERT_TRUE(jit);
2779//
2780// ObjPtr var = jit->Run("123\\1");
2781// ASSERT_TRUE(var);
2782// ASSERT_EQ(ObjType::Rational, var->getType()) << toString(var->getType());
2783// ASSERT_EQ(123, var->GetValueAsInteger());
2784// ASSERT_DOUBLE_EQ(123.0, var->GetValueAsNumber());
2785//
2786// ObjPtr var2 = jit->Run("123\\1");
2787// ASSERT_TRUE(var2);
2788// ASSERT_EQ(ObjType::Rational, var2->getType()) << toString(var2->getType());
2789// ASSERT_EQ(123, var2->GetValueAsInteger());
2790// ASSERT_DOUBLE_EQ(123, var2->GetValueAsNumber());
2791//
2792// var = jit->Run("-123\\1");
2793// ASSERT_TRUE(var);
2794// ASSERT_EQ(ObjType::Rational, var->getType()) << toString(var->getType());
2795// ASSERT_EQ(-123, var->GetValueAsInteger());
2796// ASSERT_DOUBLE_EQ(-123.0, var->GetValueAsNumber());
2797//
2798// var2 = jit->Run("-123\\1");
2799// ASSERT_TRUE(var2);
2800// ASSERT_EQ(ObjType::Rational, var2->getType()) << toString(var2->getType());
2801// ASSERT_EQ(-123, var2->GetValueAsInteger());
2802// ASSERT_DOUBLE_EQ(-123, var2->GetValueAsNumber());
2803//}
2804//
2981//
2982//TEST(RunTest, Tensor) {
2983//
2984// std::string from_str = "русские буквы для ПРОВЕРКИ КОНВЕРТАЦИИ символов";
2985// std::wstring to_str = utf8_decode(from_str);
2986// std::string conv_str = utf8_encode(to_str);
2987//
2988// ASSERT_STREQ(from_str.c_str(), conv_str.c_str());
2989//
2990// // Байтовые строки
2991// ObjPtr str = Obj::CreateString("test");
2992//
2993// ASSERT_STREQ("test", str->m_value.c_str());
2994//
2995// torch::Tensor tstr_t;
2996//
2997// ConvertStringToTensor(str->m_value, tstr_t, ObjType::Int8);
2998//
2999// ASSERT_TRUE(tstr_t.defined());
3000// ASSERT_EQ(tstr_t.index({0}).item<int>(), 't');
3001// ASSERT_EQ(tstr_t.index({1}).item<int>(), 'e');
3002// ASSERT_EQ(tstr_t.index({2}).item<int>(), 's');
3003// ASSERT_EQ(tstr_t.index({3}).item<int>(), 't');
3004//
3005//
3006// torch::Tensor tensot_temp = *str->toType(ObjType::Tensor)->m_tensor;
3007// ASSERT_TRUE(tensot_temp.defined());
3008// ASSERT_EQ(tensot_temp.index({0}).item<int>(), 't');
3009// ASSERT_EQ(tensot_temp.index({1}).item<int>(), 'e');
3010// ASSERT_EQ(tensot_temp.index({2}).item<int>(), 's');
3011// ASSERT_EQ(tensot_temp.index({3}).item<int>(), 't');
3012//
3013// ObjPtr t_str = CreateTensor(tensot_temp);
3014// ASSERT_EQ(t_str->m_var_type_current, ObjType::Int8) << toString(t_str->m_var_type_current);
3015// ASSERT_EQ(4, t_str->size());
3016// ASSERT_TRUE(t_str->m_tensor->defined());
3017//
3018// ASSERT_EQ(t_str->m_tensor->index({0}).item<int>(), 't');
3019// ASSERT_EQ(t_str->m_tensor->index({1}).item<int>(), 'e');
3020// ASSERT_EQ(t_str->m_tensor->index({2}).item<int>(), 's');
3021// ASSERT_EQ(t_str->m_tensor->index({3}).item<int>(), 't');
3022//
3023// ASSERT_EQ(t_str->index_get({0})->GetValueAsInteger(), 't');
3024// ASSERT_EQ(t_str->index_get({1})->GetValueAsInteger(), 'e');
3025// ASSERT_EQ(t_str->index_get({2})->GetValueAsInteger(), 's');
3026// ASSERT_EQ(t_str->index_get({3})->GetValueAsInteger(), 't');
3027//
3028// ASSERT_STREQ(t_str->toType(ObjType::StrWide)->GetValueAsString().c_str(), "test") << t_str->toType(ObjType::StrWide)->GetValueAsString();
3029//
3030// t_str->index_set_({1}, Obj::CreateString("E"));
3031// t_str->index_set_({2}, Obj::CreateString("S"));
3032//
3033// EXPECT_STREQ(t_str->toType(ObjType::StrWide)->GetValueAsString().c_str(), "tESt") << t_str->toType(ObjType::StrWide)->GetValueAsString();
3034//
3035// // Символьные сторки
3036// ObjPtr wstr = Obj::CreateString(L"ТЕСТ");
3037// ObjPtr t_wstr = CreateTensor(*wstr->toType(ObjType::Tensor)->m_tensor);
3038// if (sizeof (wchar_t) == 2) {
3039// ASSERT_EQ(t_wstr->m_var_type_current, ObjType::Int16);
3040// } else {
3041// ASSERT_TRUE(sizeof (wchar_t) == 4);
3042// ASSERT_EQ(t_wstr->m_var_type_current, ObjType::Int32);
3043// }
3044// ASSERT_EQ(4, t_wstr->size());
3045//
3046// ASSERT_EQ(t_wstr->index_get({0})->GetValueAsInteger(), L'Т');
3047// ASSERT_EQ(t_wstr->index_get({1})->GetValueAsInteger(), L'Е');
3048// ASSERT_EQ(t_wstr->index_get({2})->GetValueAsInteger(), L'С');
3049// ASSERT_EQ(t_wstr->index_get({3})->GetValueAsInteger(), L'Т');
3050//
3051// std::wstring test_wide = t_wstr->toType(ObjType::StrWide)->GetValueAsStringWide();
3052// EXPECT_STREQ(utf8_encode(test_wide).c_str(), "ТЕСТ");
3053//
3054// std::string test_str = t_wstr->toType(ObjType::StrWide)->GetValueAsString();
3055// EXPECT_STREQ(test_str.c_str(), "ТЕСТ") << test_str;
3056//
3057// t_wstr->index_set_({1}, Obj::CreateString(L"е"));
3058// t_wstr->index_set_({2}, Obj::CreateString(L"с"));
3059//
3060// test_str = t_wstr->toType(ObjType::StrWide)->GetValueAsString();
3061// EXPECT_STREQ(test_str.c_str(), "ТесТ") << test_str;
3062//
3063//}
3064//
3065//TEST(RunTest, Iterator) {
3066//
3067// ObjPtr dict = Obj::CreateDict();
3068//
3069// dict->push_back(Obj::Arg(1, "1"));
3070// dict->push_back(Obj::Arg(2, "22"));
3071// dict->push_back(Obj::Arg(3, "333"));
3072// dict->push_back(Obj::Arg(4));
3073// dict->push_back(Obj::Arg(5, "555"));
3074//
3075// ASSERT_EQ(5, dict->size());
3076//
3077// auto all = std::regex("(.|\\n)*");
3078// ASSERT_TRUE(std::regex_match("1", all));
3079// ASSERT_TRUE(std::regex_match("22", all));
3080// ASSERT_TRUE(std::regex_match("333", all));
3081// ASSERT_TRUE(std::regex_match("", all));
3082// ASSERT_TRUE(std::regex_match("\n", all));
3083// ASSERT_TRUE(std::regex_match("\n\n\\n", all));
3084//
3085//
3086// Iterator <Obj> iter(dict);
3087//
3088// ASSERT_TRUE(iter == iter.begin());
3089// ASSERT_TRUE(iter != iter.end());
3090//
3091// ObjPtr copy = Obj::CreateDict();
3092// for (auto &elem : iter) {
3093//
3094// copy->push_back(elem.second, elem.first);
3095// }
3096//
3097// ASSERT_TRUE(iter == iter.begin());
3098// ASSERT_TRUE(iter != iter.end());
3099//
3100// ASSERT_EQ(dict->size(), copy->size());
3101//
3102//
3103// ASSERT_TRUE(iter == iter.begin());
3104//
3105// ObjPtr one = iter.read_and_next(0);
3106// ASSERT_TRUE(one);
3107// ASSERT_EQ(1, one->GetValueAsInteger());
3108//
3109// ASSERT_EQ(2, (*iter).second->GetValueAsInteger());
3110// one = iter.read_and_next(0);
3111// ASSERT_TRUE(one);
3112// ASSERT_EQ(2, one->GetValueAsInteger());
3113//
3114// ASSERT_EQ(3, (*iter).second->GetValueAsInteger());
3115// one = iter.read_and_next(0);
3116// ASSERT_TRUE(one);
3117// ASSERT_EQ(3, one->GetValueAsInteger());
3118//
3119// ASSERT_EQ(4, (*iter).second->GetValueAsInteger());
3120// one = iter.read_and_next(0);
3121// ASSERT_TRUE(one);
3122// ASSERT_EQ(4, one->GetValueAsInteger());
3123//
3124// ASSERT_EQ(5, (*iter).second->GetValueAsInteger());
3125// one = iter.read_and_next(0);
3126// ASSERT_TRUE(one);
3127// ASSERT_EQ(5, one->GetValueAsInteger());
3128//
3129// one = iter.read_and_next(0);
3130// ASSERT_TRUE(one);
3131// ASSERT_EQ(ObjType::IteratorEnd, one->getType()) << one << " " << toString(one->getType());
3132//
3133// one = iter.read_and_next(0);
3134// ASSERT_TRUE(one);
3135// ASSERT_EQ(ObjType::IteratorEnd, one->getType()) << one << " " << toString(one->getType());
3136//
3137//
3138//
3139//
3140// ASSERT_TRUE(iter == iter.end());
3141// iter.reset();
3142// ASSERT_TRUE(iter == iter.begin());
3143// ASSERT_TRUE(iter != iter.end());
3144//
3145// ObjPtr dict1 = iter.read_and_next(-3);
3146// ASSERT_TRUE(dict1);
3147// ASSERT_EQ(3, dict1->size());
3148// ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
3149// ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
3150// ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
3151//
3152// ObjPtr dict2 = iter.read_and_next(-3);
3153// ASSERT_TRUE(dict2);
3154// ASSERT_EQ(3, dict2->size());
3155// ASSERT_EQ(4, dict2->at(0).second->GetValueAsInteger());
3156// ASSERT_EQ(5, dict2->at(1).second->GetValueAsInteger());
3157// ASSERT_EQ(ObjType::IteratorEnd, dict2->at(2).second->getType());
3158//
3159// ObjPtr dict3 = iter.read_and_next(-3);
3160// ASSERT_TRUE(dict3);
3161// ASSERT_EQ(3, dict1->size());
3162// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(0).second->getType());
3163// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(1).second->getType());
3164// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(2).second->getType());
3165//
3166//
3167//
3168// ASSERT_TRUE(iter == iter.end());
3169// iter.reset();
3170// ASSERT_TRUE(iter == iter.begin());
3171// ASSERT_TRUE(iter != iter.end());
3172//
3173// dict1 = iter.read_and_next(3);
3174// ASSERT_TRUE(dict1);
3175// ASSERT_EQ(3, dict1->size());
3176// ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
3177// ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
3178// ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
3179//
3180// dict2 = iter.read_and_next(3);
3181// ASSERT_TRUE(dict2);
3182// ASSERT_EQ(2, dict2->size());
3183// ASSERT_EQ(4, dict2->at(0).second->GetValueAsInteger());
3184// ASSERT_EQ(5, dict2->at(1).second->GetValueAsInteger());
3185//
3186// dict3 = iter.read_and_next(3);
3187// ASSERT_TRUE(dict3);
3188// ASSERT_EQ(0, dict3->size());
3189//
3190//
3191//
3192//
3193// Iterator <Obj> flt(dict, "");
3194// ObjPtr flt_res = flt.read_and_next(100);
3195// ASSERT_TRUE(flt_res);
3196// ASSERT_EQ(1, flt_res->size());
3197// ASSERT_EQ(4, flt_res->at(0).second->GetValueAsInteger());
3198//
3199//
3200// Iterator <Obj> flt1(dict, ".");
3201// ObjPtr flt1_res = flt1.read_and_next(100);
3202// ASSERT_TRUE(flt1_res);
3203// ASSERT_EQ(1, flt1_res->size());
3204// ASSERT_EQ(1, flt1_res->at(0).second->GetValueAsInteger());
3205//
3206//
3207// Iterator <Obj> flt2(dict, "..");
3208// ObjPtr flt2_res = flt2.read_and_next(100);
3209// ASSERT_TRUE(flt2_res);
3210// ASSERT_EQ(1, flt2_res->size());
3211// ASSERT_EQ(2, flt2_res->at(0).second->GetValueAsInteger());
3212//
3213// Iterator <Obj> flt3(dict, "...");
3214// ObjPtr flt3_res = flt3.read_and_next(100);
3215// ASSERT_TRUE(flt3_res);
3216// ASSERT_EQ(2, flt3_res->size());
3217// ASSERT_EQ(3, flt3_res->at(0).second->GetValueAsInteger());
3218// ASSERT_EQ(5, flt3_res->at(1).second->GetValueAsInteger());
3219//
3220//
3221//
3222// // ObjPtr iter1 = dict->MakeIterator();
3223//
3224//}
3225//
3226//TEST(RunTest, System) {
3227//
3228// ASSERT_STREQ("name", ExtractName("name").c_str());
3229// ASSERT_STREQ("name", ExtractName("::name").c_str());
3230// ASSERT_STREQ("name", ExtractName("ns::name").c_str());
3231// ASSERT_STREQ("", ExtractName("\\file").c_str());
3232// ASSERT_STREQ("", ExtractName("\\\\dir.file").c_str());
3233// ASSERT_STREQ("var", ExtractName("\\dir.file::var").c_str());
3234// ASSERT_STREQ("var.field", ExtractName("\\\\dir.file::var.field").c_str());
3235//
3236//
3237// ASSERT_STREQ("\\file", ExtractModuleName("\\file").c_str());
3238// ASSERT_STREQ("\\\\dir.file", ExtractModuleName("\\\\dir.file").c_str());
3239// ASSERT_STREQ("\\dir.file", ExtractModuleName("\\dir.file::var").c_str());
3240// ASSERT_STREQ("\\\\dir.file", ExtractModuleName("\\\\dir.file::var.field").c_str());
3241//
3242//
3243// ObjPtr none = Obj::CreateNone();
3244//
3245// ASSERT_TRUE(none->at("__error_field_name__").second);
3246// ASSERT_STREQ("Internal field '__error_field_name__' not exist!", none->at("__error_field_name__").second->GetValueAsString().c_str());
3247//
3248// ASSERT_TRUE(none->at("__type__").second);
3249// ASSERT_STREQ(":None", none->at("__type__").second->GetValueAsString().c_str());
3250//
3251// ASSERT_TRUE(none->at("__type_fixed__").second);
3252// ASSERT_STREQ(":None", none->at("__type_fixed__").second->GetValueAsString().c_str());
3253//
3254// ASSERT_TRUE(none->at("__name__").second);
3255// ASSERT_STREQ("", none->at("__name__").second->GetValueAsString().c_str());
3256//
3257// ASSERT_TRUE(none->at("__full_name__").second);
3258// ASSERT_STREQ("", none->at("__full_name__").second->GetValueAsString().c_str());
3259//
3260// ASSERT_TRUE(none->at("__module__").second);
3261// ASSERT_STREQ("", none->at("__module__").second->GetValueAsString().c_str());
3262//
3263// ASSERT_TRUE(none->at("__class__").second);
3264// ASSERT_STREQ("", none->at("__class__").second->GetValueAsString().c_str());
3265//
3266// ASSERT_TRUE(none->at("__base__").second);
3267// ASSERT_STREQ("(,)", none->at("__base__").second->GetValueAsString().c_str());
3268//
3269// // ASSERT_TRUE(none->at("__doc__").second);
3270// // ASSERT_STREQ("Help system not implemented!!!!!", none->at("__doc__").second->GetValueAsString().c_str());
3271//
3272// ASSERT_TRUE(none->at("__str__").second);
3273// ASSERT_STREQ("_", none->at("__str__").second->GetValueAsString().c_str());
3274//
3275// none->m_var_is_init = false;
3276// ASSERT_TRUE(none->at("__error_field_name__").second);
3277// ASSERT_STREQ(":Undefined", none->at("__error_field_name__").second->GetValueAsString().c_str());
3278//
3279//
3280// ObjPtr str = Obj::CreateString("str");
3281// str->m_var_name = "name";
3282//
3283// ASSERT_TRUE(str->at("__type__").second);
3284// ASSERT_STREQ(":StrChar", str->at("__type__").second->GetValueAsString().c_str());
3285//
3286// ASSERT_TRUE(str->at("__type_fixed__").second);
3287// ASSERT_STREQ(":String", str->at("__type_fixed__").second->GetValueAsString().c_str());
3288//
3289// ASSERT_TRUE(str->at("__name__").second);
3290// ASSERT_STREQ("name", str->at("__name__").second->GetValueAsString().c_str());
3291//
3292// ASSERT_TRUE(str->at("__full_name__").second);
3293// ASSERT_STREQ("name", str->at("__full_name__").second->GetValueAsString().c_str());
3294//
3295// ASSERT_TRUE(str->at("__module__").second);
3296// ASSERT_STREQ("", str->at("__module__").second->GetValueAsString().c_str());
3297//
3298// ASSERT_TRUE(str->at("__class__").second);
3299// ASSERT_STREQ("", str->at("__class__").second->GetValueAsString().c_str());
3300//
3301// ASSERT_TRUE(str->at("__base__").second);
3302// ASSERT_STREQ("(,)", str->at("__base__").second->GetValueAsString().c_str());
3303//
3304// // ASSERT_TRUE(str->at("__doc__").second);
3305// // ASSERT_STREQ("Help system not implemented!!!!!", str->at("__doc__").second->GetValueAsString().c_str());
3306//
3307// ASSERT_TRUE(str->at("__str__").second);
3308// ASSERT_STREQ("name='str'", str->at("__str__").second->GetValueAsString().c_str());
3309//
3310//
3311// ObjPtr cls = Obj::CreateClass("class");
3312// cls->m_var_name = "::ns::name";
3313// cls->push_back(Obj::CreateRange(0, 10, 3), "filed");
3314//
3315// ASSERT_TRUE(cls->at("__type__").second);
3316// ASSERT_STREQ(":Class", cls->at("__type__").second->GetValueAsString().c_str());
3317//
3318// ASSERT_TRUE(cls->at("__type_fixed__").second);
3319// ASSERT_STREQ(":None", cls->at("__type_fixed__").second->GetValueAsString().c_str());
3320//
3321// ASSERT_TRUE(cls->at("__name__").second);
3322// ASSERT_STREQ("name", cls->at("__name__").second->GetValueAsString().c_str());
3323//
3324// ASSERT_TRUE(cls->at("__full_name__").second);
3325// ASSERT_STREQ("::ns::name", cls->at("__full_name__").second->GetValueAsString().c_str());
3326//
3327// ASSERT_TRUE(cls->at("__module__").second);
3328// ASSERT_STREQ("", cls->at("__module__").second->GetValueAsString().c_str());
3329//
3330// ASSERT_TRUE(cls->at("__class__").second);
3331// ASSERT_STREQ("class", cls->at("__class__").second->GetValueAsString().c_str());
3332//
3333// ASSERT_TRUE(cls->at("__base__").second);
3334// ASSERT_STREQ("(,)", cls->at("__base__").second->GetValueAsString().c_str());
3335//
3336// // ASSERT_TRUE(cls->at("__doc__").second);
3337// // ASSERT_STREQ("Help system not implemented!!!!!", cls->at("__doc__").second->GetValueAsString().c_str());
3338//
3339// ASSERT_TRUE(cls->at("__str__").second);
3340// ASSERT_STREQ("::ns::name=class(filed=0..10..3)", cls->at("__str__").second->GetValueAsString().c_str());
3341//}
3342//
3343//
3344//
3345//#endif // UNITTEST
Generated by doxygen 1.11.0