NewLang Project
Yet another programm language
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Loading...
Searching...
No Matches
parser_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
8#include "parser.h"
9#include "term.h"
10#include "version.h"
11#include "runtime.h"
12//#include "nlc.h"
13
14using namespace newlang;
15
16class ParserTest : public ::testing::Test {
17protected:
18
19
20
21 std::vector<std::string> m_postlex;
22
23 Logger::FuncCallback *m_log_callback_save;
24 void *m_log_callback_arg_save;
25 std::string m_output;
26
27 static void LoggerCallback(void *param, Logger::LogLevelType level, const char * str, bool flush) {
28 ParserTest *p = static_cast<ParserTest *> (param);
29 fprintf(stdout, "%s", str);
30 if (flush) {
31 fflush(stdout);
32 }
33 if (p) {
34 p->m_output += str;
35 }
36 }
37
38 void SetUp() {
39 Logger::Instance()->SaveCallback(m_log_callback_save, m_log_callback_arg_save);
40 Logger::Instance()->SetCallback(&LoggerCallback, this);
41 }
42
43 void TearDown() {
44 Logger::Instance()->SetCallback(m_log_callback_save, m_log_callback_arg_save);
45 }
46
47 TermPtr Parse(std::string str, MacroPtr buffer = nullptr, DiagPtr diag = nullptr) {
48 m_postlex.clear();
49 ast = Parser::ParseString(str, buffer, &m_postlex, diag);
50 return ast;
51 }
52
53 int Count(TermID token_id) {
54 int result = 0;
55 for (int c = 0; c < ast->size(); c++) {
56 if ((*ast)[c].second->m_id == token_id) {
57 result++;
58 }
59 }
60 return result;
61 }
62
63 std::string LexOut() {
64 std::string result;
65 for (int i = 0; i < m_postlex.size(); i++) {
66 if (!result.empty()) {
67 result += " ";
68 }
69 result += m_postlex[i];
70 }
71 trim(result);
72 return result;
73 }
74
75 TermPtr ast;
76};
77
78TEST_F(ParserTest, LiteralInteger) {
79 ASSERT_TRUE(Parse("100;"));
80 ASSERT_EQ(TermID::INTEGER, ast->getTermID()) << newlang::toString(ast->getTermID());
81 ASSERT_STREQ("100", ast->m_text.c_str());
82}
83
84TEST_F(ParserTest, LiteralNumber) {
85 ASSERT_TRUE(Parse("100.222;"));
86 ASSERT_EQ(TermID::NUMBER, ast->getTermID()) << newlang::toString(ast->getTermID());
87 ASSERT_STREQ("100.222", ast->m_text.c_str());
88
89 ASSERT_TRUE(Parse("1.2E-20;"));
90 ASSERT_EQ(TermID::NUMBER, ast->getTermID()) << newlang::toString(ast->getTermID());
91 ASSERT_STREQ("1.2E-20", ast->m_text.c_str());
92
93 ASSERT_TRUE(Parse("1.2E+20;"));
94 ASSERT_EQ(TermID::NUMBER, ast->getTermID()) << newlang::toString(ast->getTermID());
95 ASSERT_STREQ("1.2E+20", ast->m_text.c_str());
96
97 ASSERT_TRUE(Parse("0.e-10;"));
98 ASSERT_EQ(TermID::NUMBER, ast->getTermID()) << newlang::toString(ast->getTermID());
99 ASSERT_STREQ("0.e-10", ast->m_text.c_str());
100
101 ASSERT_TRUE(Parse("0.e+10;"));
102 ASSERT_EQ(TermID::NUMBER, ast->getTermID()) << newlang::toString(ast->getTermID());
103 ASSERT_STREQ("0.e+10", ast->m_text.c_str());
104}
105
106TEST_F(ParserTest, LiteralString) {
107 ASSERT_TRUE(Parse("\"\";"));
108 ASSERT_EQ(TermID::STRWIDE, ast->getTermID()) << newlang::toString(ast->getTermID());
109 ASSERT_STREQ("\"\"", ast->toString().c_str());
110}
111
112TEST_F(ParserTest, LiteralString0) {
113 ASSERT_TRUE(Parse("\"\"(123);"));
114 ASSERT_TRUE(Parse("\"\"(123);"));
115 ASSERT_EQ(TermID::STRWIDE, ast->getTermID()) << newlang::toString(ast->getTermID());
116 ASSERT_STREQ("\"\"(123)", ast->toString().c_str());
117}
118
119TEST_F(ParserTest, LiteralString1) {
120 ASSERT_TRUE(Parse("\"\";"));
121 ASSERT_EQ(TermID::STRWIDE, ast->getTermID()) << newlang::toString(ast->getTermID());
122 ASSERT_STREQ("\"\"", ast->toString().c_str());
123}
124
125TEST_F(ParserTest, LiteralString3) {
126 ASSERT_TRUE(Parse("'';"));
127 ASSERT_EQ(TermID::STRCHAR, ast->getTermID()) << newlang::toString(ast->getTermID());
128 ASSERT_STREQ("''", ast->toString().c_str());
129}
130
131TEST_F(ParserTest, LiteralString4) {
132 ASSERT_TRUE(Parse("'strbyte'(term(), 123);"));
133 ASSERT_EQ(TermID::STRCHAR, ast->getTermID()) << newlang::toString(ast->getTermID());
134 ASSERT_STREQ("'strbyte'(term(), 123)", ast->toString().c_str());
135}
136
137TEST_F(ParserTest, LiteralEval1) {
138 ASSERT_TRUE(Parse("``"));
139 ASSERT_EQ(TermID::EVAL, ast->getTermID()) << newlang::toString(ast->getTermID());
140 ASSERT_STREQ("``", ast->toString().c_str());
141}
142
143TEST_F(ParserTest, LiteralEval2) {
144 ASSERT_TRUE(Parse("`strbyte(term(), 123);`"));
145 ASSERT_EQ(TermID::EVAL, ast->getTermID()) << newlang::toString(ast->getTermID());
146 ASSERT_STREQ("`strbyte(term(), 123);`", ast->toString().c_str());
147}
148
149TEST_F(ParserTest, LiteralRational) {
150 ASSERT_TRUE(Parse("1\\1;"));
151 ASSERT_EQ(TermID::RATIONAL, ast->getTermID()) << newlang::toString(ast->getTermID());
152 ASSERT_STREQ("1\\1", ast->toString().c_str());
153
154 /* Защита от случайной операции деления на единицу вместо указания дроби */
155 ASSERT_ANY_THROW(Parse("1/1"));
156 ASSERT_ANY_THROW(Parse("rrr := 1/1"));
157 ASSERT_NO_THROW(Parse("rrr := 1\\1"));
158 ASSERT_ANY_THROW(Parse("rrr := 11111111111111111/1"));
159 ASSERT_NO_THROW(Parse("rrr := 11111111111111111\\1"));
160
161 ASSERT_TRUE(Parse("100\\100;"));
162 ASSERT_EQ(TermID::RATIONAL, ast->getTermID()) << newlang::toString(ast->getTermID());
163 ASSERT_STREQ("100\\100", ast->toString().c_str());
164
165 ASSERT_TRUE(Parse("123456789123456789123456789\\123456789123456789123456789;"));
166 ASSERT_EQ(TermID::RATIONAL, ast->getTermID()) << newlang::toString(ast->getTermID());
167 ASSERT_STREQ("123456789123456789123456789\\123456789123456789123456789", ast->toString().c_str());
168}
169
170TEST_F(ParserTest, DISABLED_LiteralComplex) {
171 ASSERT_TRUE(Parse("1+0j;"));
172 ASSERT_EQ(TermID::COMPLEX, ast->getTermID()) << newlang::toString(ast->getTermID());
173 ASSERT_STREQ("1+0j", ast->toString().c_str());
174
175 ASSERT_TRUE(Parse("1+0.1j;"));
176 ASSERT_EQ(TermID::COMPLEX, ast->getTermID()) << newlang::toString(ast->getTermID());
177 ASSERT_STREQ("1+0.1j", ast->toString().c_str());
178}
179
180TEST_F(ParserTest, TermSimple) {
181 ASSERT_TRUE(Parse("term();"));
182 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
183 ASSERT_TRUE(ast->isCall());
184 ASSERT_STREQ("term", ast->m_text.c_str());
185}
186
187TEST_F(ParserTest, InternalName) {
188 ASSERT_TRUE(Parse("term.filed();"));
189 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
190 ASSERT_STREQ("term", ast->m_text.c_str());
191 ASSERT_TRUE(ast->m_name.empty());
192}
193
194TEST_F(ParserTest, Tensor1) {
195 ASSERT_TRUE(Parse("[,]:Int8"));
196 ASSERT_EQ(TermID::TENSOR, ast->getTermID()) << newlang::toString(ast->getTermID());
197 ASSERT_STREQ("[,]:Int8", ast->toString().c_str());
198
199 ASSERT_TRUE(Parse("term[1];"));
200 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
201 ASSERT_STREQ("term", ast->m_text.c_str());
202 ASSERT_TRUE(ast->Right());
203
204 ASSERT_EQ(TermID::INDEX, ast->Right()->getTermID()) << newlang::toString(ast->getTermID());
205 ASSERT_EQ(1, ast->Right()->size());
206 ASSERT_STREQ("1", (*ast->Right())[0].second->getText().c_str());
207
208 ASSERT_TRUE(Parse("term[1..2];"));
209 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
210 ASSERT_STREQ("term[1..2]", ast->toString().c_str());
211
212 // ASSERT_TRUE(ast->Right());
213 // ASSERT_EQ(TermID::INDEX, ast->Right()->getTermID()) << EnumStr(ast->getTermID());
214 // ASSERT_EQ(2, ast->Right()->getItemCount());
215 // ASSERT_STREQ("1", (*ast->Right())[0]->getText().c_str());
216 // ASSERT_STREQ("2", (*ast->Right())[1]->getText().c_str());
217}
218
219TEST_F(ParserTest, Tensor2) {
220 ASSERT_TRUE(Parse("term[1, 2];"));
221 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
222 ASSERT_STREQ("term", ast->m_text.c_str());
223 ASSERT_TRUE(ast->Right());
224
225 ASSERT_EQ(TermID::INDEX, ast->Right()->getTermID()) << newlang::toString(ast->getTermID());
226 ASSERT_EQ(2, ast->Right()->size());
227 ASSERT_STREQ("1", (*ast->Right())[0].second->getText().c_str());
228 ASSERT_STREQ("2", (*ast->Right())[1].second->getText().c_str());
229
230 ASSERT_TRUE(Parse("term[1, 1..2, 3];"));
231
232 ASSERT_EQ(TermID::INDEX, ast->Right()->getTermID()) << newlang::toString(ast->getTermID());
233 ASSERT_EQ(3, ast->Right()->size());
234 ASSERT_STREQ("1", (*ast->Right())[0].second->getText().c_str());
235 ASSERT_STREQ("1..2", (*ast->Right())[1].second->toString().c_str());
236 ASSERT_STREQ("3", (*ast->Right())[2].second->getText().c_str());
237}
238
239TEST_F(ParserTest, Tensor3) {
240 ASSERT_TRUE(Parse("term := [1,2,];"));
241
242 ASSERT_TRUE(Parse("term[1, 3] := 0;"));
243
244 ASSERT_TRUE(Parse("term[1, 3] := [ [1,2,3,],];"));
245
246 // ASSERT_EQ(TermID::TERM, ast->getTermID()) << EnumStr(ast->getTermID());
247 // ASSERT_STREQ("term", ast->m_text.c_str());
248 // ASSERT_TRUE(ast->Right());
249 //
250 // ASSERT_EQ(TermID::INDEX, ast->Right()->getTermID()) << EnumStr(ast->getTermID());
251 // ASSERT_EQ(2, ast->Right()->size());
252 // ASSERT_STREQ("1", (*ast->Right())[0]->getText().c_str());
253 // ASSERT_STREQ("2", (*ast->Right())[1]->getText().c_str());
254 //
255 // ASSERT_TRUE(Parse("term[1, 1..2, 3];"));
256 //
257 // ASSERT_EQ(TermID::INDEX, ast->Right()->getTermID()) << EnumStr(ast->getTermID());
258 // ASSERT_EQ(3, ast->Right()->size());
259 // ASSERT_STREQ("1", (*ast->Right())[0]->getText().c_str());
260 // ASSERT_STREQ("1..2", (*ast->Right())[1]->toString().c_str());
261 // ASSERT_STREQ("3", (*ast->Right())[2]->getText().c_str());
262}
263
264TEST_F(ParserTest, Tensor4) {
265 ASSERT_TRUE(Parse(":Type( 1 );"));
266 ASSERT_STREQ(":Type(1)", ast->toString().c_str());
267
268 ASSERT_TRUE(Parse(":Type( [1,2,] )"));
269 ASSERT_STREQ(":Type([1, 2,])", ast->toString().c_str());
270
271 ASSERT_TRUE(Parse(":Type( 1, 2 )"));
272 ASSERT_STREQ(":Type(1, 2)", ast->toString().c_str());
273
274 ASSERT_TRUE(Parse(":Type( name=1 , name2=2 )"));
275 ASSERT_STREQ(":Type(name=1, name2=2)", ast->toString().c_str());
276
277 ASSERT_TRUE(Parse(":Type( \"str\" )"));
278 ASSERT_STREQ(":Type(\"str\")", ast->toString().c_str());
279
280 ASSERT_TRUE(Parse(":Int32[3]( \"str\" ) "));
281 ASSERT_STREQ(":Int32[3](\"str\")", ast->toString().c_str());
282
283 ASSERT_TRUE(Parse(":Int32[2,2](1,2,3,4);"));
284 ASSERT_STREQ(":Int32[2,2](1, 2, 3, 4)", ast->toString().c_str());
285
286 ASSERT_TRUE(Parse(":Int32[2,2]( 0, ... )"));
287 ASSERT_STREQ(":Int32[2,2](0, ...)", ast->toString().c_str());
288
289 ASSERT_TRUE(Parse(":Int32( ... ... dict )"));
290 ASSERT_STREQ(":Int32(... ...dict)", ast->toString().c_str());
291
292 ASSERT_TRUE(Parse(":Int32( ... dict )"));
293 ASSERT_STREQ(":Int32(...dict)", ast->toString().c_str());
294
295 ASSERT_TRUE(Parse(":Int32[2,2]( ... rand() ... )"));
296 ASSERT_STREQ(":Int32[2,2](...rand()...)", ast->toString().c_str());
297
298 ASSERT_TRUE(Parse(":type[10]( 1, 2, ... rand() ... )"));
299 ASSERT_STREQ(":type[10](1, 2, ...rand()...)", ast->toString().c_str());
300
301 ASSERT_TRUE(Parse(":range( 0..100 )"));
302 ASSERT_STREQ(":range(0..100)", ast->toString().c_str());
303
304 ASSERT_TRUE(Parse("range( 0 .. 100 .. 0.1 )"));
305 ASSERT_STREQ("range(0..100..0.1)", ast->toString().c_str());
306}
307
308/*
309 * - Установка типов у литералов
310 * - Проверка соответствия типов литералов и их значений
311 *
312 * - Встроенные функции преобразования простых типов данных
313 * - Передача аргументов функций по ссылкам
314 * - Проверка типов аргументов при вызове функций
315 * - Проверка типов возвращаемых значений у функций
316 * - Проверка типов у операторов присвоения
317 */
318TEST_F(ParserTest, ScalarType) {
319 /*
320 * - Установка типов у литералов
321 * - Проверка соответствия типов литералов и их значений
322 */
323
324 ASSERT_TRUE(Parse("0;"));
325 ASSERT_TRUE(ast->m_type);
326 ASSERT_TRUE(isDefaultType(ast->m_type));
327 ASSERT_STREQ("0", ast->toString().c_str());
328 ASSERT_STREQ(":Bool", ast->m_type->m_text.c_str());
329
330 ASSERT_TRUE(Parse("1;"));
331 ASSERT_TRUE(ast->m_type);
332 ASSERT_TRUE(isDefaultType(ast->m_type));
333 ASSERT_STREQ("1", ast->toString().c_str());
334 ASSERT_STREQ(":Bool", ast->m_type->m_text.c_str());
335
336 ASSERT_TRUE(Parse("2;"));
337 ASSERT_STREQ("2", ast->toString().c_str());
338 ASSERT_TRUE(ast->m_type);
339 ASSERT_TRUE(isDefaultType(ast->m_type));
340 ASSERT_STREQ(":Int8", ast->m_type->m_text.c_str());
341
342 ASSERT_TRUE(Parse("2_2;"));
343 ASSERT_STREQ("2_2", ast->toString().c_str());
344 ASSERT_TRUE(ast->m_type);
345 ASSERT_TRUE(isDefaultType(ast->m_type));
346 ASSERT_STREQ(":Int8", ast->m_type->m_text.c_str());
347
348 ASSERT_TRUE(Parse("-1;"));
349 ASSERT_STREQ("-1", ast->toString().c_str());
350 ASSERT_TRUE(ast->m_type);
351 ASSERT_TRUE(isDefaultType(ast->m_type));
352 ASSERT_STREQ(":Int8", ast->m_type->m_text.c_str());
353
354 ASSERT_TRUE(Parse("256;"));
355 ASSERT_STREQ("256", ast->toString().c_str());
356 ASSERT_TRUE(ast->m_type);
357 ASSERT_TRUE(isDefaultType(ast->m_type));
358 ASSERT_STREQ(":Int16", ast->m_type->m_text.c_str());
359
360 ASSERT_TRUE(Parse("10_000;"));
361 ASSERT_STREQ("10_000", ast->toString().c_str());
362 ASSERT_TRUE(ast->m_type);
363 ASSERT_TRUE(isDefaultType(ast->m_type));
364 ASSERT_STREQ(":Int16", ast->m_type->m_text.c_str());
365
366 ASSERT_TRUE(Parse("100_000;"));
367 ASSERT_STREQ("100_000", ast->toString().c_str());
368 ASSERT_TRUE(ast->m_type);
369 ASSERT_TRUE(isDefaultType(ast->m_type));
370 ASSERT_STREQ(":Int32", ast->m_type->m_text.c_str());
371
372 ASSERT_TRUE(Parse("0.0;"));
373 ASSERT_STREQ("0.0", ast->toString().c_str());
374 ASSERT_TRUE(ast->m_type);
375 ASSERT_TRUE(isDefaultType(ast->m_type));
376 ASSERT_STREQ(":Float64", ast->m_type->m_text.c_str());
377
378
379
380 ASSERT_TRUE(Parse("0:Bool;"));
381 ASSERT_STREQ("0:Bool", ast->toString().c_str());
382 ASSERT_TRUE(ast->m_type);
383 ASSERT_FALSE(isDefaultType(ast->m_type));
384 ASSERT_STREQ(":Bool", ast->m_type->m_text.c_str());
385
386 ASSERT_TRUE(Parse("0:Int32;"));
387 ASSERT_STREQ("0:Int32", ast->toString().c_str());
388 ASSERT_TRUE(ast->m_type);
389 ASSERT_FALSE(isDefaultType(ast->m_type));
390 ASSERT_STREQ(":Int32", ast->m_type->m_text.c_str());
391
392 ASSERT_TRUE(Parse("0:Int64;"));
393 ASSERT_STREQ("0:Int64", ast->toString().c_str());
394 ASSERT_TRUE(ast->m_type);
395 ASSERT_FALSE(isDefaultType(ast->m_type));
396 ASSERT_STREQ(":Int64", ast->m_type->m_text.c_str());
397
398 ASSERT_TRUE(Parse("0:Float32;"));
399 ASSERT_STREQ("0:Float32", ast->toString().c_str());
400 ASSERT_TRUE(ast->m_type);
401 ASSERT_FALSE(isDefaultType(ast->m_type));
402 ASSERT_STREQ(":Float32", ast->m_type->m_text.c_str());
403
404 // ASSERT_TRUE(Parse("0 : Half"));
405 // ASSERT_STREQ("0:Half", ast->toString().c_str());
406 // ASSERT_STREQ(":Half", ast->m_type->m_text.c_str());
407
408 ASSERT_TRUE(Parse("0:Float64;"));
409 ASSERT_STREQ("0:Float64", ast->toString().c_str());
410 ASSERT_TRUE(ast->m_type);
411 ASSERT_FALSE(isDefaultType(ast->m_type));
412 ASSERT_STREQ(":Float64", ast->m_type->m_text.c_str());
413
414
415 ASSERT_TRUE(Parse("1:Bool;"));
416 ASSERT_STREQ("1:Bool", ast->toString().c_str());
417 ASSERT_TRUE(ast->m_type);
418 ASSERT_FALSE(isDefaultType(ast->m_type));
419 ASSERT_STREQ(":Bool", ast->m_type->m_text.c_str());
420
421 ASSERT_TRUE(Parse("1:Int8;"));
422 ASSERT_STREQ("1:Int8", ast->toString().c_str());
423 ASSERT_TRUE(ast->m_type);
424 ASSERT_FALSE(isDefaultType(ast->m_type));
425 ASSERT_STREQ(":Int8", ast->m_type->m_text.c_str());
426
427 ASSERT_TRUE(Parse("1:Int8;"));
428 ASSERT_STREQ("1:Int8", ast->toString().c_str());
429 ASSERT_TRUE(ast->m_type);
430 ASSERT_FALSE(isDefaultType(ast->m_type));
431 ASSERT_STREQ(":Int8", ast->m_type->m_text.c_str());
432
433 ASSERT_TRUE(Parse("1:Float64;"));
434 ASSERT_STREQ("1:Float64", ast->toString().c_str());
435 ASSERT_TRUE(ast->m_type);
436 ASSERT_FALSE(isDefaultType(ast->m_type));
437 ASSERT_STREQ(":Float64", ast->m_type->m_text.c_str());
438
439 ASSERT_TRUE(Parse("2:Int16;"));
440 ASSERT_STREQ("2:Int16", ast->toString().c_str());
441 ASSERT_TRUE(ast->m_type);
442 ASSERT_FALSE(isDefaultType(ast->m_type));
443 ASSERT_STREQ(":Int16", ast->m_type->m_text.c_str());
444
445 ASSERT_TRUE(Parse("2_2:Int32;"));
446 ASSERT_STREQ("2_2:Int32", ast->toString().c_str());
447 ASSERT_TRUE(ast->m_type);
448 ASSERT_FALSE(isDefaultType(ast->m_type));
449 ASSERT_STREQ(":Int32", ast->m_type->m_text.c_str());
450
451 ASSERT_TRUE(Parse("-1:Int8;"));
452 ASSERT_STREQ("-1:Int8", ast->toString().c_str());
453 ASSERT_TRUE(ast->m_type);
454 ASSERT_FALSE(isDefaultType(ast->m_type));
455 ASSERT_STREQ(":Int8", ast->m_type->m_text.c_str());
456
457 ASSERT_TRUE(Parse("-1 :Int64;"));
458 ASSERT_STREQ("-1:Int64", ast->toString().c_str());
459 ASSERT_TRUE(ast->m_type);
460 ASSERT_FALSE(isDefaultType(ast->m_type));
461 ASSERT_STREQ(":Int64", ast->m_type->m_text.c_str());
462
463 ASSERT_TRUE(Parse("256 :Int16;"));
464 ASSERT_STREQ("256:Int16", ast->toString().c_str());
465 ASSERT_TRUE(ast->m_type);
466 ASSERT_FALSE(isDefaultType(ast->m_type));
467 ASSERT_STREQ(":Int16", ast->m_type->m_text.c_str());
468
469 ASSERT_TRUE(Parse("10_000 :Int64;"));
470 ASSERT_STREQ("10_000:Int64", ast->toString().c_str());
471 ASSERT_TRUE(ast->m_type);
472 ASSERT_FALSE(isDefaultType(ast->m_type));
473 ASSERT_STREQ(":Int64", ast->m_type->m_text.c_str());
474
475 // ASSERT_THROW(Parse("10__000"), parser_exception);
476
477 ASSERT_TRUE(Parse("100_000: Int32;"));
478 ASSERT_STREQ("100_000:Int32", ast->toString().c_str());
479 ASSERT_TRUE(ast->m_type);
480 ASSERT_FALSE(isDefaultType(ast->m_type));
481 ASSERT_STREQ(":Int32", ast->m_type->m_text.c_str());
482
483 ASSERT_TRUE(Parse("-100_000: Int32;"));
484 ASSERT_STREQ("-100_000:Int32", ast->toString().c_str());
485 ASSERT_TRUE(ast->m_type);
486 ASSERT_FALSE(isDefaultType(ast->m_type));
487 ASSERT_STREQ(":Int32", ast->m_type->m_text.c_str());
488
489 ASSERT_TRUE(Parse("1.0 : Float32;"));
490 ASSERT_STREQ("1.0:Float32", ast->toString().c_str());
491 ASSERT_TRUE(ast->m_type);
492 ASSERT_FALSE(isDefaultType(ast->m_type));
493 ASSERT_STREQ(":Float32", ast->m_type->m_text.c_str());
494
495
496 ASSERT_TRUE(Parse("-0.0 :Float64;"));
497 ASSERT_STREQ("-0.0:Float64", ast->toString().c_str());
498 ASSERT_TRUE(ast->m_type);
499 ASSERT_FALSE(isDefaultType(ast->m_type));
500 ASSERT_STREQ(":Float64", ast->m_type->m_text.c_str());
501
502 ASSERT_ANY_THROW(Parse("2:Bool;"));
503 ASSERT_ANY_THROW(Parse("-1:Bool;"));
504 ASSERT_ANY_THROW(Parse("300:Int8;"));
505 ASSERT_ANY_THROW(Parse("100000:Int16;"));
506 ASSERT_ANY_THROW(Parse("0.0:Bool;"));
507 ASSERT_ANY_THROW(Parse("0.0:Int8;"));
508 ASSERT_ANY_THROW(Parse("0.0:Int32;"));
509 ASSERT_ANY_THROW(Parse("0.0:Int64;"));
510}
511
512TEST_F(ParserTest, TensorType) {
513 ASSERT_TRUE(Parse("term:Int8[1,2] := [ [1,2,],[3,4,],];"));
514 ASSERT_STREQ("term:Int8[1,2] := [[1, 2,], [3, 4,],];", ast->toString().c_str());
515
516 ASSERT_TRUE(Parse("term[..., 3] := 0;"));
517 ASSERT_STREQ("term[..., 3] := 0;", ast->toString().c_str());
518
519 ASSERT_TRUE(Parse("term []= [2, 3,]:Int32;"));
520 ASSERT_STREQ("term []= [2, 3,]:Int32;", ast->toString().c_str());
521
522 ASSERT_TRUE(Parse(":Bool();"));
523 ASSERT_TRUE(Parse(":Bool[...]();"));
524 ASSERT_TRUE(Parse(":Bool[1]();"));
525
526 ASSERT_TRUE(Parse(":Bool[_]();"));
527 ASSERT_TRUE(Parse("1.._..2"));
528 ASSERT_TRUE(Parse("1.._"));
529 ASSERT_TRUE(Parse(":Bool[1.._..2]();"));
530 ASSERT_TRUE(Parse(":Bool[1.._]();"));
531
532 // ASSERT_TRUE(Parse("term[1, 3] :$type []= [[1,2,3,],];"));
533 // ASSERT_STREQ("term[1, 3]:$type []= [[1, 2, 3,],];", ast->toString().c_str());
534
535 // ASSERT_EQ(TermID::TERM, ast->getTermID()) << EnumStr(ast->getTermID());
536 // ASSERT_STREQ("term", ast->m_text.c_str());
537 // ASSERT_TRUE(ast->Right());
538 //
539 // ASSERT_EQ(TermID::INDEX, ast->Right()->getTermID()) << EnumStr(ast->getTermID());
540 // ASSERT_EQ(2, ast->Right()->size());
541 // ASSERT_STREQ("1", (*ast->Right())[0]->getText().c_str());
542 // ASSERT_STREQ("2", (*ast->Right())[1]->getText().c_str());
543 //
544 // ASSERT_TRUE(Parse("term[1, 1..2, 3];"));
545 //
546 // ASSERT_EQ(TermID::INDEX, ast->Right()->getTermID()) << EnumStr(ast->getTermID());
547 // ASSERT_EQ(3, ast->Right()->size());
548 // ASSERT_STREQ("1", (*ast->Right())[0]->getText().c_str());
549 // ASSERT_STREQ("1..2", (*ast->Right())[1]->toString().c_str());
550 // ASSERT_STREQ("3", (*ast->Right())[2]->getText().c_str());
551}
552
553TEST_F(ParserTest, DictType) {
554 ASSERT_TRUE(Parse("(1,2,)"));
555 ASSERT_STREQ("(1, 2,)", ast->toString().c_str());
556
557 ASSERT_TRUE(Parse("(1, arg=2,)"));
558 ASSERT_STREQ("(1, arg=2,)", ast->toString().c_str());
559
560 ASSERT_TRUE(Parse("(1, arg=2, '',)"));
561 ASSERT_STREQ("(1, arg=2, '',)", ast->toString().c_str());
562
563 ASSERT_TRUE(Parse("(1, .arg=2,)"));
564 ASSERT_STREQ("(1, arg=2,)", ast->toString().c_str());
565
566 ASSERT_TRUE(Parse("(1, arg=2, '',)"));
567 ASSERT_STREQ("(1, arg=2, '',)", ast->toString().c_str());
568 // ASSERT_TRUE(Parse("(arg1=, arg2=22, arg3=,):Enum"));
569 // ASSERT_STREQ("(arg1=, arg2=22, arg3=,):Enum", ast->toString().c_str());
570
571 ASSERT_TRUE(Parse("(1, arg=2, '',):Class"));
572 ASSERT_STREQ("(1, arg=2, '',):Class", ast->toString().c_str());
573}
574
575TEST_F(ParserTest, TermNoArg) {
576 ASSERT_TRUE(Parse("term();"));
577 ASSERT_TRUE(ast->isCall());
578 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
579 ASSERT_STREQ("term", ast->m_text.c_str());
580
581 ASSERT_TRUE(Parse("term();"));
582 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
583 ASSERT_STREQ("term", ast->m_text.c_str());
584}
585
586TEST_F(ParserTest, TermFullName2) {
587 ASSERT_TRUE(Parse("term::name::name2;"));
588 ASSERT_STREQ("term::name::name2", ast->toString().c_str());
589}
590
591TEST_F(ParserTest, TermFullName3) {
592 ASSERT_TRUE(Parse("term::name::name2();"));
593 ASSERT_STREQ("term::name::name2()", ast->toString().c_str());
594}
595
596TEST_F(ParserTest, TermFullName4) {
597 ASSERT_TRUE(Parse("term::name::name2();"));
598 ASSERT_STREQ("term::name::name2()", ast->toString().c_str());
599}
600
601TEST_F(ParserTest, TermFullName5) {
602 ASSERT_TRUE(Parse("::term::name::name2;"));
603 ASSERT_STREQ("::term::name::name2", ast->toString().c_str());
604}
605
606TEST_F(ParserTest, TermFullName6) {
607 ASSERT_TRUE(Parse("::term::name::name2();"));
608 ASSERT_STREQ("::term::name::name2()", ast->toString().c_str());
609}
610
611TEST_F(ParserTest, TermFullName7) {
612 ASSERT_TRUE(Parse("::term::name::name2();"));
613 ASSERT_STREQ("::term::name::name2()", ast->toString().c_str());
614}
615
616TEST_F(ParserTest, TermFullName8) {
617 ASSERT_TRUE(Parse("::name2(arg);"));
618 ASSERT_STREQ("::name2(arg)", ast->toString().c_str());
619}
620
621TEST_F(ParserTest, TermFullName9) {
622 ASSERT_TRUE(Parse("name::name2(arg);"));
623 ASSERT_STREQ("name::name2(arg)", ast->toString().c_str());
624}
625
626TEST_F(ParserTest, FuncNoArg) {
627 ASSERT_TRUE(Parse("@term();"));
628 ASSERT_EQ(TermID::MACRO, ast->getTermID()) << newlang::toString(ast->getTermID());
629 ASSERT_STREQ("@term", ast->m_text.c_str());
630}
631
632TEST_F(ParserTest, TermNoArgSpace) {
633 ASSERT_TRUE(Parse("term( );"));
634 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
635 ASSERT_STREQ("term", ast->m_text.c_str());
636 ASSERT_EQ(0, ast->size());
637}
638
639TEST_F(ParserTest, TermArgTerm) {
640 ASSERT_TRUE(Parse("term(arg);"));
641 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
642 ASSERT_STREQ("term", ast->m_text.c_str());
643 ASSERT_EQ(1, ast->size());
644 ASSERT_STREQ("arg", (*ast)[0].second->m_text.c_str());
645 ASSERT_FALSE((*ast)[0].second->m_ref);
646
647
648 ASSERT_TRUE(Parse("term(name=value);"));
649 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
650 ASSERT_STREQ("term", ast->m_text.c_str());
651
652 ASSERT_EQ(1, ast->size());
653 ASSERT_STREQ("name", (*ast)[0].second->getName().c_str());
654 ASSERT_STREQ("value", (*ast)[0].second->getText().c_str());
655 ASSERT_FALSE((*ast)[0].second->m_ref);
656}
657
658TEST_F(ParserTest, TermArgTermRef) {
659 ASSERT_TRUE(Parse("term(&arg);"));
660 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
661 ASSERT_STREQ("term", ast->m_text.c_str());
662 ASSERT_EQ(1, ast->size());
663 ASSERT_STREQ("arg", (*ast)[0].second->m_text.c_str());
664 ASSERT_TRUE((*ast)[0].second->m_ref);
665
666
667 ASSERT_TRUE(Parse("term(name=&value);"));
668 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
669 ASSERT_STREQ("term", ast->m_text.c_str());
670
671 ASSERT_EQ(1, ast->size());
672 ASSERT_STREQ("name", (*ast)[0].second->getName().c_str());
673 ASSERT_STREQ("value", (*ast)[0].second->getText().c_str());
674 ASSERT_TRUE((*ast)[0].second->m_ref);
675
676
677 ASSERT_TRUE(Parse("term(name=&?value);"));
678 ASSERT_TRUE(Parse("term(name=&&value);"));
679 ASSERT_TRUE(Parse("term(name=&*value);"));
680 ASSERT_TRUE(Parse("term(&?name=value);"));
681 ASSERT_TRUE(Parse("term(&&name=value);"));
682 ASSERT_TRUE(Parse("term(&*name=value);"));
683
684}
685
686TEST_F(ParserTest, Misc) {
687
688 ASSERT_NO_THROW(Parse("func(arg:Int32) := { };"));
689 ASSERT_NO_THROW(Parse("func(arg:~Int32) := { };"));
690 ASSERT_NO_THROW(Parse("func(arg:~~Int32) := { };"));
691 ASSERT_NO_THROW(Parse("func(arg:~~~Int32) := { };"));
692
693 ASSERT_NO_THROW(Parse("func( & arg:Int32 ) := { };"));
694 ASSERT_NO_THROW(Parse("func( &? arg:Int32 ) := { };"));
695 ASSERT_NO_THROW(Parse("func( &* arg:Int32 ) := { };"));
696 ASSERT_NO_THROW(Parse("func( && arg:Int32 ) := { };"));
697
698 ASSERT_ANY_THROW(Parse("func( & arg:Int32 = 0 ) := { };"));
699 ASSERT_ANY_THROW(Parse("func( &? arg:Int32 = 0 ) := { };"));
700 ASSERT_ANY_THROW(Parse("func( &* arg:Int32 = 0 ) := { };"));
701 ASSERT_ANY_THROW(Parse("func( && arg:Int32 = 0 ) := { };"));
702
703 ASSERT_NO_THROW(Parse("func( & arg:Int32 = term ) := { };"));
704 ASSERT_NO_THROW(Parse("func( &? arg:Int32 = term ) := { };"));
705 ASSERT_NO_THROW(Parse("func( &* arg:Int32 = term ) := { };"));
706 ASSERT_NO_THROW(Parse("func( && arg:Int32 = term ) := { };"));
707
708 ASSERT_NO_THROW(Parse("func( & arg ) := { };"));
709 ASSERT_NO_THROW(Parse("func( &? arg ) := { };"));
710 ASSERT_NO_THROW(Parse("func( &* arg ) := { };"));
711 ASSERT_NO_THROW(Parse("func( && arg ) := { };"));
712
713 ASSERT_NO_THROW(Parse("func( & arg = func() ) := { };"));
714 ASSERT_NO_THROW(Parse("func( &? arg = func() ) := { };"));
715 ASSERT_NO_THROW(Parse("func( &* arg = func() ) := { };"));
716 ASSERT_NO_THROW(Parse("func( && arg = func() ) := { };"));
717
718 ASSERT_ANY_THROW(Parse("func( & arg = 0 ) := { };"));
719 ASSERT_ANY_THROW(Parse("func( &? arg = 0 ) := { };"));
720 ASSERT_ANY_THROW(Parse("func( &* arg = 0 ) := { };"));
721 ASSERT_ANY_THROW(Parse("func( && arg = 0 ) := { };"));
722
723 ASSERT_NO_THROW(Parse("func( & arg = term(0) ) := { };"));
724 ASSERT_NO_THROW(Parse("func( &? arg = term(0) ) := { };"));
725 ASSERT_NO_THROW(Parse("func( &* arg = term(0) ) := { };"));
726 ASSERT_NO_THROW(Parse("func( && arg = term(0) ) := { };"));
727
728 ASSERT_ANY_THROW(Parse("func( & arg:Int32 = 0 ) := { };"));
729 ASSERT_ANY_THROW(Parse("func( &? arg:~Int32 = 0 ) := { };"));
730 ASSERT_ANY_THROW(Parse("func( &* arg:~~Int32 = 0 ) := { };"));
731 ASSERT_ANY_THROW(Parse("func( && arg:~~~Int32 = 0 ) := { };"));
732
733 ASSERT_NO_THROW(Parse("func( & arg:Int32 = val ) := { };"));
734 ASSERT_NO_THROW(Parse("func( &? arg:~Int32 = val ) := { };"));
735 ASSERT_NO_THROW(Parse("func( &* arg:~~Int32 = val ) := { };"));
736 ASSERT_NO_THROW(Parse("func( && arg:~~~Int32 = val ) := { };"));
737
738 ASSERT_NO_THROW(Parse("func( & arg:Int32 = term(0) ) := { };"));
739 ASSERT_NO_THROW(Parse("func( &? arg:~Int32 = term(0) ) := { };"));
740 ASSERT_NO_THROW(Parse("func( &* arg:~~Int32 = term(0) ) := { };"));
741 ASSERT_NO_THROW(Parse("func( && arg:~~~Int32 = term(0) ) := { };"));
742
743 ASSERT_NO_THROW(Parse("func( arg = & val );"));
744 ASSERT_NO_THROW(Parse("func( arg = &? val );"));
745 ASSERT_NO_THROW(Parse("func( arg = &* val );"));
746 ASSERT_NO_THROW(Parse("func( arg = && val );"));
747
748 ASSERT_NO_THROW(Parse(":RefInt32 := & :Int32;"));
749 ASSERT_NO_THROW(Parse(":RefInt32 := &? :Int32;"));
750 ASSERT_NO_THROW(Parse(":RefInt32 := &* :Int32;"));
751 ASSERT_NO_THROW(Parse(":RefInt32 := && :Int32;"));
752
753 ASSERT_NO_THROW(Parse("var:Int32 := 0;"));
754 ASSERT_NO_THROW(Parse("& var:Int32 := 0;"));
755 ASSERT_NO_THROW(Parse("&? var:Int32 := 0;"));
756 ASSERT_NO_THROW(Parse("&& var:Int32 := 0;"));
757 ASSERT_NO_THROW(Parse("&* var:Int32 := 0;"));
758
759 ASSERT_NO_THROW(Parse("var:Int32 := 0;"));
760 ASSERT_NO_THROW(Parse("&(var, __timeout__=1000) var:Int32 := 0;"));
761 ASSERT_NO_THROW(Parse("&?(var, __timeout__=1000) var:Int32 := 0;"));
762 ASSERT_NO_THROW(Parse("&&(var, __timeout__=1000) var:Int32 := 0;"));
763 ASSERT_NO_THROW(Parse("&*(var, __timeout__=1000) var:Int32 := 0;"));
764}
765
766TEST_F(ParserTest, TermArgTermSpace) {
767 ASSERT_TRUE(Parse(" \n \t term( \n arg \n ) ; \n "));
768 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
769 ASSERT_STREQ("term", ast->m_text.c_str());
770 ASSERT_EQ(1, ast->size());
771 ASSERT_STREQ("arg", (*ast)[0].second->m_text.c_str());
772}
773
774TEST_F(ParserTest, TermArgs1) {
775 ASSERT_TRUE(Parse("term(arg1);"));
776 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
777 ASSERT_STREQ("term", ast->m_text.c_str());
778 ASSERT_EQ(1, ast->size());
779 ASSERT_STREQ("arg1", (*ast)[0].second->m_text.c_str());
780}
781
782TEST_F(ParserTest, TermArgs2) {
783 ASSERT_TRUE(Parse("term(arg1,arg2);"));
784 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
785 ASSERT_STREQ("term", ast->m_text.c_str());
786 ASSERT_EQ(2, ast->size());
787 ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
788 ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
789 ASSERT_FALSE((*ast)[0].second->m_ref);
790 ASSERT_FALSE((*ast)[1].second->m_ref);
791}
792
793TEST_F(ParserTest, TermArgsRef) {
794 ASSERT_TRUE(Parse("term(*arg1, *^arg2);"));
795 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
796 ASSERT_STREQ("term", ast->m_text.c_str());
797 ASSERT_EQ(2, ast->size());
798 // ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
799 // ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
800 // ASSERT_TRUE((*ast)[0].second->m_ref);
801 // ASSERT_TRUE((*ast)[1].second->m_ref);
802
803 ASSERT_TRUE(Parse("term(. name1=*arg1, . name2=*^arg2);"));
804 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
805
806 ASSERT_TRUE(Parse("term(name1=*arg1, name2=*^arg2);"));
807 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
808 // ASSERT_STREQ("term", ast->m_text.c_str());
809 // ASSERT_EQ(2, ast->size());
810 // ASSERT_STREQ("name1", (*ast)[0].first.c_str());
811 // ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
812 // ASSERT_STREQ("name2", (*ast)[1].first.c_str());
813 // ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
814 // ASSERT_TRUE((*ast)[0].second->m_ref);
815 // ASSERT_TRUE((*ast)[1].second->m_ref);
816
817 ASSERT_TRUE(Parse("term(*(arg1), *^(arg2));"));
818 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
819 // ASSERT_STREQ("term", ast->m_text.c_str());
820 // ASSERT_EQ(2, ast->size());
821 // ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
822 // ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
823 // ASSERT_TRUE((*ast)[0].second->m_ref);
824 // ASSERT_TRUE((*ast)[1].second->m_ref);
825
826 ASSERT_TRUE(Parse("term(name1=*(arg1), name2=*^(arg2));"));
827 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
828 ASSERT_STREQ("term", ast->m_text.c_str());
829 ASSERT_EQ(2, ast->size());
830 // ASSERT_STREQ("name1", (*ast)[0].first.c_str());
831 // ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
832 // ASSERT_STREQ("name2", (*ast)[1].first.c_str());
833 // ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
834 // ASSERT_TRUE((*ast)[0].second->m_ref);
835 // ASSERT_TRUE((*ast)[1].second->m_ref);
836
837
838
839 ASSERT_TRUE(Parse("term(&arg1, &&arg2, &*arg3);"));
840 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
841 ASSERT_STREQ("term", ast->m_text.c_str());
842 ASSERT_EQ(3, ast->size());
843 // ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
844 // ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
845 // ASSERT_STREQ("arg3", (*ast)[2].second->getText().c_str());
846 // ASSERT_TRUE((*ast)[0].second->m_ref);
847 // ASSERT_TRUE((*ast)[1].second->m_ref);
848 // ASSERT_TRUE((*ast)[2].second->m_ref);
849
850 ASSERT_TRUE(Parse("term(name1=&arg1, name2=&&arg2, name3=&*arg3);"));
851 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
852 ASSERT_STREQ("term", ast->m_text.c_str());
853 ASSERT_EQ(3, ast->size());
854 // ASSERT_STREQ("name1", (*ast)[0].first.c_str());
855 // ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
856 // ASSERT_STREQ("name2", (*ast)[1].first.c_str());
857 // ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
858 // ASSERT_STREQ("name2", (*ast)[2].first.c_str());
859 // ASSERT_STREQ("arg3", (*ast)[2].second->getText().c_str());
860 // ASSERT_TRUE((*ast)[0].second->m_ref);
861 // ASSERT_TRUE((*ast)[1].second->m_ref);
862 // ASSERT_TRUE((*ast)[2].second->m_ref);
863
864 ASSERT_TRUE(Parse("term(&^arg1, &&^arg2, &*^arg3);"));
865 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
866 ASSERT_STREQ("term", ast->m_text.c_str());
867 ASSERT_EQ(3, ast->size());
868 // ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
869 // ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
870 // ASSERT_STREQ("arg3", (*ast)[2].second->getText().c_str());
871 // ASSERT_TRUE((*ast)[0].second->m_ref);
872 // ASSERT_TRUE((*ast)[1].second->m_ref);
873 // ASSERT_TRUE((*ast)[2].second->m_ref);
874
875 ASSERT_TRUE(Parse("term(name1=&^arg1, name2=&&^arg2, name3=&*^arg3);"));
876 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
877 ASSERT_STREQ("term", ast->m_text.c_str());
878 ASSERT_EQ(3, ast->size());
879 // ASSERT_STREQ("name1", (*ast)[0].first.c_str());
880 // ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
881 // ASSERT_STREQ("name2", (*ast)[1].first.c_str());
882 // ASSERT_STREQ("arg2", (*ast)[1].second->getText().c_str());
883 // ASSERT_STREQ("name2", (*ast)[2].first.c_str());
884 // ASSERT_STREQ("arg3", (*ast)[2].second->getText().c_str());
885 // ASSERT_TRUE((*ast)[0].second->m_ref);
886 // ASSERT_TRUE((*ast)[1].second->m_ref);
887 // ASSERT_TRUE((*ast)[2].second->m_ref);
888
889}
890
891TEST_F(ParserTest, TermArgMixed) {
892 ASSERT_TRUE(Parse("term(\narg1,\n arg2\n = \narg3 \n);"));
893 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
894 ASSERT_STREQ("term", ast->m_text.c_str());
895
896 ASSERT_EQ(2, ast->size());
897 ASSERT_STREQ("arg1", (*ast)[0].second->getText().c_str());
898 ASSERT_STREQ("arg2", (*ast)[1].second->getName().c_str());
899 ASSERT_STREQ("arg3", (*ast)[1].second->getText().c_str());
900}
901
902TEST_F(ParserTest, ArgsType) {
903 ASSERT_TRUE(Parse("term(bool:Bool=term(100), int:Int32=100, long:Int64=@term()):Float64:={long;};"));
904 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
905 ASSERT_STREQ("term(bool:Bool=term(100), int:Int32=100, long:Int64=@term()):Float64 := {long;};", ast->toString().c_str());
906
907 ASSERT_TRUE(Parse("term(&bool:~Bool=term(100), &* int:~Int32=name::name, &? long:~~Int64=@term()):~~~Float64:={long;};"));
908 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
909 // ASSERT_STREQ("term(bool:Bool=&term(100), int:Int32=&*name::name, long:Int64=&?@term()):Float64 := {long;};;", ast->toString().c_str());
910}
911
912TEST_F(ParserTest, ArgsType1) {
913 ASSERT_TRUE(Parse("term(long:Int64=@term());"));
914 ASSERT_STREQ("term(long:Int64=@term())", ast->toString().c_str());
915}
916
917TEST_F(ParserTest, Any) {
918 ASSERT_TRUE(Parse("term((,));"));
919 ASSERT_TRUE(Parse("term([1,]);"));
920 ASSERT_TRUE(Parse("term((,):Class);"));
921 ASSERT_TRUE(Parse("term([1,]:Int8);"));
922 ASSERT_TRUE(Parse("term(1..2);"));
923 ASSERT_TRUE(Parse("term(1..2..1\\1);"));
924
925 ASSERT_TRUE(Parse("term(name=(,));"));
926 ASSERT_TRUE(Parse("term(name=[1,]);"));
927 ASSERT_TRUE(Parse("term(name=(,):Class);"));
928 ASSERT_TRUE(Parse("term(name=[1,]:Int8);"));
929 ASSERT_TRUE(Parse("term(name=1..2);"));
930 ASSERT_TRUE(Parse("term(name=1..2..1\\1);"));
931
932 ASSERT_TRUE(Parse("term(1, name=(,));"));
933 ASSERT_TRUE(Parse("term(1, name=[1,]);"));
934 ASSERT_TRUE(Parse("term(1, name=(,):Class);"));
935 ASSERT_TRUE(Parse("term(1, name=[1,]:Int8);"));
936 ASSERT_TRUE(Parse("term(1, name=1..2);"));
937 ASSERT_TRUE(Parse("term(1, name=1..2..1\\1);"));
938
939}
940
941TEST_F(ParserTest, TermCall) {
942 ASSERT_TRUE(Parse("var2 := min(200, var, 400);"));
943 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
944 ASSERT_STREQ(":=", ast->m_text.c_str());
945
946
947 TermPtr right = ast->Right();
948 ASSERT_TRUE(right);
949 ASSERT_EQ(3, right->size());
950 ASSERT_STREQ("200", (*right)[0].second->getText().c_str());
951 ASSERT_FALSE((*right)[0].second->m_left);
952 ASSERT_FALSE((*right)[0].second->m_right);
953 ASSERT_STREQ("var", (*right)[1].second->getText().c_str());
954 ASSERT_FALSE((*right)[1].second->m_left);
955 ASSERT_FALSE((*right)[1].second->m_right);
956 ASSERT_STREQ("400", (*right)[2].second->getText().c_str());
957 ASSERT_FALSE((*right)[2].second->m_left);
958 ASSERT_FALSE((*right)[2].second->m_right);
959}
960
961TEST_F(ParserTest, TermCollection) {
962 ASSERT_TRUE(Parse("term([2,], [arg1,arg2,]);"));
963 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
964 ASSERT_STREQ("term", ast->m_text.c_str());
965 ASSERT_EQ(2, ast->size());
966 ASSERT_EQ(TermID::TENSOR, (*ast)[0].second->getTermID()) << newlang::toString(ast->getTermID());
967 ASSERT_EQ(TermID::TENSOR, (*ast)[1].second->getTermID()) << newlang::toString(ast->getTermID());
968}
969
970TEST_F(ParserTest, TermCollection2) {
971 ASSERT_TRUE(Parse("term((,), name=[arg1,arg2,]);"));
972 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
973 ASSERT_STREQ("term", ast->m_text.c_str());
974 ASSERT_EQ(2, ast->size());
975 ASSERT_EQ(TermID::DICT, (*ast)[0].second->getTermID()) << newlang::toString((*ast)[0].second->getTermID());
976 ASSERT_EQ(TermID::TENSOR, (*ast)[1].second->getTermID()) << newlang::toString((*ast)[1].second->getTermID());
977}
978
979TEST_F(ParserTest, OpsCall) {
980 ASSERT_TRUE(Parse("call(1+1)"));
981 ASSERT_TRUE(Parse("call(1-1)"));
982 ASSERT_TRUE(Parse("call(1\\1-1)"));
983 ASSERT_TRUE(Parse("call(term+1)"));
984 ASSERT_TRUE(Parse("call(term-1)"));
985 ASSERT_TRUE(Parse("call(term+term)"));
986 ASSERT_TRUE(Parse("call(term-term)"));
987 ASSERT_TRUE(Parse("call(term-term,term*2)"));
988}
989
990TEST_F(ParserTest, ArgMixedFail) {
991 // EXPECT_THROW(
992 // Parse("term(arg2=arg3, arg1);"), std::runtime_error
993 // );
994 EXPECT_ANY_THROW(Parse("term(arg1,arg2=arg3,,);"));
995 EXPECT_ANY_THROW(Parse("term(,);"));
996
997}
998
999TEST_F(ParserTest, Iterator) {
1000 ASSERT_TRUE(Parse("term!!;"));
1001 ASSERT_STREQ("!!", ast->m_text.c_str());
1002
1003 TermPtr arg = ast->Left();
1004 ASSERT_TRUE(arg);
1005 ASSERT_STREQ("term", arg->getText().c_str());
1006
1007 ASSERT_TRUE(Parse("term(arg)!!;"));
1008 ASSERT_STREQ("!!", ast->getText().c_str());
1009
1010 arg = ast->Left();
1011 ASSERT_TRUE(arg);
1012 ASSERT_STREQ("term", arg->getText().c_str());
1013 ASSERT_EQ(1, arg->size());
1014 ASSERT_STREQ("arg", (*arg)[0].second->getText().c_str());
1015
1016 // #pragma GCC warning "ITERATOR"
1017 // ASSERT_TRUE(Parse("term(arg=value)??(100)"));
1018 // ASSERT_STREQ("??", ast->getText().c_str());
1019 // ASSERT_EQ(1, ast->getItemCount());
1020 // ASSERT_STREQ("100", (*ast)[0]->getText().c_str());
1021 //
1022 // arg = ast->Left();
1023 // ASSERT_TRUE(arg);
1024 // ASSERT_STREQ("term", arg->getText().c_str());
1025 // ASSERT_EQ(1, arg->getItemCount());
1026 // ASSERT_STREQ("arg", (*arg)[0]->getName().c_str());
1027 // ASSERT_STREQ("value", (*arg)[0]->getText().c_str());
1028 //
1029 //
1030 // ASSERT_TRUE(Parse("term2(arg=value) ?? (iter_arg=100)"));
1031 // ASSERT_EQ(1, ast->getItemCount());
1032 // ASSERT_STREQ("??", ast->getText().c_str());
1033 // ASSERT_EQ(1, ast->getItemCount());
1034 // ASSERT_STREQ("100", (*ast)[0]->getText().c_str());
1035 // ASSERT_STREQ("iter_arg", (*ast)[0]->getName().c_str());
1036 //
1037 // arg = ast->Left();
1038 // ASSERT_TRUE(arg);
1039 // ASSERT_STREQ("term2", arg->getText().c_str());
1040 // ASSERT_EQ(1, arg->getItemCount());
1041 // ASSERT_STREQ("arg", (*arg)[0]->getName().c_str());
1042 // ASSERT_STREQ("value", (*arg)[0]->getText().c_str());
1043
1044
1045
1046 // ASSERT_FALSE(Parse("term2(arg=value)?(iter_arg=100)?"));
1047 // ASSERT_FALSE(Parse("term2(arg=value)??"));
1048 EXPECT_ANY_THROW(Parse("term2(arg=value)!;?"));
1049
1050
1051 ASSERT_TRUE(Parse("term2(arg=value?);"));
1052 ASSERT_EQ(1, ast->size());
1053 ASSERT_STREQ("term2", ast->getText().c_str());
1054 ASSERT_EQ(1, ast->size());
1055 ASSERT_STREQ("arg", ast->name(0).c_str());
1056 ASSERT_STREQ("?", (*ast)[0].second->getText().c_str());
1057 ASSERT_TRUE((*ast)[0].second->Left());
1058 ASSERT_STREQ("value", (*ast)[0].second->Left()->getText().c_str());
1059
1060
1061 // @todo Проблемы с итератором у именованного аргумента !!!!!!!!!!!!!!!!!!!!
1062
1063 // ASSERT_TRUE(Parse("term2(arg=value(10)?(iter_val=555))"));
1064 // ASSERT_EQ(1, ast->getItemCount());
1065 // ASSERT_STREQ("term2", (*ast)[0]->getText().c_str());
1066 // ASSERT_EQ(1, (*ast)[0]->getItemCount());
1067 // ASSERT_STREQ("arg", (*ast)[0]->name(0).c_str());
1068 // ASSERT_STREQ("?", (*(*ast)[0])[0]->getText().c_str());
1069 // ASSERT_EQ(1, (*(*ast)[0])[0]->getItemCount());
1070 //
1071 // ASSERT_TRUE((*(*ast)[0])[0]->Left());
1072 // ASSERT_STREQ("value", (*(*ast)[0])[0]->Left()->getText().c_str());
1073 // ASSERT_EQ(1, (*(*ast)[0])[0]->Left()->getItemCount());
1074
1075}
1076
1077TEST_F(ParserTest, MathPlus) {
1078 ASSERT_TRUE(Parse("test := 123+456;"));
1079 ASSERT_STREQ(":=", ast->m_text.c_str());
1080 ASSERT_TRUE(ast->Left());
1081 ASSERT_TRUE(ast->Right());
1082 ASSERT_STREQ("test", ast->Left()->m_text.c_str());
1083 TermPtr op = ast->Right();
1084 ASSERT_TRUE(op);
1085 ASSERT_STREQ("+", op->m_text.c_str());
1086 ASSERT_TRUE(op->Right());
1087 ASSERT_TRUE(op->Left());
1088 ASSERT_STREQ("123", op->Left()->m_text.c_str());
1089 ASSERT_STREQ("456", op->Right()->m_text.c_str());
1090}
1091
1092TEST_F(ParserTest, MathMinus) {
1093 ASSERT_TRUE(Parse("test := 123-456;"));
1094 ASSERT_STREQ(":=", ast->m_text.c_str());
1095 ASSERT_TRUE(ast->Left());
1096 ASSERT_TRUE(ast->Right());
1097 ASSERT_STREQ("test", ast->Left()->m_text.c_str());
1098 TermPtr op = ast->Right();
1099 ASSERT_TRUE(op);
1100 ASSERT_STREQ("-", op->m_text.c_str());
1101 ASSERT_TRUE(op->Right());
1102 ASSERT_TRUE(op->Left());
1103 ASSERT_STREQ("123", op->Left()->m_text.c_str());
1104 ASSERT_STREQ("456", op->Right()->m_text.c_str());
1105}
1106
1107TEST_F(ParserTest, MathMul) {
1108 ASSERT_TRUE(Parse("test := 123*456;"));
1109 ASSERT_STREQ(":=", ast->m_text.c_str());
1110 ASSERT_TRUE(ast->Left());
1111 ASSERT_TRUE(ast->Right());
1112 ASSERT_STREQ("test", ast->Left()->m_text.c_str());
1113 TermPtr op = ast->Right();
1114 ASSERT_TRUE(op);
1115 ASSERT_STREQ("*", op->m_text.c_str());
1116 ASSERT_TRUE(op->Right());
1117 ASSERT_TRUE(op->Left());
1118 ASSERT_STREQ("123", op->Left()->m_text.c_str());
1119 ASSERT_STREQ("456", op->Right()->m_text.c_str());
1120}
1121
1122TEST_F(ParserTest, MathDiv) {
1123 ASSERT_TRUE(Parse("test := 123/456;"));
1124 ASSERT_STREQ(":=", ast->m_text.c_str());
1125 ASSERT_TRUE(ast->Left());
1126 ASSERT_TRUE(ast->Right());
1127 ASSERT_STREQ("test", ast->Left()->m_text.c_str());
1128 TermPtr op = ast->Right();
1129 ASSERT_TRUE(op);
1130 ASSERT_STREQ("/", op->m_text.c_str());
1131 ASSERT_TRUE(op->Right());
1132 ASSERT_TRUE(op->Left());
1133 ASSERT_STREQ("123", op->Left()->m_text.c_str());
1134 ASSERT_STREQ("456", op->Right()->m_text.c_str());
1135}
1136
1137TEST_F(ParserTest, MathNeg) {
1138 ASSERT_TRUE(Parse("test := -456;"));
1139 ASSERT_STREQ(":=", ast->m_text.c_str());
1140 ASSERT_TRUE(ast->Left());
1141 ASSERT_TRUE(ast->Right());
1142 ASSERT_STREQ("test", ast->Left()->m_text.c_str());
1143 TermPtr op = ast->Right();
1144 ASSERT_TRUE(op);
1145 ASSERT_STREQ("-456", op->m_text.c_str());
1146
1147
1148 ASSERT_TRUE(Parse("1000-456"));
1149 ASSERT_STREQ("-", ast->m_text.c_str());
1150 ASSERT_TRUE(ast->Left());
1151 ASSERT_TRUE(ast->Right());
1152 ASSERT_STREQ("1000", ast->Left()->m_text.c_str());
1153 op = ast->Right();
1154 ASSERT_TRUE(op);
1155 ASSERT_STREQ("456", op->m_text.c_str());
1156
1157 ASSERT_TRUE(Parse("-(456)"));
1158 ASSERT_STREQ("-", ast->m_text.c_str());
1159 ASSERT_FALSE(ast->Left());
1160 ASSERT_TRUE(ast->Right());
1161 op = ast->Right();
1162 ASSERT_TRUE(op);
1163 ASSERT_STREQ("456", op->m_text.c_str());
1164
1165 ASSERT_ANY_THROW(Parse("1000 456"));
1166}
1167
1168TEST_F(ParserTest, MathPrioritet) {
1169 ASSERT_TRUE(Parse("1+2*3"));
1170 ASSERT_STREQ("+", ast->m_text.c_str());
1171 ASSERT_TRUE(ast->Left());
1172 ASSERT_TRUE(ast->Right());
1173 ASSERT_STREQ("1", ast->Left()->m_text.c_str());
1174 TermPtr op = ast->Right();
1175 ASSERT_TRUE(op);
1176 ASSERT_STREQ("*", op->m_text.c_str());
1177 ASSERT_TRUE(op->Right());
1178 ASSERT_TRUE(op->Left());
1179 ASSERT_STREQ("2", op->Left()->m_text.c_str());
1180 ASSERT_STREQ("3", op->Right()->m_text.c_str());
1181
1182
1183 ASSERT_TRUE(Parse("1*2+3"));
1184 ASSERT_STREQ("+", ast->m_text.c_str());
1185 ASSERT_TRUE(ast->Left());
1186 ASSERT_TRUE(ast->Right());
1187 ASSERT_STREQ("3", ast->Right()->m_text.c_str());
1188 op = ast->Left();
1189 ASSERT_TRUE(op);
1190 ASSERT_STREQ("*", op->m_text.c_str());
1191 ASSERT_TRUE(op->Right());
1192 ASSERT_TRUE(op->Left());
1193 ASSERT_STREQ("1", op->Left()->m_text.c_str());
1194 ASSERT_STREQ("2", op->Right()->m_text.c_str());
1195
1196
1197 ASSERT_TRUE(Parse("(1*2)+3"));
1198 ASSERT_STREQ("+", ast->m_text.c_str());
1199 ASSERT_TRUE(ast->Left());
1200 ASSERT_TRUE(ast->Right());
1201 ASSERT_STREQ("3", ast->Right()->m_text.c_str());
1202 op = ast->Left();
1203 ASSERT_TRUE(op);
1204 ASSERT_STREQ("*", op->m_text.c_str());
1205 ASSERT_TRUE(op->Right());
1206 ASSERT_TRUE(op->Left());
1207 ASSERT_STREQ("1", op->Left()->m_text.c_str());
1208 ASSERT_STREQ("2", op->Right()->m_text.c_str());
1209
1210
1211 ASSERT_TRUE(Parse("1*(2+3)"));
1212 ASSERT_STREQ("*", ast->m_text.c_str());
1213 ASSERT_TRUE(ast->Left());
1214 ASSERT_TRUE(ast->Right());
1215 ASSERT_STREQ("1", ast->Left()->m_text.c_str());
1216 op = ast->Right();
1217 ASSERT_TRUE(op);
1218 ASSERT_STREQ("+", op->m_text.c_str());
1219 ASSERT_TRUE(op->Right());
1220 ASSERT_TRUE(op->Left());
1221 ASSERT_STREQ("2", op->Left()->m_text.c_str());
1222 ASSERT_STREQ("3", op->Right()->m_text.c_str());
1223}
1224
1225TEST_F(ParserTest, CodeSimple) {
1226 ASSERT_TRUE(Parse("{%code+code%};"));
1227 ASSERT_STREQ("code+code", ast->m_text.c_str());
1228}
1229
1230TEST_F(ParserTest, CodeSimple2) {
1231 ASSERT_TRUE(Parse("{% code+code %};"));
1232 ASSERT_STREQ(" code+code ", ast->m_text.c_str());
1233}
1234
1235TEST_F(ParserTest, Brakets1) {
1236 ASSERT_TRUE(Parse("(1+2)"));
1237 ASSERT_STREQ("1 + 2", ast->toString().c_str());
1238}
1239
1240TEST_F(ParserTest, Brakets2) {
1241 ASSERT_TRUE(Parse("(1==2)"));
1242 ASSERT_STREQ("1 == 2", ast->toString().c_str());
1243}
1244
1245TEST_F(ParserTest, Brakets3) {
1246 ASSERT_TRUE(Parse("(call())"));
1247 ASSERT_STREQ("call()", ast->toString().c_str());
1248}
1249
1250TEST_F(ParserTest, Brakets4) {
1251 ASSERT_TRUE(Parse("(:call())"));
1252 ASSERT_STREQ(":call()", ast->toString().c_str());
1253}
1254
1255TEST_F(ParserTest, Brakets5) {
1256 ASSERT_TRUE(Parse("(:call()==0)"));
1257 ASSERT_STREQ(":call() == 0", ast->toString().c_str());
1258}
1259
1260TEST_F(ParserTest, AssignSimple) {
1261 ASSERT_TRUE(Parse("term := term2;"));
1262 ASSERT_STREQ("term := term2;", ast->toString().c_str());
1263}
1264
1265TEST_F(ParserTest, AssignSimple2) {
1266 ASSERT_TRUE(Parse("\t term := term2() ; \n"));
1267 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1268 ASSERT_TRUE(ast->Left());
1269 ASSERT_TRUE(ast->Right());
1270 ASSERT_STREQ("term", ast->Left()->m_text.c_str());
1271 ASSERT_EQ(0, ast->Left()->size());
1272 ASSERT_STREQ("term2", ast->Right()->m_text.c_str());
1273 ASSERT_EQ(0, ast->Right()->size());
1274 ASSERT_STREQ("term := term2();", ast->toString().c_str());
1275}
1276
1277TEST_F(ParserTest, AssignFullName) {
1278 ASSERT_TRUE(Parse("term::name() := {term2;};"));
1279 ASSERT_STREQ("term::name() := {term2;};", ast->toString().c_str());
1280}
1281
1282TEST_F(ParserTest, AssignClass0) {
1283 ASSERT_TRUE(Parse("term := :Class();"));
1284 ASSERT_STREQ("term := :Class();", ast->toString().c_str());
1285}
1286
1287TEST_F(ParserTest, AssignClass1) {
1288 ASSERT_TRUE(Parse(":class := :Class() {} ;"));
1289 ASSERT_STREQ(":class := :Class(){};", ast->toString().c_str());
1290}
1291
1292TEST_F(ParserTest, AssignClass2) {
1293 ASSERT_TRUE(Parse(":class := ::ns::func(arg1, arg2=\"\") {};"));
1294 ASSERT_STREQ(":class := ::ns::func(arg1, arg2=\"\"){};", ast->toString().c_str());
1295}
1296
1297TEST_F(ParserTest, Namespace) {
1298 ASSERT_TRUE(Parse("name{ func() := {} };"));
1299 ASSERT_TRUE(Parse("name::space{ func() := {} };"));
1300 ASSERT_TRUE(Parse("::name::space{ func() := {} };"));
1301 ASSERT_TRUE(Parse("::{ func() := {} };"));
1302}
1303
1304TEST_F(ParserTest, AssignFullName2) {
1305 ASSERT_TRUE(Parse("term::name::name2() := term2;"));
1306 ASSERT_STREQ("term::name::name2() := term2;", ast->toString().c_str());
1307}
1308
1309TEST_F(ParserTest, AssignFullName3) {
1310 ASSERT_TRUE(Parse("::term::name::name3() := term2;"));
1311 ASSERT_STREQ("::term::name::name3() := term2;", ast->toString().c_str());
1312}
1313
1314//TEST_F(ParserTest, FiledAssign) {
1315// ASSERT_TRUE(Parse("$1.val := 123;"));
1316// ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1317// ASSERT_TRUE(ast->Left());
1318// ASSERT_TRUE(ast->Right());
1319//
1320// ASSERT_EQ(TermID::ARGUMENT, ast->Left()->getTermID());
1321// ASSERT_STREQ("$1", ast->Left()->m_text.c_str());
1322// ASSERT_TRUE(ast->Left()->m_name.empty());
1323//
1324// ASSERT_TRUE(ast->Left()->Right());
1325// ASSERT_STREQ("val", ast->Left()->Right()->m_text.c_str());
1326//
1327// ASSERT_EQ(TermID::INTEGER, ast->Right()->getTermID());
1328// ASSERT_STREQ("123", ast->Right()->m_text.c_str());
1329//}
1330
1331//TEST_F(ParserTest, FiledAssign2) {
1332// ASSERT_TRUE(Parse("term.field1.field2 := 123;"));
1333// ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1334// ASSERT_TRUE(ast->Left());
1335// ASSERT_TRUE(ast->Right());
1336//
1337// ASSERT_EQ(TermID::NAME, ast->Left()->getTermID());
1338// ASSERT_STREQ("term", ast->Left()->m_text.c_str());
1339// ASSERT_TRUE(ast->Left()->m_name.empty());
1340//
1341// ASSERT_TRUE(ast->Left()->Right());
1342// ASSERT_STREQ("field1", ast->Left()->Right()->m_text.c_str());
1343// ASSERT_TRUE(ast->Left()->Right()->Right());
1344// ASSERT_STREQ("field2", ast->Left()->Right()->Right()->m_text.c_str());
1345// ASSERT_FALSE(ast->Left()->Right()->Right()->Right());
1346//
1347// ASSERT_EQ(TermID::INTEGER, ast->Right()->getTermID());
1348// ASSERT_STREQ("123", ast->Right()->m_text.c_str());
1349//
1350// ASSERT_STREQ("term.field1.field2 := 123;", ast->toString().c_str());
1351//}
1352
1353TEST_F(ParserTest, ArrayAssign) {
1354 ASSERT_TRUE(Parse("$0[0] = 123;"));
1355 ASSERT_EQ(TermID::ASSIGN, ast->getTermID()) << newlang::toString(ast->getTermID());
1356 ASSERT_TRUE(ast->Left());
1357 ASSERT_TRUE(ast->Right());
1358
1359 ASSERT_EQ(TermID::ARGUMENT, ast->Left()->getTermID());
1360 ASSERT_STREQ("$0", ast->Left()->m_text.c_str());
1361 ASSERT_TRUE(ast->Left()->m_name.empty());
1362
1363 ASSERT_TRUE(ast->Left()->Right());
1364 ASSERT_EQ(TermID::INDEX, ast->Left()->Right()->getTermID());
1365 ASSERT_STREQ("[", ast->Left()->Right()->m_text.c_str());
1366 ASSERT_EQ(1, ast->Left()->Right()->size());
1367 ASSERT_STREQ("0", (*ast->Left()->Right())[0].second->m_text.c_str());
1368
1369
1370}
1371
1372TEST_F(ParserTest, DISABLED_ArrayAssign2) {
1373 ASSERT_TRUE(Parse("term[1][1..3] = 123;"));
1374 ASSERT_EQ(TermID::ASSIGN, ast->getTermID()) << newlang::toString(ast->getTermID());
1375 ASSERT_TRUE(ast->Left());
1376 ASSERT_TRUE(ast->Right());
1377
1378 ASSERT_EQ(TermID::NAME, ast->Left()->getTermID());
1379 ASSERT_STREQ("term", ast->Left()->m_text.c_str());
1380 ASSERT_TRUE(ast->Left()->m_name.empty());
1381
1382 ASSERT_TRUE(ast->Left()->Right());
1383 ASSERT_STREQ("[", ast->Left()->Right()->m_text.c_str());
1384 ASSERT_TRUE(ast->Left()->Right()->Right());
1385 ASSERT_STREQ("[", ast->Left()->Right()->Right()->m_text.c_str());
1386 ASSERT_FALSE(ast->Left()->Right()->Right()->Right());
1387
1388 ASSERT_EQ(TermID::INTEGER, ast->Right()->getTermID());
1389 ASSERT_STREQ("123", ast->Right()->m_text.c_str());
1390
1391 ASSERT_STREQ("term[1][1, 2, 3]=123;", ast->toString().c_str());
1392}
1393
1394TEST_F(ParserTest, DISABLED_FieldArray) {
1395 ASSERT_TRUE(Parse("term.val[1].field := value[-1..@count()..5].field;"));
1396 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1397 ASSERT_STREQ("term.val[1].field := value[-1..@count()..5].field;", ast->toString().c_str());
1398}
1399
1400TEST_F(ParserTest, AssignSimple3) {
1401 ASSERT_TRUE(Parse("\t term := term2( ) ; \n"));
1402 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1403 ASSERT_TRUE(ast->Left());
1404 ASSERT_TRUE(ast->Right());
1405 ASSERT_STREQ("term := term2();", ast->toString().c_str());
1406}
1407
1408TEST_F(ParserTest, AssignSimpleArg) {
1409 ASSERT_TRUE(Parse("\t term ::= term2( arg ) ; \n"));
1410 ASSERT_EQ(TermID::CREATE_ONCE, ast->getTermID()) << newlang::toString(ast->getTermID());
1411 ASSERT_TRUE(ast->Left());
1412 ASSERT_TRUE(ast->Right());
1413 ASSERT_STREQ("term ::= term2(arg);", ast->toString().c_str());
1414}
1415
1416TEST_F(ParserTest, AssignSimpleNamedArg) {
1417 ASSERT_TRUE(Parse("\t term := $term2( arg = arg2 )\n;\n\n"));
1418 ASSERT_STREQ("term := $term2(arg=arg2);", ast->toString().c_str());
1419}
1420
1421TEST_F(ParserTest, AssignNamedArgs0) {
1422 ASSERT_TRUE(Parse("\t term := \\term2( arg, arg1 = arg2 ) ; \n"));
1423 ASSERT_STREQ("term := \\term2(arg, arg1=arg2);", ast->toString().c_str());
1424}
1425
1426TEST_F(ParserTest, AssignNamedArgs1) {
1427 ASSERT_TRUE(Parse("\t term := @term2( arg, arg1 = arg2 ) ; \n"));
1428 ASSERT_STREQ("term := @term2(arg, arg1=arg2);", ast->toString().c_str());
1429}
1430
1431TEST_F(ParserTest, AssignNamedArgs2) {
1432 ASSERT_TRUE(Parse("\t term := $term2( arg, arg1 = arg2(arg3)) ; \n"));
1433 ASSERT_STREQ("term := $term2(arg, arg1=arg2(arg3));", ast->toString().c_str());
1434}
1435
1436TEST_F(ParserTest, AssignNamedArgs3) {
1437 ASSERT_TRUE(Parse("\t $term := term2( \\arg, arg1 = 123 ) ; \n"));
1438 ASSERT_STREQ("$term := term2(\\arg, arg1=123);", ast->toString().c_str());
1439}
1440
1441TEST_F(ParserTest, AssignNamedArgs4) {
1442 ASSERT_TRUE(Parse("\t %term := term2( arg, arg1 = \\arg2($arg3)) ; \n"));
1443 ASSERT_STREQ("%term := term2(arg, arg1=\\arg2($arg3));", ast->toString().c_str());
1444}
1445
1446TEST_F(ParserTest, AssignNamedArgs5) {
1447 ASSERT_TRUE(Parse("\t %term := term2( arg, arg1 = \\\\arg2($arg3)) ; \n"));
1448 ASSERT_STREQ("%term := term2(arg, arg1=\\\\arg2($arg3));", ast->toString().c_str());
1449}
1450
1451TEST_F(ParserTest, AssignNamedArgs6) {
1452 ASSERT_TRUE(Parse("\t %term := term2( arg, arg1 = @arg2($arg3)) ; \n"));
1453 ASSERT_STREQ("%term := term2(arg, arg1=@arg2($arg3));", ast->toString().c_str());
1454}
1455
1456TEST_F(ParserTest, AssignString) {
1457 ASSERT_TRUE(Parse("term := \"строка\";"));
1458 ASSERT_STREQ("term := \"строка\";", ast->toString().c_str());
1459}
1460
1461TEST_F(ParserTest, AssignString2) {
1462 ASSERT_TRUE(Parse("$2 := \"строка\" ; \n"));
1463 ASSERT_STREQ("$2 := \"строка\";", ast->toString().c_str());
1464}
1465
1466TEST_F(ParserTest, AssignStringControlChar) {
1467 ASSERT_TRUE(Parse("$2 := \"стр\\\"\t\r\xffока\\s\" ; \n"));
1468 ASSERT_STREQ("$2 := \"стр\"\t\r\xffока\x20\";", ast->toString().c_str());
1469}
1470
1471TEST_F(ParserTest, AssignStringMultiline) {
1472 ASSERT_TRUE(Parse("term := 'стр\\\n\t ока\\\n \\s' ; \n"));
1473 ASSERT_STREQ("term := 'стр\n\t ока\n \x20';", ast->toString().c_str());
1474}
1475
1476TEST_F(ParserTest, AssignDictEmpty) {
1477 ASSERT_TRUE(Parse("term := ( , );"));
1478 ASSERT_STREQ("term := (,);", ast->toString().c_str());
1479}
1480
1481TEST_F(ParserTest, AssignDict) {
1482 ASSERT_TRUE(Parse("term := (name,)"));
1483 ASSERT_TRUE(ast);
1484 ASSERT_TRUE(ast->m_left);
1485 ASSERT_TRUE(ast->m_right);
1486 ASSERT_TRUE(ast->m_right->m_id == TermID::DICT);
1487 ASSERT_STREQ("term := (name,);", ast->toString().c_str());
1488
1489 ASSERT_TRUE(Parse("term := ( 123 , )"));
1490 ASSERT_STREQ("term := (123,);", ast->toString().c_str());
1491
1492 ASSERT_TRUE(Parse("term := ( name = 123 , )"));
1493 ASSERT_STREQ("term := (name=123,);", ast->toString().c_str());
1494}
1495
1496TEST_F(ParserTest, AssignArray) {
1497 ASSERT_TRUE(Parse("term := [ 123 , ]"));
1498 ASSERT_STREQ("term := [123,];", ast->toString().c_str());
1499}
1500
1501TEST_F(ParserTest, ArgsArray1) {
1502 ASSERT_TRUE(Parse("term([1,]);"));
1503 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
1504 ASSERT_STREQ("term", ast->m_text.c_str());
1505 ASSERT_EQ(1, ast->size());
1506 ASSERT_STREQ("[1,]", (*ast)[0].second->toString().c_str());
1507}
1508
1509TEST_F(ParserTest, LogicEq) {
1510 ASSERT_TRUE(Parse("var := 1==2;"));
1511 ASSERT_STREQ("var := 1 == 2;", ast->toString().c_str());
1512}
1513
1514TEST_F(ParserTest, LogicNe) {
1515 ASSERT_TRUE(Parse("var := 1!=2;"));
1516 ASSERT_STREQ("var := 1 != 2;", ast->toString().c_str());
1517}
1518
1519TEST_F(ParserTest, InstanceName) {
1520 ASSERT_TRUE(Parse("var ~ Class"));
1521 ASSERT_TRUE(Parse("var ~ :Class"));
1522 ASSERT_TRUE(Parse("var ~ 'name'"));
1523 ASSERT_TRUE(Parse("var ~ $var"));
1524 ASSERT_TRUE(Parse("1 ~ $var"));
1525 ASSERT_TRUE(Parse("'строка' ~ 'тип'"));
1526 ASSERT_TRUE(Parse("1..20 ~ var_name"));
1527
1528 ASSERT_TRUE(Parse("var ~~ Class"));
1529 ASSERT_TRUE(Parse("var ~~ :Class"));
1530 ASSERT_TRUE(Parse("var ~~ 'name'"));
1531 ASSERT_TRUE(Parse("var ~~ $var"));
1532 ASSERT_TRUE(Parse("1 ~~ $var"));
1533 ASSERT_TRUE(Parse("'строка' ~~ 'тип'"));
1534 ASSERT_TRUE(Parse("1..20 ~~ var_name"));
1535}
1536
1537TEST_F(ParserTest, FunctionSimple) {
1538 ASSERT_TRUE(Parse("func() := {{%%}};"));
1539 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1540 ASSERT_STREQ("func() := {{%%};};", ast->toString().c_str());
1541}
1542
1543TEST_F(ParserTest, FunctionSimpleTwo) {
1544 ASSERT_TRUE(Parse("func() := {{% %};{% %}};"));
1545 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1546 ASSERT_STREQ("func() := {{% %}; {% %};};", ast->toString().c_str());
1547}
1548
1549TEST_F(ParserTest, FunctionSimple2) {
1550 ASSERT_TRUE(Parse("func(arg) := {$0:=0;};"));
1551 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1552 ASSERT_STREQ("func(arg) := {$0 := 0;};", ast->toString().c_str());
1553}
1554
1555TEST_F(ParserTest, FunctionSimple3) {
1556 ASSERT_TRUE(Parse("func(arg) := {{% %};{% %};{% %}; $99:=0;};"));
1557 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1558 ASSERT_STREQ("func(arg) := {{% %}; {% %}; {% %}; $99 := 0;};", ast->toString().c_str());
1559}
1560
1561TEST_F(ParserTest, FunctionSimple4) {
1562 ASSERT_TRUE(Parse("func(arg) := {$33:=0;};"));
1563 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1564 ASSERT_STREQ("func(arg) := {$33 := 0;};", ast->toString().c_str());
1565}
1566
1567TEST_F(ParserTest, FunctionSimple5) {
1568 ASSERT_TRUE(Parse("print(str=\"\") :={% printf(\"%s\", static_cast<char *>($str)); %};"));
1569 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1570 ASSERT_STREQ("print(str=\"\") := {% printf(\"%s\", static_cast<char *>($str)); %};", ast->toString().c_str());
1571}
1572
1573TEST_F(ParserTest, FunctionTrans2) {
1574 ASSERT_TRUE(Parse("func(arg1, arg2 = 5) :- {% return $arg1; %};"));
1575 ASSERT_STREQ("func(arg1, arg2=5) :- {% return $arg1; %};", ast->toString().c_str());
1576}
1577
1578TEST_F(ParserTest, FunctionTrans3) {
1579 ASSERT_TRUE(Parse("func(arg1, arg2 = 5) ::- {% return $arg1; %};"));
1580 ASSERT_STREQ("func(arg1, arg2=5) ::- {% return $arg1; %};", ast->toString().c_str());
1581}
1582
1583TEST_F(ParserTest, FunctionTrans4) {
1584 ASSERT_TRUE(Parse("func(arg1, arg2 = 5) :- { [$arg1 < $arg2] --> {% return $arg1; %}; };"));
1585 ASSERT_STREQ("func(arg1, arg2=5) :- {[$arg1 < $arg2]-->{% return $arg1; %};};", ast->toString().c_str());
1586}
1587
1588TEST_F(ParserTest, FunctionTrans5) {
1589 ASSERT_TRUE(Parse("func(arg1, arg2 = 5) :- { [$arg1<$arg2] --> {% return $arg1; %}, [...] --> {% return $arg2; %}; };"));
1590 ASSERT_STREQ("func(arg1, arg2=5) :- {[$arg1 < $arg2]-->{% return $arg1; %},\n [...]-->{% return $arg2; %};;};", ast->toString().c_str());
1591 // func(arg1, arg2=5) :- {[$arg1 < $arg2]-->{% return $arg1; %},\n [...]-->{% return $arg2; %};;};
1592}
1593
1594TEST_F(ParserTest, FunctionRussian1) {
1595 ASSERT_TRUE(Parse("мин(arg) := {$00:=0;};"));
1596 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1597 ASSERT_STREQ("мин(arg) := {$00 := 0;};", ast->toString().c_str());
1598}
1599
1600TEST_F(ParserTest, FunctionRussian2) {
1601 ASSERT_TRUE(Parse("мин(арг) := {$1:=0;};"));
1602 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1603 ASSERT_STREQ("мин(арг) := {$1 := 0;};", ast->toString().c_str());
1604}
1605
1606TEST_F(ParserTest, FunctionRussian3) {
1607 ASSERT_TRUE(Parse("русс(10,20);"));
1608 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
1609 ASSERT_STREQ("русс(10, 20)", ast->toString().c_str());
1610}
1611
1612TEST_F(ParserTest, FunctionRussian4) {
1613 ASSERT_TRUE(Parse("мин(10,20);"));
1614 ASSERT_EQ(TermID::NAME, ast->getTermID()) << newlang::toString(ast->getTermID());
1615 ASSERT_STREQ("мин(10, 20)", ast->toString().c_str());
1616}
1617
1618TEST_F(ParserTest, FunctionArgs) {
1619 ASSERT_TRUE(Parse("мин(...) := {$1:=0;};"));
1620 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1621 ASSERT_STREQ("мин(...) := {$1 := 0;};", ast->toString().c_str());
1622}
1623
1624TEST_F(ParserTest, FunctionArgs2) {
1625 ASSERT_TRUE(Parse("мин(arg, ...) := {$1:=0;};"));
1626 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1627 ASSERT_STREQ("мин(arg, ...) := {$1 := 0;};", ast->toString().c_str());
1628}
1629
1630TEST_F(ParserTest, FunctionArgs3) {
1631 ASSERT_TRUE(Parse("мин(arg1, arg2, ...) := {$0:=0;};"));
1632 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1633 ASSERT_STREQ("мин(arg1, arg2, ...) := {$0 := 0;};", ast->toString().c_str());
1634}
1635
1636TEST_F(ParserTest, FunctionKwArgs1) {
1637 ASSERT_TRUE(Parse("мин(...) := {$0:=0;func();var;};"));
1638 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1639 ASSERT_STREQ("мин(...) := {$0 := 0; func(); var;};", ast->toString().c_str());
1640}
1641
1642TEST_F(ParserTest, FunctionKwArgs2) {
1643 ASSERT_TRUE(Parse("мин(arg=123 , ...) := {$0:=0;};"));
1644 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1645 ASSERT_STREQ("мин(arg=123, ...) := {$0 := 0;};", ast->toString().c_str());
1646}
1647
1648TEST_F(ParserTest, FunctionKwArgs3) {
1649 ASSERT_TRUE(Parse("мин(arg1=1, arg2=2 ,...) := {$0:=0;};"));
1650 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1651 ASSERT_STREQ("мин(arg1=1, arg2=2, ...) := {$0 := 0;};", ast->toString().c_str());
1652}
1653
1654TEST_F(ParserTest, FunctionArgsAll) {
1655 ASSERT_TRUE(Parse("мин(arg1=1, arg2=2 , ...) := {$0:=0;};"));
1656 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1657 ASSERT_STREQ("мин(arg1=1, arg2=2, ...) := {$0 := 0;};", ast->toString().c_str());
1658}
1659
1660TEST_F(ParserTest, FunctionArgsAll2) {
1661 ASSERT_TRUE(Parse("мин(arg, arg1=1, arg2=2, ...) := {$0:=0;};"));
1662 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1663 ASSERT_STREQ("мин(arg, arg1=1, arg2=2, ...) := {$0 := 0;};", ast->toString().c_str());
1664}
1665
1666TEST_F(ParserTest, FunctionEmpty) {
1667 ASSERT_TRUE(Parse("мин(arg, arg1=1, arg2=2, ...) := {};"));
1668 ASSERT_STREQ("мин(arg, arg1=1, arg2=2, ...) := {};", ast->toString().c_str());
1669}
1670
1671TEST_F(ParserTest, FunctionEmpty2) {
1672 ASSERT_TRUE(Parse("мин(...) :- {};"));
1673 ASSERT_STREQ("мин(...) :- {};", ast->toString().c_str());
1674}
1675
1676TEST_F(ParserTest, FunctionArgsFail) {
1677 ASSERT_ANY_THROW(Parse("мин(... ...) := {$0:=0;};"));
1678 ASSERT_ANY_THROW(Parse("мин(arg ...) := {$0:=0;};"));
1679 ASSERT_ANY_THROW(Parse("мин(arg=1 ..., arg) := {$0:=0;};"));
1680 ASSERT_ANY_THROW(Parse("мин(arg=1, arg ...) := {$0:=0;};"));
1681 ASSERT_ANY_THROW(Parse("мин(arg=1 ...) := {$0:=0;};"));
1682}
1683
1684TEST_F(ParserTest, ArrayAdd7) {
1685 ASSERT_TRUE(Parse("name() := term2;")); // $[].name:=term2;
1686 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1687 ASSERT_STREQ("name() := term2;", ast->toString().c_str());
1688}
1689
1690TEST_F(ParserTest, Ellipsis1) {
1691 ASSERT_TRUE(Parse("name := term2(arg1 , ... ... dict);")); //
1692 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1693 ASSERT_STREQ("name := term2(arg1, ... ...dict);", ast->toString().c_str());
1694}
1695
1696//TEST_F(ParserTest, Complex1) {
1697// ASSERT_TRUE(Parse("10+20j"));
1698// ASSERT_EQ(TermID::COMPLEX, ast->getTermID()) << newlang::toString(ast->getTermID());
1699// ASSERT_STREQ("10+20j;", ast->toString().c_str());
1700//}
1701//
1702//TEST_F(ParserTest, Complex2) {
1703// ASSERT_TRUE(Parse("0j"));
1704// ASSERT_EQ(TermID::COMPLEX, ast->getTermID()) << newlang::toString(ast->getTermID());
1705// ASSERT_STREQ("0j;", ast->toString().c_str());
1706//}
1707//
1708//TEST_F(ParserTest, Complex3) {
1709// ASSERT_TRUE(Parse("0.1-0.20j"));
1710// ASSERT_EQ(TermID::COMPLEX, ast->getTermID()) << newlang::toString(ast->getTermID());
1711// ASSERT_STREQ("0.1-0.20j;", ast->toString().c_str());
1712//}
1713//
1714//TEST_F(ParserTest, Rational) {
1715// ASSERT_TRUE(Parse("1@1"));
1716// ASSERT_EQ(TermID::RATIONAL, ast->getTermID()) << newlang::toString(ast->getTermID());
1717// ASSERT_STREQ("1@1;", ast->toString().c_str());
1718//}
1719//
1720//TEST_F(ParserTest, Rational2) {
1721// ASSERT_TRUE(Parse("1@-20"));
1722// ASSERT_EQ(TermID::RATIONAL, ast->getTermID()) << newlang::toString(ast->getTermID());
1723// ASSERT_STREQ("1@-20;", ast->toString().c_str());
1724//}
1725//
1726//TEST_F(ParserTest, Rational3) {
1727// ASSERT_TRUE(Parse("-3@+11"));
1728// ASSERT_EQ(TermID::RATIONAL, ast->getTermID()) << newlang::toString(ast->getTermID());
1729// ASSERT_STREQ("-3@+11;", ast->toString().c_str());
1730//}
1731//
1732//TEST_F(ParserTest, ArrayAdd9) {
1733// ASSERT_TRUE(Parse("$name := term2"));
1734// ASSERT_EQ(TermID::CREATE_ONCE, ast->getTermID()) << newlang::toString(ast->getTermID());
1735// ASSERT_STREQ("$name := term2;", ast->toString().c_str());
1736//}
1737
1738TEST_F(ParserTest, Ellipsis2) {
1739 ASSERT_TRUE(Parse("\\name := term2( ... arg);"));
1740 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1741 ASSERT_STREQ("\\name := term2(...arg);", ast->toString().c_str());
1742}
1743
1744TEST_F(ParserTest, Func1) {
1745 ASSERT_TRUE(Parse("func_arg(arg1 :Int8, arg2) :Int8 := { $arg1+$arg2; };"));
1746 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1747 ASSERT_STREQ("func_arg(arg1:Int8, arg2):Int8 := {$arg1 + $arg2;};", ast->toString().c_str());
1748}
1749
1750TEST_F(ParserTest, Func2) {
1751 ASSERT_TRUE(Parse("func_arg(arg1:&Int8, &arg2) :&Int8 := { $arg1+$arg2; };"));
1752 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1753 ASSERT_STREQ("func_arg(arg1:&Int8, &arg2):&Int8 := {$arg1 + $arg2;};", ast->toString().c_str());
1754}
1755
1756TEST_F(ParserTest, Func3) {
1757 ASSERT_TRUE(Parse("$res:Int8 ::= func_arg(100, 100);"));
1758 ASSERT_EQ(TermID::CREATE_ONCE, ast->getTermID()) << newlang::toString(ast->getTermID());
1759 ASSERT_STREQ("$res:Int8 ::= func_arg(100, 100);", ast->toString().c_str());
1760}
1761
1762TEST_F(ParserTest, Func4) {
1763 ASSERT_TRUE(Parse("res() := func_arg(100, 100); res() := func_arg(100, 100); res() := func_arg(100, 100);"));
1764}
1765
1766TEST_F(ParserTest, Comment) {
1767 ASSERT_TRUE(Parse("#!line1"));
1768 ASSERT_TRUE(Parse("#!line1\n"));
1769 ASSERT_TRUE(Parse("#!line1\n#!line2"));
1770 ASSERT_TRUE(Parse("#!line1\n#!line2\n\n#!line4"));
1771 //ASSERT_EQ(TermID::COMMENT, ast->getTermID()) << EnumStr(ast->getTermID());
1772}
1773
1774TEST_F(ParserTest, Comment2) {
1775 ASSERT_TRUE(Parse("#!line1\n#line2\n \n\n/* \n \n */ \n"));
1776 // ASSERT_EQ(TermID::BLOCK, ast->getTermID()) << EnumStr(ast->getTermID());
1777 // ASSERT_EQ(3, ast->m_block.size());
1778 // ASSERT_EQ(TermID::COMMENT, ast->m_block[0]->getTermID()) << EnumStr(ast->getTermID());
1779 // ASSERT_EQ(TermID::COMMENT, ast->m_block[1]->getTermID()) << EnumStr(ast->getTermID());
1780 // ASSERT_EQ(TermID::COMMENT, ast->m_block[2]->getTermID()) << EnumStr(ast->getTermID());
1781}
1782
1783TEST_F(ParserTest, Comment3) {
1784 const char *str = "print(str=\"\") := { {% %} };\n"
1785 "#!/bin/nlc;\n"
1786 "\n"
1787 "\n"
1788 "# @print(\"Привет, мир!\\n\");\n";
1789 ASSERT_TRUE(Parse(str));
1790 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1791 // ASSERT_EQ(3, ast->m_block.size());
1792 // ASSERT_EQ(TermID::FUNCTION, ast->m_block[0]->getTermID())<< EnumStr(ast->getTermID());
1793 // ASSERT_EQ(TermID::COMMENT, ast->m_block[1]->getTermID())<< EnumStr(ast->getTermID());
1794 // ASSERT_EQ(TermID::COMMENT, ast->m_block[2]->getTermID())<< EnumStr(ast->getTermID());
1795}
1796
1797TEST_F(ParserTest, Comment4) {
1798 const char *str = "#!/bin/nlc;\n"
1799 "print1(str=\"\") := {% %};\n"
1800 "print2(str=\"\") := {% %};\n"
1801 "# @print(\"Привет, мир!\\n\");\n";
1802 ASSERT_TRUE(Parse(str));
1803 ASSERT_EQ(TermID::BLOCK, ast->getTermID()) << newlang::toString(ast->getTermID());
1804 ASSERT_EQ(2, ast->m_block.size());
1805 // ASSERT_EQ(TermID::COMMENT, ast->m_block[0]->getTermID()) << EnumStr(ast->getTermID());
1806 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->m_block[0]->getTermID()) << newlang::toString(ast->getTermID());
1807 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->m_block[1]->getTermID()) << newlang::toString(ast->getTermID());
1808 // ASSERT_EQ(TermID::COMMENT, ast->m_block[2]->getTermID())<< EnumStr(ast->getTermID());
1809}
1810
1811TEST_F(ParserTest, Comment5) {
1812 const char *str = "term();\n"
1813 "print1(str=\"\") := {% %};\n"
1814 "print2(str=\"\") := { {% %} };\n\n"
1815 "print3(str=\"\") := {% %};\n\n\n"
1816 "# @print(\"Привет, мир!\\n\");\n";
1817 ASSERT_TRUE(Parse(str));
1818 ASSERT_EQ(TermID::BLOCK, ast->getTermID()) << newlang::toString(ast->getTermID());
1819 ASSERT_EQ(4, ast->m_block.size());
1820 ASSERT_EQ(TermID::NAME, ast->m_block[0]->getTermID()) << newlang::toString(ast->getTermID());
1821
1822 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->m_block[1]->getTermID()) << newlang::toString(ast->getTermID());
1823 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->m_block[2]->getTermID()) << newlang::toString(ast->getTermID());
1824 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->m_block[3]->getTermID()) << newlang::toString(ast->getTermID());
1825}
1826
1827TEST_F(ParserTest, Comment6) {
1828 ASSERT_TRUE(Parse("# @@macro @@@"));
1829 ASSERT_FALSE(ast->size());
1830 ASSERT_TRUE(Parse("# @@macro @@@\n"));
1831 ASSERT_FALSE(ast->size());
1832 ASSERT_TRUE(Parse("/* @@macro @@@ */"));
1833 ASSERT_FALSE(ast->size());
1834 ASSERT_TRUE(Parse("/* @@macro @@@\n*/"));
1835 ASSERT_FALSE(ast->size());
1836 ASSERT_TRUE(Parse("/* @@macro @@@\n\n*/"));
1837 ASSERT_FALSE(ast->size());
1838 ASSERT_TRUE(Parse("/*/* @@macro @@@\n\n*/*/"));
1839 ASSERT_FALSE(ast->size());
1840}
1841
1842TEST_F(ParserTest, CommentIncluded) {
1843 // const char *str = "/* !!!!!!! \n"
1844 // "@print(\"Привет, мир!\\n\");\n*/";
1845 // "# @print(\"Привет, мир!\\n\");\n";
1846 // ASSERT_TRUE(Parse(str));
1847
1848 const char *str2 = "/* /* /* /* term();\n"
1849 "print1(str=\"\") ::= term();\n"
1850 "print2(str=\"\") ::= term();\n\n */ "
1851 "print3( */ str=\"\") ::= term();\n\n\n"
1852 "ddd */ "
1853 "# @print(\"Привет, мир!\\n\");\n";
1854 ASSERT_TRUE(Parse(str2));
1855}
1856
1857TEST_F(ParserTest, Types) {
1858 EXPECT_TRUE(Parse(":type1 := :type;"));
1859 EXPECT_TRUE(Parse(":type2 := :type;"));
1860 EXPECT_TRUE(Parse(":type3 := type();"));
1861 EXPECT_TRUE(Parse(":type4 := type();;"));
1862
1863 // EXPECT_TRUE(Parse(":type5 ::= ()"));
1864 // EXPECT_TRUE(Parse(":type6 ::= ();"));
1865 EXPECT_TRUE(Parse(":type7 ::= :Type;"));
1866 EXPECT_TRUE(Parse(":type8 ::= :Type();;"));
1867
1868 EXPECT_TRUE(Parse(":type9 := (1234,);"));
1869 EXPECT_TRUE(Parse(":type10 := (1234, name=1234,);"));
1870 EXPECT_TRUE(Parse(":type11 := class1(1234);"));
1871 EXPECT_TRUE(Parse(":type12 := :class1(1234, name=1234);;"));
1872
1873 // EXPECT_TRUE(Parse(":type13 := class1(), class2()"));
1874 // EXPECT_TRUE(Parse(":type14 := class1(), class2(), (name=value);"));
1875 // EXPECT_TRUE(Parse(":type15 := :class1, :class1(arg, arg=222)"));
1876 // EXPECT_TRUE(Parse(":type16 := class1(args), (extra,), (extra=222,);"));
1877
1878 EXPECT_TRUE(Parse(":type17 := class(1234);"));
1879 // EXPECT_TRUE(Parse(":type18 := class(name=1234), class2();"));
1880 // EXPECT_TRUE(Parse(":type19 := class(name=1234), class2()"));
1881 EXPECT_TRUE(Parse(":type20 := (1234, name=1234,);"));
1882}
1883
1884TEST_F(ParserTest, Const2) {
1885 ASSERT_TRUE(Parse("const^ ::= \"CONST\";"));
1886 ASSERT_EQ(TermID::CREATE_ONCE, ast->getTermID()) << newlang::toString(ast->getTermID());
1887 ASSERT_STREQ("const^ ::= \"CONST\";", ast->toString().c_str());
1888}
1889
1890TEST_F(ParserTest, Const3) {
1891 ASSERT_TRUE(Parse("const^ := 123;"));
1892 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->getTermID()) << newlang::toString(ast->getTermID());
1893 ASSERT_STREQ("const^ := 123;", ast->toString().c_str());
1894}
1895
1896TEST_F(ParserTest, Sequence) {
1897 ASSERT_NO_THROW(Parse(";"));
1898 ASSERT_NO_THROW(Parse(";;"));
1899 ASSERT_NO_THROW(Parse(";;;"));
1900 ASSERT_NO_THROW(Parse("val;"));
1901 ASSERT_NO_THROW(Parse("val;val;"));
1902
1903 ASSERT_NO_THROW(Parse("val;;"));
1904 ASSERT_NO_THROW(Parse("val;;;"));
1905 ASSERT_NO_THROW(Parse("val;;;;val;;;;"));
1906
1907 ASSERT_NO_THROW(Parse("val();"));
1908 ASSERT_NO_THROW(Parse("val();val();"));
1909
1910 ASSERT_NO_THROW(Parse("val();"));
1911 ASSERT_NO_THROW(Parse("val();;;"));
1912 ASSERT_NO_THROW(Parse("val();;;val();;;"));
1913
1914 // ASSERT_NO_THROW(Parse("(){};"));
1915 ASSERT_NO_THROW(Parse("_()::={val;};"));
1916 ASSERT_NO_THROW(Parse("_()::={val;val;};"));
1917
1918 ASSERT_NO_THROW(Parse("_( ):-{val;;}; _()::={*fff;*};"));
1919 ASSERT_NO_THROW(Parse("_( ):-{val;;;}; _()::={*fff;*};;"));
1920 ASSERT_NO_THROW(Parse("_()::={val;;;;val;_()::={_()::={fff;};};};;;;"));
1921 ASSERT_NO_THROW(Parse("_()::={*val;;;;val;;;_(123, 333)::-{_()::={*fff;*};};_( ):-{fff;};*};;;;"));
1922
1923 ASSERT_NO_THROW(Parse("_()::={val();};"));
1924 ASSERT_NO_THROW(Parse("_()::={val();val();};"));
1925 ASSERT_NO_THROW(Parse("_()::={val();val();;};"));
1926
1927 ASSERT_NO_THROW(Parse("_()::={val();};"));
1928 ASSERT_NO_THROW(Parse("_()::={val();;;};;;"));
1929 ASSERT_NO_THROW(Parse("_()::= {val();;;val();;;};;;"));
1930 ASSERT_NO_THROW(Parse("_()::= {val();;;_()::={val();};;;;};;;"));
1931}
1932
1933TEST_F(ParserTest, BlockTry) {
1934 ASSERT_TRUE(Parse("_()::={*1; 2; 3;*}; 4;"));
1935 ASSERT_EQ(2, ast->m_block.size());
1936 ASSERT_EQ(TermID::BLOCK, ast->getTermID()) << newlang::toString(ast->getTermID());
1937 ASSERT_EQ(TermID::CREATE_ONCE, ast->m_block[0]->getTermID()) << newlang::toString(ast->m_block[0]->getTermID());
1938 ASSERT_EQ(TermID::INTEGER, ast->m_block[1]->getTermID()) << newlang::toString(ast->m_block[1]->getTermID());
1939
1940 ASSERT_TRUE(Parse("_():={- 1; 2; 3; --4--; 5; 6;-}; 100;"));
1941 ASSERT_EQ(2, ast->m_block.size());
1942 ASSERT_EQ(TermID::CREATE_OVERLAP, ast->m_block[0]->getTermID()) << newlang::toString(ast->m_block[0]->getTermID());
1943 ASSERT_EQ(TermID::INTEGER, ast->m_block[1]->getTermID()) << newlang::toString(ast->m_block[1]->getTermID());
1944
1945 ASSERT_TRUE(Parse("_()::-{+ 1; 2; 3; ++4++; 5; 6;+}; 100;"));
1946 ASSERT_EQ(2, ast->m_block.size());
1947 ASSERT_EQ(TermID::BLOCK, ast->getTermID()) << newlang::toString(ast->getTermID());
1948 ASSERT_EQ(TermID::PURE_OVERLAP, ast->m_block[0]->getTermID()) << newlang::toString(ast->m_block[0]->getTermID());
1949
1950 ASSERT_TRUE(Parse("_():- {1; 2; 3; ++4++; 5; 6;};"));
1951 ASSERT_EQ(0, ast->m_block.size());
1952 ASSERT_EQ(TermID::PURE_ONCE, ast->getTermID()) << newlang::toString(ast->getTermID());
1953}
1954
1955TEST_F(ParserTest, Repeat) {
1956 ASSERT_TRUE(Parse("[val] <-> val;"));
1957 ASSERT_TRUE(Parse("val <-> [val];;"));
1958 ASSERT_TRUE(Parse("[val] <-> {val;};"));
1959 ASSERT_TRUE(Parse("[val] <-> {val;};;"));
1960 ASSERT_TRUE(Parse("[val] <-> {val;};"));
1961 ASSERT_TRUE(Parse("[val] <-> {val;};;"));
1962
1963 ASSERT_TRUE(Parse("val <-> [val()];"));
1964 ASSERT_TRUE(Parse("val <-> [val()];;"));
1965 ASSERT_TRUE(Parse("[val()] <-> {val();};"));
1966 ASSERT_TRUE(Parse("[val()] <-> {val();};;"));
1967 ASSERT_TRUE(Parse("[val()] <-> {val();};"));
1968 ASSERT_TRUE(Parse("[val()] <-> {val();};;"));
1969
1970 ASSERT_TRUE(Parse("[val()] <-> {val()};val();"));
1971 ASSERT_TRUE(Parse("val <-> [val()];val();"));
1972 ASSERT_TRUE(Parse("[val()] <-> {val();val();};"));
1973 ASSERT_TRUE(Parse("[val()] <-> {val();val();};;"));
1974 ASSERT_TRUE(Parse("[val()] <-> {val();val();};"));
1975 ASSERT_TRUE(Parse("[val()] <-> {val();val();};;"));
1976}
1977
1978TEST_F(ParserTest, Else) {
1979 ASSERT_TRUE(Parse("[val] <-> val, [...]-->else;"));
1980 ASSERT_TRUE(Parse("[val] <->{val}, [...]-->{else}"));
1981}
1982
1983TEST_F(ParserTest, CheckResult) {
1984
1985 ASSERT_TRUE(Parse("{ expr }; "));
1986 ASSERT_TRUE(Parse("{- expr -}"));
1987 ASSERT_TRUE(Parse("{+ expr +}"));
1988 ASSERT_TRUE(Parse("{* expr *}"));
1989
1990 ASSERT_TRUE(Parse("{ expr }; "));
1991 ASSERT_TRUE(Parse("** {- expr -}"));
1992 ASSERT_TRUE(Parse("** {+ expr +}"));
1993 ASSERT_TRUE(Parse("** {* expr *}"));
1994
1995 ASSERT_TRUE(Parse("{ ++expr++ }; "));
1996 ASSERT_TRUE(Parse("{- +-expr-+ -}"));
1997 ASSERT_TRUE(Parse("{+ --expr-- +}"));
1998 ASSERT_TRUE(Parse("{* --expr-- *}"));
1999
2000 ASSERT_TRUE(Parse("{ ++100++ }; "));
2001 ASSERT_TRUE(Parse("{- --100-- -}"));
2002 ASSERT_TRUE(Parse("{+ --100-- +}"));
2003 ASSERT_TRUE(Parse("{* --100-- *}"));
2004
2005 ASSERT_TRUE(Parse("{ expr } :Type; "));
2006 ASSERT_TRUE(Parse("{- expr -} :Type "));
2007 ASSERT_TRUE(Parse("{+ expr +} :Type "));
2008 ASSERT_TRUE(Parse("{* expr *} :Type "));
2009
2010 // ASSERT_FALSE(Parse("{ expr }: Type "));
2011 // ASSERT_FALSE(Parse("{- expr -}: Type "));
2012 // ASSERT_FALSE(Parse("{+ expr +}: Type "));
2013 // ASSERT_FALSE(Parse("{* expr *}: Type "));
2014
2015
2016 ASSERT_TRUE(Parse("{ expr }:<:Type, :Type> "));
2017 ASSERT_TRUE(Parse("{- expr -}:<:Type, :Type> "));
2018 ASSERT_TRUE(Parse("{+ expr +}:<:Type, :Type>; "));
2019 ASSERT_TRUE(Parse("{* expr *}:<:Type, :Type>;; "));
2020
2021 ASSERT_TRUE(Parse("{ expr }:<...> "));
2022 ASSERT_TRUE(Parse("{- expr -}:<...> "));
2023 ASSERT_TRUE(Parse("{+ expr +}:<...>; "));
2024 ASSERT_TRUE(Parse("{* expr *} : < ... >;; "));
2025
2026}
2027
2028/*
2029 * \while(1) {
2030 * }
2031 * \while(1) {+
2032 * ++; # break
2033 * +}
2034 * \while(1){-
2035 * --; # break
2036 * -}
2037 * \while(1) {*
2038 * ++; # break
2039 * --; # break
2040 * *}
2041 *
2042 * \‍(){
2043 * }
2044 * \‍(){+
2045 * +}
2046 * \‍(){-
2047 * -}
2048 * \‍(){*
2049 * ++; # break
2050 * --; # break
2051 * *}
2052 *
2053 */
2054TEST_F(ParserTest, OperInt) {
2055 ASSERT_TRUE(Parse("_()::={val * val}"));
2056 ASSERT_TRUE(Parse("_()::={+val * val+}"));
2057 ASSERT_TRUE(Parse("_():None::={- val * val -}"));
2058 ASSERT_TRUE(Parse("_():None ::= {*val * val*}"));
2059 ASSERT_TRUE(Parse("_()::= {val * val}"));
2060 ASSERT_TRUE(Parse("_()::= {+val * val+}"));
2061 ASSERT_TRUE(Parse("_()::= {-val * val-}"));
2062 ASSERT_TRUE(Parse("_()::= {*val * val*}"));
2063}
2064
2065TEST_F(ParserTest, Operators) {
2066 ASSERT_TRUE(Parse("val + val;"));
2067 ASSERT_TRUE(Parse("val - val;"));
2068 ASSERT_TRUE(Parse("_()::={val * val;};"));
2069 ASSERT_TRUE(Parse("_()::={val / val;};"));
2070
2071 ASSERT_TRUE(Parse("val + val();"));
2072 ASSERT_TRUE(Parse("val - val();;"));
2073 ASSERT_TRUE(Parse("val * val();;"));
2074 ASSERT_TRUE(Parse("_()::={val / val();};"));
2075
2076 ASSERT_TRUE(Parse("val + val();"));
2077 ASSERT_TRUE(Parse("val - val();; val - val();"));
2078 ASSERT_TRUE(Parse("val * val();; val - val();;"));
2079 ASSERT_TRUE(Parse("_()::={val / val(); val - val()};;"));
2080
2081 ASSERT_TRUE(Parse("(val + val());"));
2082 ASSERT_TRUE(Parse("(val - val()) + (val - val());"));
2083 ASSERT_TRUE(Parse("(val * val()) - (val - val());"));
2084 ASSERT_TRUE(Parse("_()::={val / val() + (val - val())};"));
2085 ASSERT_TRUE(Parse("_()::= {* val * val() / (val - val()); *} :None;"));
2086
2087 ASSERT_TRUE(Parse("val + [1,2,];"));
2088 ASSERT_TRUE(Parse("val * [1,]:Int8;"));
2089 ASSERT_TRUE(Parse("val ~ (,)"));
2090 ASSERT_TRUE(Parse("val ~ (,):Class"));
2091
2092}
2093
2094TEST_F(ParserTest, Repeat0) {
2095 ASSERT_TRUE(Parse("[human || $ttttt && 123 != test[0].field ] <-> if_1;"));
2096 ASSERT_STREQ("[human || $ttttt && 123 != test[0].field]<->if_1;", ast->toString().c_str());
2097}
2098
2099TEST_F(ParserTest, Repeat1) {
2100 ASSERT_TRUE(Parse("[test == human] <-> if_1;"));
2101 ASSERT_STREQ("[test == human]<->if_1;", ast->toString().c_str());
2102}
2103
2104TEST_F(ParserTest, Repeat2) {
2105 ASSERT_TRUE(Parse("[test != human] <-> {if_1;};"));
2106 ASSERT_STREQ("[test != human]<->{if_1;};", ast->toString().c_str());
2107
2108 ASSERT_TRUE(Parse("{if_1;} <-> [test!=human];"));
2109 ASSERT_STREQ("{if_1;}<->[test != human];", ast->toString().c_str());
2110}
2111
2112TEST_F(ParserTest, Repeat3) {
2113 ASSERT_TRUE(Parse("[test != human] <-> {if_1;if_2;then3;};"));
2114 ASSERT_STREQ("[test != human]<->{if_1; if_2; then3;};", ast->toString().c_str());
2115
2116 ASSERT_TRUE(Parse("{if_1;if_2;then3;} <-> [test != human];"));
2117 ASSERT_STREQ("{if_1; if_2; then3;}<->[test != human];", ast->toString().c_str());
2118}
2119
2120TEST_F(ParserTest, Repeat4) {
2121 ASSERT_TRUE(Parse("[test()] <-> {if_1;if_2;then3;};"));
2122 ASSERT_STREQ("[test()]<->{if_1; if_2; then3;};", ast->toString().c_str());
2123
2124 ASSERT_TRUE(Parse("[test()] <-> {if_1;if_2;then3;};"));
2125 ASSERT_STREQ("[test()]<->{if_1; if_2; then3;};", ast->toString().c_str());
2126
2127 ASSERT_TRUE(Parse("{if_1;if_2;then3;} <-> [test()];"));
2128 ASSERT_STREQ("{if_1; if_2; then3;}<->[test()];", ast->toString().c_str());
2129
2130 ASSERT_TRUE(Parse("{if_1;if_2;then3;} <-> [test()];"));
2131 ASSERT_STREQ("{if_1; if_2; then3;}<->[test()];", ast->toString().c_str());
2132}
2133
2134TEST_F(ParserTest, Repeat5) {
2135 ASSERT_TRUE(Parse(" [ test! ]<-> {if_1;if_2;then3;};"));
2136 ASSERT_STREQ("[test!]<->{if_1; if_2; then3;};", ast->toString().c_str());
2137
2138 ASSERT_TRUE(Parse(" [test!] <-> {if_1;if_2;then3;};"));
2139 ASSERT_STREQ("[test!]<->{if_1; if_2; then3;};", ast->toString().c_str());
2140
2141 ASSERT_TRUE(Parse("{if_1;if_2;then3;}<->[test!];"));
2142 ASSERT_STREQ("{if_1; if_2; then3;}<->[test!];", ast->toString().c_str());
2143
2144 ASSERT_TRUE(Parse("{if_1;if_2;then3;}<->[test!];"));
2145 ASSERT_STREQ("{if_1; if_2; then3;}<->[test!];", ast->toString().c_str());
2146}
2147
2148TEST_F(ParserTest, Repeat6) {
2149 ASSERT_TRUE(Parse("[test!] <-> {if_1;if_2;then3;};"));
2150 ASSERT_STREQ("[test!]<->{if_1; if_2; then3;};", ast->toString().c_str());
2151}
2152
2153TEST_F(ParserTest, Repeat7) {
2154 ASSERT_TRUE(Parse("[test[0].field != $test!] <-> if_1;"));
2155 ASSERT_STREQ("[test[0].field != $test!]<->if_1;", ast->toString().c_str());
2156}
2157
2158TEST_F(ParserTest, Range) {
2159 ASSERT_TRUE(Parse("0.1..0.9..0.1;"));
2160 ASSERT_STREQ("0.1..0.9..0.1", ast->toString().c_str());
2161}
2162
2163TEST_F(ParserTest, Range1) {
2164 ASSERT_TRUE(Parse("[i!] <-> call();"));
2165 ASSERT_STREQ("[i!]<->call();", ast->toString().c_str());
2166
2167 ASSERT_TRUE(Parse("call() <-> [i!];"));
2168 ASSERT_STREQ("call()<->[i!];", ast->toString().c_str());
2169}
2170
2171TEST_F(ParserTest, Range2) {
2172 ASSERT_TRUE(Parse("[i()] <-> @error(\"Error\");"));
2173 ASSERT_STREQ("[i()]<->@error(\"Error\");", ast->toString().c_str());
2174}
2175
2176TEST_F(ParserTest, RangeCall) {
2177 ASSERT_TRUE(Parse("0.1..$sss"));
2178 ASSERT_TRUE(Parse("0.1..1*2"));
2179 ASSERT_TRUE(Parse("0.1..term()"));
2180 ASSERT_TRUE(Parse("0.1..term()..1*2+2-term"));
2181 ASSERT_TRUE(Parse("$term..term()+$term..-1*2+2-@term()"));
2182}
2183
2184TEST_F(ParserTest, Follow) {
2185 //@todo Не получается сделать парсер с простым if, т.к. требуется вторая закрывающая точка с запятой
2186 ASSERT_TRUE(Parse("[test == human || ttttt&&123!=test.field ] --> if_1;"));
2187 ASSERT_STREQ("[test == human || ttttt && 123 != test.field]-->if_1;", ast->toString().c_str());
2188}
2189
2190TEST_F(ParserTest, Follow0) {
2191 ASSERT_TRUE(Parse("[test] --> follow;"));
2192 ASSERT_STREQ("[test]-->follow;", ast->toString().c_str());
2193
2194 ASSERT_TRUE(Parse("[test] --> follow;"));
2195 ASSERT_STREQ("[test]-->follow;", ast->toString().c_str());
2196
2197 ASSERT_TRUE(Parse("[test] --> {follow;};"));
2198 ASSERT_STREQ("[test]-->{follow;};", ast->toString().c_str());
2199
2200 ASSERT_TRUE(Parse("[test] --> {follow};"));
2201 ASSERT_STREQ("[test]-->{follow;};", ast->toString().c_str());
2202
2203 ASSERT_TRUE(Parse("[test] --> {follow;};"));
2204 ASSERT_STREQ("[test]-->{follow;};", ast->toString().c_str());
2205
2206 ASSERT_TRUE(Parse("[test] --> {follow;};"));
2207 ASSERT_STREQ("[test]-->{follow;};", ast->toString().c_str());
2208}
2209
2210TEST_F(ParserTest, Follow1) {
2211 //@todo Не получается сделать парсер с простым if, т.к. требуется вторая закрывающая точка с запятой
2212 ASSERT_TRUE(Parse("[test == human] --> if_1;"));
2213 ASSERT_STREQ("[test == human]-->if_1;", ast->toString().c_str());
2214}
2215
2216TEST_F(ParserTest, Follow2) {
2217 ASSERT_TRUE(Parse("[test != human] --> {if_1;};"));
2218 ASSERT_STREQ("[test != human]-->{if_1;};", ast->toString().c_str());
2219}
2220
2221TEST_F(ParserTest, Follow3) {
2222 ASSERT_TRUE(Parse("[test!=human] --> {if_1;if_2;then3;};"));
2223 ASSERT_STREQ("[test != human]-->{if_1; if_2; then3;};", ast->toString().c_str());
2224}
2225
2226TEST_F(ParserTest, Follow4) {
2227 ASSERT_TRUE(Parse("[test != human] --> {if_1;if_2;then3;}, [...] --> {else;};"));
2228 // ASSERT_STREQ("(test!=human)->{if_1; if_2; then3;},\n (_) ->{else;};", ast->toString().c_str());
2229}
2230
2231TEST_F(ParserTest, Follow5) {
2232 ASSERT_TRUE(Parse("[@test1('')] --> {then1;}, [$test2] --> {then2;then2;}, [@test3+$test3] --> {then3;};"));
2233 // ASSERT_STREQ("(@test1)->{then1;}\n ($test2)->{then2; then2;}\n(@test3+$test3)->{then3;};", ast->toString().c_str());
2234}
2235
2236TEST_F(ParserTest, Follow6) {
2237 ASSERT_TRUE(Parse("[@test1()] --> {then1;}, [$test2] --> {then2;}, [@test3+$test3] --> {then3;}, [...] --> {else;else();};"));
2238 // ASSERT_STREQ("(@test1)->{then1;},\n ($test2)->{then2;},\n (@test3+$test3)->{then3;},\n _ ->{else; else();};", ast->toString().c_str());
2239}
2240
2241TEST_F(ParserTest, DISABLED_Follow7) {
2242 ASSERT_TRUE(Parse("[test.field[0] > iter!!] --> if_1;"));
2243 // ASSERT_STREQ("(test.field[0].field2>iter!!)->{if_1;};", ast->toString().c_str());
2244}
2245
2246/*
2247 try:
2248 a = float(input("Введите число: ")
2249 print (100 / a)
2250 except ValueError:
2251 print ("Это не число!")
2252 except ZeroDivisionError:
2253 print ("На ноль делить нельзя!")
2254 except:
2255 print ("Неожиданная ошибка.")
2256 else:
2257 print ("Код выполнился без ошибок")
2258 finally:
2259 print ("Я выполняюсь в любом случае!")
2260
2261
2262 {* # try:
2263 a = float(input("Введите число: ");
2264 print (100 / a);
2265 *} ~> {
2266
2267 [:ValueError] --> print ("Это не число!"), # except ValueError:
2268 [:ZeroDivisionError] --> print ("На ноль делить нельзя!"), # except ZeroDivisionError
2269 [:IntMinus] --> print ("Неожиданная ошибка."), # except:
2270 [...] --> print ("Код выполнился без ошибок"); # else:
2271
2272 print ("Я выполняюсь в любом случае!"); # finally:
2273 };
2274 */
2275
2276TEST_F(ParserTest, Match1) {
2277 ASSERT_TRUE(Parse("[1]==>{[1]-->first;}"));
2278}
2279
2280TEST_F(ParserTest, Match1_0) {
2281 ASSERT_TRUE(Parse("[1]==>{[1]-->{first};}"));
2282}
2283
2284TEST_F(ParserTest, Match2) {
2285 ASSERT_TRUE(Parse("[1]==>{[1]-->first;[2]-->second();}"));
2286}
2287
2288TEST_F(ParserTest, Match2_0) {
2289 ASSERT_ANY_THROW(
2290 Parse("[1]==>{[1]-->first;[...]-->end();[2]-->second();}");
2291 );
2292}
2293
2294TEST_F(ParserTest, Match3) {
2295 ASSERT_TRUE(Parse("[1]==>{[1]-->first;[2]-->second();[...]-->end();}"));
2296}
2297
2298TEST_F(ParserTest, Match3_0) {
2299 ASSERT_TRUE(Parse("[1]==>{[1]-->first;[2]-->{second();second()};[...]-->{end()};}"));
2300}
2301
2302TEST_F(ParserTest, Error) {
2303 ASSERT_TRUE(Parse("--;"));
2304 ASSERT_TRUE(Parse("--;;"));
2305 ASSERT_TRUE(Parse("ns:: --;"));
2306 ASSERT_TRUE(Parse("ns:: --;;"));
2307 ASSERT_TRUE(Parse("ns::ns:: --;"));
2308 ASSERT_TRUE(Parse("ns::ns:: --;;"));
2309 ASSERT_TRUE(Parse(":: --;"));
2310 ASSERT_TRUE(Parse(":: --;;"));
2311 ASSERT_TRUE(Parse("::ns --;"));
2312 ASSERT_TRUE(Parse("::ns --;;"));
2313 ASSERT_TRUE(Parse("::ns:: --;"));
2314 ASSERT_TRUE(Parse("::ns:: --;;"));
2315 ASSERT_TRUE(Parse("--_--;"));
2316 ASSERT_TRUE(Parse("--_--;;"));
2317 ASSERT_TRUE(Parse("-- eval --;"));
2318 ASSERT_TRUE(Parse("--eval--;;"));
2319 ASSERT_TRUE(Parse("--eval()--;"));
2320 ASSERT_TRUE(Parse("-- eval() --;;"));
2321 ASSERT_TRUE(Parse("--0--;"));
2322 ASSERT_TRUE(Parse("--0--;;"));
2323 ASSERT_TRUE(Parse("ns:: --0--;"));
2324 ASSERT_TRUE(Parse("ns:: --0--;;"));
2325 ASSERT_TRUE(Parse("++ 0.1 ++;"));
2326 ASSERT_TRUE(Parse("-- 0.1 --;;"));
2327 ASSERT_TRUE(Parse("name ++ 0.1 ++;"));
2328 ASSERT_TRUE(Parse("name -- 0.1 --;;"));
2329 ASSERT_TRUE(Parse("--[0,]--;"));
2330 ASSERT_TRUE(Parse("++(0,)++;;"));
2331 ASSERT_TRUE(Parse("--(0,1,2,3,):Class--;;"));
2332 ASSERT_TRUE(Parse("--(0,2,3,) :Class --;;"));
2333 ASSERT_TRUE(Parse("--(0,)--;;"));
2334 ASSERT_TRUE(Parse("--:Class(var)--;"));
2335 ASSERT_TRUE(Parse("--:Class[0](1)--;"));
2336 ASSERT_TRUE(Parse("--call()--;"));
2337 ASSERT_TRUE(Parse("--call()--;;"));
2338 ASSERT_TRUE(Parse("--call(arg)--;"));
2339 ASSERT_TRUE(Parse("--call(arg)--;;"));
2340 ASSERT_TRUE(Parse("--:class--;"));
2341 ASSERT_TRUE(Parse("--:class--;;"));
2342 ASSERT_TRUE(Parse("--:class()--;"));
2343 ASSERT_TRUE(Parse("--:class()--;;"));
2344 ASSERT_TRUE(Parse("--:class(arg)--;"));
2345 ASSERT_TRUE(Parse("++:class(arg)++;;"));
2346 ASSERT_TRUE(Parse("ns:: --:class--;"));
2347 ASSERT_TRUE(Parse("ns:: --:class--;;"));
2348 ASSERT_TRUE(Parse("ns::ns:: --:class--;"));
2349 ASSERT_TRUE(Parse("ns::ns:: --:class--;;"));
2350 ASSERT_TRUE(Parse(":: --:class--;"));
2351 ASSERT_TRUE(Parse(":: --:class--;;"));
2352 ASSERT_TRUE(Parse("::ns --:class--;"));
2353 ASSERT_TRUE(Parse("::ns --:class--;;"));
2354 ASSERT_TRUE(Parse("::ns:: --:class--;"));
2355 ASSERT_TRUE(Parse("::ns:: --:class--;;"));
2356
2357 ASSERT_TRUE(Parse("++;"));
2358 ASSERT_TRUE(Parse("++;;"));
2359 ASSERT_TRUE(Parse("ns:: ++;"));
2360 ASSERT_TRUE(Parse("ns:: ++;;"));
2361 ASSERT_TRUE(Parse("ns::ns:: ++;"));
2362 ASSERT_TRUE(Parse("ns::ns:: ++;;"));
2363 ASSERT_TRUE(Parse(":: ++;"));
2364 ASSERT_TRUE(Parse(":: ++;;"));
2365 ASSERT_TRUE(Parse("::ns ++;"));
2366 ASSERT_TRUE(Parse("::ns ++;;"));
2367 ASSERT_TRUE(Parse("::ns:: ++;"));
2368 ASSERT_TRUE(Parse("::ns:: ++;;"));
2369 ASSERT_TRUE(Parse("++_++;"));
2370 ASSERT_TRUE(Parse("++_++;;"));
2371 ASSERT_TRUE(Parse("++ eval ++;"));
2372 ASSERT_TRUE(Parse("++eval++;;"));
2373 ASSERT_TRUE(Parse("++eval()++;"));
2374 ASSERT_TRUE(Parse("++ eval() ++;;"));
2375 ASSERT_TRUE(Parse("++0++;"));
2376 ASSERT_TRUE(Parse("++0++;;"));
2377 ASSERT_TRUE(Parse("++ 0.1 ++;"));
2378 ASSERT_TRUE(Parse("++ 0.1 ++;;"));
2379 ASSERT_TRUE(Parse("++[0,]++;"));
2380 ASSERT_TRUE(Parse("++(0,)++;;"));
2381 ASSERT_TRUE(Parse("++(0,1,2,3,):Class++;;"));
2382 ASSERT_TRUE(Parse("++(0,2,3,) :Class ++;;"));
2383 ASSERT_TRUE(Parse("++(0,)++;;"));
2384 ASSERT_TRUE(Parse("++:Class(var)++;"));
2385 ASSERT_TRUE(Parse("++:Class[0](1)++;"));
2386 ASSERT_TRUE(Parse("++call()++;"));
2387 ASSERT_TRUE(Parse("++call()++;;"));
2388 ASSERT_TRUE(Parse("++call(arg)++;"));
2389 ASSERT_TRUE(Parse("++call(arg)++;;"));
2390 ASSERT_TRUE(Parse("++:class++;"));
2391 ASSERT_TRUE(Parse("++:class++;;"));
2392 ASSERT_TRUE(Parse("++:class()++;"));
2393 ASSERT_TRUE(Parse("++:class()++;;"));
2394 ASSERT_TRUE(Parse("++:class(arg)++;"));
2395 ASSERT_TRUE(Parse("++:class(arg)++;;"));
2396 ASSERT_TRUE(Parse("ns:: ++:class++;"));
2397 ASSERT_TRUE(Parse("ns:: ++:class++;;"));
2398 ASSERT_TRUE(Parse("ns::ns:: ++:class++;"));
2399 ASSERT_TRUE(Parse("ns::ns:: ++:class++;;"));
2400 ASSERT_TRUE(Parse(":: ++:class++;"));
2401 ASSERT_TRUE(Parse(":: ++:class++;;"));
2402 ASSERT_TRUE(Parse("::ns ++:class++;"));
2403 ASSERT_TRUE(Parse("::ns ++:class++;;"));
2404 ASSERT_TRUE(Parse("::ns:: ++:class++;"));
2405 ASSERT_TRUE(Parse("::ns:: ++:class++;;"));
2406
2407 ASSERT_TRUE(Parse("+-;"));
2408 ASSERT_TRUE(Parse("+-;;"));
2409 ASSERT_TRUE(Parse("ns:: +-;"));
2410 ASSERT_TRUE(Parse("ns:: +-;;"));
2411 ASSERT_TRUE(Parse("ns::ns:: +-;"));
2412 ASSERT_TRUE(Parse("ns::ns:: +-;;"));
2413 ASSERT_TRUE(Parse(":: +-;"));
2414 ASSERT_TRUE(Parse(":: +-;;"));
2415 ASSERT_TRUE(Parse("::ns +-;"));
2416 ASSERT_TRUE(Parse("::ns +-;;"));
2417 ASSERT_TRUE(Parse("::ns:: +-;"));
2418 ASSERT_TRUE(Parse("::ns:: +-;;"));
2419 ASSERT_TRUE(Parse("ns:: +-:class+-;"));
2420 ASSERT_TRUE(Parse("ns:: +-:class+-;;"));
2421 ASSERT_TRUE(Parse("ns::ns:: +-:class+-;"));
2422 ASSERT_TRUE(Parse("ns::ns:: +-:class+-;;"));
2423 ASSERT_TRUE(Parse(":: +-:class+-;"));
2424 ASSERT_TRUE(Parse(":: +-:class+-;;"));
2425 ASSERT_TRUE(Parse("::ns +-:class+-;"));
2426 ASSERT_TRUE(Parse("::ns +-:class+-;;"));
2427 ASSERT_TRUE(Parse("::ns:: +-:class+-;"));
2428 ASSERT_TRUE(Parse("::ns:: +-:class+-;;"));
2429
2430 ASSERT_TRUE(Parse("-+;"));
2431 ASSERT_TRUE(Parse("-+;;"));
2432 ASSERT_TRUE(Parse("ns:: -+;"));
2433 ASSERT_TRUE(Parse("ns:: -+;;"));
2434 ASSERT_TRUE(Parse("ns::ns:: -+;"));
2435 ASSERT_TRUE(Parse("ns::ns:: -+;;"));
2436 ASSERT_TRUE(Parse(":: -+;"));
2437 ASSERT_TRUE(Parse(":: -+;;"));
2438 ASSERT_TRUE(Parse("::ns -+;"));
2439 ASSERT_TRUE(Parse("::ns -+;;"));
2440 ASSERT_TRUE(Parse("::ns:: -+;"));
2441 ASSERT_TRUE(Parse("::ns:: -+;;"));
2442 ASSERT_TRUE(Parse("ns:: -+:class-+;"));
2443 ASSERT_TRUE(Parse("ns:: -+:class-+;;"));
2444 ASSERT_TRUE(Parse("ns::ns:: -+:class-+;"));
2445 ASSERT_TRUE(Parse("ns::ns:: -+:class-+;;"));
2446 ASSERT_TRUE(Parse(":: -+:class-+;"));
2447 ASSERT_TRUE(Parse(":: -+:class-+;;"));
2448 ASSERT_TRUE(Parse("::ns -+:class-+;"));
2449 ASSERT_TRUE(Parse("::ns -+:class-+;;"));
2450 ASSERT_TRUE(Parse("::ns:: -+:class-+;"));
2451 ASSERT_TRUE(Parse("::ns:: -+:class-+;;"));
2452
2453
2454}
2455
2456TEST_F(ParserTest, Docs) {
2457 ASSERT_TRUE(Parse("/** doc */ { }"));
2458 ASSERT_TRUE(Parse("/// \n{ }"));
2459 ASSERT_TRUE(Parse("{ ///< doc\n }"));
2460
2461 ASSERT_TRUE(Parse("/** doc\n\n */\n value := { };"));
2462 ASSERT_TRUE(Parse("/// doc1 \n/// doc2\n value := { };"));
2463 ASSERT_TRUE(Parse("value := 100; ///< doc"));
2464 ASSERT_TRUE(Parse("value := 100; ///< doc\n"));
2465}
2466
2467TEST_F(ParserTest, HelloWorld) {
2468 ASSERT_TRUE(Parse("hello(str=\"\") := { printf(format:FmtChar, ...):Int32 := Pointer('printf'); printf('%s', $1); $str;};"));
2469 // ASSERT_STREQ("!!!!!!!!!!!!!!", ast->toString().c_str());
2470}
2471
2472TEST_F(ParserTest, Class) {
2473 EXPECT_TRUE(Parse(":Name := :Class(){};"));
2474 EXPECT_TRUE(Parse(":Name := :_(){ filed1 = 1; };"));
2475 EXPECT_TRUE(Parse(":Name := ns::Class(){ filed1 := 1; filed1 ::= 2; };"));
2476 EXPECT_TRUE(Parse(":Name := ::(){ func = {};};"));
2477 EXPECT_TRUE(Parse(":Name := :Class(){ func1 := {}; func2 ::= {};};"));
2478 EXPECT_TRUE(Parse("Name := Class(){ func() = {};};"));
2479 EXPECT_TRUE(Parse("::Name() := ::Func(){ func1() := {}; func2(arg) ::= {};};"));
2480 EXPECT_TRUE(Parse(":Name := ::Class(){ func() = {};};"));
2481 EXPECT_TRUE(Parse(":Name := :Class(args) { func1() := {}; func2(arg) ::= {};};"));
2482
2483
2484 EXPECT_TRUE(Parse("Name := :Class(){};"));
2485 EXPECT_TRUE(Parse("Name := :_(){ filed1 = 1; };"));
2486 EXPECT_TRUE(Parse("::ns::Name := ns::Class(){ filed1 := 1; filed1 ::= 2; };"));
2487 EXPECT_TRUE(Parse("Name::ns := ::(){ func = {};};"));
2488 EXPECT_TRUE(Parse("Name::ns := :Class(){ func1 := {}; func2 ::= {};};"));
2489 EXPECT_TRUE(Parse("::Name := Class(){ func() = {};};"));
2490 EXPECT_TRUE(Parse("::Name() := ::Func(){ func1() := {}; .func2(arg) ::= {};};"));
2491 EXPECT_TRUE(Parse("::Name := ::Class(){ func() = {};};"));
2492 EXPECT_TRUE(Parse("::Name := :Class(args) { func1() := {}; func2(arg) ::= {};};"));
2493
2494 EXPECT_TRUE(Parse("Name() := :Class(), Class(){};"));
2495 EXPECT_TRUE(Parse("Name() := :_(), Class(), Class(){ .filed1 = 1; };"));
2496 EXPECT_TRUE(Parse("::ns::Name() := ns::Class(), Class(), Class(){ filed1 := 1; filed1 ::= 2; };"));
2497 EXPECT_TRUE(Parse("Name::ns() := ::(), Class(){ func = {};};"));
2498 EXPECT_TRUE(Parse("Name::ns() := :Class(), Class(), Class(), Class(){ func1 := {}; func2 ::= {};};"));
2499 EXPECT_TRUE(Parse("::Name() := Class(), Class(), Class(), Class(){ func() = {};};"));
2500 EXPECT_TRUE(Parse("{ ::Name() := ::Func(), ns::ns::Class(){ func1() := {}; func2(arg) ::= {};}; }"));
2501 EXPECT_TRUE(Parse("ns { ::Name() := ::Class(), Class(){ func() = {};}; }"));
2502 EXPECT_TRUE(Parse("ns::ns{ ::Name() := Class(args), ns::Class(), ::ns::Class() { :func1() := {}; func2(arg) ::= {};};}"));
2503
2504 EXPECT_TRUE(Parse("ns::ns::Name:: :func1()"));
2505 EXPECT_TRUE(Parse(":: :func1"));
2506 EXPECT_TRUE(Parse("::ns::ns::Name:: :func1 := {}"));
2507}
2508
2509TEST_F(ParserTest, Module) {
2510 ASSERT_TRUE(Parse("\\module(func)"));
2511 ASSERT_TRUE(Parse("\\\\dir\\module(func)"));
2512 ASSERT_TRUE(Parse("\\dir\\dir\\module(func)"));
2513
2514 // ASSERT_TRUE(Parse("\\module (*)"));
2515 // ASSERT_TRUE(Parse("\\dir\\module (*)"));
2516 // ASSERT_TRUE(Parse("\\\\dir\\dir\\module (*)"));
2517 //
2518 // ASSERT_TRUE(Parse("\\\\module (func, func2)"));
2519 // ASSERT_TRUE(Parse("\\dir\\module (func, *)"));
2520 // ASSERT_TRUE(Parse("\\dir\\dir\\module (func, _)"));
2521 //
2522 // ASSERT_TRUE(Parse("\\module (func, ::func2)"));
2523 // ASSERT_TRUE(Parse("\\dir\\module (ns::func, *)"));
2524 // ASSERT_TRUE(Parse("\\dir\\dir\\module (::ns::func, _)"));
2525
2526 ASSERT_TRUE(Parse("\\module (name=func, name=func2, name=::func3)"));
2527 ASSERT_TRUE(Parse("\\\\dir\\module (name=ns::func, name='')"));
2528 ASSERT_TRUE(Parse("\\dir\\dir\\module (name=::ns::func, name=_)"));
2529
2530 ASSERT_TRUE(Parse("\\module::var"));
2531 ASSERT_TRUE(Parse("\\module::ns::var"));
2532 ASSERT_TRUE(Parse("\\\\module::ns::func()"));
2533
2534 ASSERT_TRUE(Parse("\\\\dir\\module::var"));
2535 ASSERT_TRUE(Parse("\\dir\\dir\\module::ns::var"));
2536 ASSERT_TRUE(Parse("\\dir\\dir\\dir\\module::ns::func()"));
2537
2538 // ASSERT_TRUE(Parse("\\module (name=func, name=::name::*)"));
2539 // ASSERT_TRUE(Parse("\\dir.module (name=ns::name::*, name=*)"));
2540}
2541
2542TEST_F(ParserTest, SkipBrackets) {
2543
2544
2545 Macro macro;
2546 BlockType buffer;
2547
2548 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 0));
2549 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 1));
2550
2551 buffer.push_back(Term::Create(parser::token_type::NAME, TermID::NAME, "name"));
2552
2553 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 0));
2554 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 1));
2555
2556 buffer.push_back(Term::Create(parser::token_type::SYMBOL, TermID::SYMBOL, "("));
2557 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 0));
2558 ASSERT_ANY_THROW(Parser::SkipBrackets(buffer, 1));
2559
2560 buffer.push_back(Term::Create(parser::token_type::SYMBOL, TermID::SYMBOL, ")"));
2561 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 0));
2562 ASSERT_EQ(2, Parser::SkipBrackets(buffer, 1));
2563 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 2));
2564
2565
2566 buffer.insert(buffer.begin(), Term::Create(parser::token_type::NAME, TermID::NAME, "first")); // first name ( )
2567
2568 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 0));
2569 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 1));
2570
2571 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 0));
2572 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 1));
2573 ASSERT_EQ(2, Parser::SkipBrackets(buffer, 2));
2574 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 3));
2575
2576
2577 buffer.insert(buffer.end() - 1, Term::Create(parser::token_type::SYMBOL, TermID::SYMBOL, "..."));
2578 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 0));
2579 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 1));
2580 ASSERT_EQ(3, Parser::SkipBrackets(buffer, 2));
2581 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 3));
2582 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 4));
2583 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 5));
2584
2585 buffer.insert(buffer.end() - 1, Term::Create(parser::token_type::NAME, TermID::NAME, "name"));
2586 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 0));
2587 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 1));
2588 ASSERT_EQ(4, Parser::SkipBrackets(buffer, 2));
2589 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 3));
2590 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 4));
2591 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 5));
2592 ASSERT_EQ(0, Parser::SkipBrackets(buffer, 6));
2593
2594}
2595
2596TEST_F(ParserTest, MacroCreate) {
2597 MacroPtr macro = std::make_shared<Macro>();
2598 TermPtr term;
2599 ASSERT_NO_THROW(
2600 term = Parse("@@ name @@ := macro", macro)
2601 );
2602 ASSERT_TRUE(term);
2603 ASSERT_TRUE(term->Left()) << term->toString();
2604 ASSERT_TRUE(term->Right()) << term->toString();
2605
2606 ASSERT_ANY_THROW(
2607 term = Parse("{ @@ name @@ := macro }", macro)
2608 );
2609 ASSERT_ANY_THROW(
2610 term = Parse("{+ @@ name @@ := macro +}", macro)
2611 );
2612}
2613
2614TEST_F(ParserTest, DISABLED_Convert) {
2615 std::vector<const char *> list = {
2616 "brother(human!, human!)?;",
2617 "func(arg1, arg2 = 5) :- { ($arg1 < $2) -> {% return $arg1; %}, [...] --> {% return *$1 * *$2; %}; };",
2618 "func_sum(arg1, arg2) :- {$arg1 + $arg2;};",
2619 };
2620 Parser parser;
2621 for (size_t i = 0; i < list.size(); i++) {
2622 ASSERT_NO_THROW(
2623 parser.Parse(list[i]);
2624 ) << "FROM: " << list[i];
2625 std::string to_str = parser.GetAst()->toString() + ";";
2626 ASSERT_NO_THROW(
2627 parser.Parse(to_str);
2628 ) << "CONVERT: " << to_str;
2629 }
2630}
2631
2632#endif // UNITTEST
newlang::Logger::LogLevelType
uint8_t LogLevelType
Definition logger.h:319
newlang::Parser::Parse
TermPtr Parse(const std::string str, bool expand_module=false)
Definition parser.cpp:44
newlang::Parser::GetAst
TermPtr GetAst()
Definition parser.cpp:126
result
int result
Definition lexer.l:367
newlang
Definition nlc.h:59
newlang::TermID
TermID
Definition term.h:119
newlang::TermPtr
std::shared_ptr< Term > TermPtr
Definition variable.h:33
newlang::MacroPtr
std::shared_ptr< Macro > MacroPtr
Definition types.h:244
newlang::BlockType
std::vector< TermPtr > BlockType
Definition types.h:239
newlang::DiagPtr
std::shared_ptr< Diag > DiagPtr
Definition types.h:243
newlang::toString
const char * toString(TermID type)
Definition term.h:126
newlang::isDefaultType
bool isDefaultType(const TermPtr &term)
Definition parser.cpp:1060
newlang::trim
std::string & trim(std::string &s, const char *t=ws)
Definition types.h:111
warning_pop.h
warning_push.h
Generated by doxygen 1.11.0