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#include "jit.h"
16
17
18using namespace newlang;
19
20TEST(ObjTest, Empty) {
21 Obj var;
22 ASSERT_TRUE(var.empty());
23 ASSERT_EQ(ObjType::None, var.getType());
24}
25
26TEST(ObjTest, Value) {
27 Obj var;
28
29 var.SetValue_(0);
30 ASSERT_EQ(ObjType::Bool, var.getType());
31
32 var.SetValue_(1);
33 ASSERT_EQ(ObjType::Bool, var.getType());
34
35 var.SetValue_(1.0);
36 ASSERT_EQ(ObjType::Float32, var.getType());
37
38 var.SetValue_(1.0E+40);
39 ASSERT_EQ(ObjType::Float64, var.getType());
40
41 var.SetValue_(true);
42 ASSERT_EQ(ObjType::Bool, var.getType());
43
44 var.SetValue_(2);
45 ASSERT_EQ(ObjType::Int8, var.getType());
46
47 var.SetValue_(-100);
48 ASSERT_EQ(ObjType::Int8, var.getType());
49
50 var.SetValue_(1000);
51 ASSERT_EQ(ObjType::Int16, var.getType());
52
53 var.SetValue_(100000);
54 ASSERT_EQ(ObjType::Int32, var.getType());
55
56 var.SetValue_(10000000000);
57 ASSERT_EQ(ObjType::Int64, var.getType());
58
59 var.SetValue_(2.0);
60 ASSERT_EQ(ObjType::Float32, var.getType());
61
62 var.SetValue_(2.0E+40);
63 ASSERT_EQ(ObjType::Float64, var.getType());
64
65 var.SetValue_(false);
66 ASSERT_EQ(ObjType::Bool, var.getType());
67}
68
69TEST(ObjTest, String) {
70 Obj var;
71
72 var.SetValue_(std::string("test"));
73 ASSERT_EQ(ObjType::StrChar, var.getType()) << toString(var.getType());
74
75 Obj str1;
76 str1.SetValue_(L"Test str");
77 ASSERT_EQ(ObjType::StrWide, str1.getType()) << toString(str1.getType());
78
79 Obj str2;
80 str2.SetValue_(std::string("test2"));
81 ASSERT_EQ(ObjType::StrChar, str2.getType()) << toString(str2.getType());
82
83 ObjPtr str_byte = Obj::CreateString("byte");
84 ASSERT_STREQ("byte", str_byte->GetValueAsString().c_str());
85 ASSERT_EQ(4, str_byte->size());
86 ASSERT_EQ(4, str_byte->m_value.size());
87 ASSERT_STREQ("b", (*str_byte)[0].second->GetValueAsString().c_str());
88 ASSERT_STREQ("y", (*str_byte)[1].second->GetValueAsString().c_str());
89 ASSERT_STREQ("t", (*str_byte)[2].second->GetValueAsString().c_str());
90 ASSERT_STREQ("e", (*str_byte)[3].second->GetValueAsString().c_str());
91
92 str_byte->op_set_index(0, "B");
93 str_byte->op_set_index(1, "Y");
94 ASSERT_STREQ("BYte", str_byte->GetValueAsString().c_str());
95 str_byte->op_set_index(2, "T");
96 str_byte->op_set_index(3, "E");
97 ASSERT_STREQ("BYTE", str_byte->GetValueAsString().c_str());
98
99 ObjPtr str_char = Obj::CreateString(L"строка");
100 ASSERT_EQ(6, str_char->size());
101 ASSERT_EQ(6, str_char->m_string.size());
102
103 ASSERT_STREQ("с", (*str_char)[0].second->GetValueAsString().c_str());
104 ASSERT_STREQ("т", (*str_char)[1].second->GetValueAsString().c_str());
105 ASSERT_STREQ("р", (*str_char)[2].second->GetValueAsString().c_str());
106 ASSERT_STREQ("о", (*str_char)[3].second->GetValueAsString().c_str());
107 ASSERT_STREQ("к", (*str_char)[4].second->GetValueAsString().c_str());
108 ASSERT_STREQ("а", (*str_char)[5].second->GetValueAsString().c_str());
109
110 str_char->op_set_index(0, "С");
111 str_char->op_set_index(1, "Т");
112 ASSERT_STREQ("СТрока", str_char->GetValueAsString().c_str());
113 str_char->op_set_index(2, "Р");
114 str_char->op_set_index(3, "О");
115 ASSERT_STREQ("СТРОка", str_char->GetValueAsString().c_str());
116
117}
118
119TEST(ObjTest, CreateFromInteger) {
120
121 Variable var01(100);
122 ASSERT_EQ(ObjType::Int8, var01.GetValueAsObject()->getType()) << toString(var01.GetValueAsObject()->getType());
123
124 Variable var02 = var01;
125 ASSERT_EQ(ObjType::Int8, var02.GetValueAsObject()->getType()) << toString(var02.GetValueAsObject()->getType());
126
127
128 Variable obj01(Obj::CreateValue(100));
129 ASSERT_EQ(ObjType::Int8, var01.GetValueAsObject()->getType()) << toString(var01.GetValueAsObject()->getType());
130
131 Variable obj02 = obj01;
132 ASSERT_EQ(ObjType::Int8, obj02.GetValueAsObject()->getType()) << toString(obj02.GetValueAsObject()->getType());
133
134 Variable obj03(std::monostate(), "");
135 obj03 = obj01;
136 ASSERT_EQ(ObjType::Int8, obj03.GetValueAsObject()->getType()) << toString(obj03.GetValueAsObject()->getType());
137
138
139 LatterType latter1(VariablePair::Create(Term::CreateName("latter1"), Obj::CreateNone()));
140
141 ASSERT_TRUE(latter1.GetVariablePair().term);
142 ASSERT_STREQ("latter1", latter1.GetVariablePair().term->m_text.c_str());
143 ASSERT_STREQ("_", latter1.GetVariablePair().var.GetValueAsObject()->toString().c_str());
144
145 LatterType latter2(VariablePair::Create(Term::CreateName("latter2"), Obj::CreateValue(1)));
146 ASSERT_TRUE(latter2.GetVariablePair().term);
147 ASSERT_STREQ("latter2", latter2.GetVariablePair().term->m_text.c_str());
148 ASSERT_STREQ("1", latter2.GetVariablePair().var.GetValueAsObject()->toString().c_str());
149
150 latter1 = latter2;
151
152 ASSERT_TRUE(latter1.GetVariablePair().term);
153 ASSERT_STREQ("latter2", latter1.GetVariablePair().term->m_text.c_str());
154 ASSERT_STREQ("1", latter1.GetVariablePair().var.GetValueAsObject()->toString().c_str());
155
156
157 JIT *jit = JIT::ReCreate();
158
159 ObjPtr var = jit->Run("123");
160 ASSERT_TRUE(var);
161 ASSERT_EQ(ObjType::Int8, var->getType()) << toString(var->getType());
162 ASSERT_EQ(123, var->GetValueAsInteger());
163
164 ObjPtr var2 = jit->Run("123");
165 ASSERT_TRUE(var2);
166 ASSERT_EQ(ObjType::Int8, var2->getType()) << toString(var2->getType());
167 ASSERT_EQ(123, var2->GetValueAsInteger());
168
169 var = jit->Run("-123");
170 ASSERT_TRUE(var);
171 ASSERT_EQ(ObjType::Int8, var->getType()) << toString(var->getType());
172 ASSERT_EQ(-123, var->GetValueAsInteger());
173
174 var2 = jit->Run("-123");
175 ASSERT_TRUE(var2);
176 ASSERT_EQ(ObjType::Int8, var2->getType()) << toString(var2->getType());
177 ASSERT_EQ(-123, var2->GetValueAsInteger());
178}
179
180TEST(ObjTest, CreateFromNumber) {
181
182 JIT *jit = JIT::ReCreate();
183
184 ObjPtr var = jit->Run("123.123");
185 ASSERT_TRUE(var);
186 ASSERT_EQ(ObjType::Float32, var->getType());
187 ASSERT_DOUBLE_EQ(123.123, var->GetValueAsNumber());
188
189 ObjPtr var2 = jit->Run("123.123");
190 ASSERT_TRUE(var2);
191 ASSERT_EQ(ObjType::Float32, var2->getType());
192 ASSERT_DOUBLE_EQ(123.123, var2->GetValueAsNumber());
193
194 var = jit->Run("-123.123");
195 ASSERT_TRUE(var);
196 ASSERT_EQ(ObjType::Float64, var->getType());
197 ASSERT_DOUBLE_EQ(-123.123, var->GetValueAsNumber());
198
199 var2 = jit->Run("-123.123E+40");
200 ASSERT_TRUE(var2);
201 ASSERT_EQ(ObjType::Float64, var2->getType());
202 ASSERT_DOUBLE_EQ(-123.123E+40, var2->GetValueAsNumber());
203}
204
205TEST(ObjTest, CreateFromString) {
206
207 JIT *jit = JIT::ReCreate();
208
209 ObjPtr var = jit->Run("\"123.123\"");
210 ASSERT_TRUE(var);
211 ASSERT_EQ(ObjType::StrWide, var->getType());
212 ASSERT_STREQ("123.123", var->GetValueAsString().c_str());
213
214 ObjPtr var2 = jit->Run("\"123.123\"");
215 ASSERT_TRUE(var2);
216 ASSERT_EQ(ObjType::StrWide, var2->getType());
217 ASSERT_STREQ("123.123", var2->GetValueAsString().c_str());
218
219 var = jit->Run("'строка'");
220 ASSERT_TRUE(var);
221 ASSERT_EQ(ObjType::StrChar, var->getType());
222 ASSERT_STREQ("строка", var->GetValueAsString().c_str());
223
224 var2 = jit->Run("'строка'");
225 ASSERT_TRUE(var2);
226 ASSERT_EQ(ObjType::StrChar, var2->getType());
227 ASSERT_STREQ("строка", var2->GetValueAsString().c_str());
228}
229
230TEST(ObjTest, CreateFromRational) {
231
232 JIT *jit = JIT::ReCreate();
233
234 ObjPtr var = jit->Run("123\\1");
235 ASSERT_TRUE(var);
236 ASSERT_EQ(ObjType::Rational, var->getType()) << toString(var->getType());
237 ASSERT_EQ(123, var->GetValueAsInteger());
238 ASSERT_DOUBLE_EQ(123.0, var->GetValueAsNumber());
239
240 ObjPtr var2 = jit->Run("123\\1");
241 ASSERT_TRUE(var2);
242 ASSERT_EQ(ObjType::Rational, var2->getType()) << toString(var2->getType());
243 ASSERT_EQ(123, var2->GetValueAsInteger());
244 ASSERT_DOUBLE_EQ(123, var2->GetValueAsNumber());
245
246 var = jit->Run("-123\\1");
247 ASSERT_TRUE(var);
248 ASSERT_EQ(ObjType::Rational, var->getType()) << toString(var->getType());
249 ASSERT_EQ(-123, var->GetValueAsInteger());
250 ASSERT_DOUBLE_EQ(-123.0, var->GetValueAsNumber());
251
252 var2 = jit->Run("-123\\1");
253 ASSERT_TRUE(var2);
254 ASSERT_EQ(ObjType::Rational, var2->getType()) << toString(var2->getType());
255 ASSERT_EQ(-123, var2->GetValueAsInteger());
256 ASSERT_DOUBLE_EQ(-123, var2->GetValueAsNumber());
257}
258
259TEST(ObjTest, Dict) {
260
261 JIT *jit = JIT::ReCreate();
262 ASSERT_TRUE(jit);
263
264 Obj var(ObjType::Dictionary);
265 ASSERT_TRUE(var.empty());
266 EXPECT_ANY_THROW(var[0]);
267
268 ASSERT_EQ(0, var.size());
269 ObjPtr var2;
270 ASSERT_NO_THROW(var2 = jit->Run("(,)"));
271
272 var.push_back(Obj::CreateString("Test1"));
273 ASSERT_EQ(1, var.size());
274 var.push_back(Obj::CreateString("Test3"));
275 ASSERT_EQ(2, var.size());
276 var.insert(var.at_index_const(1), Obj::Arg(2, "2"));
277 var.insert(var.at_index_const(0), Obj::Arg(0, "0"));
278 ASSERT_EQ(4, var.size());
279
280 ASSERT_TRUE(var[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
281 ASSERT_TRUE(var[1].second->op_accurate(Obj::CreateString("Test1")));
282 ASSERT_TRUE(var[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
283 ASSERT_TRUE(var[3].second->op_accurate(Obj::CreateString(L"Test3")));
284
285 ASSERT_NO_THROW(var2 = jit->Run("(0, \"Test1\", 2, 'Test3',)"));
286
287 ASSERT_TRUE((*var2)[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
288 ASSERT_TRUE((*var2)[1].second->op_accurate(Obj::CreateString("Test1")));
289 ASSERT_TRUE((*var2)[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
290 ASSERT_TRUE((*var2)[3].second->op_accurate(Obj::CreateString(L"Test3")));
291
292 ObjPtr var3;
293
294 ASSERT_NO_THROW(var3 = jit->Run("(0, \"Test1\", 2, 'Test3',)"));
295
296 ASSERT_TRUE((*var3)[0].second->op_accurate(Obj::CreateValue(0, ObjType::None)));
297 ASSERT_TRUE((*var3)[1].second->op_accurate(Obj::CreateString("Test1")));
298 ASSERT_TRUE((*var3)[2].second->op_accurate(Obj::CreateValue(2, ObjType::None)));
299 ASSERT_TRUE((*var3)[3].second->op_accurate(Obj::CreateString(L"Test3")));
300}
301
302TEST(ObjTest, AsMap) {
303
304 ObjPtr map = Obj::CreateType(ObjType::Dictionary);
305 ASSERT_TRUE(map->empty());
306 EXPECT_ANY_THROW((*map)["test1"]);
307 ASSERT_EQ(0, map->size());
308
309 ObjPtr temp = Obj::CreateString("Test");
310 map->push_back(temp, "test1");
311 map->push_back(Obj::CreateValue(100, ObjType::None), "test2");
312 ASSERT_EQ(2, map->size());
313 ASSERT_STREQ((*map)["test1"].second->toString().c_str(), temp->toString().c_str()) << temp->toString().c_str();
314
315 ASSERT_TRUE((*map)["test2"].second);
316 ObjPtr temp100 = Obj::CreateValue(100, ObjType::None);
317 ASSERT_TRUE(map->exist(temp100, true));
318
319 ObjPtr test2 = (*map)["test2"].second;
320 ASSERT_TRUE(test2);
321 ASSERT_TRUE(test2);
322 ASSERT_STREQ("100", test2->toString().c_str());
323}
324
325TEST(ObjTest, Eq) {
326
327 ObjPtr var_int = Obj::CreateValue(100, ObjType::None);
328 ObjPtr var_num = Obj::CreateValue(100.0, ObjType::None);
329 ObjPtr var_str = Obj::CreateString(L"STRING");
330 ObjPtr var_bool = Obj::CreateBool(true);
331 ObjPtr var_empty = Obj::CreateNone();
332
333 ASSERT_EQ(var_int->m_var_type_current, ObjType::Int8) << (int) var_int->getType();
334 ASSERT_EQ(var_num->m_var_type_current, ObjType::Float32) << (int) var_num->getType();
335 ASSERT_EQ(var_str->m_var_type_current, ObjType::StrWide) << (int) var_str->getType();
336 ASSERT_EQ(var_bool->m_var_type_current, ObjType::Bool) << (int) var_bool->getType();
337 ASSERT_EQ(var_empty->m_var_type_current, ObjType::None) << (int) var_empty->getType();
338 ASSERT_TRUE(var_empty->empty()) << (int) var_empty->getType();
339 ASSERT_FALSE(var_int->empty()) << (int) var_int->getType();
340
341
342 ASSERT_TRUE(var_int->op_accurate(Obj::CreateValue(100, ObjType::None)));
343 ASSERT_FALSE(var_int->op_accurate(Obj::CreateValue(111, ObjType::None)));
344
345 ASSERT_TRUE(var_num->op_equal(Obj::CreateValue(100.0, ObjType::None)));
346 ASSERT_FALSE(var_num->op_equal(Obj::CreateValue(100.0001, ObjType::None)));
347 ASSERT_TRUE(var_num->op_accurate(Obj::CreateValue(100.0, ObjType::None)));
348 ASSERT_FALSE(var_num->op_accurate(Obj::CreateValue(100.0001, ObjType::None)));
349
350 ASSERT_TRUE(var_int->op_equal(Obj::CreateValue(100.0, ObjType::None)));
351 ASSERT_TRUE(var_int->op_accurate(Obj::CreateValue(100.0, ObjType::None)));
352 ASSERT_FALSE(var_int->op_equal(Obj::CreateValue(100.1, ObjType::None)));
353 ASSERT_FALSE(var_int->op_accurate(Obj::CreateValue(100.1, ObjType::None)));
354
355
356 ObjPtr var_int2 = Obj::CreateValue(101, ObjType::None);
357 ObjPtr var_num2 = Obj::CreateValue(100.1, ObjType::None);
358
359
360 ASSERT_TRUE(var_int->op_accurate(var_int));
361 ASSERT_FALSE(var_int->op_accurate(var_int2));
362
363 ASSERT_TRUE(var_num->op_accurate(var_num));
364 ASSERT_FALSE(var_num->op_accurate(var_num2));
365
366 ASSERT_TRUE(var_int->op_equal(var_num));
367
368 ASSERT_FALSE(var_int->op_equal(var_num2));
369 ASSERT_FALSE(var_num2->op_equal(var_int));
370
371 ObjPtr var_bool2 = Obj::CreateBool(false);
372
373 ASSERT_TRUE(var_bool->op_accurate(var_bool));
374 ASSERT_FALSE(var_bool->op_accurate(var_bool2));
375
376 ObjPtr var_str2 = Obj::CreateString("STRING2");
377
378 ASSERT_TRUE(var_str->op_accurate(var_str));
379 ASSERT_TRUE(var_str->op_accurate(Obj::CreateString("STRING")));
380 ASSERT_FALSE(var_str->op_accurate(var_str2));
381
382
383 ObjPtr var_empty2 = Obj::CreateNone();
384
385 ASSERT_TRUE(var_empty->op_accurate(var_empty));
386 ASSERT_TRUE(var_empty->op_accurate(var_empty2));
387}
388
389TEST(ObjTest, Exist) {
390
391 Obj var_array(ObjType::Dictionary);
392
393 var_array.push_back(Obj::CreateString("item1"));
394 var_array.push_back(Obj::CreateString("item2"));
395
396 ObjPtr item = Obj::CreateString("item1");
397 ASSERT_TRUE(var_array.exist(item, true));
398 item->SetValue_("item2");
399 ASSERT_TRUE(var_array.exist(item, true));
400 item->SetValue_("item");
401 ASSERT_FALSE(var_array.exist(item, true));
402
403
404 Obj var_map(ObjType::Dictionary);
405
406 var_map.push_back(Obj::CreateString("MAP_VALUE1"), "map1");
407 var_map.push_back(Obj::CreateString("MAP_VALUE2"), "map2");
408
409 ASSERT_TRUE(var_map[std::string("map1")].second);
410 ASSERT_TRUE(var_map["map2"].second);
411 ASSERT_EQ(var_map.find("map"), var_map.end());
412
413}
414
415TEST(ObjTest, Intersec) {
416
417 Obj var_array(ObjType::Dictionary);
418 Obj var_array2(ObjType::Dictionary);
419
420 var_array.push_back(Obj::CreateString("item1"));
421 var_array.push_back(Obj::CreateString("item2"));
422
423 ObjPtr result = var_array.op_bit_and(var_array2, true);
424 ASSERT_TRUE(result->empty());
425
426 var_array2.push_back(Obj::CreateString("item3"));
427
428 result = var_array.op_bit_and(var_array2, true);
429 ASSERT_TRUE(result->empty());
430
431 var_array2.push_back(Obj::CreateString("item1"));
432 result = var_array.op_bit_and(var_array2, true);
433 ASSERT_FALSE(result->empty());
434 ASSERT_EQ(1, result->size());
435
436 var_array2.push_back(Obj::CreateString("item2"));
437 result = var_array.op_bit_and(var_array2, true);
438 ASSERT_FALSE(result->empty());
439 ASSERT_EQ(2, result->size());
440 //
441 // result = Op:intersec(var_array, var_array2);
442 // ASSERT_TRUE(Var::isEmpty(result));
443 //
444 //
445 // ASSERT_TRUE(var_array.Exist(std::string("item1")));
446 //
447 // ASSERT_TRUE(var_array.Exist(std::string("item1")));
448 // ASSERT_TRUE(var_array.Exist(std::string("item2")));
449 // ASSERT_FALSE(var_array.Exist(std::string("item")));
450 //
451 //
452 // Var var_map(Var::Type::MAP);
453 //
454 // var_map.Set("map1", "MAP1");
455 // var_map.Set("map2", "MAP2");
456 //
457 // ASSERT_TRUE(var_map.Exist(std::string("map1")));
458 // ASSERT_TRUE(var_map.Exist(std::string("map2")));
459 // ASSERT_FALSE(var_map.Exist(std::string("map")));
460
461
462
463
464 // Var var_object(Var::Type::OBJECT);
465 // Var var_list(Var::Type::LIST);
466 //
467 // var_list.Set("map1", "MAP1");
468 // var_map.Set("map2", "MAP2");
469 //
470 // ASSERT_TRUE(var_map.Exist("map1"));
471 // ASSERT_TRUE(var_map.Exist("map2"));
472 // ASSERT_FALSE(var_map.Exist("map"));
473}
474
475TEST(ObjTest, Print) {
476
477 JIT *jit = JIT::ReCreate();
478 ASSERT_TRUE(jit);
479
480 ObjPtr var_int = Obj::CreateValue(100, ObjType::None);
481 ObjPtr var_num = Obj::CreateValue(100.123, ObjType::None);
482 ObjPtr var_str = Obj::CreateString(L"STRCHAR");
483 ObjPtr var_strbyte = Obj::CreateString("STRBYTE");
484 ObjPtr var_bool = Obj::CreateBool(true);
485 ObjPtr var_empty = Obj::CreateNone();
486
487 ASSERT_STREQ("100", var_int->toString().c_str()) << var_int;
488 ASSERT_STREQ("100.123", var_num->toString().c_str()) << var_num;
489 ASSERT_STREQ("\"STRCHAR\"", var_str->toString().c_str()) << var_str;
490 ASSERT_STREQ("'STRBYTE'", var_strbyte->toString().c_str()) << var_strbyte;
491 ASSERT_STREQ("1", var_bool->toString().c_str()) << var_bool;
492 ASSERT_STREQ("_", var_empty->toString().c_str()) << var_empty;
493
494 ObjPtr var_dict = Obj::CreateType(ObjType::Dictionary);
495
496 ASSERT_STREQ("(,)", var_dict->toString().c_str()) << var_dict;
497
498 var_dict->m_var_name = "dict";
499 ASSERT_STREQ("dict=(,)", var_dict->toString().c_str()) << var_dict;
500
501 var_dict->push_back(Obj::CreateString(L"item1"));
502 ASSERT_STREQ("dict=(\"item1\",)", var_dict->toString().c_str()) << var_dict;
503 var_dict->push_back(var_int);
504 var_dict->push_back(var_bool);
505 ASSERT_STREQ("dict=(\"item1\", 100, 1,)", var_dict->toString().c_str()) << var_dict;
506
507
508 ObjPtr var_array = Obj::CreateDict(); //CreateTensor({1});
509
510 ASSERT_STREQ("(,)", var_array->toString().c_str()) << var_array;
511
512 var_array->m_var_name = "array";
513 ASSERT_STREQ("array=(,)", var_array->toString().c_str()) << var_array;
514
515 var_array->push_back(Obj::CreateString("item1"));
516 ASSERT_STREQ("array=('item1',)", var_array->toString().c_str()) << var_array;
517 ASSERT_NO_THROW(var_array->push_back(var_int));
518 ASSERT_NO_THROW(var_array->push_back(var_bool));
519 ASSERT_STREQ("array=('item1', 100, 1,)", var_array->toString().c_str()) << var_array;
520
521}
522
523
524//TEST(Args, All) {
525// Context ctx(RunTime::Init());
526// Parser p1;
527//
528// ASSERT_TRUE(p1.Parse("test()"));
529// Obj local;
530// Obj proto1(&ctx, p1.GetAst(), false, &local); // Функция с принимаемыми аргументами (нет аргументов)
531// ASSERT_EQ(0, proto1.size());
532// // ASSERT_FALSE(proto1.m_is_ellipsis);
533//
534//
535// ObjPtr arg_999 = Obj::CreateDict(Obj::Arg(Obj::CreateValue(999, ObjType::None)));
536// EXPECT_EQ(ObjType::Int16, (*arg_999)[0].second->getType()) << torch::toString(toTorchType((*arg_999)[0].second->getType()));
537//
538// ObjPtr arg_empty_named = Obj::CreateDict(Obj::Arg());
539// ASSERT_EQ(ObjType::None, (*arg_empty_named)[0].second->getType());
540//
541// ObjPtr arg_123_named = Obj::CreateDict(Obj::Arg(123, "named"));
542// EXPECT_EQ(ObjType::Int8, (*arg_123_named)[0].second->getType()) << torch::toString(toTorchType((*arg_123_named)[0].second->getType()));
543//
544// ObjPtr arg_999_123_named = Obj::CreateDict();
545// ASSERT_EQ(0, arg_999_123_named->size());
546// *arg_999_123_named += arg_empty_named;
547// ASSERT_EQ(1, arg_999_123_named->size());
548// *arg_999_123_named += arg_123_named;
549// ASSERT_EQ(2, arg_999_123_named->size());
550//
551// ASSERT_ANY_THROW(proto1.ConvertToArgs(arg_999.get(), true, nullptr)); // Прототип не принимает позиционных аргументов
552//
553// ASSERT_ANY_THROW(proto1.ConvertToArgs(arg_empty_named.get(), true, nullptr)); // Прототип не принимает именованных аргументов
554//
555//
556// TermPtr proto_term = Parser::ParseString("test(arg1)", nullptr, nullptr);
557// ASSERT_EQ(1, proto_term->size()) << proto_term->toString();
558//
559// Parser p2;
560// ASSERT_TRUE(p2.Parse("test(arg1)"));
561// ASSERT_EQ(1, p2.GetAst()->size()) << p2.GetAst()->toString();
562//
563// const Obj proto2(&ctx, p2.GetAst(), false, &local);
564// ASSERT_EQ(1, proto2.size()) << proto2.toString();
565// // ASSERT_FALSE(proto2.m_is_ellipsis);
566// ASSERT_STREQ("arg1", proto2.name(0).c_str());
567// ASSERT_EQ(nullptr, proto2.at(0).second);
568//
569// ObjPtr o_arg_999 = proto2.ConvertToArgs(arg_999.get(), true, nullptr);
570// ASSERT_TRUE((*o_arg_999)[0].second);
571// ASSERT_STREQ("999", (*o_arg_999)[0].second->toString().c_str());
572//
573// // proto2[0].reset(); // Иначе типы гурментов буду отличаться
574// ObjPtr o_arg_empty_named = proto2.ConvertToArgs(arg_empty_named.get(), false, nullptr);
575// ASSERT_TRUE((*o_arg_empty_named)[0].second);
576// ASSERT_STREQ("_", (*o_arg_empty_named)[0].second->toString().c_str());
577//
578// ASSERT_ANY_THROW(proto2.ConvertToArgs(arg_123_named.get(), true, nullptr)); // Имя аругмента отличается
579//
580//
581// // Нормальный вызов
582// Parser p3;
583// ASSERT_TRUE(p3.Parse("test(empty=_, ...) := {}"));
584// const Obj proto3(&ctx, p3.GetAst()->Left(), false, &local);
585// ASSERT_EQ(2, proto3.size());
586// // ASSERT_TRUE(proto3.m_is_ellipsis);
587// ASSERT_STREQ("empty", proto3.name(0).c_str());
588// ASSERT_TRUE(proto3.at(0).second);
589// ASSERT_EQ(ObjType::None, proto3.at(0).second->getType());
590// ASSERT_STREQ("...", proto3.name(1).c_str());
591// ASSERT_FALSE(proto3.at(1).second);
592//
593// ObjPtr proto3_arg = proto3.ConvertToArgs(arg_999.get(), true, nullptr);
594// ASSERT_EQ(1, proto3_arg->size());
595// ASSERT_TRUE((*proto3_arg)[0].second);
596// ASSERT_STREQ("999", (*proto3_arg)[0].second->toString().c_str());
597// ASSERT_STREQ("empty", proto3_arg->name(0).c_str());
598//
599// // Дополнительный аргумент
600// ObjPtr arg_extra = Obj::CreateDict(Obj::Arg(Obj::CreateValue(999, ObjType::None)), Obj::Arg(123, "named"));
601//
602// ASSERT_EQ(2, arg_extra->size());
603// EXPECT_EQ(ObjType::Int16, (*arg_extra)[0].second->getType()) << torch::toString(toTorchType((*arg_extra)[0].second->getType()));
604// EXPECT_EQ(ObjType::Int8, (*arg_extra)[1].second->getType()) << torch::toString(toTorchType((*arg_extra)[1].second->getType()));
605//
606//
607// ObjPtr proto3_extra = proto3.ConvertToArgs(arg_extra.get(), true, nullptr);
608// ASSERT_EQ(2, proto3_extra->size());
609// ASSERT_STREQ("999", (*proto3_extra)[0].second->toString().c_str());
610// ASSERT_STREQ("empty", proto3_extra->name(0).c_str());
611// ASSERT_STREQ("123", (*proto3_extra)[1].second->toString().c_str());
612// ASSERT_STREQ("named", proto3_extra->name(1).c_str());
613//
614//
615// // Аргумент по умолчанию
616// Parser p4;
617// ASSERT_TRUE(p4.Parse("test(num=123) := { }"));
618// Obj proto123(&ctx, p4.GetAst()->Left(), false, &local);
619// ASSERT_EQ(1, proto123.size());
620// // ASSERT_FALSE(proto123.m_is_ellipsis);
621// ASSERT_STREQ("num", proto123.name(0).c_str());
622// ASSERT_TRUE(proto123[0].second);
623// ASSERT_STREQ("123", proto123[0].second->toString().c_str());
624//
625//
626// // Изменен порядок
627// Parser p5;
628// ASSERT_TRUE(p5.Parse("test(arg1, str=\"string\") := {}"));
629// Obj proto_str(&ctx, p5.GetAst()->Left(), false, &local);
630// ASSERT_EQ(2, proto_str.size());
631// // ASSERT_FALSE(proto_str.m_is_ellipsis);
632// ASSERT_STREQ("arg1", proto_str.at(0).first.c_str());
633// ASSERT_EQ(nullptr, proto_str[0].second);
634//
635// ObjPtr arg_str = Obj::CreateDict(Obj::Arg(L"СТРОКА", "str"), Obj::Arg(555, "arg1"));
636//
637// ObjPtr proto_str_arg = proto_str.ConvertToArgs(arg_str.get(), true, nullptr);
638// ASSERT_STREQ("arg1", proto_str_arg->at(0).first.c_str());
639// ASSERT_TRUE(proto_str_arg->at(0).second);
640// ASSERT_STREQ("555", (*proto_str_arg)[0].second->toString().c_str());
641// ASSERT_STREQ("str", proto_str_arg->at(1).first.c_str());
642// ASSERT_TRUE((*proto_str_arg)[1].second);
643// ASSERT_STREQ("\"СТРОКА\"", (*proto_str_arg)[1].second->toString().c_str());
644//
645//
646// Parser p6;
647// ASSERT_TRUE(p6.Parse("test(arg1, ...) := {}"));
648// Obj proto_any(&ctx, p6.GetAst()->Left(), false, &local);
649// // ASSERT_TRUE(proto_any.m_is_ellipsis);
650// ASSERT_EQ(2, proto_any.size());
651// ASSERT_STREQ("arg1", proto_any.at(0).first.c_str());
652// ASSERT_EQ(nullptr, proto_any.at(0).second);
653//
654// ObjPtr any = proto_any.ConvertToArgs(arg_str.get(), true, nullptr);
655// ASSERT_EQ(2, any->size());
656// ASSERT_STREQ("arg1", any->at(0).first.c_str());
657// ASSERT_TRUE(any->at(0).second);
658// ASSERT_STREQ("555", (*any)[0].second->toString().c_str());
659// ASSERT_STREQ("str", any->at(1).first.c_str());
660// ASSERT_TRUE(any->at(1).second);
661// ASSERT_STREQ("\"СТРОКА\"", (*any)[1].second->toString().c_str());
662//
663//
664// Parser p7;
665// ASSERT_TRUE(p7.Parse("func(arg) := {}"));
666// Obj proto_func(&ctx, p7.GetAst()->Left(), false, &local);
667// // ASSERT_TRUE(proto_any.m_is_ellipsis);
668// ASSERT_EQ(1, proto_func.size());
669// ASSERT_STREQ("arg", proto_func.at(0).first.c_str());
670// ASSERT_EQ(nullptr, proto_func.at(0).second);
671//
672// ObjPtr arg_str2 = Obj::CreateDict(Obj::Arg("STRING"));
673//
674// proto_func.ConvertToArgs_(arg_str2.get(), true, nullptr);
675// ASSERT_EQ(1, proto_func.size());
676// ASSERT_STREQ("arg", proto_func.at(0).first.c_str());
677// ASSERT_TRUE(proto_func.at(0).second);
678// ASSERT_STREQ("'STRING'", proto_func[0].second->toString().c_str());
679// ASSERT_EQ(ObjType::StrChar, proto_func[0].second->getType());
680//
681// //
682// Parser p8;
683// ASSERT_TRUE(p8.Parse("min(arg, ...) := {}"));
684// Obj min_proto(&ctx, p8.GetAst()->Left(), false, &local);
685// ObjPtr min_args = Obj::CreateDict(Obj::Arg(200), Obj::Arg(100), Obj::Arg(300));
686// ObjPtr min_arg = min_proto.ConvertToArgs(min_args.get(), true, nullptr);
687//
688// ASSERT_EQ(3, min_arg->size());
689// ASSERT_STREQ("200", (*min_arg)[0].second->toString().c_str());
690// ASSERT_STREQ("100", (*min_arg)[1].second->toString().c_str());
691// ASSERT_STREQ("300", (*min_arg)[2].second->toString().c_str());
692//
693// Parser p9;
694// ASSERT_TRUE(p9.Parse("min(200, 100, 300)"));
695// Obj args_term(&ctx, p9.GetAst(), true, &local);
696// ASSERT_STREQ("200", args_term[0].second->toString().c_str());
697// ASSERT_STREQ("100", args_term[1].second->toString().c_str());
698// ASSERT_STREQ("300", args_term[2].second->toString().c_str());
699//}
700
701TEST(ObjTest, FromLimit) {
702
703 std::multimap<int64_t, ObjType> IntTypes = {
704 {0, ObjType::Bool},
705 {1, ObjType::Bool},
706 {2, ObjType::Int8},
707 {127, ObjType::Int8},
708 // {255, ObjType::Int8},
709 {256, ObjType::Int16},
710 {-1, ObjType::Int8},
711 {-200, ObjType::Int16},
712 {66000, ObjType::Int32},
713 {-33000, ObjType::Int32},
714 {5000000000, ObjType::Int64},
715 };
716
717 for (auto elem : IntTypes) {
718 ASSERT_EQ(elem.second, typeFromLimit(elem.first)) << elem.first << " " << toString(elem.second);
719 }
720
721 ASSERT_EQ(ObjType::Float32, typeFromLimit(1.0));
722 ASSERT_EQ(ObjType::Float64, typeFromLimit(0.0)); //@todo Fix???????
723 ASSERT_EQ(ObjType::Float64, typeFromLimit(1E+40));
724
725}
726
727TEST(ObjTest, Tensor) {
728
729 RuntimePtr rt = RunTime::Init();
730
731 std::string from_str = "русские буквы для ПРОВЕРКИ КОНВЕРТАЦИИ символов";
732 std::wstring to_str = utf8_decode(from_str);
733 std::string conv_str = utf8_encode(to_str);
734
735 ASSERT_STREQ(from_str.c_str(), conv_str.c_str());
736
737 // Байтовые строки
738 ObjPtr str = Obj::CreateString("test");
739
740 ASSERT_STREQ("test", str->m_value.c_str());
741
742 torch::Tensor tstr_t;
743
744 ConvertStringToTensor(str->m_value, tstr_t, ObjType::Int8);
745
746 ASSERT_TRUE(tstr_t.defined());
747 ASSERT_EQ(tstr_t.index({0}).item<int>(), 't');
748 ASSERT_EQ(tstr_t.index({1}).item<int>(), 'e');
749 ASSERT_EQ(tstr_t.index({2}).item<int>(), 's');
750 ASSERT_EQ(tstr_t.index({3}).item<int>(), 't');
751
752
753 torch::Tensor tensot_temp = *str->toType(ObjType::Tensor)->m_tensor;
754 ASSERT_TRUE(tensot_temp.defined());
755 ASSERT_EQ(tensot_temp.index({0}).item<int>(), 't');
756 ASSERT_EQ(tensot_temp.index({1}).item<int>(), 'e');
757 ASSERT_EQ(tensot_temp.index({2}).item<int>(), 's');
758 ASSERT_EQ(tensot_temp.index({3}).item<int>(), 't');
759
760 ObjPtr t_str = CreateTensor(tensot_temp);
761 ASSERT_EQ(t_str->m_var_type_current, ObjType::Int8) << toString(t_str->m_var_type_current);
762 ASSERT_EQ(4, t_str->size());
763 ASSERT_TRUE(t_str->m_tensor->defined());
764
765 ASSERT_EQ(t_str->m_tensor->index({0}).item<int>(), 't');
766 ASSERT_EQ(t_str->m_tensor->index({1}).item<int>(), 'e');
767 ASSERT_EQ(t_str->m_tensor->index({2}).item<int>(), 's');
768 ASSERT_EQ(t_str->m_tensor->index({3}).item<int>(), 't');
769
770 ASSERT_EQ(t_str->index_get({0})->GetValueAsInteger(), 't');
771 ASSERT_EQ(t_str->index_get({1})->GetValueAsInteger(), 'e');
772 ASSERT_EQ(t_str->index_get({2})->GetValueAsInteger(), 's');
773 ASSERT_EQ(t_str->index_get({3})->GetValueAsInteger(), 't');
774
775 ASSERT_STREQ(t_str->toType(ObjType::StrWide)->GetValueAsString().c_str(), "test") << t_str->toType(ObjType::StrWide)->GetValueAsString();
776
777 t_str->index_set_({1}, Obj::CreateString("E"));
778 t_str->index_set_({2}, Obj::CreateString("S"));
779
780 EXPECT_STREQ(t_str->toType(ObjType::StrWide)->GetValueAsString().c_str(), "tESt") << t_str->toType(ObjType::StrWide)->GetValueAsString();
781
782 // Символьные сторки
783 ObjPtr wstr = Obj::CreateString(L"ТЕСТ");
784 ObjPtr t_wstr = CreateTensor(*wstr->toType(ObjType::Tensor)->m_tensor);
785 if (sizeof (wchar_t) == 2) {
786 ASSERT_EQ(t_wstr->m_var_type_current, ObjType::Int16);
787 } else {
788 ASSERT_TRUE(sizeof (wchar_t) == 4);
789 ASSERT_EQ(t_wstr->m_var_type_current, ObjType::Int32);
790 }
791 ASSERT_EQ(4, t_wstr->size());
792
793 ASSERT_EQ(t_wstr->index_get({0})->GetValueAsInteger(), L'Т');
794 ASSERT_EQ(t_wstr->index_get({1})->GetValueAsInteger(), L'Е');
795 ASSERT_EQ(t_wstr->index_get({2})->GetValueAsInteger(), L'С');
796 ASSERT_EQ(t_wstr->index_get({3})->GetValueAsInteger(), L'Т');
797
798 std::wstring test_wide = t_wstr->toType(ObjType::StrWide)->GetValueAsStringWide();
799 EXPECT_STREQ(utf8_encode(test_wide).c_str(), "ТЕСТ");
800
801 std::string test_str = t_wstr->toType(ObjType::StrWide)->GetValueAsString();
802 EXPECT_STREQ(test_str.c_str(), "ТЕСТ") << test_str;
803
804 t_wstr->index_set_({1}, Obj::CreateString(L"е"));
805 t_wstr->index_set_({2}, Obj::CreateString(L"с"));
806
807 test_str = t_wstr->toType(ObjType::StrWide)->GetValueAsString();
808 EXPECT_STREQ(test_str.c_str(), "ТесТ") << test_str;
809
810}
811
812TEST(ObjTest, Ops) {
813
814 ObjPtr var_zero = Obj::CreateValue(0, ObjType::None);
815 ASSERT_TRUE(var_zero->is_bool_type());
816 ASSERT_TRUE(var_zero->is_arithmetic_type());
817 ASSERT_EQ(ObjType::Bool, var_zero->m_var_type_current);
818
819 ObjPtr var_bool = Obj::CreateBool(true);
820 ASSERT_TRUE(var_bool->is_bool_type());
821 ASSERT_TRUE(var_bool->is_arithmetic_type());
822 ASSERT_EQ(ObjType::Bool, var_bool->m_var_type_current);
823
824 ObjPtr var_char = Obj::CreateValue(100);
825 ASSERT_TRUE(var_char->is_arithmetic_type());
826 ASSERT_EQ(ObjType::Int8, var_char->m_var_type_current);
827
828 ObjPtr var_int = Obj::CreateValue(100000);
829 ASSERT_TRUE(var_int->is_arithmetic_type());
830 ASSERT_EQ(ObjType::Int32, var_int->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
831
832 ObjPtr var_float = Obj::CreateValue(1.0);
833 ASSERT_TRUE(var_float->is_arithmetic_type());
834 ASSERT_EQ(ObjType::Float32, var_float->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
835
836 ObjPtr var_tensor = Obj::CreateRange(0, 10)->toType(ObjType::Int32);
837 ASSERT_TRUE(var_tensor->is_arithmetic_type());
838 ASSERT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
839
840 var_tensor->operator*=(var_bool);
841 ASSERT_TRUE(var_tensor->is_arithmetic_type());
842 EXPECT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
843
844 var_tensor->operator*=(var_int);
845 ASSERT_TRUE(var_tensor->is_arithmetic_type());
846 EXPECT_EQ(ObjType::Int32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
847
848 var_tensor->operator*=(var_float);
849 ASSERT_TRUE(var_tensor->is_arithmetic_type());
850 EXPECT_EQ(ObjType::Float32, var_tensor->m_var_type_current) << newlang::toString(var_char->m_var_type_current);
851}
852
853TEST(ObjTest, Iterator) {
854
855 ObjPtr dict = Obj::CreateDict();
856
857 dict->push_back(Obj::Arg(1, "1"));
858 dict->push_back(Obj::Arg(2, "22"));
859 dict->push_back(Obj::Arg(3, "333"));
860 dict->push_back(Obj::Arg(4));
861 dict->push_back(Obj::Arg(5, "555"));
862
863 ASSERT_EQ(5, dict->size());
864
865 auto all = std::regex("(.|\\n)*");
866 ASSERT_TRUE(std::regex_match("1", all));
867 ASSERT_TRUE(std::regex_match("22", all));
868 ASSERT_TRUE(std::regex_match("333", all));
869 ASSERT_TRUE(std::regex_match("", all));
870 ASSERT_TRUE(std::regex_match("\n", all));
871 ASSERT_TRUE(std::regex_match("\n\n\\n", all));
872
873
874 Iterator <Obj> iter(dict);
875
876 ASSERT_TRUE(iter == iter.begin());
877 ASSERT_TRUE(iter != iter.end());
878
879 ObjPtr copy = Obj::CreateDict();
880 for (auto &elem : iter) {
881
882 copy->push_back(elem.second, elem.first);
883 }
884
885 ASSERT_TRUE(iter == iter.begin());
886 ASSERT_TRUE(iter != iter.end());
887
888 ASSERT_EQ(dict->size(), copy->size());
889
890
891 ASSERT_TRUE(iter == iter.begin());
892
893 ObjPtr one = iter.read_and_next(0);
894 ASSERT_TRUE(one);
895 ASSERT_EQ(1, one->GetValueAsInteger());
896
897 ASSERT_EQ(2, (*iter).second->GetValueAsInteger());
898 one = iter.read_and_next(0);
899 ASSERT_TRUE(one);
900 ASSERT_EQ(2, one->GetValueAsInteger());
901
902 ASSERT_EQ(3, (*iter).second->GetValueAsInteger());
903 one = iter.read_and_next(0);
904 ASSERT_TRUE(one);
905 ASSERT_EQ(3, one->GetValueAsInteger());
906
907 ASSERT_EQ(4, (*iter).second->GetValueAsInteger());
908 one = iter.read_and_next(0);
909 ASSERT_TRUE(one);
910 ASSERT_EQ(4, one->GetValueAsInteger());
911
912 ASSERT_EQ(5, (*iter).second->GetValueAsInteger());
913 one = iter.read_and_next(0);
914 ASSERT_TRUE(one);
915 ASSERT_EQ(5, one->GetValueAsInteger());
916
917 one = iter.read_and_next(0);
918 ASSERT_TRUE(one);
919 ASSERT_EQ(ObjType::IteratorEnd, one->getType()) << one << " " << toString(one->getType());
920
921 one = iter.read_and_next(0);
922 ASSERT_TRUE(one);
923 ASSERT_EQ(ObjType::IteratorEnd, one->getType()) << one << " " << toString(one->getType());
924
925
926
927
928 ASSERT_TRUE(iter == iter.end());
929 iter.reset();
930 ASSERT_TRUE(iter == iter.begin());
931 ASSERT_TRUE(iter != iter.end());
932
933 ObjPtr dict1 = iter.read_and_next(-3);
934 ASSERT_TRUE(dict1);
935 ASSERT_EQ(3, dict1->size());
936 ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
937 ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
938 ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
939
940 ObjPtr dict2 = iter.read_and_next(-3);
941 ASSERT_TRUE(dict2);
942 ASSERT_EQ(3, dict2->size());
943 ASSERT_EQ(4, dict2->at(0).second->GetValueAsInteger());
944 ASSERT_EQ(5, dict2->at(1).second->GetValueAsInteger());
945 ASSERT_EQ(ObjType::IteratorEnd, dict2->at(2).second->getType());
946
947 ObjPtr dict3 = iter.read_and_next(-3);
948 ASSERT_TRUE(dict3);
949 ASSERT_EQ(3, dict1->size());
950 ASSERT_EQ(ObjType::IteratorEnd, dict3->at(0).second->getType());
951 ASSERT_EQ(ObjType::IteratorEnd, dict3->at(1).second->getType());
952 ASSERT_EQ(ObjType::IteratorEnd, dict3->at(2).second->getType());
953
954
955
956 ASSERT_TRUE(iter == iter.end());
957 iter.reset();
958 ASSERT_TRUE(iter == iter.begin());
959 ASSERT_TRUE(iter != iter.end());
960
961 dict1 = iter.read_and_next(3);
962 ASSERT_TRUE(dict1);
963 ASSERT_EQ(3, dict1->size());
964 ASSERT_EQ(1, dict1->at(0).second->GetValueAsInteger());
965 ASSERT_EQ(2, dict1->at(1).second->GetValueAsInteger());
966 ASSERT_EQ(3, dict1->at(2).second->GetValueAsInteger());
967
968 dict2 = iter.read_and_next(3);
969 ASSERT_TRUE(dict2);
970 ASSERT_EQ(2, dict2->size());
971 ASSERT_EQ(4, dict2->at(0).second->GetValueAsInteger());
972 ASSERT_EQ(5, dict2->at(1).second->GetValueAsInteger());
973
974 dict3 = iter.read_and_next(3);
975 ASSERT_TRUE(dict3);
976 ASSERT_EQ(0, dict3->size());
977
978
979
980
981 Iterator <Obj> flt(dict, "");
982 ObjPtr flt_res = flt.read_and_next(100);
983 ASSERT_TRUE(flt_res);
984 ASSERT_EQ(1, flt_res->size());
985 ASSERT_EQ(4, flt_res->at(0).second->GetValueAsInteger());
986
987
988 Iterator <Obj> flt1(dict, ".");
989 ObjPtr flt1_res = flt1.read_and_next(100);
990 ASSERT_TRUE(flt1_res);
991 ASSERT_EQ(1, flt1_res->size());
992 ASSERT_EQ(1, flt1_res->at(0).second->GetValueAsInteger());
993
994
995 Iterator <Obj> flt2(dict, "..");
996 ObjPtr flt2_res = flt2.read_and_next(100);
997 ASSERT_TRUE(flt2_res);
998 ASSERT_EQ(1, flt2_res->size());
999 ASSERT_EQ(2, flt2_res->at(0).second->GetValueAsInteger());
1000
1001 Iterator <Obj> flt3(dict, "...");
1002 ObjPtr flt3_res = flt3.read_and_next(100);
1003 ASSERT_TRUE(flt3_res);
1004 ASSERT_EQ(2, flt3_res->size());
1005 ASSERT_EQ(3, flt3_res->at(0).second->GetValueAsInteger());
1006 ASSERT_EQ(5, flt3_res->at(1).second->GetValueAsInteger());
1007
1008
1009
1010 // ObjPtr iter1 = dict->MakeIterator();
1011
1012}
1013
1014//TEST(ObjTest, System) {
1015//
1016// ASSERT_STREQ("name", ExtractName("name").c_str());
1017// ASSERT_STREQ("name", ExtractName("::name").c_str());
1018// ASSERT_STREQ("name", ExtractName("ns::name").c_str());
1019// ASSERT_STREQ("", ExtractName("\\file").c_str());
1020// ASSERT_STREQ("", ExtractName("\\\\dir.file").c_str());
1021// ASSERT_STREQ("var", ExtractName("\\dir.file::var").c_str());
1022// ASSERT_STREQ("var.field", ExtractName("\\\\dir.file::var.field").c_str());
1023//
1024//
1025// ASSERT_STREQ("\\file", ExtractModuleName("\\file").c_str());
1026// ASSERT_STREQ("\\\\dir.file", ExtractModuleName("\\\\dir.file").c_str());
1027// ASSERT_STREQ("\\dir.file", ExtractModuleName("\\dir.file::var").c_str());
1028// ASSERT_STREQ("\\\\dir.file", ExtractModuleName("\\\\dir.file::var.field").c_str());
1029//
1030//
1031// ObjPtr none = Obj::CreateNone();
1032//
1033// ASSERT_TRUE(none->at("__error_field_name__").second);
1034// ASSERT_STREQ("Internal field '__error_field_name__' not exist!", none->at("__error_field_name__").second->GetValueAsString().c_str());
1035//
1036// ASSERT_TRUE(none->at("__type__").second);
1037// ASSERT_STREQ(":None", none->at("__type__").second->GetValueAsString().c_str());
1038//
1039// ASSERT_TRUE(none->at("__type_fixed__").second);
1040// ASSERT_STREQ(":None", none->at("__type_fixed__").second->GetValueAsString().c_str());
1041//
1042// ASSERT_TRUE(none->at("__name__").second);
1043// ASSERT_STREQ("", none->at("__name__").second->GetValueAsString().c_str());
1044//
1045// ASSERT_TRUE(none->at("__full_name__").second);
1046// ASSERT_STREQ("", none->at("__full_name__").second->GetValueAsString().c_str());
1047//
1048// ASSERT_TRUE(none->at("__module__").second);
1049// ASSERT_STREQ("", none->at("__module__").second->GetValueAsString().c_str());
1050//
1051// ASSERT_TRUE(none->at("__class__").second);
1052// ASSERT_STREQ("", none->at("__class__").second->GetValueAsString().c_str());
1053//
1054// ASSERT_TRUE(none->at("__base__").second);
1055// ASSERT_STREQ("(,)", none->at("__base__").second->GetValueAsString().c_str());
1056//
1057// ASSERT_TRUE(none->at("__doc__").second);
1058// ASSERT_STREQ("Help system not implemented!!!!!", none->at("__doc__").second->GetValueAsString().c_str());
1059//
1060// ASSERT_TRUE(none->at("__str__").second);
1061// ASSERT_STREQ("_", none->at("__str__").second->GetValueAsString().c_str());
1062//
1063// none->m_var_is_init = false;
1064// ASSERT_TRUE(none->at("__error_field_name__").second);
1065// ASSERT_STREQ(":Undefined", none->at("__error_field_name__").second->GetValueAsString().c_str());
1066//
1067//
1068// ObjPtr str = Obj::CreateString("str");
1069// str->m_var_name = "name";
1070//
1071// ASSERT_TRUE(str->at("__type__").second);
1072// ASSERT_STREQ(":StrChar", str->at("__type__").second->GetValueAsString().c_str());
1073//
1074// ASSERT_TRUE(str->at("__type_fixed__").second);
1075// ASSERT_STREQ(":String", str->at("__type_fixed__").second->GetValueAsString().c_str());
1076//
1077// ASSERT_TRUE(str->at("__name__").second);
1078// ASSERT_STREQ("name", str->at("__name__").second->GetValueAsString().c_str());
1079//
1080// ASSERT_TRUE(str->at("__full_name__").second);
1081// ASSERT_STREQ("name", str->at("__full_name__").second->GetValueAsString().c_str());
1082//
1083// ASSERT_TRUE(str->at("__module__").second);
1084// ASSERT_STREQ("", str->at("__module__").second->GetValueAsString().c_str());
1085//
1086// ASSERT_TRUE(str->at("__class__").second);
1087// ASSERT_STREQ("", str->at("__class__").second->GetValueAsString().c_str());
1088//
1089// ASSERT_TRUE(str->at("__base__").second);
1090// ASSERT_STREQ("(,)", str->at("__base__").second->GetValueAsString().c_str());
1091//
1092// ASSERT_TRUE(str->at("__doc__").second);
1093// ASSERT_STREQ("Help system not implemented!!!!!", str->at("__doc__").second->GetValueAsString().c_str());
1094//
1095// ASSERT_TRUE(str->at("__str__").second);
1096// ASSERT_STREQ("name='str'", str->at("__str__").second->GetValueAsString().c_str());
1097//
1098//
1099// ObjPtr cls = Obj::CreateClass("class");
1100// cls->m_var_name = "::ns::name";
1101// cls->push_back(Obj::CreateRange(0, 10, 3), "filed");
1102//
1103// ASSERT_TRUE(cls->at("__type__").second);
1104// ASSERT_STREQ(":Class", cls->at("__type__").second->GetValueAsString().c_str());
1105//
1106// ASSERT_TRUE(cls->at("__type_fixed__").second);
1107// ASSERT_STREQ(":None", cls->at("__type_fixed__").second->GetValueAsString().c_str());
1108//
1109// ASSERT_TRUE(cls->at("__name__").second);
1110// ASSERT_STREQ("name", cls->at("__name__").second->GetValueAsString().c_str());
1111//
1112// ASSERT_TRUE(cls->at("__full_name__").second);
1113// ASSERT_STREQ("::ns::name", cls->at("__full_name__").second->GetValueAsString().c_str());
1114//
1115// ASSERT_TRUE(cls->at("__module__").second);
1116// ASSERT_STREQ("", cls->at("__module__").second->GetValueAsString().c_str());
1117//
1118// ASSERT_TRUE(cls->at("__class__").second);
1119// ASSERT_STREQ("class", cls->at("__class__").second->GetValueAsString().c_str());
1120//
1121// ASSERT_TRUE(cls->at("__base__").second);
1122// ASSERT_STREQ("(,)", cls->at("__base__").second->GetValueAsString().c_str());
1123//
1124// ASSERT_TRUE(cls->at("__doc__").second);
1125// ASSERT_STREQ("Help system not implemented!!!!!", cls->at("__doc__").second->GetValueAsString().c_str());
1126//
1127// ASSERT_TRUE(cls->at("__str__").second);
1128// ASSERT_STREQ("::ns::name=class(filed=0..10..3)", cls->at("__str__").second->GetValueAsString().c_str());
1129//}
1130
1131/*
1132 * Реализация ссылочной модели состоит из следующих компонентов:
1133 * - Obj - статический объект (даннные), на которые можно получить ссылку (Reference)
1134 * - ObjPtr - динамический объект (shared_ptr), на которые можно получить ссылку (Reference)
1135 * - Sync - статический объект синхронизации доступа к данным (всегда привязан к какому либо объекту с тяжелой ссылкой && или &*,
1136 * тогда как легкие ссылки (& или &?) не имеют собственого объекта Sync).
1137 * - Reference - Слабая ссылка (weak_ptr) на объект. Является одним из типов ObjType
1138 * - Taken - Легкий объект с захваченной ссылкой (shared_ptr или nullptr если захват weak_ptr или объекта синхронизации неудался).
1139 * Ссылка живая, пока валиден объект Taken, полученный при захвате ссылки (Reference).
1140 * - Захват (класс Taken с shared_ptr) можно получить из любого объекта Obj (хоть из объекта, хоть из ссылки на объект).
1141 */
1142
1143
1144//void call_thread_throw() {
1145// try {
1146// LOG_RUNTIME("Call from thread!");
1147// } catch (...) {
1148// }
1149//}
1150//
1151//bool call_start = false;
1152//bool call_done = false;
1153//std::mutex call_m;
1154//std::condition_variable cv;
1155//
1156//void call_thread(ObjPtr obj) {
1157// std::unique_lock lk(call_m);
1158// cv.wait(lk, [] {
1159// return call_start; });
1160//
1161// try {
1162// std::vector<Taken> t;
1163// for (int i = 1; i < 5; ++i) {
1164// t.push_back(obj->Take(true, std::chrono::milliseconds(5)));
1165// std::cout << "Thread step " << i;
1166// if (t.back()) {
1167// std::cout << " value: " << (*t.back()).toString();
1168// *t.back() += Obj::CreateValue(i);
1169// }
1170// std::cout << "\n";
1171// std::this_thread::sleep_for(std::chrono::milliseconds(10));
1172// }
1173// call_done = true;
1174// } catch (...) {
1175// }
1176//
1177// lk.unlock();
1178// cv.notify_one();
1179//}
1180//
1181//TEST(ObjTest, Reference) {
1182//
1183// Obj obj = *Obj::CreateValue(1);
1184// Obj obj2 = *Obj::CreateValue(2);
1185//
1186// ASSERT_STREQ("1", obj.toString().c_str());
1187// ASSERT_STREQ("2", obj2.toString().c_str());
1188//
1189// Obj &obj_ref = obj;
1190// ASSERT_STREQ("1", obj_ref.toString().c_str());
1191//
1192// obj_ref = obj2;
1193// ASSERT_STREQ("2", obj_ref.toString().c_str());
1194//
1195// ASSERT_STREQ("2", obj.toString().c_str());
1196// ASSERT_STREQ("2", obj2.toString().c_str());
1197//
1198//
1199// Sync sync_single(RefType::LiteSingle);
1200// ASSERT_EQ(sync_single.GetThreadId(), std::this_thread::get_id());
1201//
1202// Sync sync_thread(RefType::LiteThread);
1203// ASSERT_EQ(sync_thread.GetThreadId(), std::this_thread::get_id());
1204//
1205// Sync sync_mono(RefType::SyncMono);
1206// Sync sync_mono_ro(RefType::SyncMonoConst);
1207//
1208// Sync sync_multi(RefType::SyncMulti);
1209// Sync sync_multi_ro(RefType::SyncMultiConst);
1210//
1211// ObjPtr obj_none = Obj::CreateValue(1, ObjType::Integer);
1212// ObjPtr val_single = Obj::CreateValue(1, ObjType::Integer, &sync_single);
1213// ObjPtr val_thread = Obj::CreateValue(2, ObjType::Integer, &sync_thread);
1214//
1215// ObjPtr val_mono = Obj::CreateValue(3, ObjType::Integer, &sync_mono);
1216// ObjPtr val_mono_ro = Obj::CreateValue(4, ObjType::Integer, &sync_mono_ro);
1217//
1218// ObjPtr val_multi = Obj::CreateValue(5, ObjType::Integer, &sync_multi);
1219// ObjPtr val_multi_ro = Obj::CreateValue(6, ObjType::Integer, &sync_multi_ro);
1220//
1221// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::None));
1222// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::LiteSingle));
1223// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::LiteSingleConst));
1224// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::LiteThread));
1225// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::LiteThreadConst));
1226// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::SyncMono));
1227// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::SyncMonoConst));
1228// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::SyncMulti));
1229// ASSERT_ANY_THROW(Obj::CreateReference(obj.shared(), RefType::SyncMultiConst));
1230//
1231// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::None));
1232// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::LiteSingle));
1233// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::LiteSingleConst));
1234// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::LiteThread));
1235// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::LiteThreadConst));
1236// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::SyncMono));
1237// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::SyncMonoConst));
1238// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::SyncMulti));
1239// ASSERT_ANY_THROW(Obj::CreateReference(obj_none, RefType::SyncMultiConst));
1240//
1241// ASSERT_ANY_THROW(Obj::CreateReference(val_single, RefType::None));
1242// ASSERT_NO_THROW(Obj::CreateReference(val_single, RefType::LiteSingle));
1243// ASSERT_NO_THROW(Obj::CreateReference(val_single, RefType::LiteSingleConst));
1244// ASSERT_ANY_THROW(Obj::CreateReference(val_single, RefType::LiteThread));
1245// ASSERT_ANY_THROW(Obj::CreateReference(val_single, RefType::LiteThreadConst));
1246// ASSERT_ANY_THROW(Obj::CreateReference(val_single, RefType::SyncMono));
1247// ASSERT_ANY_THROW(Obj::CreateReference(val_single, RefType::SyncMonoConst));
1248// ASSERT_ANY_THROW(Obj::CreateReference(val_single, RefType::SyncMulti));
1249// ASSERT_ANY_THROW(Obj::CreateReference(val_single, RefType::SyncMultiConst));
1250//
1251// ASSERT_ANY_THROW(Obj::CreateReference(val_thread, RefType::None));
1252// ASSERT_ANY_THROW(Obj::CreateReference(val_thread, RefType::LiteSingle));
1253// ASSERT_ANY_THROW(Obj::CreateReference(val_thread, RefType::LiteSingleConst));
1254// ASSERT_NO_THROW(Obj::CreateReference(val_thread, RefType::LiteThread));
1255// ASSERT_NO_THROW(Obj::CreateReference(val_thread, RefType::LiteThreadConst));
1256// ASSERT_ANY_THROW(Obj::CreateReference(val_thread, RefType::SyncMono));
1257// ASSERT_ANY_THROW(Obj::CreateReference(val_thread, RefType::SyncMonoConst));
1258// ASSERT_ANY_THROW(Obj::CreateReference(val_thread, RefType::SyncMulti));
1259// ASSERT_ANY_THROW(Obj::CreateReference(val_thread, RefType::SyncMultiConst));
1260//
1261//
1262// ASSERT_ANY_THROW(Obj::CreateReference(val_mono, RefType::None));
1263// ASSERT_ANY_THROW(Obj::CreateReference(val_mono, RefType::LiteSingle));
1264// ASSERT_ANY_THROW(Obj::CreateReference(val_mono, RefType::LiteSingleConst));
1265// ASSERT_ANY_THROW(Obj::CreateReference(val_mono, RefType::LiteThread));
1266// ASSERT_ANY_THROW(Obj::CreateReference(val_mono, RefType::LiteThreadConst));
1267// ASSERT_NO_THROW(Obj::CreateReference(val_mono, RefType::SyncMono));
1268// ASSERT_NO_THROW(Obj::CreateReference(val_mono, RefType::SyncMonoConst));
1269// ASSERT_ANY_THROW(Obj::CreateReference(val_mono_ro, RefType::SyncMono));
1270// ASSERT_NO_THROW(Obj::CreateReference(val_mono_ro, RefType::SyncMonoConst));
1271// ASSERT_ANY_THROW(Obj::CreateReference(val_mono, RefType::SyncMulti));
1272// ASSERT_ANY_THROW(Obj::CreateReference(val_mono, RefType::SyncMultiConst));
1273//
1274// ASSERT_ANY_THROW(Obj::CreateReference(val_multi, RefType::None));
1275// ASSERT_ANY_THROW(Obj::CreateReference(val_multi, RefType::LiteSingle));
1276// ASSERT_ANY_THROW(Obj::CreateReference(val_multi, RefType::LiteSingleConst));
1277// ASSERT_ANY_THROW(Obj::CreateReference(val_multi, RefType::LiteThread));
1278// ASSERT_ANY_THROW(Obj::CreateReference(val_multi, RefType::LiteThreadConst));
1279// ASSERT_ANY_THROW(Obj::CreateReference(val_multi, RefType::SyncMono));
1280// ASSERT_ANY_THROW(Obj::CreateReference(val_multi, RefType::SyncMonoConst));
1281// ASSERT_NO_THROW(Obj::CreateReference(val_multi, RefType::SyncMulti));
1282// ASSERT_NO_THROW(Obj::CreateReference(val_multi, RefType::SyncMultiConst));
1283// ASSERT_ANY_THROW(Obj::CreateReference(val_multi_ro, RefType::SyncMulti));
1284// ASSERT_NO_THROW(Obj::CreateReference(val_multi_ro, RefType::SyncMultiConst));
1285//
1286//
1287//
1288// ObjPtr ref_single = Obj::CreateReference(val_single, RefType::LiteSingle);
1289// ObjPtr ref_single_ro = Obj::CreateReference(val_single, RefType::LiteSingleConst);
1290// ObjPtr ref_thread = Obj::CreateReference(val_thread, RefType::LiteThread);
1291// ObjPtr ref_thread_ro = Obj::CreateReference(val_thread, RefType::LiteThreadConst);
1292// ASSERT_TRUE(ref_single);
1293// ASSERT_TRUE(ref_single_ro);
1294// ASSERT_TRUE(ref_thread);
1295// ASSERT_TRUE(ref_thread_ro);
1296//
1297// ASSERT_EQ(1, val_single.use_count());
1298// {
1311// }
1312// ASSERT_EQ(1, val_single.use_count());
1313//
1314// std::cout << std::thread::hardware_concurrency() << "\n";
1315//
1316// ASSERT_NO_THROW(
1317// std::thread thread_throw(call_thread_throw);
1318// thread_throw.join();
1319// );
1320//
1321// ASSERT_FALSE(call_done);
1322// ASSERT_STREQ("11", val_single->toString().c_str());
1323// std::thread thread_fail(call_thread, ref_single);
1324// {
1325// std::lock_guard lk(call_m);
1326// call_start = true;
1327// }
1328// cv.notify_one();
1329// // running
1330// thread_fail.join();
1331// ASSERT_STREQ("11", val_single->toString().c_str());
1332// ASSERT_FALSE(call_done);
1333// {
1334// std::lock_guard lk(call_m);
1335// call_start = false;
1336// }
1337//
1338// ASSERT_STREQ("2", val_thread->toString().c_str());
1339// ASSERT_FALSE(call_done);
1340// std::thread thread_done(call_thread, ref_thread);
1341// {
1342// std::lock_guard lk(call_m);
1343// call_start = true;
1344// }
1345// cv.notify_one();
1346// thread_done.join();
1347// ASSERT_STREQ("12", val_thread->toString().c_str());
1348// {
1349// std::unique_lock lk(call_m);
1350// cv.wait(lk, [] {
1351// return call_done; });
1352// }
1353// ASSERT_TRUE(call_done);
1354//
1355//
1356//
1357// ObjPtr ref_mono = Obj::CreateReference(val_mono, RefType::SyncMono);
1358// ObjPtr ref_mono_ro = Obj::CreateReference(val_mono, RefType::SyncMonoConst);
1359// ObjPtr ref_mono_ro2 = Obj::CreateReference(val_mono_ro, RefType::SyncMonoConst);
1360// ASSERT_TRUE(ref_mono);
1361// ASSERT_TRUE(ref_mono_ro);
1362// ASSERT_TRUE(ref_mono_ro2);
1363//
1364//
1365// {
1366// std::lock_guard lk(call_m);
1367// call_start = false;
1368// call_done = false;
1369// }
1370//
1371// {
1384// }
1385//
1386//
1387// {
1388// std::lock_guard lk(call_m);
1389// call_start = false;
1390// call_done = false;
1391// }
1392//
1393// {
1394// ASSERT_STREQ("3", val_mono->toString().c_str());
1395// ASSERT_FALSE(call_done);
1396// std::thread thread_mono(call_thread, ref_mono);
1397// {
1398// std::lock_guard lk(call_m);
1399// call_start = true;
1400// }
1401// cv.notify_one();
1402// thread_mono.join();
1403// ASSERT_STREQ("9", val_mono->toString().c_str());
1404// ASSERT_TRUE(call_done);
1405// }
1406//
1407//
1408// ObjPtr ref_multi = Obj::CreateReference(val_multi, RefType::SyncMulti);
1409// ObjPtr ref_multi_ro = Obj::CreateReference(val_multi, RefType::SyncMultiConst);
1410// ObjPtr ref_multi_ro2 = Obj::CreateReference(val_multi_ro, RefType::SyncMultiConst);
1411// ASSERT_TRUE(ref_multi);
1412// ASSERT_TRUE(ref_multi_ro);
1413// ASSERT_TRUE(ref_multi_ro2);
1414//
1415//
1416//
1417// {
1418// std::lock_guard lk(call_m);
1419// call_start = false;
1420// call_done = false;
1421// }
1422//
1423// {
1436// }
1437//
1438// {
1439// std::lock_guard lk(call_m);
1440// call_start = false;
1441// call_done = false;
1442// }
1443//
1444// {
1445// ASSERT_STREQ("5", val_multi->toString().c_str());
1446// ASSERT_FALSE(call_done);
1447// std::thread thread_multi(call_thread, ref_multi);
1448// {
1449// std::lock_guard lk(call_m);
1450// call_start = true;
1451// }
1452// cv.notify_one();
1453// thread_multi.join();
1454// ASSERT_STREQ("15", val_multi->toString().c_str());
1455// ASSERT_TRUE(call_done);
1456// }
1457//
1458//}
1459
1460//TEST(ObjTest, VarData) {
1461//
1462//
1463// /*
1464// * Владаелец данных (корень иерархии владельцев ссылки на данные) - может быть только один. Хранит сами данные и объект синхронизации.
1465// * Копия данных (сильная ссылка) - более низкий уровень иерархии. Ссылается на владельца и увеличивает счетчик ссылок.
1466// * Ссылка на данные (слабая ссылка) - любой уровень иерархии. Ссылается на владельца, но <НЕ> увеличивает счетчик ссылок.
1467// * Для работы с данными обязательно требуется захват данных! (захват объекта синхронизации, если он есть).
1468// * - Для владельца объекта не приводит к увличению счетчика ссылок (может быть на одном уровне с владельцем).
1469// * - Для копии данных увеличивает счетчик ссылок (может быть только ниже уровнях владельца).
1470// * - Для слабой ссылки требуется преобразования в сильнуый указатель, потом как с копией данных.
1471// *
1472// * Для использования weak_ptr требуется shared_ptr, причем указатель должен дыть не только на данные, но и объект синхронизации.
1473// */
1474//
1475// VarData var_int(123);
1476//
1477// EXPECT_EQ(64, sizeof (VarData));
1478// EXPECT_EQ(64, sizeof (var_int));
1479//
1480// EXPECT_EQ(8, sizeof (var_int.sync));
1481// EXPECT_EQ(16, sizeof (var_int.owner));
1482// EXPECT_EQ(40, sizeof (var_int.data));
1483// EXPECT_EQ(40, sizeof (VarData::DataType));
1484//
1485// EXPECT_EQ(2, sizeof (std::variant<std::monostate>));
1486// EXPECT_EQ(2, sizeof (std::variant<bool>));
1487// EXPECT_EQ(2, sizeof (std::variant<int8_t>));
1488// EXPECT_EQ(4, sizeof (std::variant<int16_t>));
1489// EXPECT_EQ(8, sizeof (std::variant<int32_t>));
1490// EXPECT_EQ(16, sizeof (std::variant<int64_t>));
1491// EXPECT_EQ(40, sizeof (std::variant<std::string>));
1492// EXPECT_EQ(40, sizeof (std::variant<std::string, std::wstring>));
1493// EXPECT_EQ(32, sizeof (std::string));
1494// EXPECT_EQ(32, sizeof (std::wstring));
1495// EXPECT_EQ(32, sizeof (Rational));
1496// EXPECT_EQ(8, sizeof (std::unique_ptr<VarGuard>));
1497// EXPECT_EQ(16, sizeof (std::weak_ptr<VarData>));
1498// EXPECT_EQ(16, sizeof (std::shared_ptr<VarData>));
1499//
1500//
1501// EXPECT_EQ(16, sizeof (ObjPtr));
1502// EXPECT_EQ(632, sizeof (Obj));
1503//
1504// EXPECT_EQ(16, sizeof (TermPtr));
1505// EXPECT_EQ(440, sizeof (Term)); // 640
1506//
1507// EXPECT_EQ(16, sizeof (VarGuard));
1508// EXPECT_EQ(48, sizeof (Sync));
1509//
1510//
1511//
1512//
1513// ASSERT_TRUE(var_int.owner);
1514// ASSERT_EQ(1, var_int.owner.use_count());
1515// ASSERT_TRUE(std::holds_alternative<int64_t>(var_int.data));
1516// ASSERT_NO_THROW(ASSERT_EQ(var_int.get<int64_t>(), 123););
1517//
1518// VarData var_int_take(var_int.Take());
1519// ASSERT_FALSE(var_int_take.owner);
1520// ASSERT_TRUE(std::holds_alternative<std::unique_ptr < VarGuard >> (var_int_take.data)) << var_int_take.data.index();
1521// ASSERT_NO_THROW(ASSERT_EQ(var_int_take.get<int64_t>(), 123););
1522//
1523// ASSERT_EQ(1, var_int.owner.use_count());
1524// ASSERT_FALSE(std::get<std::unique_ptr < VarGuard >> (var_int_take.data)->m_is_locked);
1525// ASSERT_FALSE(std::get<std::unique_ptr < VarGuard >> (var_int_take.data)->m_edit_mode);
1526//
1527// VarData var_int_copy(var_int.Copy());
1528// ASSERT_FALSE(var_int_copy.owner);
1529// ASSERT_TRUE(std::holds_alternative<std::shared_ptr < VarData >> (var_int_copy.data)) << var_int_copy.data.index();
1530// ASSERT_NO_THROW(ASSERT_EQ(var_int_copy.get<int64_t>(), 123););
1531//
1532// ASSERT_EQ(2, var_int.owner.use_count()); // !!!!!!!!!!!!!!!!!!!!!!
1533// ASSERT_EQ(2, std::get<std::shared_ptr < VarData >> (var_int_copy.data).use_count());
1534//
1535// {
1536// VarData var_int_copy2(var_int.Copy());
1537// ASSERT_FALSE(var_int_copy2.owner);
1538// ASSERT_TRUE(std::holds_alternative<std::shared_ptr < VarData >> (var_int_copy2.data)) << var_int_copy2.data.index();
1539// ASSERT_NO_THROW(ASSERT_EQ(var_int_copy2.get<int64_t>(), 123););
1540//
1541// ASSERT_EQ(3, var_int.owner.use_count()); // !!!!!!!!!!!!!!!!!!!!!!
1542// ASSERT_EQ(3, std::get<std::shared_ptr < VarData >> (var_int_copy.data).use_count());
1543// ASSERT_EQ(3, std::get<std::shared_ptr < VarData >> (var_int_copy2.data).use_count());
1544//
1545// VarData var_int_copy3(var_int_copy2.Copy());
1546// ASSERT_FALSE(var_int_copy3.owner);
1547// ASSERT_TRUE(std::holds_alternative<std::shared_ptr < VarData >> (var_int_copy3.data)) << var_int_copy3.data.index();
1548// ASSERT_NO_THROW(ASSERT_EQ(var_int_copy3.get<int64_t>(), 123););
1549//
1550// ASSERT_EQ(4, var_int.owner.use_count()); // !!!!!!!!!!!!!!!!!!!!!!
1551// ASSERT_EQ(4, std::get<std::shared_ptr < VarData >> (var_int_copy.data).use_count());
1552// ASSERT_EQ(4, std::get<std::shared_ptr < VarData >> (var_int_copy2.data).use_count());
1553// ASSERT_EQ(4, std::get<std::shared_ptr < VarData >> (var_int_copy3.data).use_count());
1554// }
1555//
1556// VarData var_int_ref(var_int.Ref());
1557// ASSERT_FALSE(var_int_ref.owner);
1558// ASSERT_TRUE(std::holds_alternative<std::weak_ptr < VarData >> (var_int_ref.data)) << var_int_ref.data.index();
1559// ASSERT_NO_THROW(ASSERT_EQ(var_int_ref.get<int64_t>(), 123););
1560//
1561// ASSERT_EQ(2, var_int.owner.use_count());
1562// ASSERT_EQ(2, std::get<std::shared_ptr < VarData >> (var_int_copy.data).use_count());
1563//
1564// var_int += var_int;
1565// ASSERT_NO_THROW(ASSERT_EQ(var_int.get<int64_t>(), 246););
1566//
1567// VarData var_rat(Rational(1));
1568// ASSERT_TRUE(var_rat.owner);
1569// ASSERT_TRUE(std::holds_alternative<Rational> (var_rat.data)) << var_rat.data.index();
1570// ASSERT_NO_THROW(ASSERT_STREQ("1\\1", var_rat.get<Rational>().GetAsString().c_str()););
1571//
1572// var_rat += var_int;
1573// ASSERT_TRUE(var_rat.owner);
1574// ASSERT_TRUE(std::holds_alternative<Rational> (var_rat.data)) << var_rat.data.index();
1575// ASSERT_NO_THROW(ASSERT_STREQ("247\\1", var_rat.get<Rational>().GetAsString().c_str()););
1576// ASSERT_NO_THROW(ASSERT_STREQ("246\\1", var_int.get<Rational>().GetAsString().c_str()););
1577//
1578//
1579// VarData var_num(0.123);
1580// ASSERT_TRUE(var_num.owner);
1581// ASSERT_TRUE(std::holds_alternative<double>(var_num.data));
1582// ASSERT_NO_THROW(ASSERT_DOUBLE_EQ(var_num.get<double>(), 0.123););
1583// ASSERT_NO_THROW(ASSERT_DOUBLE_EQ(var_rat.get<double>(), 247.0););
1584//
1585//
1586// VarData var_str("str");
1587// ASSERT_TRUE(var_str.owner);
1588// ASSERT_TRUE(std::holds_alternative<std::string>(var_str.data));
1589// ASSERT_NO_THROW(ASSERT_STREQ("str", var_str.get<std::string>().c_str()););
1590//
1591// VarData var_obj(Obj::CreateEmpty());
1592// ASSERT_TRUE(var_obj.owner);
1593// ASSERT_TRUE(std::holds_alternative<ObjPtr>(var_obj.data));
1594// ASSERT_NO_THROW(ASSERT_TRUE(var_obj.get<ObjPtr>()););
1595// ASSERT_NO_THROW(ASSERT_STREQ("_", var_obj.get<ObjPtr>()->toString().c_str()));
1596//
1597// // Convert simple type
1598// ASSERT_NO_THROW(ASSERT_STREQ("'str'", var_str.get<ObjPtr>()->toString().c_str()));
1599// ASSERT_NO_THROW(ASSERT_STREQ("246", var_int.get<ObjPtr>()->toString().c_str()));
1600// ASSERT_NO_THROW(ASSERT_STREQ("247\\1", var_rat.get<ObjPtr>()->toString().c_str()));
1601// ASSERT_NO_THROW(ASSERT_STREQ("0.123", var_num.get<ObjPtr>()->toString().c_str()));
1602//
1603//}
1604
1605TEST(ObjTest, Variable) {
1606
1607
1608 /*
1609 * - Переменная по значению (variable by value) - данные хранятся непосредственно в самой переменной.
1610 * Переменная используется только в текущем потоке (без возможности создания ссылок).
1611 * Оператор захвата не используется.
1612 * - Владеющая переменная (owner variable) - в переменой находится только сильный (владеющий) указатель на данные, которые находятся на стеке или в куче.
1613 * Переменная предназначена для монопольного использования только в текущем потоке (без возможности создания ссылок).
1614 * Для обращения к данным требуется использовать оператор захвата (разименовывать указатель).
1615 * - Общая переменная (shared variable) - в переменой находится только сильный (владеющий) указатель на данные, которые находятся на стеке или в куче.
1616 * Переменная предназначена для раздельного доступа из разных потоков.
1617 * Для обращения к данным требуется использовать оператор захвата (блокировка доступа и разименование указателя)
1618 * - Переменная ссылка (link variable) - в переменой находится только слабый (не владеющий) указатель на общую переменную.
1619 * Для работы с данными требуется оператор захвата (блокировка доступа, преобразование слабого указателя в сильный и его разименование).
1620 */
1621
1622 // value1 := 1; # Variable by value
1623 // *owner := 2; # Owner reference variable
1624 //
1625 // copy1 := value1; # Copy data from value1
1626 // local1 := owner; # Error owner copy shared to variable by value
1627 // local2 := *owner; # Copy data to variable by value
1628 // *copy_owner := *owner; # Copy data from to new shared variable
1629 // {
1630 // *local3 := owner; # But copy owner reference to local variable
1631 // local4 := *owner; # Copy data from reference variable
1632 //
1633 // *local5 = 5; # The owner has new value 5
1634 // }
1635 //
1636 // & common: = 3; # Shared reference variable with link
1637 // link := & common; # Weak pointer to common variable
1638 // *link = 6; # The common has new value 6
1639
1640 Variable var_int(123);
1641
1642 EXPECT_EQ(8, sizeof (std::exception));
1643 EXPECT_EQ(16, sizeof (std::runtime_error));
1644 EXPECT_EQ(8, sizeof (std::chrono::milliseconds));
1645 EXPECT_EQ(16, sizeof (std::string_view));
1646 EXPECT_EQ(8, sizeof (std::source_location));
1647 EXPECT_EQ(16, sizeof (std::stacktrace));
1648
1649 EXPECT_EQ(16, sizeof (std::runtime_error));
1650 EXPECT_EQ(8, sizeof (Variable *));
1651 EXPECT_EQ(16, sizeof (std::shared_ptr<Variable>));
1652 EXPECT_EQ(24, sizeof (std::variant<Variable *, std::shared_ptr < Variable>>));
1653 EXPECT_EQ(8, sizeof (std::shared_ptr<Sync> *));
1654
1655 EXPECT_EQ(40, sizeof (VariableTaken)); // 16+24
1656
1657 // const Variable & variable; 8
1658 // const std::chrono::milliseconds & timeout; 8
1659 // const std::string_view & message; 8
1660 // const std::source_location & location; 8
1661 // std::stacktrace stacktrace; 16
1662 // const bool editmode; 1 (8)
1663
1664 EXPECT_EQ(48, sizeof (Variable)); //56 64
1665 EXPECT_EQ(48, sizeof (var_int));
1666
1667 EXPECT_EQ(48, sizeof (VariableVariant));
1668
1669 EXPECT_EQ(112, sizeof (Sync));
1670 EXPECT_EQ(8, sizeof (std::unique_ptr<Sync>));
1671 EXPECT_EQ(16, sizeof (std::shared_ptr<Sync>));
1672 EXPECT_EQ(8, sizeof (std::unique_ptr<VariableTaken>));
1673 EXPECT_EQ(16, sizeof (std::shared_ptr<VariableTaken>));
1674
1675 // EXPECT_EQ(16, sizeof (var_int.sync));
1676 EXPECT_EQ(48, sizeof (VariableVariant));
1677
1678 EXPECT_EQ(2, sizeof (std::variant<std::monostate>));
1679 EXPECT_EQ(2, sizeof (std::variant<bool>));
1680 EXPECT_EQ(2, sizeof (std::variant<int8_t>));
1681 EXPECT_EQ(4, sizeof (std::variant<int16_t>));
1682 EXPECT_EQ(8, sizeof (std::variant<int32_t>));
1683 EXPECT_EQ(16, sizeof (std::variant<int64_t>));
1684 EXPECT_EQ(40, sizeof (std::variant<std::string>));
1685 EXPECT_EQ(40, sizeof (std::variant<std::string, std::wstring>));
1686 EXPECT_EQ(32, sizeof (std::string));
1687 EXPECT_EQ(32, sizeof (std::wstring));
1688 EXPECT_EQ(32, sizeof (Rational));
1689 EXPECT_EQ(8, sizeof (std::unique_ptr<VariableTaken>));
1690 EXPECT_EQ(16, sizeof (std::weak_ptr<Variable>));
1691 EXPECT_EQ(16, sizeof (std::shared_ptr<Variable>));
1692
1693 EXPECT_EQ(32, sizeof (VariableShared));
1694 EXPECT_EQ(32, sizeof (VariableWeak));
1695 EXPECT_EQ(40, sizeof (VariableTaken));
1696
1697
1698 EXPECT_EQ(16, sizeof (ObjPtr));
1699 EXPECT_EQ(632, sizeof (Obj));
1700
1701 EXPECT_EQ(16, sizeof (TermPtr));
1702 EXPECT_EQ(440, sizeof (Term)); // 640
1703
1704 EXPECT_EQ(1, sizeof (ObjType));
1705 EXPECT_EQ(1, sizeof (bool));
1706 EXPECT_EQ(40, sizeof (std::vector<bool>));// Битовый вектор
1707 EXPECT_EQ(24, sizeof (std::vector<char>));
1708 EXPECT_EQ(24, sizeof (std::vector<int>));
1709 EXPECT_EQ(24, sizeof (std::vector<ObjType>));
1710 EXPECT_EQ(24, sizeof (std::vector<uint8_t>));
1711 EXPECT_EQ(24, sizeof (std::vector<int64_t>));
1712 EXPECT_EQ(48, sizeof (Dict< Obj>::PairType)); // std::list<std::pair<std::string, std::shared_ptr<T>>>
1713 EXPECT_EQ(120, sizeof (Iterator < Obj>)); // !!!!!!!!!!!!
1714
1715 class ZeroClass {
1716 };
1717 class ZeroClass2 : public std::enable_shared_from_this<ZeroClass> {
1718 };
1719 class ZeroClass3 : public Dict<ZeroClass3> {
1720 };
1721 class ZeroClass4 {
1722 };
1723
1724 EXPECT_EQ(1, sizeof (ZeroClass));
1725 EXPECT_EQ(16, sizeof (ZeroClass2));
1726 EXPECT_EQ(32, sizeof (ZeroClass3)); // std::list<std::pair<std::string, std::shared_ptr<T>>>
1727 EXPECT_EQ(120, sizeof (Iterator < ZeroClass>)); // !!!!!!!!!!!!
1728 EXPECT_EQ(120, sizeof (Iterator < ZeroClass4>)); // !!!!!!!!!!!!
1729
1730
1731 ASSERT_TRUE(std::holds_alternative<int64_t>(var_int));
1732 ASSERT_NO_THROW(ASSERT_EQ(std::get<int64_t>(var_int), 123););
1733 // ASSERT_FALSE(var_int.sync);
1734
1735 ASSERT_NO_THROW(EXPECT_TRUE(var_int.is_taked()));
1736 ASSERT_NO_THROW(ASSERT_TRUE(var_int.GetValueAsBoolean()));
1737 ASSERT_NO_THROW(ASSERT_EQ(123, var_int.GetValueAsInteger()));
1738 ASSERT_NO_THROW(ASSERT_DOUBLE_EQ(123, var_int.GetValueAsNumber()));
1739
1740 Variable var_int_shared(456, "*");
1741 ASSERT_TRUE(std::holds_alternative<VariableShared> (var_int_shared)) << VariableCaseToString(var_int_shared.index());
1742 // ASSERT_FALSE(var_int.sync);
1743
1744 ASSERT_NO_THROW(EXPECT_TRUE(var_int_shared.is_taked()));
1745 ASSERT_NO_THROW(ASSERT_TRUE(var_int_shared.GetValueAsBoolean()));
1746 ASSERT_NO_THROW(ASSERT_EQ(456, var_int_shared.GetValueAsInteger()));
1747 ASSERT_NO_THROW(ASSERT_DOUBLE_EQ(456, var_int_shared.GetValueAsNumber()));
1748
1749 VariableShared temp1 = std::get<VariableShared> (var_int_shared);
1750 ASSERT_EQ(2, temp1.data.use_count());
1751 ASSERT_TRUE(std::holds_alternative<int64_t>(*temp1.data));
1752 ASSERT_NO_THROW(ASSERT_EQ(std::get<int64_t>(*temp1.data), 456););
1753 ASSERT_FALSE(temp1.sync);
1754
1755 VariableShared temp2 = std::get<VariableShared> (var_int_shared);
1756 ASSERT_EQ(3, temp1.data.use_count());
1757 ASSERT_EQ(3, temp2.data.use_count());
1758 ASSERT_TRUE(std::holds_alternative<int64_t>(*temp2.data));
1759 ASSERT_NO_THROW(ASSERT_EQ(std::get<int64_t>(*temp2.data), 456););
1760 ASSERT_FALSE(temp2.sync);
1761
1762
1763 // ASSERT_FALSE(var_int_take.owner);
1764 // ASSERT_TRUE(std::holds_alternative<std::unique_ptr < VarGuard >> (var_int_take.data)) << var_int_take.data.index();
1765 // ASSERT_NO_THROW(ASSERT_EQ(var_int_take.get<int64_t>(), 123););
1766 //
1767 //
1768 // VarData var_int_take(var_int.Take());
1769 // ASSERT_FALSE(var_int_take.owner);
1770 // ASSERT_TRUE(std::holds_alternative<std::unique_ptr < VarGuard >> (var_int_take.data)) << var_int_take.data.index();
1771 // ASSERT_NO_THROW(ASSERT_EQ(var_int_take.get<int64_t>(), 123););
1772 //
1773 // ASSERT_EQ(1, var_int.owner.use_count());
1774 // ASSERT_FALSE(std::get<std::unique_ptr < VarGuard >> (var_int_take.data)->m_is_locked);
1775 // ASSERT_FALSE(std::get<std::unique_ptr < VarGuard >> (var_int_take.data)->m_edit_mode);
1776 //
1777 // VarData var_int_copy(var_int.Copy());
1778 // ASSERT_FALSE(var_int_copy.owner);
1779 // ASSERT_TRUE(std::holds_alternative<std::shared_ptr < VarData >> (var_int_copy.data)) << var_int_copy.data.index();
1780 // ASSERT_NO_THROW(ASSERT_EQ(var_int_copy.get<int64_t>(), 123););
1781 //
1782 // ASSERT_EQ(2, var_int.owner.use_count()); // !!!!!!!!!!!!!!!!!!!!!!
1783 // ASSERT_EQ(2, std::get<std::shared_ptr < VarData >> (var_int_copy.data).use_count());
1784 //
1785 // {
1786 // VarData var_int_copy2(var_int.Copy());
1787 // ASSERT_FALSE(var_int_copy2.owner);
1788 // ASSERT_TRUE(std::holds_alternative<std::shared_ptr < VarData >> (var_int_copy2.data)) << var_int_copy2.data.index();
1789 // ASSERT_NO_THROW(ASSERT_EQ(var_int_copy2.get<int64_t>(), 123););
1790 //
1791 // ASSERT_EQ(3, var_int.owner.use_count()); // !!!!!!!!!!!!!!!!!!!!!!
1792 // ASSERT_EQ(3, std::get<std::shared_ptr < VarData >> (var_int_copy.data).use_count());
1793 // ASSERT_EQ(3, std::get<std::shared_ptr < VarData >> (var_int_copy2.data).use_count());
1794 //
1795 // VarData var_int_copy3(var_int_copy2.Copy());
1796 // ASSERT_FALSE(var_int_copy3.owner);
1797 // ASSERT_TRUE(std::holds_alternative<std::shared_ptr < VarData >> (var_int_copy3.data)) << var_int_copy3.data.index();
1798 // ASSERT_NO_THROW(ASSERT_EQ(var_int_copy3.get<int64_t>(), 123););
1799 //
1800 // ASSERT_EQ(4, var_int.owner.use_count()); // !!!!!!!!!!!!!!!!!!!!!!
1801 // ASSERT_EQ(4, std::get<std::shared_ptr < VarData >> (var_int_copy.data).use_count());
1802 // ASSERT_EQ(4, std::get<std::shared_ptr < VarData >> (var_int_copy2.data).use_count());
1803 // ASSERT_EQ(4, std::get<std::shared_ptr < VarData >> (var_int_copy3.data).use_count());
1804 // }
1805 //
1806 // VarData var_int_ref(var_int.Ref());
1807 // ASSERT_FALSE(var_int_ref.owner);
1808 // ASSERT_TRUE(std::holds_alternative<std::weak_ptr < VarData >> (var_int_ref.data)) << var_int_ref.data.index();
1809 // ASSERT_NO_THROW(ASSERT_EQ(var_int_ref.get<int64_t>(), 123););
1810 //
1811 // ASSERT_EQ(2, var_int.owner.use_count());
1812 // ASSERT_EQ(2, std::get<std::shared_ptr < VarData >> (var_int_copy.data).use_count());
1813 //
1814
1815 var_int += var_int;
1816 ASSERT_NO_THROW(ASSERT_EQ(var_int.GetValueAsInteger(), 246););
1817
1818 var_int += 5;
1819 ASSERT_NO_THROW(ASSERT_EQ(var_int.GetValueAsInteger(), 251););
1820
1821 var_int -= 10;
1822 ASSERT_NO_THROW(ASSERT_EQ(var_int.GetValueAsInteger(), 241););
1823
1824 var_int *= 100;
1825 ASSERT_NO_THROW(ASSERT_EQ(var_int.GetValueAsInteger(), 24100););
1826
1827 var_int /= 10;
1828 ASSERT_NO_THROW(ASSERT_EQ(var_int.GetValueAsInteger(), 2410););
1829
1830 var_int %= 2000;
1831 ASSERT_NO_THROW(ASSERT_EQ(var_int.GetValueAsInteger(), 410););
1832
1833
1834 Variable var_str = "";
1835 ASSERT_TRUE(std::holds_alternative<std::string>(var_str));
1836
1837 var_str += "+";
1838 ASSERT_NO_THROW(ASSERT_STREQ("+", var_str.GetValueAsString().c_str()));
1839
1840 ASSERT_EQ(2, VariableOp::iadd.size());
1841 VariableOp::OperatorType::VirtualFuncType * store = VariableOp::iadd.override(&VariableOp::__iadd_only_numbers__);
1842 ASSERT_EQ(3, VariableOp::iadd.size());
1843
1844 ASSERT_ANY_THROW(
1845 var_str += "+";
1846 );
1847
1848 VariableOp::iadd.pop_back();
1849 ASSERT_EQ(2, VariableOp::iadd.size());
1850
1851 var_str *= 3;
1852 ASSERT_NO_THROW(ASSERT_STREQ("+++", var_str.GetValueAsString().c_str()););
1853
1854
1855 // VarData var_rat(Rational(1));
1856 // ASSERT_TRUE(var_rat.owner);
1857 // ASSERT_TRUE(std::holds_alternative<Rational> (var_rat.data)) << var_rat.data.index();
1858 // ASSERT_NO_THROW(ASSERT_STREQ("1\\1", var_rat.get<Rational>().GetAsString().c_str()););
1859 //
1860 // var_rat += var_int;
1861 // ASSERT_TRUE(var_rat.owner);
1862 // ASSERT_TRUE(std::holds_alternative<Rational> (var_rat.data)) << var_rat.data.index();
1863 // ASSERT_NO_THROW(ASSERT_STREQ("247\\1", var_rat.get<Rational>().GetAsString().c_str()););
1864 // ASSERT_NO_THROW(ASSERT_STREQ("246\\1", var_int.get<Rational>().GetAsString().c_str()););
1865 //
1866 //
1867 // VarData var_num(0.123);
1868 // ASSERT_TRUE(var_num.owner);
1869 // ASSERT_TRUE(std::holds_alternative<double>(var_num.data));
1870 // ASSERT_NO_THROW(ASSERT_DOUBLE_EQ(var_num.get<double>(), 0.123););
1871 // ASSERT_NO_THROW(ASSERT_DOUBLE_EQ(var_rat.get<double>(), 247.0););
1872 //
1873 //
1874 // VarData var_str("str");
1875 // ASSERT_TRUE(var_str.owner);
1876 // ASSERT_TRUE(std::holds_alternative<std::string>(var_str.data));
1877 // ASSERT_NO_THROW(ASSERT_STREQ("str", var_str.get<std::string>().c_str()););
1878 //
1879 // VarData var_obj(Obj::CreateEmpty());
1880 // ASSERT_TRUE(var_obj.owner);
1881 // ASSERT_TRUE(std::holds_alternative<ObjPtr>(var_obj.data));
1882 // ASSERT_NO_THROW(ASSERT_TRUE(var_obj.get<ObjPtr>()););
1883 // ASSERT_NO_THROW(ASSERT_STREQ("_", var_obj.get<ObjPtr>()->toString().c_str()));
1884 //
1885 // // Convert simple type
1886 // ASSERT_NO_THROW(ASSERT_STREQ("'str'", var_str.get<ObjPtr>()->toString().c_str()));
1887 // ASSERT_NO_THROW(ASSERT_STREQ("246", var_int.get<ObjPtr>()->toString().c_str()));
1888 // ASSERT_NO_THROW(ASSERT_STREQ("247\\1", var_rat.get<ObjPtr>()->toString().c_str()));
1889 // ASSERT_NO_THROW(ASSERT_STREQ("0.123", var_num.get<ObjPtr>()->toString().c_str()));
1890
1891}
1892
1893#endif // UNITTEST
newlang::Dict::PairType
std::pair< std::string, Type > PairType
Definition dict.h:77
newlang::JIT::Run
ObjPtr Run(const std::string_view str, Obj *args=nullptr)
Definition jit.cpp:2558
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::Variable::GetValueAsObject
ObjPtr GetValueAsObject() const
Definition variable.cpp:458
result
int result
Definition lexer.l:367
newlang
Definition nlc.h:59
newlang::utf8_decode
std::wstring utf8_decode(const std::string str)
Definition variable.cpp:22
newlang::TermPtr
std::shared_ptr< Term > TermPtr
Definition variable.h:33
newlang::ObjPtr
std::shared_ptr< Obj > ObjPtr
Definition variable.h:28
newlang::RuntimePtr
std::shared_ptr< RunTime > RuntimePtr
Definition types.h:242
newlang::VariableCaseToString
const char * VariableCaseToString(size_t index)
Definition variable.h:425
newlang::ObjType
ObjType
Definition types.h:524
newlang::typeFromLimit
ObjType typeFromLimit(int64_t value, ObjType type_default=ObjType::Int64)
Definition object.cpp:3788
newlang::toString
const char * toString(TermID type)
Definition term.h:126
newlang::utf8_encode
std::string utf8_encode(const std::wstring wstr)
Definition variable.cpp:10
ConvertStringToTensor
void ConvertStringToTensor(const std::string &from, torch::Tensor &to, ObjType type=ObjType::None)
Definition object.cpp:2151
CreateTensor
ObjPtr CreateTensor(torch::Tensor tensor)
Definition object.cpp:52
newlang::VariableShared::data
std::shared_ptr< Variable > data
Definition variable.h:379
newlang::VariableShared::sync
std::shared_ptr< Sync > sync
Объект синхронизации доступа к защищённой переменной
Definition variable.h:380
warning_pop.h
warning_push.h
Generated by doxygen 1.11.0