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