/
gbykov
/
FreeCAD
GigaCode
beta
ОбзорЦентр заботыВойти

FreeCAD

Форк
0
Ветки: 15Коммиты: 36666Теги: 26
FreeCAD
/tests
/src
/App
/
Expression.cpp 
282 строки · 9.5 Кб
1
#include "gtest/gtest.h"
2


3
#include "App/ExpressionParser.h"
4
#include "App/ExpressionTokenizer.h"
5


6
// clang-format off
7
TEST(Expression, tokenize)
8
{
9
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromUtf8(""), 10), QString());
10
    // 0.0000 deg-
11
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromUtf8("0.00000 \xC2\xB0-"), 10), QString());
12
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromUtf8("0.00000 \xC2\xB0-s"), 11), QString::fromLatin1("s"));
13
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromUtf8("0.00000 \xC2\xB0-ss"), 12), QString::fromLatin1("ss"));
14
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromUtf8("0.00000 deg"), 5), QString());
15
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromUtf8("0.00000 deg"), 11), QString::fromLatin1("deg"));
16
}
17


18
TEST(Expression, tokenizeQuantity)
19
{
20
    auto result = App::ExpressionParser::tokenize("0.00000 deg");
21
    EXPECT_EQ(result.size(), 2);
22
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::NUM);
23
    EXPECT_EQ(std::get<1>(result[0]), 0);
24
    EXPECT_EQ(std::get<2>(result[0]), "0.00000");
25
    EXPECT_EQ(std::get<0>(result[1]), App::ExpressionParser::UNIT);
26
    EXPECT_EQ(std::get<1>(result[1]), 8);
27
    EXPECT_EQ(std::get<2>(result[1]), "deg");
28
}
29


30
TEST(Expression, tokenizeFunc)
31
{
32
    auto result = App::ExpressionParser::tokenize("sin(0.00000)");
33
    EXPECT_EQ(result.size(), 3);
34
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::FUNC);
35
    EXPECT_EQ(std::get<1>(result[0]), 0);
36
    EXPECT_EQ(std::get<2>(result[0]), "sin(");
37
    EXPECT_EQ(std::get<0>(result[1]), App::ExpressionParser::NUM);
38
    EXPECT_EQ(std::get<1>(result[1]), 4);
39
    EXPECT_EQ(std::get<2>(result[1]), "0.00000");
40
    EXPECT_EQ(std::get<1>(result[2]), 11);
41
    EXPECT_EQ(std::get<2>(result[2]), ")");
42
}
43


44
TEST(Expression, tokenizeOne)
45
{
46
    auto result = App::ExpressionParser::tokenize("1");
47
    EXPECT_EQ(result.size(), 1);
48
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::ONE);
49
    EXPECT_EQ(std::get<1>(result[0]), 0);
50
    EXPECT_EQ(std::get<2>(result[0]), "1");
51
}
52


53
TEST(Expression, tokenizeNum)
54
{
55
    auto result = App::ExpressionParser::tokenize("1.2341");
56
    EXPECT_EQ(result.size(), 1);
57
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::NUM);
58
    EXPECT_EQ(std::get<1>(result[0]), 0);
59
    EXPECT_EQ(std::get<2>(result[0]), "1.2341");
60
}
61


62
TEST(Expression, tokenizeID)
63
{
64
    auto result = App::ExpressionParser::tokenize("Something");
65
    EXPECT_EQ(result.size(), 1);
66
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::IDENTIFIER);
67
    EXPECT_EQ(std::get<1>(result[0]), 0);
68
    EXPECT_EQ(std::get<2>(result[0]), "Something");
69
}
70


71
TEST(Expression, tokenizeUnit)
72
{
73
    auto result = App::ExpressionParser::tokenize("km");
74
    EXPECT_EQ(result.size(), 1);
75
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::UNIT);
76
    EXPECT_EQ(std::get<1>(result[0]), 0);
77
    EXPECT_EQ(std::get<2>(result[0]), "km");
78
}
79


80
TEST(Expression, tokenizeUSUnit)
81
{
82
    auto result = App::ExpressionParser::tokenize("\"");
83
    EXPECT_EQ(result.size(), 1);
84
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::USUNIT);
85
    EXPECT_EQ(std::get<1>(result[0]), 0);
86
    EXPECT_EQ(std::get<2>(result[0]), "\"");
87
}
88


89
TEST(Expression, tokenizeInt)
90
{
91
    auto result = App::ExpressionParser::tokenize("123456");
92
    EXPECT_EQ(result.size(), 1);
93
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::INTEGER);
94
    EXPECT_EQ(std::get<1>(result[0]), 0);
95
    EXPECT_EQ(std::get<2>(result[0]), "123456");
96
}
97


98
TEST(Expression, tokenizePi)
99
{
100
    auto result = App::ExpressionParser::tokenize("pi");
101
    EXPECT_EQ(result.size(), 1);
102
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::CONSTANT);
103
    EXPECT_EQ(std::get<1>(result[0]), 0);
104
    EXPECT_EQ(std::get<2>(result[0]), "pi");
105
}
106


107
TEST(Expression, tokenizeE)
108
{
109
    auto result = App::ExpressionParser::tokenize("e");
110
    EXPECT_EQ(result.size(), 1);
111
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::CONSTANT);
112
    EXPECT_EQ(std::get<1>(result[0]), 0);
113
    EXPECT_EQ(std::get<2>(result[0]), "e");
114
}
115


116
TEST(Expression, tokenizeConstant)
117
{
118
    auto result = App::ExpressionParser::tokenize("True False true false None");
119
    EXPECT_EQ(result.size(), 5);
120
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::CONSTANT);
121
    EXPECT_EQ(std::get<1>(result[0]), 0);
122
    EXPECT_EQ(std::get<2>(result[0]), "True");
123
    EXPECT_EQ(std::get<0>(result[1]), App::ExpressionParser::CONSTANT);
124
    EXPECT_EQ(std::get<0>(result[2]), App::ExpressionParser::CONSTANT);
125
    EXPECT_EQ(std::get<0>(result[3]), App::ExpressionParser::CONSTANT);
126
    EXPECT_EQ(std::get<0>(result[4]), App::ExpressionParser::CONSTANT);
127
}
128


129
TEST(Expression, tokenizeEqual)
130
{
131
    auto result = App::ExpressionParser::tokenize("==");
132
    EXPECT_EQ(result.size(), 1);
133
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::EQ);
134
    EXPECT_EQ(std::get<1>(result[0]), 0);
135
    EXPECT_EQ(std::get<2>(result[0]), "==");
136
}
137


138
TEST(Expression, tokenizeNotEqual)
139
{
140
    auto result = App::ExpressionParser::tokenize("!=");
141
    EXPECT_EQ(result.size(), 1);
142
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::NEQ);
143
    EXPECT_EQ(std::get<1>(result[0]), 0);
144
    EXPECT_EQ(std::get<2>(result[0]), "!=");
145
}
146


147
TEST(Expression, tokenizeLessThan)
148
{
149
    auto result = App::ExpressionParser::tokenize("<");
150
    EXPECT_EQ(result.size(), 1);
151
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::LT);
152
    EXPECT_EQ(std::get<1>(result[0]), 0);
153
    EXPECT_EQ(std::get<2>(result[0]), "<");
154
}
155


156
TEST(Expression, tokenizeLessThanEqual)
157
{
158
    auto result = App::ExpressionParser::tokenize("<=");
159
    EXPECT_EQ(result.size(), 1);
160
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::LTE);
161
    EXPECT_EQ(std::get<1>(result[0]), 0);
162
    EXPECT_EQ(std::get<2>(result[0]), "<=");
163
}
164


165
TEST(Expression, tokenizeGreaterThan)
166
{
167
    auto result = App::ExpressionParser::tokenize(">");
168
    EXPECT_EQ(result.size(), 1);
169
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::GT);
170
    EXPECT_EQ(std::get<1>(result[0]), 0);
171
    EXPECT_EQ(std::get<2>(result[0]), ">");
172
}
173


174
TEST(Expression, tokenizeGreaterThanEqual)
175
{
176
    auto result = App::ExpressionParser::tokenize(">=");
177
    EXPECT_EQ(result.size(), 1);
178
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::GTE);
179
    EXPECT_EQ(std::get<1>(result[0]), 0);
180
    EXPECT_EQ(std::get<2>(result[0]), ">=");
181
}
182


183
TEST(Expression, tokenizeMinus)
184
{
185
    auto result = App::ExpressionParser::tokenize("1-1");
186
    EXPECT_EQ(result.size(), 3);
187
    EXPECT_EQ(std::get<0>(result[1]), App::ExpressionParser::MINUSSIGN);
188
    EXPECT_EQ(std::get<1>(result[1]), 1);
189
    EXPECT_EQ(std::get<2>(result[1]), "-");
190
}
191


192
TEST(Expression, tokenizeCell1)
193
{
194
    auto result = App::ExpressionParser::tokenize("$A$12");
195
    EXPECT_EQ(result.size(), 1);
196
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::CELLADDRESS);
197
    EXPECT_EQ(std::get<1>(result[0]), 0);
198
    EXPECT_EQ(std::get<2>(result[0]), "$A$12");
199
}
200


201
TEST(Expression, tokenizeCell2)
202
{
203
    auto result = App::ExpressionParser::tokenize("A$12");
204
    EXPECT_EQ(result.size(), 1);
205
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::CELLADDRESS);
206
    EXPECT_EQ(std::get<1>(result[0]), 0);
207
    EXPECT_EQ(std::get<2>(result[0]), "A$12");
208
}
209


210
TEST(Expression, tokenizeCell3)
211
{
212
    auto result = App::ExpressionParser::tokenize("$A12");
213
    EXPECT_EQ(result.size(), 1);
214
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::CELLADDRESS);
215
    EXPECT_EQ(std::get<1>(result[0]), 0);
216
    EXPECT_EQ(std::get<2>(result[0]), "$A12");
217
}
218


219
TEST(Expression, tokenizeString)
220
{
221
    auto result = App::ExpressionParser::tokenize("<<Test>>");
222
    EXPECT_EQ(result.size(), 1);
223
    EXPECT_EQ(std::get<0>(result[0]), App::ExpressionParser::STRING);
224
    EXPECT_EQ(std::get<1>(result[0]), 0);
225
    EXPECT_EQ(std::get<2>(result[0]), "<<Test>>");
226
}
227


228
TEST(Expression, tokenizeExponent)
229
{
230
    // TODO
231
}
232


233
TEST(Expression, tokenizeNumAndUnit)
234
{
235
    // TODO
236
}
237


238
TEST(Expression, tokenizePos)
239
{
240
    // TODO
241
}
242


243
TEST(Expression, tokenizeNeg)
244
{
245
    // TODO
246
}
247


248
TEST(Expression, tokenizePi_rad)
249
{
250
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromLatin1("p"), 1), QString::fromLatin1("p"));
251
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromLatin1("pi"), 2), QString());
252
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromLatin1("pi "), 3), QString());
253
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromLatin1("pi r"), 4), QString::fromLatin1("r"));
254
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromLatin1("pi ra"), 5), QString::fromLatin1("ra"));
255
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromLatin1("pi rad"), 6), QString::fromLatin1("rad"));
256
    EXPECT_EQ(App::ExpressionTokenizer().perform(QString::fromLatin1("pi rad"), 2), QString());
257
}
258


259
TEST(Expression, toString)
260
{
261
    App::UnitExpression expr{nullptr, Base::Quantity{}, "pi rad"};
262
    EXPECT_EQ(expr.toString(), "pi rad");
263
}
264


265
TEST(Expression, test_pi_rad)
266
{
267
    auto constant = std::make_unique<App::ConstantExpression>(nullptr, "pi");
268
    auto unit = std::make_unique<App::UnitExpression>(nullptr, Base::Quantity{}, "rad");
269
    auto op = std::make_unique<App::OperatorExpression>(nullptr, constant.get(), App::OperatorExpression::UNIT, unit.get());
270
    EXPECT_EQ(op->toString(), "pi rad");
271
    op.release();
272
}
273


274
TEST(Expression, test_e_rad)
275
{
276
    auto constant = std::make_unique<App::ConstantExpression>(nullptr, "e");
277
    auto unit = std::make_unique<App::UnitExpression>(nullptr, Base::Quantity{}, "rad");
278
    auto op = std::make_unique<App::OperatorExpression>(nullptr, constant.get(), App::OperatorExpression::UNIT, unit.get());
279
    EXPECT_EQ(op->toString(), "e rad");
280
    op.release();
281
}
282
// clang-format on
283

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.