NewLang Project
Yet another programm language
Loading...
Searching...
No Matches
alg_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#include "warning_pop.h"
6
7#include <signal.h>
8
9#include "jit.h"
10#include "runtime.h"
11
12using namespace newlang;
13
14TEST(Alg, Foreach) {
15
16 JIT * jit = JIT::ReCreate();
17 ASSERT_TRUE(jit);
18
19 ObjPtr test = Obj::CreateDict();
20
21 test->push_back(Obj::Arg(10));
22 test->push_back(Obj::Arg(11));
23 test->push_back(Obj::Arg(12));
24 test->push_back(Obj::Arg(13));
25 ASSERT_EQ(4, test->size());
26 ASSERT_EQ(10, (*test)[0].second->GetValueAsInteger());
27 ASSERT_EQ(13, (*test)[3].second->GetValueAsInteger());
28
29 ASSERT_EQ(test->resize_(4, nullptr), test->size());
30 ASSERT_EQ(4, test->size());
31 ASSERT_EQ(10, (*test)[0].second->GetValueAsInteger());
32 ASSERT_EQ(13, (*test)[3].second->GetValueAsInteger());
33
34 test->resize_(-3, nullptr);
35 ASSERT_EQ(3, test->size());
36 ASSERT_EQ(11, (*test)[0].second->GetValueAsInteger());
37 ASSERT_EQ(13, (*test)[2].second->GetValueAsInteger());
38
39 test->resize_(-1, nullptr);
40 ASSERT_EQ(1, test->size());
41 ASSERT_EQ(13, (*test)[0].second->GetValueAsInteger());
42
43 test->resize_(0, nullptr);
44 ASSERT_EQ(0, test->size());
45
46 ObjPtr counter;
47 ASSERT_NO_THROW(counter = jit->Run("counter := 100"));
48 ASSERT_TRUE(counter);
49 ASSERT_EQ(100, counter->GetValueAsInteger());
50
51 ASSERT_NO_THROW(counter = jit->Run("counter"));
52 ASSERT_TRUE(counter);
53 ASSERT_EQ(100, counter->GetValueAsInteger());
54 void *cnt_ptr = counter.get();
55
56 ObjPtr dict;
57 ASSERT_NO_THROW(dict = jit->Run("dict := (0,1,2,)"));
58 ASSERT_TRUE(dict);
59 ASSERT_TRUE(dict->is_dictionary_type());
60 ASSERT_EQ(3, dict->size());
61 ASSERT_EQ(0, (*dict)[0].second->GetValueAsInteger());
62 ASSERT_EQ(1, (*dict)[1].second->GetValueAsInteger());
63 ASSERT_EQ(2, (*dict)[2].second->GetValueAsInteger());
64
65
66 ASSERT_NO_THROW(counter = jit->Run("counter"));
67 ASSERT_EQ(100, counter->GetValueAsInteger());
68 ASSERT_EQ(cnt_ptr, counter.get());
69
70 ObjPtr temp;
71 ASSERT_NO_THROW(temp = jit->Run("counter, dict = ... dict"));
72 ASSERT_TRUE(temp);
73 ASSERT_TRUE(temp->is_dictionary_type()) << temp->toString();
74 ASSERT_EQ(2, temp->size());
75
76 ASSERT_NO_THROW(counter = jit->Run("counter"));
77 // ASSERT_EQ(cnt_ptr, counter.get());
78 ASSERT_EQ(0, counter->GetValueAsInteger());
79
80 ASSERT_TRUE(dict->is_dictionary_type());
81 ASSERT_EQ(2, dict->size());
82 ASSERT_EQ(1, (*dict)[0].second->GetValueAsInteger());
83 ASSERT_EQ(2, (*dict)[1].second->GetValueAsInteger());
84
85 ASSERT_NO_THROW(temp = jit->Run("counter, dict = ... dict"));
86 ASSERT_TRUE(temp);
87 ASSERT_TRUE(temp->is_dictionary_type());
88 ASSERT_EQ(1, temp->size());
89
90 ASSERT_NO_THROW(counter = jit->Run("counter"));
91 ASSERT_TRUE(counter);
92 ASSERT_EQ(1, counter->GetValueAsInteger());
93
94 ASSERT_TRUE(dict->is_dictionary_type());
95 ASSERT_EQ(1, dict->size());
96 ASSERT_EQ(2, (*dict)[0].second->GetValueAsInteger());
97
98 ASSERT_NO_THROW(temp = jit->Run("counter += 1"));
99 ASSERT_TRUE(temp);
100 ASSERT_EQ(2, temp->GetValueAsInteger());
101
102 ASSERT_NO_THROW(temp = jit->Run("counter += counter"));
103 ASSERT_TRUE(temp);
104 ASSERT_EQ(4, temp->GetValueAsInteger());
105
106
107 ASSERT_NO_THROW(temp = jit->Run("counter, dict = ... dict"));
108 ASSERT_TRUE(temp);
109 ASSERT_TRUE(temp->is_dictionary_type()) << temp->toString();
110 ASSERT_EQ(0, temp->size());
111
112 ASSERT_NO_THROW(counter = jit->Run("counter"));
113 ASSERT_TRUE(counter);
114 ASSERT_EQ(2, counter->GetValueAsInteger());
115
116 ASSERT_TRUE(dict->is_dictionary_type());
117 ASSERT_EQ(0, dict->size());
118
119 ASSERT_NO_THROW(temp = jit->Run("{ counter, dict = ... dict }"));
120 ASSERT_TRUE(temp);
121 ASSERT_TRUE(temp->is_dictionary_type());
122 ASSERT_TRUE(dict->is_dictionary_type());
123 ASSERT_EQ(0, dict->size());
124
125 ASSERT_NO_THROW(counter = jit->Run("counter"));
126 ASSERT_TRUE(counter);
127 ASSERT_TRUE(counter->is_none_type()) << counter->toString();
128
129
130 dict->push_back(Obj::Arg(10));
131 dict->push_back(Obj::Arg(20));
132 dict->push_back(Obj::Arg(30));
133 dict->push_back(Obj::Arg(40));
134 dict->push_back(Obj::Arg(50));
135 ASSERT_EQ(5, dict->size());
136
137 ASSERT_NO_THROW(temp = jit->Run("dict"));
138 ASSERT_TRUE(temp);
139 ASSERT_TRUE(temp->is_dictionary_type());
140 ASSERT_FALSE(temp->is_scalar());
141 ASSERT_TRUE(temp->GetValueAsBoolean());
142 ASSERT_EQ(5, temp->size());
143
144 void *ptr_dict = temp.get();
145
146 ASSERT_NO_THROW(temp = jit->Run(":Bool[...](dict)"));
147 ASSERT_TRUE(temp);
148 ASSERT_TRUE(temp->is_bool_type());
149 ASSERT_FALSE(temp->is_scalar());
150 ASSERT_TRUE(temp->GetValueAsBoolean());
151 ASSERT_EQ(5, temp->size());
152
153 ASSERT_NO_THROW(temp = jit->Run(":Bool[_](dict)"));
154 ASSERT_TRUE(temp);
155 ASSERT_TRUE(temp->is_bool_type());
156 ASSERT_FALSE(temp->is_scalar());
157 ASSERT_TRUE(temp->GetValueAsBoolean());
158 ASSERT_EQ(5, temp->size());
159
160 ASSERT_NO_THROW(temp = jit->Run(":Bool[0](dict)"));
161 ASSERT_TRUE(temp);
162 ASSERT_TRUE(temp->is_bool_type());
163 ASSERT_TRUE(temp->is_scalar());
164 ASSERT_TRUE(temp->GetValueAsBoolean());
165 ASSERT_EQ(0, temp->size());
166
167 ASSERT_NO_THROW(temp = jit->Run(":Bool(dict)"));
168 ASSERT_TRUE(temp);
169 ASSERT_TRUE(temp->is_bool_type());
170 ASSERT_TRUE(temp->is_scalar());
171 ASSERT_TRUE(temp->GetValueAsBoolean());
172 ASSERT_EQ(0, temp->size());
173
174 ASSERT_NO_THROW(temp = jit->Run("@not(dict)"));
175 ASSERT_TRUE(temp);
176 ASSERT_TRUE(temp->is_bool_type());
177 ASSERT_FALSE(temp->GetValueAsBoolean());
178
179 ASSERT_NO_THROW(temp = jit->Run("dict"));
180 ASSERT_TRUE(temp);
181 ASSERT_EQ(ptr_dict, temp.get());
182 ASSERT_STREQ("(10, 20, 30, 40, 50,)", temp->toString().c_str());
183
184 ObjPtr summa;
185 ASSERT_NO_THROW(summa = jit->Run("::summa := 0"));
186 ASSERT_STREQ("0", summa->toString().c_str());
187 ASSERT_NO_THROW(summa = jit->Run("summa += 100"));
188 ASSERT_STREQ("100", summa->toString().c_str());
189
190 ASSERT_NO_THROW(temp = jit->Run(":Bool[...]( (1,) )"));
191 ASSERT_STREQ("[1,]:Bool", temp->toString().c_str());
192 ASSERT_NO_THROW(temp = jit->Run(":Bool( (1,) )"));
193 ASSERT_STREQ("1", temp->toString().c_str());
194
195 ASSERT_NO_THROW(temp = jit->Run(":Bool[...]( (1,) )"));
196 ASSERT_STREQ("[1,]:Bool", temp->toString().c_str());
197 ASSERT_NO_THROW(temp = jit->Run(":Bool( (1,) )"));
198 ASSERT_STREQ("1", temp->toString().c_str());
199
200 ASSERT_NO_THROW(temp = jit->Run(":Bool[...]( (0,) )"));
201 ASSERT_STREQ("[0,]:Bool", temp->toString().c_str());
202 ASSERT_NO_THROW(temp = jit->Run(":Bool( (0,) )"));
203 ASSERT_STREQ("1", temp->toString().c_str());
204
205 ASSERT_ANY_THROW(temp = jit->Run(":Bool[...]( (,) )"));
206 ASSERT_ANY_THROW(temp = jit->Run(":Bool[_]( (,) )"));
207 ASSERT_NO_THROW(temp = jit->Run(":Bool( (,) )"));
208 ASSERT_STREQ("0", temp->toString().c_str());
209
210
211 ASSERT_NO_THROW(summa = jit->Run("summa"));
212 ASSERT_STREQ("100", summa->toString().c_str());
213
214 ASSERT_NO_THROW(temp = jit->Run("counter = 0; [dict] <-> {counter, dict := ... dict; summa += counter}")) << jit->Dump("*dict*;*count*");
215
216 ASSERT_NO_THROW(summa = jit->Run("summa"));
217 ASSERT_STREQ("250", summa->toString().c_str());
218
219 ASSERT_NO_THROW(temp = jit->Run("counter"));
220 ASSERT_TRUE(temp);
221 ASSERT_TRUE(temp->is_integer());
222 ASSERT_STREQ("50", temp->toString().c_str());
223
224 ASSERT_TRUE(dict->is_dictionary_type());
225 ASSERT_EQ(0, dict->size());
226
227
228 ASSERT_NO_THROW(dict = jit->Run("dict := (0,1,2,3,4,)"));
229 // ASSERT_EQ(ptr_dict, dict.get());
230 ASSERT_STREQ("(0, 1, 2, 3, 4,)", dict->toString().c_str());
231
232
233 ASSERT_NO_THROW(temp = jit->Run("dict"));
234 // ASSERT_EQ(ptr_dict, temp.get());
235 ASSERT_STREQ("(0, 1, 2, 3, 4,)", temp->toString().c_str());
236
237 ObjPtr item;
238 ASSERT_NO_THROW(item = jit->Run("item := 0"));
239 ASSERT_EQ(0, item->GetValueAsInteger());
240 ASSERT_NO_THROW(item = jit->Run("item, dict := ... dict; item"));
241 ASSERT_EQ(0, item->GetValueAsInteger());
242
243 ASSERT_NO_THROW(temp = jit->Run("dict"));
244 // ASSERT_EQ(ptr_dict, temp.get());
245 ASSERT_STREQ("(1, 2, 3, 4,)", temp->toString().c_str());
246
247 ASSERT_NO_THROW(item = jit->Run("item, dict := ... dict; item"));
248 ASSERT_EQ(1, item->GetValueAsInteger());
249
250 ASSERT_NO_THROW(temp = jit->Run("dict"));
251 // ASSERT_EQ(ptr_dict, temp.get());
252 ASSERT_STREQ("(2, 3, 4,)", temp->toString().c_str());
253
254 ASSERT_NO_THROW(item = jit->Run("item, dict := ... dict; item"));
255 ASSERT_EQ(2, item->GetValueAsInteger());
256
257
258 ASSERT_NO_THROW(summa = jit->Run("sum := 0"));
259 ASSERT_TRUE(summa);
260 ASSERT_STREQ("0", summa->toString().c_str());
261 ASSERT_NO_THROW(summa = jit->Run("sum += 1"));
262 ASSERT_TRUE(summa);
263 ASSERT_STREQ("1", summa->toString().c_str());
264 ASSERT_NO_THROW(summa = jit->Run("sum += 2"));
265 ASSERT_TRUE(summa);
266 ASSERT_STREQ("3", summa->toString().c_str());
267
268 ASSERT_NO_THROW(temp = jit->Run("dict"));
269 // ASSERT_EQ(ptr_dict, temp.get());
270 ASSERT_STREQ("(3, 4,)", temp->toString().c_str());
271
272 ObjPtr cnt;
273 ASSERT_NO_THROW(dict = jit->Run("dict := (0,1,2,3,4,)"));
274 ASSERT_NO_THROW(temp = jit->Run("dict"));
275 // ASSERT_EQ(ptr_dict, temp.get());
276 ASSERT_STREQ("(0, 1, 2, 3, 4,)", temp->toString().c_str());
277
278 LOG_DEBUG("\n\n\n");
279
280 ASSERT_NO_THROW(temp = jit->Run("val::=1; item := 0; [dict] <-> {item, dict := ... dict; print('Sum: %s, Item: %s\\n', :StrChar(sum), :StrChar(item)); sum += item}")) << jit->Dump("*print*");
281 ASSERT_TRUE(temp);
282 ASSERT_STREQ("13", temp->GetValueAsString().c_str());
283
284 ASSERT_NO_THROW(summa = jit->Run("item"));
285 ASSERT_EQ(4, summa->GetValueAsInteger());
286
287 ASSERT_NO_THROW(summa = jit->Run("sum"));
288 ASSERT_EQ(13, summa->GetValueAsInteger());
289
290
291
292
293
294 ASSERT_NO_THROW(counter = jit->Run("counter := 55"));
295 ASSERT_EQ(55, counter->GetValueAsInteger());
296
297 ObjPtr tensor;
298 ASSERT_NO_THROW(tensor = jit->Run("tensor := [10,11,12,]"));
299 ASSERT_TRUE(tensor);
300 ASSERT_TRUE(tensor->is_tensor_type());
301 ASSERT_TRUE(tensor->GetValueAsBoolean());
302 ASSERT_EQ(3, tensor->size());
303 ASSERT_EQ(10, (*tensor)[0].second->GetValueAsInteger());
304 ASSERT_EQ(11, (*tensor)[1].second->GetValueAsInteger());
305 ASSERT_EQ(12, (*tensor)[2].second->GetValueAsInteger());
306
307 ASSERT_NO_THROW(temp = jit->Run("counter, tensor := ... tensor "));
308 ASSERT_TRUE(temp);
309 ASSERT_TRUE(temp->is_tensor_type());
310 ASSERT_EQ(2, temp->size());
311
312 ASSERT_NO_THROW(counter = jit->Run("counter"));
313 ASSERT_EQ(10, counter->GetValueAsInteger());
314
315 ASSERT_TRUE(tensor->is_tensor_type());
316 ASSERT_TRUE(tensor->GetValueAsBoolean());
317 ASSERT_EQ(2, tensor ->size());
318 ASSERT_EQ(11, (*tensor)[0].second->GetValueAsInteger());
319 ASSERT_EQ(12, (*tensor)[1].second->GetValueAsInteger());
320
321 ASSERT_NO_THROW(temp = jit->Run("counter, tensor := ... tensor "));
322 ASSERT_TRUE(temp);
323 ASSERT_TRUE(temp->is_tensor_type());
324 ASSERT_EQ(1, temp->size());
325
326 ASSERT_NO_THROW(counter = jit->Run("counter"));
327 ASSERT_EQ(11, counter->GetValueAsInteger());
328
329 ASSERT_TRUE(tensor->is_tensor_type());
330 ASSERT_TRUE(tensor->GetValueAsBoolean());
331 ASSERT_EQ(1, tensor ->size());
332 ASSERT_EQ(12, (*tensor)[0].second->GetValueAsInteger());
333
334 ASSERT_NO_THROW(temp = jit->Run("counter, tensor := ... tensor "));
335 ASSERT_TRUE(temp);
336 ASSERT_TRUE(temp->is_none_type());
337
338 ASSERT_NO_THROW(counter = jit->Run("counter"));
339 ASSERT_EQ(12, counter->GetValueAsInteger());
340
341 ASSERT_TRUE(tensor->is_none_type());
342 ASSERT_FALSE(tensor->GetValueAsBoolean());
343
344 ASSERT_ANY_THROW(temp = jit->Run("counter, tensor := ... tensor"));
345 // ASSERT_TRUE(temp);
346 // ASSERT_TRUE(temp->is_tensor_type());
347 // ASSERT_TRUE(temp->empty());
348 // ASSERT_FALSE(tensor->GetValueAsBoolean());
349 // ASSERT_TRUE(tensor->is_tensor_type());
350 // ASSERT_TRUE(tensor->empty());
351
352 ASSERT_NO_THROW(counter = jit->Run("counter"));
353 ASSERT_TRUE(counter);
354 ASSERT_TRUE(counter->empty());
355
356
357 ObjPtr summa2;
358 ObjPtr tensor2;
359 ObjPtr temp2;
360
361 ASSERT_NO_THROW(jit->Run("item2 := 0"));
362 ASSERT_NO_THROW(summa2 = jit->Run("summa := 0"));
363 ASSERT_NO_THROW(tensor2 = jit->Run("tensor := [10,20,30,40,50,60,]"));
364 ASSERT_NO_THROW(temp2 = jit->Run("[tensor] <-> {item2, tensor := ... tensor; summa += item2}"));
365 ASSERT_TRUE(temp2);
366 ASSERT_EQ(210, temp2->GetValueAsInteger()) << temp2->toString();
367
368 ASSERT_NO_THROW(summa2 = jit->Run("summa"));
369 ASSERT_EQ(210, summa2->GetValueAsInteger());
370
371 ASSERT_NO_THROW(temp2 = jit->Run("item2"));
372 ASSERT_EQ(60, temp2->GetValueAsInteger());
373
374 ASSERT_NO_THROW(tensor2 = jit->Run("tensor"));
375 ASSERT_TRUE(tensor2->is_none_type());
376 ASSERT_FALSE(tensor2->GetValueAsBoolean());
377
378 ObjPtr tensor_size;
379 ASSERT_NO_THROW(tensor_size = jit->Run("tensor_size := [10,20,30,40,]"));
380 ASSERT_EQ(4, tensor_size->size());
381 ASSERT_EQ(10, (*tensor_size)[0].second->GetValueAsInteger());
382 ASSERT_EQ(40, (*tensor_size)[3].second->GetValueAsInteger());
383
384 tensor_size->resize_(-10, nullptr);
385 ASSERT_EQ(10, tensor_size->size());
386 ASSERT_EQ(0, (*tensor_size)[0].second->GetValueAsInteger());
387 ASSERT_EQ(0, (*tensor_size)[5].second->GetValueAsInteger());
388 ASSERT_EQ(10, (*tensor_size)[6].second->GetValueAsInteger());
389 ASSERT_EQ(40, (*tensor_size)[9].second->GetValueAsInteger());
390
391}
392
393TEST(Alg, Repeat) {
394
395 JIT * jit = JIT::ReCreate();
396 ASSERT_TRUE(jit);
397
398 ObjPtr result = nullptr;
399
400 ASSERT_NO_THROW(result = jit->Run("result := 0"));
401 ASSERT_TRUE(result);
402 ASSERT_EQ(0, result->GetValueAsInteger());
403
404 ObjPtr cond;
405 ASSERT_NO_THROW(cond = jit->Run("result < 4"));
406 ASSERT_TRUE(cond);
407 ASSERT_TRUE(cond->GetValueAsBoolean());
408
409 ASSERT_NO_THROW(result = jit->Run("result += 1"));
410 ASSERT_TRUE(result);
411 ASSERT_EQ(1, result->GetValueAsInteger());
412
413 ASSERT_NO_THROW(cond = jit->Run("result < 4"));
414 ASSERT_TRUE(cond);
415 ASSERT_TRUE(cond->GetValueAsBoolean());
416
417 ASSERT_NO_THROW(result = jit->Run("result += 3"));
418 ASSERT_TRUE(result);
419 ASSERT_EQ(4, result->GetValueAsInteger());
420
421 ASSERT_NO_THROW(cond = jit->Run("result < 4"));
422 ASSERT_TRUE(cond);
423 ASSERT_FALSE(cond->GetValueAsBoolean());
424
425
426 ObjPtr counter;
427 ASSERT_NO_THROW(counter = jit->Run("counter := 0"));
428 ASSERT_EQ(0, counter->GetValueAsInteger());
429
430 ASSERT_EQ(4, result->GetValueAsInteger());
431 ASSERT_NO_THROW(result = jit->Run("result -= 1"));
432 ASSERT_EQ(3, result->GetValueAsInteger());
433
434 ASSERT_NO_THROW(counter = jit->Run("[result -= 1] <-> {counter += 1}"));
435 ASSERT_TRUE(counter);
436 ASSERT_EQ(2, counter->GetValueAsInteger());
437
438 ASSERT_NO_THROW(counter = jit->Run("counter"));
439 ASSERT_EQ(2, counter->GetValueAsInteger());
440
441
442
443 ASSERT_NO_THROW(counter = jit->Run("{result += 1; counter += 1} <-> [result < 10]"));
444 ASSERT_EQ(10, result->GetValueAsInteger());
445
446 ASSERT_TRUE(counter);
447 ASSERT_EQ(12, counter->GetValueAsInteger());
448
449 ASSERT_NO_THROW(counter = jit->Run("counter"));
450 ASSERT_EQ(12, counter->GetValueAsInteger());
451
452 ASSERT_NO_THROW(counter = jit->Run("result"));
453 ASSERT_EQ(10, counter->GetValueAsInteger());
454
455}
456
457TEST(Alg, Follow) {
458
459 JIT * jit = JIT::ReCreate();
460 ASSERT_TRUE(jit);
461
462 ObjPtr result = nullptr;
463
464 ASSERT_NO_THROW(result = jit->Run("[1]-->100"));
465 ASSERT_TRUE(result);
466 ASSERT_EQ(100, result->GetValueAsInteger());
467
468 ASSERT_NO_THROW(result = jit->Run("[-1]-->99"));
469 ASSERT_TRUE(result);
470 ASSERT_EQ(99, result->GetValueAsInteger());
471
472 ASSERT_NO_THROW(result = jit->Run("[0]-->111"));
473 ASSERT_TRUE(result);
474 ASSERT_TRUE(result->is_none_type());
475
476 ASSERT_NO_THROW(result = jit->Run("[1]-->111"));
477 ASSERT_TRUE(result);
478 ASSERT_EQ(111, result->GetValueAsInteger());
479
480
481
482 ASSERT_NO_THROW(result = jit->Run("[0]-->100,[1]-->300"));
483 ASSERT_TRUE(result);
484 ASSERT_EQ(300, result->GetValueAsInteger());
485
486 ASSERT_NO_THROW(result = jit->Run("[0]-->100,[0]-->300,[99]-->99,[...]-->1000"));
487 ASSERT_TRUE(result);
488 ASSERT_EQ(99, result->GetValueAsInteger());
489
490 ASSERT_NO_THROW(result = jit->Run("[0]-->111,[...]-->1000"));
491 ASSERT_TRUE(result);
492 ASSERT_EQ(1000, result->GetValueAsInteger());
493
494 ASSERT_NO_THROW(result = jit->Run("[0]-->{100},[1]-->{10;20;30}"));
495 ASSERT_TRUE(result);
496 ASSERT_EQ(30, result->GetValueAsInteger());
497
498 ASSERT_NO_THROW(result = jit->Run("[0]-->{100},[0]-->{300},[99]-->{99},[...]-->{1000}"));
499 ASSERT_TRUE(result);
500 ASSERT_EQ(99, result->GetValueAsInteger());
501
502 ASSERT_NO_THROW(result = jit->Run("[0]-->111,[...]-->{30;50;1000}"));
503 ASSERT_TRUE(result);
504 ASSERT_EQ(1000, result->GetValueAsInteger());
505
506
507 ASSERT_NO_THROW(result = jit->Run("cond := 100; [cond]-->111,[...]-->1000"));
508 ASSERT_TRUE(result);
509 ASSERT_EQ(111, result->GetValueAsInteger());
510
511 ASSERT_NO_THROW(result = jit->Run("cond2 := 0; [cond2]-->111,[...]-->1000"));
512 ASSERT_TRUE(result);
513 ASSERT_EQ(1000, result->GetValueAsInteger());
514
515 ASSERT_NO_THROW(result = jit->Run("val := 1\\1; [val == 1]-->111,[...]-->1000"));
516 ASSERT_TRUE(result);
517 ASSERT_EQ(111, result->GetValueAsInteger());
518
519 ASSERT_NO_THROW(result = jit->Run("val := 1\\1; [val < 0]-->111,[...]-->1000"));
520 ASSERT_TRUE(result);
521 ASSERT_EQ(1000, result->GetValueAsInteger());
522
523 ASSERT_NO_THROW(result = jit->Run("val := 1\\1; [val > 0]-->{111},[...]-->1000"));
524 ASSERT_TRUE(result);
525 ASSERT_EQ(111, result->GetValueAsInteger());
526}
527
528TEST(Alg, Return) {
529
530 JIT * jit = JIT::ReCreate();
531 ASSERT_TRUE(jit);
532
533 ObjPtr result = nullptr;
534 ObjPtr value = nullptr;
535
536 try {
537 ASSERT_ANY_THROW(result = jit->Run("--"));
538 } catch (IntMinus &except) {
539 ASSERT_TRUE(except);
540 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(except.getType());
541 ASSERT_TRUE(except.m_return_obj);
542 ASSERT_TRUE(except.m_return_obj->is_none_type());
543 }
544 ASSERT_FALSE(result);
545
546 try {
547 ASSERT_ANY_THROW(result = jit->Run(":: --"));
548 } catch (IntAny &except) {
549 ASSERT_TRUE(except);
550 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(result->getType());
551 ASSERT_STREQ("::", except.m_value.c_str());
552 ASSERT_TRUE(except.m_return_obj);
553 ASSERT_TRUE(except.m_return_obj->is_none_type());
554 }
555 result = nullptr;
556
557 try {
558 ASSERT_ANY_THROW(result = jit->Run("--100--"));
559 } catch (IntMinus &except) {
560 ASSERT_TRUE(except);
561 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(except.getType());
562 ASSERT_TRUE(except.m_return_obj);
563 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
564 }
565 ASSERT_FALSE(result);
566
567 try {
568 ASSERT_ANY_THROW(result = jit->Run(":: --100--"));
569 } catch (IntAny &except) {
570 ASSERT_TRUE(except);
571 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
572 ASSERT_STREQ("::", except.m_value.c_str());
573 ASSERT_TRUE(except.m_return_obj);
574 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
575 }
576 result = nullptr;
577
578
579
580 try {
581 ASSERT_ANY_THROW(result = jit->Run("++"));
582 } catch (IntPlus &except) {
583 ASSERT_TRUE(except);
584 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
585 ASSERT_STREQ("::", except.m_value.c_str());
586 ASSERT_TRUE(except.m_return_obj);
587 ASSERT_TRUE(except.m_return_obj->is_none_type());
588 }
589 ASSERT_FALSE(result);
590
591 try {
592 ASSERT_ANY_THROW(result = jit->Run(":: ++"));
593 } catch (IntAny &except) {
594 ASSERT_TRUE(except);
595 ASSERT_STREQ("::", except.m_value.c_str());
596 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
597 ASSERT_TRUE(except.m_return_obj);
598 ASSERT_TRUE(except.m_return_obj->is_none_type());
599 }
600 result = nullptr;
601
602 try {
603 ASSERT_ANY_THROW(result = jit->Run("++100++"));
604 } catch (IntPlus &except) {
605 ASSERT_TRUE(except);
606 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
607 ASSERT_TRUE(except.m_return_obj);
608 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
609 }
610 ASSERT_FALSE(result);
611
612 try {
613 ASSERT_ANY_THROW(result = jit->Run(":: ++100++"));
614 } catch (IntAny &except) {
615 ASSERT_TRUE(except);
616 ASSERT_EQ(ObjType::RetPlus, except.getType()) << newlang::toString(except.getType());
617 ASSERT_TRUE(except.m_return_obj);
618 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
619 }
620 result = nullptr;
621
622
623
624
625
626 try {
627 ASSERT_ANY_THROW(result = jit->Run("{ -- }"));
628 } catch (IntMinus &except) {
629 ASSERT_TRUE(except);
630 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(except.getType());
631 ASSERT_TRUE(except.m_return_obj);
632 ASSERT_TRUE(except.m_return_obj->is_none_type());
633 }
634 ASSERT_FALSE(result);
635
636 try {
637 ASSERT_NO_THROW(result = jit->Run("ns{ ns ++ }"));
638 ASSERT_TRUE(result);
639 ASSERT_TRUE(result->is_none_type()) << result->toString();
640 } catch (IntAny &except) {
641 ASSERT_TRUE(0);
642 }
643 result = nullptr;
644
645 try {
646 ASSERT_NO_THROW(result = jit->Run("ns{ { ns ++ } }"));
647 ASSERT_TRUE(result);
648 ASSERT_TRUE(result->is_none_type()) << result->toString();
649 } catch (IntAny &except) {
650 ASSERT_TRUE(0);
651 }
652 result = nullptr;
653
654
655 try {
656 ASSERT_ANY_THROW(result = jit->Run("{ ++100++; 200 }"));
657 } catch (IntPlus &except) {
658 ASSERT_TRUE(except);
659 ASSERT_EQ(ObjType::RetMinus, except.getType()) << newlang::toString(except.getType());
660 ASSERT_TRUE(except.m_return_obj);
661 ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
662 }
663 ASSERT_FALSE(result);
664
665 try {
666 ASSERT_NO_THROW(result = jit->Run("ns { ns ++100++; 200}"));
667 ASSERT_TRUE(result);
668 ASSERT_STREQ("100", result->toString().c_str());
669 } catch (IntAny &except) {
670 ASSERT_TRUE(0);
671 }
672 result = nullptr;
673
674 try {
675 ASSERT_NO_THROW(result = jit->Run("br:= 5; ns { br+=1; [br>10]--> ns:: ++ br ++; ns:: --br--; 200 }"));
676 ASSERT_TRUE(result);
677 ASSERT_STREQ("11", result->toString().c_str());
678 } catch (IntAny &except) {
679 ASSERT_TRUE(0);
680 }
681 result = nullptr;
682
683
684
685
686
687 // try {
688 // ASSERT_NO_THROW(result = jit->Run("{ ++100++ }"));
689 // } catch (Return &except) {
690 // ASSERT_TRUE(except);
691 // ASSERT_EQ(ObjType::RetPlus, except.getType());
692 // ASSERT_TRUE(except.m_return_obj);
693 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
694 // }
695 // ASSERT_FALSE(result);
696 //
697 // try {
698 // ASSERT_NO_THROW(result = jit->Run("{- ++100++ -}"));
699 // } catch (Return &except) {
700 // ASSERT_TRUE(except);
701 // ASSERT_EQ(ObjType::RetPlus, except.getType());
702 // ASSERT_TRUE(except.m_return_obj);
703 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
704 // }
705 // ASSERT_FALSE(result);
706 //
707 // try {
708 // ASSERT_NO_THROW(result = jit->Run("--'Тест'--"));
709 // } catch (Return &except) {
710 // ASSERT_TRUE(except);
711 // ASSERT_EQ(ObjType::RetMinus, except.getType());
712 // ASSERT_TRUE(except.m_return_obj);
713 // ASSERT_STREQ("'Тест'", except.m_return_obj->toString().c_str());
714 // }
715 // ASSERT_FALSE(result);
716 //
717 // try {
718 // ASSERT_NO_THROW(result = jit->Run("--:Int32--"));
719 // } catch (Return &except) {
720 // ASSERT_TRUE(except);
721 // ASSERT_EQ(ObjType::RetMinus, except.getType());
722 // ASSERT_TRUE(except.m_return_obj);
723 // ASSERT_EQ(ObjType::Type, except.m_return_obj->getType()) << toString(except.m_return_obj->getType());
724 // ASSERT_EQ(ObjType::Int32, except.m_return_obj->m_var_type_fixed) << toString(except.m_return_obj->m_var_type_fixed);
725 // }
726 // ASSERT_FALSE(result);
727 //
728 // try {
729 // ASSERT_NO_THROW(result = jit->Run("{ --:Int32-- }"));
730 // } catch (Return &except) {
731 // ASSERT_TRUE(except);
732 // ASSERT_EQ(ObjType::RetMinus, except.getType());
733 // ASSERT_TRUE(except.m_return_obj);
734 // ASSERT_EQ(ObjType::Type, except.m_return_obj->getType()) << toString(except.m_return_obj->getType());
735 // ASSERT_EQ(ObjType::Int32, except.m_return_obj->m_var_type_fixed) << toString(except.m_return_obj->m_var_type_fixed);
736 // }
737 // ASSERT_FALSE(result);
738 //
739 // try {
740 // ASSERT_NO_THROW(result = jit->Run("{+ --:Int32-- +}"));
741 // } catch (Return &except) {
742 // ASSERT_TRUE(except);
743 // ASSERT_EQ(ObjType::RetMinus, except.getType());
744 // ASSERT_TRUE(except.m_return_obj);
745 // ASSERT_EQ(ObjType::Type, except.m_return_obj->getType()) << toString(except.m_return_obj->getType());
746 // ASSERT_EQ(ObjType::Int32, except.m_return_obj->m_var_type_fixed) << toString(except.m_return_obj->m_var_type_fixed);
747 // }
748 // ASSERT_FALSE(result);
749 //
750 // try {
751 // ASSERT_NO_THROW(result = jit->Run("--:Error()--"));
752 // } catch (Return &except) {
753 // ASSERT_TRUE(except);
754 // ASSERT_EQ(ObjType::RetMinus, except.getType());
755 // ASSERT_TRUE(except.m_return_obj);
756 // ASSERT_EQ(ObjType::Error, except.m_return_obj->getType());
757 // ASSERT_STREQ(":Error()", except.m_return_obj->toString().c_str()) << except.m_return_obj->toString();
758 // }
759 // ASSERT_FALSE(result);
760 //
761 //
762 // try {
763 // ASSERT_NO_THROW(result = jit->Run("--:Error('ТЕКСТ')--"));
764 // } catch (Return &except) {
765 // ASSERT_TRUE(except);
766 // ASSERT_EQ(ObjType::RetMinus, except.getType());
767 // ASSERT_TRUE(except.m_return_obj);
768 // ASSERT_STREQ(":RetMinus(:Error('ТЕКСТ'))", except.toString().c_str());
769 // ASSERT_STREQ(":Error('ТЕКСТ')", except.m_return_obj->toString().c_str());
770 // }
771 // ASSERT_FALSE(result);
772 //
773 //
774 // try {
775 // ASSERT_NO_THROW(result = jit->Run("[1]--> ++100++"));
776 // } catch (Return &except) {
777 // ASSERT_TRUE(except);
778 // ASSERT_EQ(ObjType::RetPlus, except.getType()) << toString(except.getType());
779 // ASSERT_TRUE(except.m_return_obj);
780 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
781 // }
782 // ASSERT_FALSE(result);
783 //
784 // try {
785 // ASSERT_NO_THROW(result = jit->Run("[1]-->{ ++100++ }"));
786 // } catch (Return &except) {
787 // ASSERT_TRUE(except);
788 // ASSERT_EQ(ObjType::RetPlus, except.getType());
789 // ASSERT_TRUE(except.m_return_obj);
790 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
791 // }
792 // ASSERT_FALSE(result);
793 //
794 // try {
795 // ASSERT_NO_THROW(result = jit->Run("[1]-->{- ++100++ -}"));
796 // } catch (Return &except) {
797 // ASSERT_TRUE(except);
798 // ASSERT_EQ(ObjType::RetPlus, except.getType());
799 // ASSERT_TRUE(except.m_return_obj);
800 // ASSERT_STREQ("100", except.m_return_obj->toString().c_str());
801 // }
802 // ASSERT_FALSE(result);
803 //
804 //
805 // result.reset();
806 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{count := 1; count += 1; count += 1; count += 1; count += 1;};")););
807 // ASSERT_TRUE(result);
808 // ASSERT_TRUE(result->is_integer()) << toString(result->getType());
809 // ASSERT_EQ(5, result->GetValueAsInteger());
810 //
811 // result.reset();
812 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{count := 1; count += 1; count += 1; count += 1; count += 1;}; 99")););
813 // ASSERT_TRUE(result);
814 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str();
815 // ASSERT_EQ(99, result->GetValueAsInteger());
816 //
817 // result.reset();
818 // ASSERT_ANY_THROW(ASSERT_NO_THROW(result = jit->Run("{count := 1; count += 1; count += 1; --55--; count += 1; count += 1;}; 5555")););
819 // ASSERT_FALSE(result);
820 //
821 // result.reset();
822 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{- count := 1; count += 1; count += 1; --77--; count += 1; count += 1; -}", nullptr, Context::CatchType::CATCH_ALL););
823 // ASSERT_TRUE(result);
824 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str();
825 // ASSERT_EQ(77, result->GetValueAsInteger());
826 //
827 // result.reset();
828 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{-count := 1; count += 1; count += 1; --77--; count += 1; count += 1;-}; 7777")););
829 // ASSERT_TRUE(result);
830 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str();
831 // ASSERT_EQ(7777, result->GetValueAsInteger());
832 //
833 // result.reset();
834 // ASSERT_ANY_THROW(ASSERT_NO_THROW(result = jit->Run("{ {count := 1; count += 1; count += 1; --:Error(88)--; count += 1; count += 1}; 8888; }")););
835 // ASSERT_FALSE(result);
836 //
837 // result.reset();
838 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {+count := 1; count += 1; count += 1; ++:Error(99)++; count += 1; count += 1+}; 888}")););
839 // ASSERT_TRUE(result);
840 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str();
841 // ASSERT_EQ(888, result->GetValueAsInteger());
842 //
843 // result.reset();
844 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {+count := 1; count += 1; count += 1; ++:Error(99)++; count += 1; count += 1+}; }")););
845 // ASSERT_TRUE(result);
846 // ASSERT_EQ(1, result->size()) << result->toString().c_str();
847 // ASSERT_EQ(99, (*result)[0].second->GetValueAsInteger()) << result->toString().c_str();
848 //
849 // result.reset();
850 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {-count := 1; count += 1; count += 1; --:Error(33)--; count += 1; count += 1-}; }")););
851 // ASSERT_TRUE(result);
852 // ASSERT_EQ(1, result->size()) << result->toString().c_str();
853 // ASSERT_EQ(33, (*result)[0].second->GetValueAsInteger()) << result->toString().c_str();
854 //
855 // result.reset();
856 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {*count := 1; count += 1; count += 1; --:Error(44)--; count += 1; count += 1*}; 9999; }")););
857 // ASSERT_TRUE(result);
858 // ASSERT_EQ(9999, result->GetValueAsInteger()) << result->toString().c_str();
859 //
860 // result.reset();
861 // // Не должен перехватытвать другой класс объекта
862 // ASSERT_ANY_THROW(ASSERT_NO_THROW(result = jit->Run("{ {*count := 1; count += 1; count += 1; --:Error(55)--; count += 1; count += 1*}:ErrorRunTime; }")););
863 // ASSERT_FALSE(result);
864 //
865 //
866 // ObjPtr test_err = ctx.m_runtime->GetTypeFromString(":Error"));
867 // ASSERT_TRUE(test_err->op_class_test(":Error", &ctx));
868 // ASSERT_FALSE(test_err->op_class_test(":ErrorRunTime", &ctx));
869 //
870 // ObjPtr test_rt = ctx.m_runtime->GetTypeFromString(":ErrorRunTime"));
871 // ASSERT_TRUE(test_rt->op_class_test(":ErrorRunTime", &ctx));
872 // ASSERT_TRUE(test_rt->op_class_test(":Error", &ctx));
873 //
874 // // result.reset();
875 // // // Не должен перехватытвать другой класс объекта, но его перехватывает внешний блок
876 // // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{* {*count := 1; count += 1; count += 1; --:Error(66)--; count += 1; count += 1*}:ErrorRunTime; 777; *}")););
877 // // ASSERT_TRUE(result);
878 // // ASSERT_TRUE(result->is_error());
879 // // ASSERT_STREQ(":RetMinus(:Error(66))", result->toString().c_str());
880 //
881 //
882 // result.reset();
883 // // Должен перехватытвать прерывание и вернуть его как обычный объект без исключения из внешнего блока
884 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {*count := 1; count += 1; count += 1; --:ErrorRunTime(77)--; count += 1; count += 1*}:ErrorRunTime }")););
885 // ASSERT_TRUE(result);
886 // ASSERT_EQ(1, result->size());
887 // ASSERT_EQ(77, (*result)[0].second->GetValueAsInteger());
888 //
889 // result.reset();
890 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{ {*count := 1; count += 1; count += 1; --:ErrorRunTime(88)--; count += 1; count += 1*}:ErrorRunTime; 9999; }")););
891 // ASSERT_TRUE(result);
892 // ASSERT_EQ(9999, result->GetValueAsInteger());
893 //
894 // result.reset();
895 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{{*count := 1; count += 1; count += 1; --:ErrorRunTime(77)--; count += 1; count += 1*}:Error }")););
896 // ASSERT_TRUE(result);
897 // ASSERT_EQ(1, result->size());
898 // ASSERT_EQ(77, (*result)[0].second->GetValueAsInteger());
899 //
900 // result.reset();
901 // ASSERT_NO_THROW(ASSERT_NO_THROW(result = jit->Run("{{*count := 1; count += 1; count += 1; --:ErrorRunTime(88)--; count += 1; count += 1*}:Error; 9999; }")););
902 // ASSERT_TRUE(result);
903 // ASSERT_EQ(9999, result->GetValueAsInteger());
904}
905
906TEST(Alg, DISABLED_BreakContinue) {
907 JIT * jit = JIT::ReCreate();
908 ASSERT_TRUE(jit);
909
910 const char * run_raw = ""
911 "count:=5;"
912 "[count<10]<->{+"
913 " [count>5]-->"
914 " ++100++;"
915 " ; "
916 " count+=1;"
917 "+};"
918 ;
919
920 ObjPtr count;
921 ObjPtr result;
922 ASSERT_NO_THROW(result = jit->Run(run_raw));
923 ASSERT_NO_THROW(count = jit->Run("count"));
924 ASSERT_TRUE(result);
925 ASSERT_TRUE(result->is_integer());
926 ASSERT_EQ(6, count->GetValueAsInteger());
927 ASSERT_EQ(100, result->GetValueAsInteger());
928
929 const char * run_macro = ""
930 "count:=5;"
931 "@while(count<10){+"
932 " @if(count>5){"
933 " @return(42);"
934 " };"
935 " count+=1;"
936 "+};"
937 "";
938
939 ASSERT_NO_THROW(result = jit->Run(run_macro));
940 ASSERT_NO_THROW(count = jit->Run("count"));
941 ASSERT_TRUE(result);
942 ASSERT_TRUE(result->is_integer());
943 ASSERT_EQ(6, count->GetValueAsInteger());
944 ASSERT_EQ(42, result->GetValueAsInteger());
945}
946
947TEST(Alg, Else) {
948
949 JIT * jit = JIT::ReCreate();
950 ASSERT_TRUE(jit);
951
952 ObjPtr result = nullptr;
953
954 ASSERT_NO_THROW(result = jit->Run("42"));
955 ASSERT_TRUE(result);
956 ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
957 ASSERT_EQ(42, result->GetValueAsInteger()) << result->toString().c_str();
958
959 ASSERT_NO_THROW(result = jit->Run("[0]<->{ 43 },[...]-->{44}"));
960 ASSERT_TRUE(result);
961 ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
962 ASSERT_EQ(44, result->GetValueAsInteger()) << result->toString().c_str();
963
964 ASSERT_NO_THROW(result = jit->Run("{- --100-- -}"));
965 ASSERT_TRUE(result);
966 ASSERT_TRUE(result->is_return()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
967 ASSERT_STREQ("--100--", result->toString().c_str());
968
969 ASSERT_NO_THROW(result = jit->Run("**{- --100-- -}"));
970 ASSERT_TRUE(result);
971 ASSERT_STREQ("100", result->toString().c_str());
972
973 // ASSERT_NO_THROW(result = jit->Run("{- 100 -},[...]-->{200}"));
974 // ASSERT_TRUE(result);
975 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
976 // ASSERT_EQ(200, result->GetValueAsInteger()) << result->toString().c_str();
977 //
978 // ASSERT_NO_THROW(result = jit->Run("{+ 100 +},[...]-->{201}"));
979 // ASSERT_TRUE(result);
980 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
981 // ASSERT_EQ(201, result->GetValueAsInteger()) << result->toString().c_str();
982 //
983 // ASSERT_NO_THROW(result = jit->Run("{* 100 *},[...]-->{202}"));
984 // ASSERT_TRUE(result);
985 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
986 // ASSERT_EQ(202, result->GetValueAsInteger()) << result->toString().c_str();
987 //
988 // ASSERT_NO_THROW(result = jit->Run("{- 100 -},[...]-->{- 204 -}"));
989 // ASSERT_TRUE(result);
990 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
991 // ASSERT_EQ(204, result->GetValueAsInteger()) << result->toString().c_str();
992 //
993 // ASSERT_NO_THROW(result = jit->Run("{- 100 -},[...]-->{+ 205 +}"));
994 // ASSERT_TRUE(result);
995 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
996 // ASSERT_EQ(205, result->GetValueAsInteger()) << result->toString().c_str();
997 //
998 // ASSERT_NO_THROW(result = jit->Run("{* 100 *},[...]-->{* 206 *}"));
999 // ASSERT_TRUE(result);
1000 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
1001 // ASSERT_EQ(206, result->GetValueAsInteger()) << result->toString().c_str();
1002 //
1003 // ASSERT_NO_THROW(result = jit->Run("{* 100 *}:Test, [...]-->{* 207 *}"));
1004 // ASSERT_TRUE(result);
1005 // ASSERT_TRUE(result->is_integer()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
1006 // ASSERT_EQ(207, result->GetValueAsInteger()) << result->toString().c_str();
1007 //
1008 // ASSERT_NO_THROW(result = jit->Run("[1] --> 1, [1] --> 2, [...] -->3"));
1009 // ASSERT_TRUE(result);
1010 // ASSERT_TRUE(result->is_integral()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
1011 // ASSERT_EQ(1, result->GetValueAsInteger()) << result->toString().c_str();
1012 //
1013 // ASSERT_NO_THROW(result = jit->Run("[0] --> 1, [1] --> 2, [...] -->3"));
1014 // ASSERT_TRUE(result);
1015 // ASSERT_TRUE(result->is_integral()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
1016 // ASSERT_EQ(2, result->GetValueAsInteger()) << result->toString().c_str();
1017 //
1018 // ASSERT_NO_THROW(result = jit->Run("[0] --> 1, [0] --> 2, [...] -->3"));
1019 // ASSERT_TRUE(result);
1020 // ASSERT_TRUE(result->is_integral()) << result->toString().c_str() << " (" << toString(result->getType()) << ")";
1021 // ASSERT_EQ(3, result->GetValueAsInteger()) << result->toString().c_str();
1022}
1023
1024#endif // UNITTEST
newlang::GlobalObjects::Dump
std::string Dump(const std::string_view filter="", const char delim=';')
Definition types.cpp:314
newlang::JIT::Run
ObjPtr Run(const std::string_view str, Obj *args=nullptr)
Definition jit.cpp:2558
newlang::Obj::getType
ObjType getType()
Definition object.h:423
newlang::Obj::m_return_obj
ObjPtr m_return_obj
Definition object.h:1912
newlang::Obj::m_value
std::string m_value
Содержит байтовую строку или байтовый массив с данными для представления в нативном виде (Struct,...
Definition object.h:1905
result
int result
Definition lexer.l:367
LOG_DEBUG
#define LOG_DEBUG(...)
Definition logger.h:119
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