NewLang Project
Yet another programm language
Loading...
Searching...
No Matches
example_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 <chrono>
8#include <stdio.h>
9
10#include "runtime.h"
11#include "analysis.h"
12
13using namespace newlang;
14
15/*
16 * Тест производительности на базе исходников из статьи
17 * https://towardsdatascience.com/how-fast-is-c-compared-to-python-978f18f474c7
18 */
19extern "C" char convert(char c);
20
21TEST(Example, SpeedCPP) {
22
23 LOG_INFO("Start speed test C++");
24
25 std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
26
27 std::string opt = "ACGT";
28 std::string s = "";
29 std::string s_last = "";
30 int len_str = 13;
31 bool change_next;
32
33 for (int i = 0; i < len_str; i++) {
34 s += opt[0];
35 }
36
37 for (int i = 0; i < len_str; i++) {
38 s_last += opt.back();
39 }
40
41 int pos = 0;
42 int counter = 1;
43 while (s != s_last) {
44 counter++;
45 // You can uncomment the next line to see all k-mers.
46 //std::cout << s << std::endl;
47 change_next = true;
48 for (int i = 0; i < len_str; i++) {
49 if (change_next) {
50 if (s[i] == opt.back()) {
51 s[i] = convert(s[i]);
52 change_next = true;
53 } else {
54 s[i] = convert(s[i]);
55 i = len_str; // break;
56 }
57 }
58 }
59 }
60
61 // You can uncomment the next line to see all k-mers.
62 // cout << s << endl;
63 std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
64 int sec = (int) std::chrono::duration_cast<std::chrono::seconds>(end - begin).count();
65 int ms = (int) std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() % 1000000;
66 LOG_INFO("Float of generated k-mers: %d at %d.%d sec", counter, sec, ms);
67
68}
69
70TEST(Example, DISABLED_SpeedNewLang) {
71
72 RuntimePtr rt = RunTime::Init();
73 ASSERT_TRUE(rt);
74
75 setvbuf(stdin, nullptr, _IONBF, 0);
76 setvbuf(stdout, nullptr, _IONBF, 0);
77 setvbuf(stderr, nullptr, _IONBF, 0);
78
79
80 ObjPtr test;
81
82 ObjPtr str = jit->Run("str := 'ABCDEF\\n';", nullptr);
83 ASSERT_TRUE(str);
84 ASSERT_STREQ("ABCDEF\n", str->GetValueAsString().c_str());
85
86 test = jit->Run("str := 'ABCDEF\\n'; print('%s', str)");
87 ASSERT_TRUE(test);
88 ASSERT_STREQ("7", test->GetValueAsString().c_str());
89
90 test = jit->Run("str[2] = 32; str", nullptr);
91 ASSERT_TRUE(test);
92 ASSERT_STREQ("AB DEF\n", test->GetValueAsString().c_str());
93
94 test = jit->Run("str[0]", nullptr);
95 ASSERT_TRUE(test);
96 ASSERT_STREQ("A", test->GetValueAsString().c_str());
97
98 test = jit->Run("str[1]", nullptr);
99 ASSERT_TRUE(test);
100 ASSERT_STREQ("B", test->GetValueAsString().c_str());
101
102 test = jit->Run("str[2]", nullptr);
103 ASSERT_TRUE(test);
104 ASSERT_STREQ(" ", test->GetValueAsString().c_str());
105
106 // LLVMAddSymbol("convert", (void *) &convert);
107 ObjPtr test_convert = jit->Run("test_convert(sym:Int8):Int8 := %convert ...");
108 ASSERT_TRUE(test_convert);
109
110 // [c == 'A'] --> 'C',
111 // [c == 'C'] --> 'G',
112 // [c == 'G'] --> 'T',
113 // [c == 'T'] --> 'A',
114 // [_] --> ' ';
115
116 test = jit->Run("test_convert(65)", nullptr);
117 ASSERT_TRUE(test);
118 ASSERT_STREQ("67", test->GetValueAsString().c_str());
119 test = jit->Run("test_convert(67)", nullptr);
120 ASSERT_TRUE(test);
121 ASSERT_STREQ("71", test->GetValueAsString().c_str());
122
123 test = jit->Run("test_convert(71)", nullptr);
124 ASSERT_TRUE(test);
125 ASSERT_STREQ("84", test->GetValueAsString().c_str());
126
127 test = jit->Run("test_convert(84)", nullptr);
128 ASSERT_TRUE(test);
129 ASSERT_STREQ("65", test->GetValueAsString().c_str());
130
131 ASSERT_NO_THROW(test = jit->Run("str"));
132 ASSERT_TRUE(test);
133 ASSERT_STREQ("AB DEF\n", test->GetValueAsString().c_str());
134
135 ASSERT_NO_THROW(test = jit->Run("str[0]"));
136 ASSERT_TRUE(test);
137 ASSERT_STREQ("A", test->GetValueAsString().c_str());
138
139 ASSERT_NO_THROW(test = jit->Run(":Int8('A')"));
140 ASSERT_TRUE(test);
141 ASSERT_STREQ("65", test->GetValueAsString().c_str());
142
143 // ASSERT_NO_THROW(test = jit->Run("test_convert('A')"));
144 // ASSERT_TRUE(test);
145 // ASSERT_STREQ("C", test->GetValueAsString().c_str());
146
147 ASSERT_NO_THROW(test = jit->Run("test_convert(:Int8(str[0]))"));
148 ASSERT_TRUE(test);
149 ASSERT_STREQ("67", test->GetValueAsString().c_str());
150
151 ASSERT_NO_THROW(test = jit->Run("str[0] = test_convert(:Int8(str[0])); str"));
152 ASSERT_TRUE(test);
153 ASSERT_STREQ("CB DEF\n", test->GetValueAsString().c_str());
154
155 Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
156 std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
157 ObjPtr result = jit->RunFile("../examples/speed_test.src");
158 std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
159 Logger::Instance()->SetLogLevel(save);
160
161
162
163 ASSERT_TRUE(result);
164 ASSERT_TRUE(result->is_string_type()) << result->toString();
165 ASSERT_STREQ("OK", result->GetValueAsString().c_str());
166
167
168 int sec = (int) std::chrono::duration_cast<std::chrono::seconds>(end - begin).count();
169 int ms = (int) std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() % 1000000;
170 LOG_INFO("Test speed complete at %d.%d sec", sec, ms);
171
172 /*
173 *
174 * Start speed test C++
175 * Float of generated k-mers: 67108864 at 2.502049 sec
176 *
177 * Start
178 * Float of generated k-mers: 67108864
179 * real 0m33,794s
180 *
181 * Start speed test NewLang
182 * Float of generated k-mers: 67108864
183 * Test complete at ????????????????????
184 *
185 * Своя функция convert
186 * 5 символов - 1.3 сек (с вывоводм строк) 0.491895 sec - без вывода строк
187 * 6 символов - 14.789793 sec (с вывоводм строк) 1.898168 sec - без вывода строк
188 * 7 символов без вывода строк - 7.671152 sec
189 * 8 символов без вывода строк - 30.412468 sec
190 *
191 * Импорт С++ функции convert
192 * 5 символов - 1.23 сек (с вывоводм строк) 0.53 sec - без вывода строк
193 * 6 символов - 13.538338 sec (с вывоводм строк) 2.30900 sec - без вывода строк
194 * 7 символов без вывода строк - 8.43029 sec
195 * 8 символов без вывода строк - 32.154832 sec
196 *
197 * После переделки способа хранения скаляров в нативном виде, а не в тензорах
198 * Своя функция convert
199 * 5 символов - 1.255214 сек (с вывоводм строк) 0.306725 sec - без вывода строк
200 * 6 символов - 15.995722 sec (с вывоводм строк) 1.253190 sec - без вывода строк
201 * 7 символов без вывода строк - 5.12946 sec
202 * 8 символов без вывода строк - 19.653851 sec
203 *
204 * Импорт С++ функции convert
205 * 5 символов - 1.195008 sec (с вывоводм строк) 0.351575 sec - без вывода строк
206 * 6 символов - 13.666785 sec (с вывоводм строк) 1.428339 sec - без вывода строк
207 * 7 символов без вывода строк - 5.628200 sec
208 * 8 символов без вывода строк - 22.258760 sec
209 *
210 * Start speed test NewLang
211 * From AAAAAAAAAA to TTTTTTTTTT
212 * Float of generated k-mers: 1048576
213 * Test complete at 320.401650 sec (более 5 минут)
214 *
215 * Никакой оптимизации не проводилось.
216 * Программа не преобразуется в промежуточный byte-code, а интерпретируется какждый раз при выполнении.
217 * LLVM код вызова нативных функий генерируется каждый раз, не при создании функции.
218 * Возможности для оптимиации производительности чрезвычайно общширны ;-)
219 */
220}
221
222TEST(Example, Rational) {
223
224 RuntimePtr rt = RunTime::Init();
225 ASSERT_TRUE(rt);
226
227 setvbuf(stdin, nullptr, _IONBF, 0);
228 setvbuf(stdout, nullptr, _IONBF, 0);
229 setvbuf(stderr, nullptr, _IONBF, 0);
230
231 ObjPtr test;
232 //fact_recur(n:Integer) := {
233 // [n > 1] --> {
234 // -- n * fact_recur(n-1) --;
235 // };
236 // 1;
237 //};
238
239 ObjPtr str;
240 ASSERT_NO_THROW(str = jit->Run("str := 'ABCDEF\\n';"));
241 ASSERT_TRUE(str);
242 ASSERT_STREQ("ABCDEF\n", str->GetValueAsString().c_str());
243
244 ObjPtr test_printf;
245 ASSERT_NO_THROW(test_printf = jit->Run("test_printf(format:FmtChar, ...):Int32 := %printf...")) << Dump(*rt) << "\n" << rt->m_main_ast->m_int_vars.Dump();
246 ASSERT_TRUE(test_printf);
247 ASSERT_STREQ("test_printf::(format:FmtChar, ...):Int32{ }", test_printf->toString().c_str());
248
249 ObjPtr iter;
250 ASSERT_NO_THROW(iter = jit->Run("iterator := (1, 5, 9999,)?"));
251 ASSERT_TRUE(iter);
252 ASSERT_TRUE(iter->getType() == ObjType::Iterator);
253 ASSERT_TRUE(iter->m_iterator);
254 ASSERT_TRUE(*iter->m_iterator.get() == iter->m_iterator->begin());
255 ASSERT_TRUE(*iter->m_iterator.get() != iter->m_iterator->end());
256
257 ObjPtr test_frac = jit->Run("test_frac := 999\\123");
258 ASSERT_TRUE(test_frac);
259 ASSERT_TRUE(test_frac->getType() == ObjType::Rational);
260 ASSERT_STREQ("999\\123", test_frac->GetValueAsString().c_str());
261
262 ObjPtr str_frac = jit->Run(":StrChar(test_frac)");
263 ASSERT_TRUE(str_frac);
264 ASSERT_TRUE(str_frac->getType() == ObjType::StrChar) << newlang::toString(str_frac->getType());
265 ASSERT_STREQ("999\\123", str_frac->GetValueAsString().c_str()) << str_frac->GetValueAsString();
266
267 ObjPtr test_prn = jit->Run("test_printf('%s\\n', :StrChar(test_frac))");
268 ASSERT_TRUE(test_prn);
269 ASSERT_STREQ("8", test_prn->GetValueAsString().c_str());
270
271 ObjPtr test_arg;
272 ASSERT_NO_THROW(test_arg = jit->Run("test_arg(arg:Rational) := {$arg*$arg}"));
273 ASSERT_TRUE(test_arg);
274 ASSERT_TRUE(test_arg->is_function_type());
275 ASSERT_FALSE(test_arg->is_none_type());
276 ASSERT_STREQ("test_arg::(arg:Rational){ }", test_arg->toString().c_str());
277
278
279
280 ObjPtr frac_test;
281 ASSERT_ANY_THROW(frac_test = jit->Run("test_arg()"));
282 ASSERT_ANY_THROW(frac_test = jit->Run("test_arg('')"));
283
284 ASSERT_NO_THROW(frac_test = jit->Run("test_arg(1)"))
285 << rt->m_main_ast->m_int_vars.Dump() << "\n"
286 << rt->m_main_ast->m_int_vars.find("test_arg$")->second->m_int_vars.Dump();
287
288 ASSERT_TRUE(frac_test);
289 ASSERT_EQ(ObjType::Rational, frac_test->getType()) << newlang::toString(frac_test->getType());
290 ASSERT_STREQ("1\\1", frac_test->GetValueAsString().c_str());
291
292 ASSERT_NO_THROW(frac_test = jit->Run("test_arg(2\\1)"));
293 ASSERT_TRUE(frac_test);
294 ASSERT_STREQ("4\\1", frac_test->GetValueAsString().c_str());
295
296 ObjPtr iter_test;
297 ASSERT_NO_THROW(iter_test = jit->Run("iter_test := :Int64(5+1)..1..-1?"));
298 ASSERT_TRUE(iter_test);
299 ASSERT_STREQ(":Iterator", iter_test->toString().c_str());
300
301 ObjPtr fact_range_test;
302 ASSERT_NO_THROW(fact_range_test = jit->Run(""
303 "n:=1\\1;"
304 "iter_cnt := @iter(6..1..-1);"
305 "[ @curr(iter_cnt) ] <-> {"
306 " print('1: n=%s, iter=%s\\n', :StrChar(n), :StrChar(@curr(iter_cnt)));"
307 " n *= @next(iter_cnt);"
308 " print('2: n=%s\\n', :StrChar(n));"
309 "};"
310 "n;"
311 ));
312 ASSERT_TRUE(fact_range_test);
313 ASSERT_STREQ("720\\1", fact_range_test->toString().c_str());
314
315 ObjPtr result;
316
317 ASSERT_NO_THROW(result = jit->RunFile("../examples/fact_40.src"));
318 ASSERT_TRUE(result);
319 ASSERT_STREQ("815915283247897734345611269596115894272000000000\\1", result->GetValueAsString().c_str());
320
321 ASSERT_NO_THROW(result = jit->RunFile("../examples/fact_40_dsl.src"));
322 ASSERT_TRUE(result);
323 ASSERT_STREQ("815915283247897734345611269596115894272000000000\\1", result->GetValueAsString().c_str());
324
325
326 Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
327 std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
328 ASSERT_NO_THROW(result = jit->RunFile("../examples/rational.src"));
329 std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
330 Logger::Instance()->SetLogLevel(save);
331
332 ASSERT_TRUE(result);
333 ASSERT_STREQ("402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\\1", result->GetValueAsString().c_str());
334
335 int sec = (int) std::chrono::duration_cast<std::chrono::seconds>(end - begin).count();
336 int ms = (int) std::chrono::duration_cast<std::chrono::microseconds>(end - begin).count() % 1000000;
337 LOG_INFO("Test factorial 1000! complete at %d.%d sec", sec, ms);
338
339
340// save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
341// begin = std::chrono::steady_clock::now();
342// result = jit->RunFile("\\\\‍('../examples/rational.src')");
343// end = std::chrono::steady_clock::now();
344// Logger::Instance()->SetLogLevel(save);
345//
346//
347// ASSERT_TRUE(result);
348// ASSERT_TRUE(result->is_string_type()) << result->toString();
349// ASSERT_STREQ("OK", result->GetValueAsString().c_str());
350
351}
352
353TEST(Example, Tensor) {
354
355 RuntimePtr rt = RunTime::Init();
356 ASSERT_TRUE(rt);
357
358
359 TermPtr ast = rt->GetParser()->Parse("print('%%%s\\n', :StrChar(123))");
360 ASSERT_TRUE(ast);
361
362 AstAnalysis analysis(*rt, rt->m_diag.get());
363 ASSERT_TRUE(analysis.Analyze(ast, ast));
364 ASSERT_EQ(2, ast->size());
365 ASSERT_TRUE((*ast)[0].second->m_id == TermID::STRCHAR);
366 ASSERT_TRUE((*ast)[1].second->m_id == TermID::TYPE);
367 ASSERT_TRUE(!(*ast)[1].second->m_int_name.empty());
368
369
370 ast = rt->GetParser()->Parse("var := 123; var2 := var * 123");
371 ASSERT_TRUE(ast);
372
373 AstAnalysis analysis2(*rt, rt->m_diag.get());
374 ASSERT_TRUE(analysis2.Analyze(ast, ast));
375 ASSERT_EQ(2, ast->m_block.size()) << ast->m_int_vars.Dump();
376 ASSERT_TRUE(!ast->m_block[0]->m_left->m_int_name.empty());
377 ASSERT_TRUE(!ast->m_block[1]->m_left->m_int_name.empty());
378 ASSERT_TRUE(ast->m_block[1]->m_right->getTermID() == TermID::OP_MATH);
379 TermPtr math = ast->m_block[1]->m_right;
380 ASSERT_TRUE(math->m_right);
381 ASSERT_TRUE(math->m_left);
382 ASSERT_TRUE(!math->m_left->m_int_name.empty());
383
384
385 ast = rt->GetParser()->Parse("rand():Int32 := %rand ...;");
386 ASSERT_TRUE(ast);
387
388 AstAnalysis analysis3(*rt, rt->m_diag.get());
389 ASSERT_TRUE(analysis3.Analyze(ast, ast));
390 ASSERT_TRUE(ast->m_right);
391 ASSERT_TRUE(ast->m_left);
392 ASSERT_TRUE(!ast->m_left->m_int_name.empty());
393
394
395 ast = rt->GetParser()->Parse("r():Int32 := %rand ...; :Tensor[10](42, ... r() ...)");
396 ASSERT_TRUE(ast);
397
398 AstAnalysis analysis4(*rt, rt->m_diag.get());
399 ASSERT_TRUE(analysis4.Analyze(ast, ast));
400 ASSERT_EQ(2, ast->m_block.size()) << ast->m_int_vars.Dump();
401 ASSERT_TRUE(!ast->m_block[0]->m_left->m_int_name.empty());
402
403 TermPtr t = ast->m_block[0]->m_left;
404 ASSERT_TRUE(t);
405 ASSERT_TRUE(!t->m_int_name.empty()) << t->toString();
406
407 t = ast->m_block[1];
408 ASSERT_TRUE(t);
409 ASSERT_EQ(2, t->size());
410 ASSERT_TRUE((*t)[1].second);
411 ASSERT_TRUE((*t)[1].second->m_right);
412 ASSERT_TRUE(!(*t)[1].second->m_right->m_int_name.empty()) << (*t)[1].second->m_right->toString();
413
414
415
416 ast = rt->GetParser()->Parse("sss := :Tensor[10](42, ... rnda() ...)");
417 ASSERT_TRUE(ast);
418
419 AstAnalysis analysis5(*rt, rt->m_diag.get());
420 ASSERT_FALSE(analysis5.Analyze(ast, ast));
421
422
423 setvbuf(stdin, nullptr, _IONBF, 0);
424 setvbuf(stdout, nullptr, _IONBF, 0);
425 setvbuf(stderr, nullptr, _IONBF, 0);
426
427
428 Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
429 std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
430 ObjPtr result = jit->RunFile("../examples/tensor.src");
431 std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
432 Logger::Instance()->SetLogLevel(save);
433
434
435 ASSERT_TRUE(result);
436 ASSERT_TRUE(result->is_integer()) << result->toString();
437 ASSERT_TRUE(result->GetValueAsInteger() == 20) << result->toString();
438
439
440 // save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
441 // begin = std::chrono::steady_clock::now();
442 // result = jit->RunFile("\\\\‍('../examples/tensor.src')");
443 // end = std::chrono::steady_clock::now();
444 // Logger::Instance()->SetLogLevel(save);
445 //
446 // ASSERT_TRUE(result);
447 // ASSERT_TRUE(result->is_string_type()) << result->toString();
448 // ASSERT_STREQ("OK", result->GetValueAsString().c_str());
449
450}
451
452TEST(Example, Hello) {
453
454 RuntimePtr rt = RunTime::Init();
455 ASSERT_TRUE(rt);
456
457 ObjPtr prn;
458 ASSERT_NO_THROW(prn = jit->Run("prn(format:FmtChar, ...):Int32 ::= %printf ..."));
459 ASSERT_TRUE(prn);
460
461 ObjPtr res = (*prn)("Привет, мир!\n");
462 ASSERT_TRUE(res);
463 ASSERT_TRUE(res->is_integer()) << res->toString();
464 ASSERT_STREQ("22", res->GetValueAsString().c_str());
465
466 // ObjPtr func = jit->Run("func(arg) := {$arg}");
467 // ASSERT_TRUE(func);
468 //
469 // res = (*func)("TEST");
470 // ASSERT_TRUE(res);
471 // ASSERT_TRUE(res->is_string_char_type()) << res->toString();
472 // ASSERT_STREQ("TEST", res->GetValueAsString().c_str());
473 // hello(str) := {
474 // printf := :Pointer('printf(format:FmtChar, ...):Int32'); # Импорт стандартной C функции
475 // printf('%s\n', $str); # Вызов C функции с проверкой типов аргументов по строке формата
476 // };
477 // hello('Привет, мир!'); # Вызвать функцию
478
479
480 setvbuf(stdin, nullptr, _IONBF, 0);
481 setvbuf(stdout, nullptr, _IONBF, 0);
482 setvbuf(stderr, nullptr, _IONBF, 0);
483
484
485 Logger::LogLevelType save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
486 std::chrono::steady_clock::time_point begin = std::chrono::steady_clock::now();
487 ObjPtr result = jit->RunFile("../examples/hello.src");
488 std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
489 Logger::Instance()->SetLogLevel(save);
490
491
492 ASSERT_TRUE(result);
493 ASSERT_TRUE(result->is_integral()) << result->toString();
494 ASSERT_STREQ("14", result->GetValueAsString().c_str());
495
496
497 // save = Logger::Instance()->SetLogLevel(LOG_LEVEL_INFO);
498 // begin = std::chrono::steady_clock::now();
499 // ASSERT_NO_THROW(result = jit->Run("\\\\‍('../examples/hello.src')"));
500 // end = std::chrono::steady_clock::now();
501 // Logger::Instance()->SetLogLevel(save);
502 //
503 //
504 // ASSERT_TRUE(result);
505 // ASSERT_TRUE(result->is_integral()) << result->toString();
506 // ASSERT_STREQ("14", result->GetValueAsString().c_str());
507}
508
509TEST(Example, Exec) {
510 RuntimePtr rt = RunTime::Init({"--nlc-no-eval-enable"});
511
512 ASSERT_FALSE(rt->m_eval_enable);
513 ASSERT_ANY_THROW(jit->Run("`ls`"));
514 rt->m_eval_enable = true;
515
516 ObjPtr exec;
517 ASSERT_NO_THROW(exec = jit->Run("`ls`"));
518 ASSERT_TRUE(exec);
519 ASSERT_TRUE(exec->is_string_char_type()) << exec->toString();
520 ASSERT_TRUE(exec->GetValueAsString().find("nlc_test\n") != std::string::npos);
521}
522
523
524#endif // UNITTEST
newlang::Logger::LogLevelType
uint8_t LogLevelType
Definition logger.h:319
result
int result
Definition lexer.l:367
LOG_LEVEL_INFO
#define LOG_LEVEL_INFO
Definition logger.h:87
LOG_INFO
#define LOG_INFO(...)
Definition logger.h:120
newlang
Definition nlc.h:59
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::toString
const char * toString(TermID type)
Definition term.h:126
newlang::Dump
std::string Dump(const T &iterable)
Definition logger.h:306
convert
char convert(char c)
Definition runtime.cpp:1328
warning_pop.h
warning_push.h
Generated by doxygen 1.11.0