NewLang Project
Yet another programm language
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Loading...
Searching...
No Matches
object_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 "rational.h"
12#include "object.h"
13#include "runtime.h"
14#include "builtin.h"
15
16
17using namespace newlang;
18
19TEST(ObjTest, Empty) {
20 Obj var;
21 ASSERT_TRUE(var.empty());
22 ASSERT_EQ(ObjType::None, var.getType());
23}
24
25TEST(ObjTest, Value) {
26 Obj var;
27
28 var.SetValue_(0);
29 ASSERT_EQ(ObjType::Bool, var.getType());
30
31 var.SetValue_(1);
32 ASSERT_EQ(ObjType::Bool, var.getType());
33
34 var.SetValue_(1.0);
35 ASSERT_EQ(ObjType::Float32, var.getType());
36
37 var.SetValue_(1.0E+40);
38 ASSERT_EQ(ObjType::Float64, var.getType());
39
40 var.SetValue_(true);
41 ASSERT_EQ(ObjType::Bool, var.getType());
42
43 var.SetValue_(2);
44 ASSERT_EQ(ObjType::Int8, var.getType());
45
46 var.SetValue_(-100);
47 ASSERT_EQ(ObjType::Int8, var.getType());
48
49 var.SetValue_(1000);
50 ASSERT_EQ(ObjType::Int16, var.getType());
51
52 var.SetValue_(100000);
53 ASSERT_EQ(ObjType::Int32, var.getType());
54
55 var.SetValue_(10000000000);
56 ASSERT_EQ(ObjType::Int64, var.getType());
57
58 var.SetValue_(2.0);
59 ASSERT_EQ(ObjType::Float32, var.getType());
60
61 var.SetValue_(2.0E+40);
62 ASSERT_EQ(ObjType::Float64, var.getType());
63
64 var.SetValue_(false);
65 ASSERT_EQ(ObjType::Bool, var.getType());
66}
67
68TEST(ObjTest, String) {
69 Obj var;
70
71 var.SetValue_(std::string("test"));
72 ASSERT_EQ(ObjType::StrChar, var.getType()) << toString(var.getType());
73
74 Obj str1;
75 str1.SetValue_(L"Test str");
76 ASSERT_EQ(ObjType::StrWide, str1.getType()) << toString(str1.getType());
77
78 Obj str2;
79 str2.SetValue_(std::string("test2"));
80 ASSERT_EQ(ObjType::StrChar, str2.getType()) << toString(str2.getType());
81
82 ObjPtr str_byte = Obj::CreateString("byte");
83 ASSERT_STREQ("byte", str_byte->GetValueAsString().c_str());
84 ASSERT_EQ(4, str_byte->size());
85 ASSERT_EQ(4, str_byte->m_value.size());
86 ASSERT_STREQ("b", (*str_byte)[0].second->GetValueAsString().c_str());
87 ASSERT_STREQ("y", (*str_byte)[1].second->GetValueAsString().c_str());
88 ASSERT_STREQ("t", (*str_byte)[2].second->GetValueAsString().c_str());
89 ASSERT_STREQ("e", (*str_byte)[3].second->GetValueAsString().c_str());
90
91 str_byte->op_set_index(0, "B");
92 str_byte->op_set_index(1, "Y");
93 ASSERT_STREQ("BYte", str_byte->GetValueAsString().c_str());
94 str_byte->op_set_index(2, "T");
95 str_byte->op_set_index(3, "E");
96 ASSERT_STREQ("BYTE", str_byte->GetValueAsString().c_str());
97
98 ObjPtr str_char = Obj::CreateString(L"строка");
99 ASSERT_EQ(6, str_char->size());
100 ASSERT_EQ(6, str_char->m_string.size());
101
102 ASSERT_STREQ("с", (*str_char)[0].second->GetValueAsString().c_str());
103 ASSERT_STREQ("т", (*str_char)[1].second->GetValueAsString().c_str());
104 ASSERT_STREQ("р", (*str_char)[2].second->GetValueAsString().c_str());
105 ASSERT_STREQ("о", (*str_char)[3].second->GetValueAsString().c_str());
106 ASSERT_STREQ("к", (*str_char)[4].second->GetValueAsString().c_str());
107 ASSERT_STREQ("а", (*str_char)[5].second->GetValueAsString().c_str());
108
109 str_char->op_set_index(0, "С");
110 str_char->op_set_index(1, "Т");
111 ASSERT_STREQ("СТрока", str_char->GetValueAsString().c_str());
112 str_char->op_set_index(2, "Р");
113 str_char->op_set_index(3, "О");
114 ASSERT_STREQ("СТРОка", str_char->GetValueAsString().c_str());
115
116
117 // ObjPtr format = Obj::CreateString("$1 $2 ${name}");
118 // ObjPtr str11 = (*format)();
119 // ASSERT_STREQ("$1 $2 ${name}", str11->GetValueAsString().c_str());
120 //
121 // ObjPtr str22 = (*format)(Obj::Arg(100));
122 // ASSERT_STREQ("100 $2 ${name}", str22->GetValueAsString().c_str());
123 // str22 = (*format)(100);
124 // ASSERT_STREQ("100 $2 ${name}", str22->GetValueAsString().c_str());
125 //
126 // ObjPtr str3 = (*format)(Obj::Arg(-1), Obj::Arg("222"));
127 // ASSERT_STREQ("-1 222 ${name}", str3->GetValueAsString().c_str());
130 //
131 // ObjPtr str4 = (*format)(Obj::Arg("value", "name"));
132 // ASSERT_STREQ("value $2 value", str4->GetValueAsString().c_str());
133 //
134 // format = Obj::CreateString("$nameno ${имя1} $name $имя");
135 // ObjPtr str5 = (*format)(Obj::Arg("value", "name"), Obj::Arg("УТФ8-УТФ8", "имя"), Obj::Arg("УТФ8", "имя1"));
136 // ASSERT_STREQ("valueno УТФ8 value УТФ8-УТФ8", str5->GetValueAsString().c_str());
137
138}
139
140//TEST(ObjTest, Dict) {
141//
142// RuntimePtr rt = RunTime::Init();
143// ASSERT_TRUE(rt);
144//
145// Obj var(ObjType::Dictionary);
146// ASSERT_TRUE(var.empty());
147// EXPECT_ANY_THROW(var[0]);
148//
149// ASSERT_EQ(0, var.size());
150// ObjPtr var2;
151// ASSERT_NO_THROW(var2 = jit->Run("(,)"));
152//
153// var.push_back(Obj::CreateString("Test1"));
154// ASSERT_EQ(1, var.size());
155// var.push_back(Obj::CreateString("Test3"));
156// ASSERT_EQ(2, var.size());
157// var.insert(var.at_index_const(1), Obj::Arg(2, "2"));
158// var.insert(var.at_index_const(0), Obj::Arg(0, "0"));
159// ASSERT_EQ(4, var.size());
160//
161// ASSERT_TRUE(var[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
162// ASSERT_TRUE(var[1].second->op_accurate(Obj::CreateString("Test1")));
163// ASSERT_TRUE(var[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
164// ASSERT_TRUE(var[3].second->op_accurate(Obj::CreateString(L"Test3")));
165//
166// ASSERT_NO_THROW(var2 = jit->Run("(0, \"Test1\", 2, 'Test3',)"));
167//
168// ASSERT_TRUE((*var2)[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
169// ASSERT_TRUE((*var2)[1].second->op_accurate(Obj::CreateString("Test1")));
170// ASSERT_TRUE((*var2)[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
171// ASSERT_TRUE((*var2)[3].second->op_accurate(Obj::CreateString(L"Test3")));
172//
173// ObjPtr var3;
174//
175// ASSERT_NO_THROW(var3 = jit->Run("(0, \"Test1\", 2, 'Test3',)"));
176//
177// ASSERT_TRUE((*var3)[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
178// ASSERT_TRUE((*var3)[1].second->op_accurate(Obj::CreateString("Test1")));
179// ASSERT_TRUE((*var3)[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
180// ASSERT_TRUE((*var3)[3].second->op_accurate(Obj::CreateString(L"Test3")));
181//}
182//
183//TEST(ObjTest, AsMap) {
184//
185// ObjPtr map = Obj::CreateType(ObjType::Dictionary);
186// ASSERT_TRUE(map->empty());
187// EXPECT_ANY_THROW((*map)["test1"]);
188// ASSERT_EQ(0, map->size());
189//
190// ObjPtr temp = Obj::CreateString("Test");
191// map->push_back(temp, "test1");
192// map->push_back(Obj::CreateValue(100, ObjType::None), "test2");
193// ASSERT_EQ(2, map->size());
194// ASSERT_STREQ((*map)["test1"].second->toString().c_str(), temp->toString().c_str()) << temp->toString().c_str();
195//
196// ASSERT_TRUE((*map)["test2"].second);
197// ObjPtr temp100 = Obj::CreateValue(100, ObjType::None);
198// ASSERT_TRUE(map->exist(temp100, true));
199//
200// ObjPtr test2 = (*map)["test2"].second;
201// ASSERT_TRUE(test2);
202// ASSERT_TRUE(test2);
203// ASSERT_STREQ("100", test2->toString().c_str());
204//}
205//
206//TEST(ObjTest, Eq) {
207//
208// ObjPtr var_int = Obj::CreateValue(100, ObjType::None);
209// ObjPtr var_num = Obj::CreateValue(100.0, ObjType::None);
210// ObjPtr var_str = Obj::CreateString(L"STRING");
211// ObjPtr var_bool = Obj::CreateBool(true);
212// ObjPtr var_empty = Obj::CreateNone();
213//
214// ASSERT_EQ(var_int->m_var_type_current, ObjType::Int8) << (int) var_int->getType();
215// ASSERT_EQ(var_num->m_var_type_current, ObjType::Float32) << (int) var_num->getType();
216// ASSERT_EQ(var_str->m_var_type_current, ObjType::StrWide) << (int) var_str->getType();
217// ASSERT_EQ(var_bool->m_var_type_current, ObjType::Bool) << (int) var_bool->getType();
218// ASSERT_EQ(var_empty->m_var_type_current, ObjType::None) << (int) var_empty->getType();
219// ASSERT_TRUE(var_empty->empty()) << (int) var_empty->getType();
220// ASSERT_FALSE(var_int->empty()) << (int) var_int->getType();
221//
222//
223// ASSERT_TRUE(var_int->op_accurate(Obj::CreateValue(100, ObjType::None)));
224// ASSERT_FALSE(var_int->op_accurate(Obj::CreateValue(111, ObjType::None)));
225//
226// ASSERT_TRUE(var_num->op_equal(Obj::CreateValue(100.0, ObjType::None)));
227// ASSERT_FALSE(var_num->op_equal(Obj::CreateValue(100.0001, ObjType::None)));
228// ASSERT_TRUE(var_num->op_accurate(Obj::CreateValue(100.0, ObjType::None)));
229// ASSERT_FALSE(var_num->op_accurate(Obj::CreateValue(100.0001, ObjType::None)));
230//
231// ASSERT_TRUE(var_int->op_equal(Obj::CreateValue(100.0, ObjType::None)));
232// ASSERT_TRUE(var_int->op_accurate(Obj::CreateValue(100.0, ObjType::None)));
233// ASSERT_FALSE(var_int->op_equal(Obj::CreateValue(100.1, ObjType::None)));
234// ASSERT_FALSE(var_int->op_accurate(Obj::CreateValue(100.1, ObjType::None)));
235//
236//
237// ObjPtr var_int2 = Obj::CreateValue(101, ObjType::None);
238// ObjPtr var_num2 = Obj::CreateValue(100.1, ObjType::None);
239//
240//
241// ASSERT_TRUE(var_int->op_accurate(var_int));
242// ASSERT_FALSE(var_int->op_accurate(var_int2));
243//
244// ASSERT_TRUE(var_num->op_accurate(var_num));
245// ASSERT_FALSE(var_num->op_accurate(var_num2));
246//
247// ASSERT_TRUE(var_int->op_equal(var_num));
248//
249// ASSERT_FALSE(var_int->op_equal(var_num2));
250// ASSERT_FALSE(var_num2->op_equal(var_int));
251//
252// ObjPtr var_bool2 = Obj::CreateBool(false);
253//
254// ASSERT_TRUE(var_bool->op_accurate(var_bool));
255// ASSERT_FALSE(var_bool->op_accurate(var_bool2));
256//
257// ObjPtr var_str2 = Obj::CreateString("STRING2");
258//
259// ASSERT_TRUE(var_str->op_accurate(var_str));
260// ASSERT_TRUE(var_str->op_accurate(Obj::CreateString("STRING")));
261// ASSERT_FALSE(var_str->op_accurate(var_str2));
262//
263//
264// ObjPtr var_empty2 = Obj::CreateNone();
265//
266// ASSERT_TRUE(var_empty->op_accurate(var_empty));
267// ASSERT_TRUE(var_empty->op_accurate(var_empty2));
268//}
269//
270//TEST(ObjTest, Ops) {
271//
272// ObjPtr var_zero = Obj::CreateValue(0, ObjType::None);
273// ASSERT_TRUE(var_zero->is_bool_type());
274// ASSERT_TRUE(var_zero->is_arithmetic_type());
275// ASSERT_EQ(ObjType::Bool, var_zero->m_var_type_current);
276//
277// ObjPtr var_bool = Obj::CreateBool(true);
278// ASSERT_TRUE(var_bool->is_bool_type());
279// ASSERT_TRUE(var_bool->is_arithmetic_type());
280// ASSERT_EQ(ObjType::Bool, var_bool->m_var_type_current);
281//
282// ObjPtr var_char = Obj::CreateValue(100);
283// ASSERT_TRUE(var_char->is_arithmetic_type());
284// ASSERT_EQ(ObjType::Int8, var_char->m_var_type_current);
285//
286// ObjPtr var_int = Obj::CreateValue(100000);
287// ASSERT_TRUE(var_int->is_arithmetic_type());
288// ASSERT_EQ(ObjType::Int32, var_int->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
289//
290// ObjPtr var_float = Obj::CreateValue(1.0);
291// ASSERT_TRUE(var_float->is_arithmetic_type());
292// ASSERT_EQ(ObjType::Float32, var_float->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
293//
294// ObjPtr var_tensor = Obj::CreateRange(0, 10)->toType(ObjType::Int32);
295// ASSERT_TRUE(var_tensor->is_arithmetic_type());
296// ASSERT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
297//
298// var_tensor->operator*=(var_bool);
299// ASSERT_TRUE(var_tensor->is_arithmetic_type());
300// EXPECT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
301//
302// var_tensor->operator*=(var_int);
303// ASSERT_TRUE(var_tensor->is_arithmetic_type());
304// EXPECT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
305//
306// var_tensor->operator*=(var_float);
307// ASSERT_TRUE(var_tensor->is_arithmetic_type());
308// EXPECT_EQ(ObjType::Float32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
309//}
310//
311//TEST(ObjTest, Exist) {
312//
313// Obj var_array(ObjType::Dictionary);
314//
315// var_array.push_back(Obj::CreateString("item1"));
316// var_array.push_back(Obj::CreateString("item2"));
317//
318// ObjPtr item = Obj::CreateString("item1");
319// ASSERT_TRUE(var_array.exist(item, true));
320// item->SetValue_("item2");
321// ASSERT_TRUE(var_array.exist(item, true));
322// item->SetValue_("item");
323// ASSERT_FALSE(var_array.exist(item, true));
324//
325//
326// Obj var_map(ObjType::Dictionary);
327//
328// var_map.push_back(Obj::CreateString("MAP_VALUE1"), "map1");
329// var_map.push_back(Obj::CreateString("MAP_VALUE2"), "map2");
330//
331// ASSERT_TRUE(var_map[std::string("map1")].second);
332// ASSERT_TRUE(var_map["map2"].second);
333// ASSERT_EQ(var_map.find("map"), var_map.end());
334//
335//}
336//
337//TEST(ObjTest, Intersec) {
338//
339// Obj var_array(ObjType::Dictionary);
340// Obj var_array2(ObjType::Dictionary);
341//
342// var_array.push_back(Obj::CreateString("item1"));
343// var_array.push_back(Obj::CreateString("item2"));
344//
345// ObjPtr result = var_array.op_bit_and(var_array2, true);
346// ASSERT_TRUE(result->empty());
347//
348// var_array2.push_back(Obj::CreateString("item3"));
349//
350// result = var_array.op_bit_and(var_array2, true);
351// ASSERT_TRUE(result->empty());
352//
353// var_array2.push_back(Obj::CreateString("item1"));
354// result = var_array.op_bit_and(var_array2, true);
355// ASSERT_FALSE(result->empty());
356// ASSERT_EQ(1, result->size());
357//
358// var_array2.push_back(Obj::CreateString("item2"));
359// result = var_array.op_bit_and(var_array2, true);
360// ASSERT_FALSE(result->empty());
361// ASSERT_EQ(2, result->size());
362// //
363// // result = Op:intersec(var_array, var_array2);
364// // ASSERT_TRUE(Var::isEmpty(result));
365// //
366// //
367// // ASSERT_TRUE(var_array.Exist(std::string("item1")));
368// //
369// // ASSERT_TRUE(var_array.Exist(std::string("item1")));
370// // ASSERT_TRUE(var_array.Exist(std::string("item2")));
371// // ASSERT_FALSE(var_array.Exist(std::string("item")));
372// //
373// //
374// // Var var_map(Var::Type::MAP);
375// //
376// // var_map.Set("map1", "MAP1");
377// // var_map.Set("map2", "MAP2");
378// //
379// // ASSERT_TRUE(var_map.Exist(std::string("map1")));
380// // ASSERT_TRUE(var_map.Exist(std::string("map2")));
381// // ASSERT_FALSE(var_map.Exist(std::string("map")));
382//
383//
384//
385//
386// // Var var_object(Var::Type::OBJECT);
387// // Var var_list(Var::Type::LIST);
388// //
389// // var_list.Set("map1", "MAP1");
390// // var_map.Set("map2", "MAP2");
391// //
392// // ASSERT_TRUE(var_map.Exist("map1"));
393// // ASSERT_TRUE(var_map.Exist("map2"));
394// // ASSERT_FALSE(var_map.Exist("map"));
395//}
396//
397//TEST(ObjTest, Print) {
398//
399// RuntimePtr rt = RunTime::Init();
400// ASSERT_TRUE(rt);
401//
402// ObjPtr var_int = Obj::CreateValue(100, ObjType::None);
403// ObjPtr var_num = Obj::CreateValue(100.123, ObjType::None);
404// ObjPtr var_str = Obj::CreateString(L"STRCHAR");
405// ObjPtr var_strbyte = Obj::CreateString("STRBYTE");
406// ObjPtr var_bool = Obj::CreateBool(true);
407// ObjPtr var_empty = Obj::CreateNone();
408//
409// ASSERT_STREQ("100", var_int->toString().c_str()) << var_int;
410// ASSERT_STREQ("100.123", var_num->toString().c_str()) << var_num;
411// ASSERT_STREQ("\"STRCHAR\"", var_str->toString().c_str()) << var_str;
412// ASSERT_STREQ("'STRBYTE'", var_strbyte->toString().c_str()) << var_strbyte;
413// ASSERT_STREQ("1", var_bool->toString().c_str()) << var_bool;
414// ASSERT_STREQ("_", var_empty->toString().c_str()) << var_empty;
415//
416// ObjPtr var_dict = Obj::CreateType(ObjType::Dictionary);
417//
418// ASSERT_STREQ("(,)", var_dict->toString().c_str()) << var_dict;
419//
420// var_dict->m_var_name = "dict";
421// ASSERT_STREQ("dict=(,)", var_dict->toString().c_str()) << var_dict;
422//
423// var_dict->push_back(Obj::CreateString(L"item1"));
424// ASSERT_STREQ("dict=(\"item1\",)", var_dict->toString().c_str()) << var_dict;
425// var_dict->push_back(var_int);
426// var_dict->push_back(var_bool);
427// ASSERT_STREQ("dict=(\"item1\", 100, 1,)", var_dict->toString().c_str()) << var_dict;
428//
429//
430// ObjPtr var_array = Obj::CreateDict(); //CreateTensor({1});
431//
432// ASSERT_STREQ("(,)", var_array->toString().c_str()) << var_array;
433//
434// var_array->m_var_name = "array";
435// ASSERT_STREQ("array=(,)", var_array->toString().c_str()) << var_array;
436//
437// var_array->push_back(Obj::CreateString("item1"));
438// ASSERT_STREQ("array=('item1',)", var_array->toString().c_str()) << var_array;
439// ASSERT_NO_THROW(var_array->push_back(var_int));
440// ASSERT_NO_THROW(var_array->push_back(var_bool));
441// ASSERT_STREQ("array=('item1', 100, 1,)", var_array->toString().c_str()) << var_array;
442//
443//}
444//
445//TEST(ObjTest, CreateFromInteger) {
446//
447// RuntimePtr rt = RunTime::Init();
448//
449// ObjPtr var = jit->Run("123");
450// ASSERT_TRUE(var);
451// ASSERT_EQ(ObjType::Int8, var->getType()) << toString(var->getType());
452// ASSERT_EQ(123, var->GetValueAsInteger());
453//
454// ObjPtr var2 = jit->Run("123");
455// ASSERT_TRUE(var2);
456// ASSERT_EQ(ObjType::Int8, var2->getType()) << toString(var2->getType());
457// ASSERT_EQ(123, var2->GetValueAsInteger());
458//
459// var = jit->Run("-123");
460// ASSERT_TRUE(var);
461// ASSERT_EQ(ObjType::Int8, var->getType()) << toString(var->getType());
462// ASSERT_EQ(-123, var->GetValueAsInteger());
463//
464// var2 = jit->Run("-123");
465// ASSERT_TRUE(var2);
466// ASSERT_EQ(ObjType::Int8, var2->getType()) << toString(var2->getType());
467// ASSERT_EQ(-123, var2->GetValueAsInteger());
468//}
469//
470//TEST(ObjTest, CreateFromNumber) {
471//
472// RuntimePtr rt = RunTime::Init();
473//
474// ObjPtr var = jit->Run("123.123");
475// ASSERT_TRUE(var);
476// ASSERT_EQ(ObjType::Float32, var->getType());
477// ASSERT_DOUBLE_EQ(123.123, var->GetValueAsNumber());
478//
479// ObjPtr var2 = jit->Run("123.123");
480// ASSERT_TRUE(var2);
481// ASSERT_EQ(ObjType::Float32, var2->getType());
482// ASSERT_DOUBLE_EQ(123.123, var2->GetValueAsNumber());
483//
484// var = jit->Run("-123.123");
485// ASSERT_TRUE(var);
486// ASSERT_EQ(ObjType::Float64, var->getType());
487// ASSERT_DOUBLE_EQ(-123.123, var->GetValueAsNumber());
488//
489// var2 = jit->Run("-123.123E+40");
490// ASSERT_TRUE(var2);
491// ASSERT_EQ(ObjType::Float64, var2->getType());
492// ASSERT_DOUBLE_EQ(-123.123E+40, var2->GetValueAsNumber());
493//}
494//
495//TEST(ObjTest, CreateFromString) {
496//
497// RuntimePtr rt = RunTime::Init();
498//
499// ObjPtr var = jit->Run("\"123.123\"");
500// ASSERT_TRUE(var);
501// ASSERT_EQ(ObjType::StrWide, var->getType());
502// ASSERT_STREQ("123.123", var->GetValueAsString().c_str());
503//
504// ObjPtr var2 = jit->Run("\"123.123\"");
505// ASSERT_TRUE(var2);
506// ASSERT_EQ(ObjType::StrWide, var2->getType());
507// ASSERT_STREQ("123.123", var2->GetValueAsString().c_str());
508//
509// var = jit->Run("'строка'");
510// ASSERT_TRUE(var);
511// ASSERT_EQ(ObjType::StrChar, var->getType());
512// ASSERT_STREQ("строка", var->GetValueAsString().c_str());
513//
514// var2 = jit->Run("'строка'");
515// ASSERT_TRUE(var2);
516// ASSERT_EQ(ObjType::StrChar, var2->getType());
517// ASSERT_STREQ("строка", var2->GetValueAsString().c_str());
518//}
519//
520//TEST(ObjTest, CreateFromRational) {
521//
522// RuntimePtr rt = RunTime::Init();
523//
524// ObjPtr var = jit->Run("123\\1");
525// ASSERT_TRUE(var);
526// ASSERT_EQ(ObjType::Rational, var->getType()) << toString(var->getType());
527// ASSERT_EQ(123, var->GetValueAsInteger());
528// ASSERT_DOUBLE_EQ(123.0, var->GetValueAsNumber());
529//
530// ObjPtr var2 = jit->Run("123\\1");
531// ASSERT_TRUE(var2);
532// ASSERT_EQ(ObjType::Rational, var2->getType()) << toString(var2->getType());
533// ASSERT_EQ(123, var2->GetValueAsInteger());
534// ASSERT_DOUBLE_EQ(123, var2->GetValueAsNumber());
535//
536// var = jit->Run("-123\\1");
537// ASSERT_TRUE(var);
538// ASSERT_EQ(ObjType::Rational, var->getType()) << toString(var->getType());
539// ASSERT_EQ(-123, var->GetValueAsInteger());
540// ASSERT_DOUBLE_EQ(-123.0, var->GetValueAsNumber());
541//
542// var2 = jit->Run("-123\\1");
543// ASSERT_TRUE(var2);
544// ASSERT_EQ(ObjType::Rational, var2->getType()) << toString(var2->getType());
545// ASSERT_EQ(-123, var2->GetValueAsInteger());
546// ASSERT_DOUBLE_EQ(-123, var2->GetValueAsNumber());
547//}
548//
725//
726//TEST(Types, FromLimit) {
727//
728// std::multimap<int64_t, ObjType> IntTypes = {
729// {0, ObjType::Bool},
730// {1, ObjType::Bool},
731// {2, ObjType::Int8},
732// {127, ObjType::Int8},
733// // {255, ObjType::Int8},
734// {256, ObjType::Int16},
735// {-1, ObjType::Int8},
736// {-200, ObjType::Int16},
737// {66000, ObjType::Int32},
738// {-33000, ObjType::Int32},
739// {5000000000, ObjType::Int64},
740// };
741//
742// for (auto elem : IntTypes) {
743// ASSERT_EQ(elem.second, typeFromLimit(elem.first)) << elem.first << " " << toString(elem.second);
744// }
745//
746// ASSERT_EQ(ObjType::Float32, typeFromLimit(1.0));
747// ASSERT_EQ(ObjType::Float64, typeFromLimit(0.0)); //@todo Fix???????
748// ASSERT_EQ(ObjType::Float64, typeFromLimit(1E+40));
749//
750//}
751//
752//TEST(ObjTest, Tensor) {
753//
754// RuntimePtr rt = RunTime::Init();
755//
756// std::string from_str = "русские буквы для ПРОВЕРКИ КОНВЕРТАЦИИ символов";
757// std::wstring to_str = utf8_decode(from_str);
758// std::string conv_str = utf8_encode(to_str);
759//
760// ASSERT_STREQ(from_str.c_str(), conv_str.c_str());
761//
762// // Байтовые строки
763// ObjPtr str = Obj::CreateString("test");
764//
765// ASSERT_STREQ("test", str->m_value.c_str());
766//
767// torch::Tensor tstr_t;
768//
769// ConvertStringToTensor(str->m_value, tstr_t, ObjType::Int8);
770//
771// ASSERT_TRUE(tstr_t.defined());
772// ASSERT_EQ(tstr_t.index({0}).item<int>(), 't');
773// ASSERT_EQ(tstr_t.index({1}).item<int>(), 'e');
774// ASSERT_EQ(tstr_t.index({2}).item<int>(), 's');
775// ASSERT_EQ(tstr_t.index({3}).item<int>(), 't');
776//
777//
778// torch::Tensor tensot_temp = *str->toType(ObjType::Tensor)->m_tensor;
779// ASSERT_TRUE(tensot_temp.defined());
780// ASSERT_EQ(tensot_temp.index({0}).item<int>(), 't');
781// ASSERT_EQ(tensot_temp.index({1}).item<int>(), 'e');
782// ASSERT_EQ(tensot_temp.index({2}).item<int>(), 's');
783// ASSERT_EQ(tensot_temp.index({3}).item<int>(), 't');
784//
785// ObjPtr t_str = CreateTensor(tensot_temp);
786// ASSERT_EQ(t_str->m_var_type_current, ObjType::Int8) << toString(t_str->m_var_type_current);
787// ASSERT_EQ(4, t_str->size());
788// ASSERT_TRUE(t_str->m_tensor->defined());
789//
790// ASSERT_EQ(t_str->m_tensor->index({0}).item<int>(), 't');
791// ASSERT_EQ(t_str->m_tensor->index({1}).item<int>(), 'e');
792// ASSERT_EQ(t_str->m_tensor->index({2}).item<int>(), 's');
793// ASSERT_EQ(t_str->m_tensor->index({3}).item<int>(), 't');
794//
795// ASSERT_EQ(t_str->index_get({0})->GetValueAsInteger(), 't');
796// ASSERT_EQ(t_str->index_get({1})->GetValueAsInteger(), 'e');
797// ASSERT_EQ(t_str->index_get({2})->GetValueAsInteger(), 's');
798// ASSERT_EQ(t_str->index_get({3})->GetValueAsInteger(), 't');
799//
800// ASSERT_STREQ(t_str->toType(ObjType::StrWide)->GetValueAsString().c_str(), "test") << t_str->toType(ObjType::StrWide)->GetValueAsString();
801//
802// t_str->index_set_({1}, Obj::CreateString("E"));
803// t_str->index_set_({2}, Obj::CreateString("S"));
804//
805// EXPECT_STREQ(t_str->toType(ObjType::StrWide)->GetValueAsString().c_str(), "tESt") << t_str->toType(ObjType::StrWide)->GetValueAsString();
806//
807// // Символьные сторки
808// ObjPtr wstr = Obj::CreateString(L"ТЕСТ");
809// ObjPtr t_wstr = CreateTensor(*wstr->toType(ObjType::Tensor)->m_tensor);
810// if (sizeof (wchar_t) == 2) {
811// ASSERT_EQ(t_wstr->m_var_type_current, ObjType::Int16);
812// } else {
813// ASSERT_TRUE(sizeof (wchar_t) == 4);
814// ASSERT_EQ(t_wstr->m_var_type_current, ObjType::Int32);
815// }
816// ASSERT_EQ(4, t_wstr->size());
817//
818// ASSERT_EQ(t_wstr->index_get({0})->GetValueAsInteger(), L'Т');
819// ASSERT_EQ(t_wstr->index_get({1})->GetValueAsInteger(), L'Е');
820// ASSERT_EQ(t_wstr->index_get({2})->GetValueAsInteger(), L'С');
821// ASSERT_EQ(t_wstr->index_get({3})->GetValueAsInteger(), L'Т');
822//
823// std::wstring test_wide = t_wstr->toType(ObjType::StrWide)->GetValueAsStringWide();
824// EXPECT_STREQ(utf8_encode(test_wide).c_str(), "ТЕСТ");
825//
826// std::string test_str = t_wstr->toType(ObjType::StrWide)->GetValueAsString();
827// EXPECT_STREQ(test_str.c_str(), "ТЕСТ") << test_str;
828//
829// t_wstr->index_set_({1}, Obj::CreateString(L"е"));
830// t_wstr->index_set_({2}, Obj::CreateString(L"с"));
831//
832// test_str = t_wstr->toType(ObjType::StrWide)->GetValueAsString();
833// EXPECT_STREQ(test_str.c_str(), "ТесТ") << test_str;
834//
835//}
836//
837//TEST(ObjTest, Iterator) {
838//
839// ObjPtr dict = Obj::CreateDict();
840//
841// dict->push_back(Obj::Arg(1, "1"));
842// dict->push_back(Obj::Arg(2, "22"));
843// dict->push_back(Obj::Arg(3, "333"));
844// dict->push_back(Obj::Arg(4));
845// dict->push_back(Obj::Arg(5, "555"));
846//
847// ASSERT_EQ(5, dict->size());
848//
849// auto all = std::regex("(.|\\n)*");
850// ASSERT_TRUE(std::regex_match("1", all));
851// ASSERT_TRUE(std::regex_match("22", all));
852// ASSERT_TRUE(std::regex_match("333", all));
853// ASSERT_TRUE(std::regex_match("", all));
854// ASSERT_TRUE(std::regex_match("\n", all));
855// ASSERT_TRUE(std::regex_match("\n\n\\n", all));
856//
857//
858// Iterator <Obj> iter(dict);
859//
860// ASSERT_TRUE(iter == iter.begin());
861// ASSERT_TRUE(iter != iter.end());
862//
863// ObjPtr copy = Obj::CreateDict();
864// for (auto &elem : iter) {
865//
866// copy->push_back(elem.second, elem.first);
867// }
868//
869// ASSERT_TRUE(iter == iter.begin());
870// ASSERT_TRUE(iter != iter.end());
871//
872// ASSERT_EQ(dict->size(), copy->size());
873//
874//
875// ASSERT_TRUE(iter == iter.begin());
876//
877// ObjPtr one = iter.read_and_next(0);
878// ASSERT_TRUE(one);
879// ASSERT_EQ(1, one->GetValueAsInteger());
880//
881// ASSERT_EQ(2, (*iter).second->GetValueAsInteger());
882// one = iter.read_and_next(0);
883// ASSERT_TRUE(one);
884// ASSERT_EQ(2, one->GetValueAsInteger());
885//
886// ASSERT_EQ(3, (*iter).second->GetValueAsInteger());
887// one = iter.read_and_next(0);
888// ASSERT_TRUE(one);
889// ASSERT_EQ(3, one->GetValueAsInteger());
890//
891// ASSERT_EQ(4, (*iter).second->GetValueAsInteger());
892// one = iter.read_and_next(0);
893// ASSERT_TRUE(one);
894// ASSERT_EQ(4, one->GetValueAsInteger());
895//
896// ASSERT_EQ(5, (*iter).second->GetValueAsInteger());
897// one = iter.read_and_next(0);
898// ASSERT_TRUE(one);
899// ASSERT_EQ(5, one->GetValueAsInteger());
900//
901// one = iter.read_and_next(0);
902// ASSERT_TRUE(one);
903// ASSERT_EQ(ObjType::IteratorEnd, one->getType()) << one << " " << toString(one->getType());
904//
905// one = iter.read_and_next(0);
906// ASSERT_TRUE(one);
907// ASSERT_EQ(ObjType::IteratorEnd, one->getType()) << one << " " << toString(one->getType());
908//
909//
910//
911//
912// ASSERT_TRUE(iter == iter.end());
913// iter.reset();
914// ASSERT_TRUE(iter == iter.begin());
915// ASSERT_TRUE(iter != iter.end());
916//
917// ObjPtr dict1 = iter.read_and_next(-3);
918// ASSERT_TRUE(dict1);
919// ASSERT_EQ(3, dict1->size());
920// ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
921// ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
922// ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
923//
924// ObjPtr dict2 = iter.read_and_next(-3);
925// ASSERT_TRUE(dict2);
926// ASSERT_EQ(3, dict2->size());
927// ASSERT_EQ(4, dict2->at(0).second->GetValueAsInteger());
928// ASSERT_EQ(5, dict2->at(1).second->GetValueAsInteger());
929// ASSERT_EQ(ObjType::IteratorEnd, dict2->at(2).second->getType());
930//
931// ObjPtr dict3 = iter.read_and_next(-3);
932// ASSERT_TRUE(dict3);
933// ASSERT_EQ(3, dict1->size());
934// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(0).second->getType());
935// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(1).second->getType());
936// ASSERT_EQ(ObjType::IteratorEnd, dict3->at(2).second->getType());
937//
938//
939//
940// ASSERT_TRUE(iter == iter.end());
941// iter.reset();
942// ASSERT_TRUE(iter == iter.begin());
943// ASSERT_TRUE(iter != iter.end());
944//
945// dict1 = iter.read_and_next(3);
946// ASSERT_TRUE(dict1);
947// ASSERT_EQ(3, dict1->size());
948// ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
949// ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
950// ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
951//
952// dict2 = iter.read_and_next(3);
953// ASSERT_TRUE(dict2);
954// ASSERT_EQ(2, dict2->size());
955// ASSERT_EQ(4, dict2->at(0).second->GetValueAsInteger());
956// ASSERT_EQ(5, dict2->at(1).second->GetValueAsInteger());
957//
958// dict3 = iter.read_and_next(3);
959// ASSERT_TRUE(dict3);
960// ASSERT_EQ(0, dict3->size());
961//
962//
963//
964//
965// Iterator <Obj> flt(dict, "");
966// ObjPtr flt_res = flt.read_and_next(100);
967// ASSERT_TRUE(flt_res);
968// ASSERT_EQ(1, flt_res->size());
969// ASSERT_EQ(4, flt_res->at(0).second->GetValueAsInteger());
970//
971//
972// Iterator <Obj> flt1(dict, ".");
973// ObjPtr flt1_res = flt1.read_and_next(100);
974// ASSERT_TRUE(flt1_res);
975// ASSERT_EQ(1, flt1_res->size());
976// ASSERT_EQ(1, flt1_res->at(0).second->GetValueAsInteger());
977//
978//
979// Iterator <Obj> flt2(dict, "..");
980// ObjPtr flt2_res = flt2.read_and_next(100);
981// ASSERT_TRUE(flt2_res);
982// ASSERT_EQ(1, flt2_res->size());
983// ASSERT_EQ(2, flt2_res->at(0).second->GetValueAsInteger());
984//
985// Iterator <Obj> flt3(dict, "...");
986// ObjPtr flt3_res = flt3.read_and_next(100);
987// ASSERT_TRUE(flt3_res);
988// ASSERT_EQ(2, flt3_res->size());
989// ASSERT_EQ(3, flt3_res->at(0).second->GetValueAsInteger());
990// ASSERT_EQ(5, flt3_res->at(1).second->GetValueAsInteger());
991//
992//
993//
994// // ObjPtr iter1 = dict->MakeIterator();
995//
996//}
997//
998//TEST(ObjTest, System) {
999//
1000// ASSERT_STREQ("name", ExtractName("name").c_str());
1001// ASSERT_STREQ("name", ExtractName("::name").c_str());
1002// ASSERT_STREQ("name", ExtractName("ns::name").c_str());
1003// ASSERT_STREQ("", ExtractName("\\file").c_str());
1004// ASSERT_STREQ("", ExtractName("\\\\dir.file").c_str());
1005// ASSERT_STREQ("var", ExtractName("\\dir.file::var").c_str());
1006// ASSERT_STREQ("var.field", ExtractName("\\\\dir.file::var.field").c_str());
1007//
1008//
1009// ASSERT_STREQ("\\file", ExtractModuleName("\\file").c_str());
1010// ASSERT_STREQ("\\\\dir.file", ExtractModuleName("\\\\dir.file").c_str());
1011// ASSERT_STREQ("\\dir.file", ExtractModuleName("\\dir.file::var").c_str());
1012// ASSERT_STREQ("\\\\dir.file", ExtractModuleName("\\\\dir.file::var.field").c_str());
1013//
1014//
1015// ObjPtr none = Obj::CreateNone();
1016//
1017// ASSERT_TRUE(none->at("__error_field_name__").second);
1018// ASSERT_STREQ("Internal field '__error_field_name__' not exist!", none->at("__error_field_name__").second->GetValueAsString().c_str());
1019//
1020// ASSERT_TRUE(none->at("__type__").second);
1021// ASSERT_STREQ(":None", none->at("__type__").second->GetValueAsString().c_str());
1022//
1023// ASSERT_TRUE(none->at("__type_fixed__").second);
1024// ASSERT_STREQ(":None", none->at("__type_fixed__").second->GetValueAsString().c_str());
1025//
1026// ASSERT_TRUE(none->at("__name__").second);
1027// ASSERT_STREQ("", none->at("__name__").second->GetValueAsString().c_str());
1028//
1029// ASSERT_TRUE(none->at("__full_name__").second);
1030// ASSERT_STREQ("", none->at("__full_name__").second->GetValueAsString().c_str());
1031//
1032// ASSERT_TRUE(none->at("__module__").second);
1033// ASSERT_STREQ("", none->at("__module__").second->GetValueAsString().c_str());
1034//
1035// ASSERT_TRUE(none->at("__class__").second);
1036// ASSERT_STREQ("", none->at("__class__").second->GetValueAsString().c_str());
1037//
1038// ASSERT_TRUE(none->at("__base__").second);
1039// ASSERT_STREQ("(,)", none->at("__base__").second->GetValueAsString().c_str());
1040//
1041// ASSERT_TRUE(none->at("__doc__").second);
1042// ASSERT_STREQ("Help system not implemented!!!!!", none->at("__doc__").second->GetValueAsString().c_str());
1043//
1044// ASSERT_TRUE(none->at("__str__").second);
1045// ASSERT_STREQ("_", none->at("__str__").second->GetValueAsString().c_str());
1046//
1047// none->m_var_is_init = false;
1048// ASSERT_TRUE(none->at("__error_field_name__").second);
1049// ASSERT_STREQ(":Undefined", none->at("__error_field_name__").second->GetValueAsString().c_str());
1050//
1051//
1052// ObjPtr str = Obj::CreateString("str");
1053// str->m_var_name = "name";
1054//
1055// ASSERT_TRUE(str->at("__type__").second);
1056// ASSERT_STREQ(":StrChar", str->at("__type__").second->GetValueAsString().c_str());
1057//
1058// ASSERT_TRUE(str->at("__type_fixed__").second);
1059// ASSERT_STREQ(":String", str->at("__type_fixed__").second->GetValueAsString().c_str());
1060//
1061// ASSERT_TRUE(str->at("__name__").second);
1062// ASSERT_STREQ("name", str->at("__name__").second->GetValueAsString().c_str());
1063//
1064// ASSERT_TRUE(str->at("__full_name__").second);
1065// ASSERT_STREQ("name", str->at("__full_name__").second->GetValueAsString().c_str());
1066//
1067// ASSERT_TRUE(str->at("__module__").second);
1068// ASSERT_STREQ("", str->at("__module__").second->GetValueAsString().c_str());
1069//
1070// ASSERT_TRUE(str->at("__class__").second);
1071// ASSERT_STREQ("", str->at("__class__").second->GetValueAsString().c_str());
1072//
1073// ASSERT_TRUE(str->at("__base__").second);
1074// ASSERT_STREQ("(,)", str->at("__base__").second->GetValueAsString().c_str());
1075//
1076// ASSERT_TRUE(str->at("__doc__").second);
1077// ASSERT_STREQ("Help system not implemented!!!!!", str->at("__doc__").second->GetValueAsString().c_str());
1078//
1079// ASSERT_TRUE(str->at("__str__").second);
1080// ASSERT_STREQ("name='str'", str->at("__str__").second->GetValueAsString().c_str());
1081//
1082//
1083// ObjPtr cls = Obj::CreateClass("class");
1084// cls->m_var_name = "::ns::name";
1085// cls->push_back(Obj::CreateRange(0, 10, 3), "filed");
1086//
1087// ASSERT_TRUE(cls->at("__type__").second);
1088// ASSERT_STREQ(":Class", cls->at("__type__").second->GetValueAsString().c_str());
1089//
1090// ASSERT_TRUE(cls->at("__type_fixed__").second);
1091// ASSERT_STREQ(":None", cls->at("__type_fixed__").second->GetValueAsString().c_str());
1092//
1093// ASSERT_TRUE(cls->at("__name__").second);
1094// ASSERT_STREQ("name", cls->at("__name__").second->GetValueAsString().c_str());
1095//
1096// ASSERT_TRUE(cls->at("__full_name__").second);
1097// ASSERT_STREQ("::ns::name", cls->at("__full_name__").second->GetValueAsString().c_str());
1098//
1099// ASSERT_TRUE(cls->at("__module__").second);
1100// ASSERT_STREQ("", cls->at("__module__").second->GetValueAsString().c_str());
1101//
1102// ASSERT_TRUE(cls->at("__class__").second);
1103// ASSERT_STREQ("class", cls->at("__class__").second->GetValueAsString().c_str());
1104//
1105// ASSERT_TRUE(cls->at("__base__").second);
1106// ASSERT_STREQ("(,)", cls->at("__base__").second->GetValueAsString().c_str());
1107//
1108// ASSERT_TRUE(cls->at("__doc__").second);
1109// ASSERT_STREQ("Help system not implemented!!!!!", cls->at("__doc__").second->GetValueAsString().c_str());
1110//
1111// ASSERT_TRUE(cls->at("__str__").second);
1112// ASSERT_STREQ("::ns::name=class(filed=0..10..3)", cls->at("__str__").second->GetValueAsString().c_str());
1113//}
1114
1115#endif // UNITTEST
newlang::Obj::empty
virtual bool empty() const
Definition object.cpp:193
newlang::Obj::SetValue_
std::enable_if< std::is_same< T, bool >::value, void >::type SetValue_(bool value)
Definition object.h:1766
newlang::Obj::getType
ObjType getType()
Definition object.h:423
newlang
Definition nlc.h:59
newlang::ObjPtr
std::shared_ptr< Obj > ObjPtr
Definition variable.h:28
newlang::toString
const char * toString(TermID type)
Definition term.h:126
warning_pop.h
warning_push.h
Generated by doxygen 1.11.0