|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
1 |
import QtQuick 2.0 |
2 |
import QtTest 1.0 |
|
3 |
import "../engine.js" as CALC |
|
4 |
||
5 |
TestCase{ |
|
6 |
name: "Get Formula Texts" |
|
7 |
||
8 |
function test_brackets_data(){ |
|
9 |
return [ |
|
10 |
{
|
|
11 |
operation: "bracket after number", |
|
12 |
prev: {engine: '5', type: 'number'}, |
|
13 |
visual: "(", engine: "(", type: 'group', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
14 |
expected: [' ( ', '(', 'group', 1] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
15 |
},
|
16 |
{
|
|
17 |
operation: "bracket after real", |
|
18 |
prev: {engine: '5', type: 'real'}, |
|
19 |
visual: "(", engine: "(", type: 'group', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
20 |
expected: [' ( ', '(', 'group', 1] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
21 |
},
|
22 |
{
|
|
23 |
operation: "bracket after const", |
|
24 |
prev: {engine: 'e', type: 'const'}, |
|
25 |
visual: "(", engine: "(", type: 'group', brackets_count: 0, |
|
26 |
expected: [' ( ', '*(', 'group', 1] |
|
27 |
},
|
|
28 |
{
|
|
29 |
operation: "bracket after operation", |
|
30 |
prev: {engine: '*', type: 'operation'}, |
|
31 |
visual: "(", engine: "(", type: 'group', brackets_count: 0, |
|
32 |
expected: [' ( ', '(', 'group', 1] |
|
33 |
},
|
|
34 |
{
|
|
35 |
operation: "bracket after operation", |
|
36 |
prev: {engine: '*', type: 'operation'}, |
|
37 |
visual: "(", engine: "(", type: 'group', brackets_count: 0, |
|
38 |
expected: [' ( ', '(', 'group', 1] |
|
39 |
},
|
|
40 |
{
|
|
41 |
operation: "closing bracket after number", |
|
42 |
prev: {engine: '5', type: 'number'}, |
|
43 |
visual: ")", engine: ")", type: 'group', brackets_count: 1, |
|
44 |
expected: [' ) ', ')', 'group', 0] |
|
45 |
},
|
|
46 |
{
|
|
47 |
operation: "closing bracket after operation", |
|
48 |
prev: {engine: '*', type: 'operation'}, |
|
49 |
visual: ")", engine: ")", type: 'group', brackets_count: 1, |
|
50 |
expected: [null, null, 'group', 1] |
|
51 |
},
|
|
52 |
{
|
|
53 |
operation: "closing bracket after function", |
|
54 |
prev: {engine: 'sin(', type: 'function'}, |
|
55 |
visual: ")", engine: ")", type: 'group', brackets_count: 1, |
|
56 |
expected: [null, null, 'group', 1] |
|
57 |
},
|
|
58 |
]
|
|
59 |
}
|
|
60 |
||
61 |
function test_numbers_and_consts_data(){ |
|
62 |
return [ |
|
63 |
{
|
|
64 |
operation: "number after number", |
|
65 |
prev: {engine: '5', type: 'number'}, |
|
66 |
visual: "3", engine: "3", type: 'number', brackets_count: 0, |
|
67 |
expected: ['3', '3', 'number', 0] |
|
68 |
},
|
|
69 |
{
|
|
70 |
operation: "number after constant", |
|
71 |
prev: {engine: 'e', type: 'const'}, |
|
72 |
visual: "3", engine: "3", type: 'number', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
73 |
expected: ['3', '3', 'number', 0] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
74 |
},
|
75 |
{
|
|
76 |
operation: "number after real", |
|
77 |
prev: {engine: '.', type: 'real'}, |
|
78 |
visual: "3", engine: "3", type: 'number', brackets_count: 0, |
|
79 |
expected: ['3', '3', 'real', 0] |
|
80 |
},
|
|
81 |
{
|
|
82 |
operation: "real after number", |
|
83 |
prev: {engine: '5', type: 'number'}, |
|
84 |
visual: ".", engine: ".", type: 'real', brackets_count: 0, |
|
85 |
expected: ['.', '.', 'real', 0] |
|
86 |
},
|
|
87 |
{
|
|
88 |
operation: "real after const", |
|
89 |
prev: {engine: 'e', type: 'const'}, |
|
90 |
visual: ".", engine: ".", type: 'real', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
91 |
expected: ['.', '.', 'real', 0] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
92 |
},
|
93 |
{
|
|
94 |
operation: "real after real", |
|
95 |
prev: {engine: '.', type: 'real'}, |
|
96 |
visual: ".", engine: ".", type: 'real', brackets_count: 0, |
|
97 |
expected: [null, null, 'real', 0] |
|
98 |
},
|
|
99 |
{
|
|
100 |
operation: "const after number", |
|
101 |
prev: {engine: '5', type: 'number'}, |
|
102 |
visual: "e", engine: "e", type: 'const', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
103 |
expected: ['e', 'e', 'const', 0] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
104 |
},
|
105 |
{
|
|
106 |
operation: "const after real", |
|
107 |
prev: {engine: '5', type: 'real'}, |
|
108 |
visual: "e", engine: "e", type: 'const', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
109 |
expected: ['e', 'e', 'const', 0] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
110 |
},
|
111 |
{
|
|
112 |
operation: "const after const", |
|
113 |
prev: {engine: 'e', type: 'const'}, |
|
114 |
visual: "e", engine: "e", type: 'const', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
115 |
expected: ['e', 'e', 'const', 0] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
116 |
},
|
117 |
{
|
|
118 |
operation: "const after function", |
|
119 |
prev: {engine: 'sin(', type: 'function'}, |
|
120 |
visual: "e", engine: "e", type: 'const', brackets_count: 0, |
|
121 |
expected: ['e', 'e', 'const', 0] |
|
122 |
},
|
|
123 |
]
|
|
124 |
}
|
|
125 |
||
126 |
function test_operations_data(){ |
|
127 |
return [ |
|
128 |
{
|
|
129 |
operation: "operation after number", |
|
130 |
prev: {engine: '5', type: 'number'}, |
|
131 |
visual: "-", engine: "-", type: 'operation', brackets_count: 0, |
|
132 |
expected: [' - ', '-', 'operation', 0] |
|
133 |
},
|
|
134 |
{
|
|
135 |
operation: "operation (multiplication) after number", |
|
136 |
prev: {engine: '5', type: 'number'}, |
|
137 |
visual: "*", engine: "*", type: 'operation', brackets_count: 0, |
|
138 |
expected: [' * ', '*', 'operation', 0] |
|
139 |
},
|
|
140 |
{
|
|
141 |
operation: "operation (multiplication) after real", |
|
142 |
prev: {engine: '5', type: 'real'}, |
|
143 |
visual: "*", engine: "*", type: 'operation', brackets_count: 0, |
|
144 |
expected: [' * ', '*', 'operation', 0] |
|
145 |
},
|
|
146 |
{
|
|
147 |
operation: "operation (multiplication) after const", |
|
148 |
prev: {engine: 'e', type: 'const'}, |
|
149 |
visual: "*", engine: "*", type: 'operation', brackets_count: 0, |
|
150 |
expected: [' * ', '*', 'operation', 0] |
|
151 |
},
|
|
152 |
{
|
|
153 |
operation: "operation (multiplication) after closing bracket", |
|
154 |
prev: {engine: ')', type: 'group'}, |
|
155 |
visual: "*", engine: "*", type: 'operation', brackets_count: 0, |
|
156 |
expected: [' * ', '*', 'operation', 0] |
|
157 |
},
|
|
158 |
{
|
|
159 |
operation: "operation (multiplication) after operation", |
|
160 |
prev: {engine: '*', type: 'operation'}, |
|
161 |
visual: "*", engine: "*", type: 'operation', brackets_count: 0, |
|
162 |
expected: [null, null, 'operation', 0] |
|
163 |
},
|
|
164 |
{
|
|
165 |
operation: "operation (division) after operation", |
|
166 |
prev: {engine: '*', type: 'operation'}, |
|
167 |
visual: "/", engine: "/", type: 'operation', brackets_count: 0, |
|
168 |
expected: [null, null, 'operation', 0] |
|
169 |
},
|
|
170 |
{
|
|
171 |
operation: "operation (division) after function", |
|
172 |
prev: {engine: 'sin(', type: 'function'}, |
|
173 |
visual: "/", engine: "/", type: 'operation', brackets_count: 0, |
|
174 |
expected: [null, null, 'operation', 0] |
|
175 |
},
|
|
176 |
{
|
|
177 |
operation: "operation (multiplication) after opening bracket", |
|
178 |
prev: {engine: '(', type: 'group'}, |
|
179 |
visual: "*", engine: "*", type: 'operation', brackets_count: 0, |
|
180 |
expected: [null, null, 'operation', 0] |
|
181 |
},
|
|
|
7.1.18
by Dalius
Factorial fixed. |
182 |
{
|
183 |
operation: "operation (factorial) after operation (minus)", |
|
184 |
prev: {engine: '-', type: 'operation'}, |
|
185 |
visual: "!", engine: "!", type: 'operation', brackets_count: 0, |
|
186 |
expected: [null, null, 'operation', 0] |
|
187 |
},
|
|
188 |
{
|
|
189 |
operation: "operation (factorial) after operation (multiplication)", |
|
190 |
prev: {engine: '*', type: 'operation'}, |
|
191 |
visual: "!", engine: "!", type: 'operation', brackets_count: 0, |
|
192 |
expected: [null, null, 'operation', 0] |
|
193 |
},
|
|
194 |
{
|
|
195 |
operation: "operation (factorial) after operation (factorial)", |
|
196 |
prev: {engine: '!', type: 'operation'}, |
|
197 |
visual: "!", engine: "!", type: 'operation', brackets_count: 0, |
|
198 |
expected: [' ! ', '!', 'operation', 0] |
|
199 |
},
|
|
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
200 |
]
|
201 |
}
|
|
202 |
||
203 |
function test_functions_data(){ |
|
204 |
return [ |
|
205 |
{
|
|
206 |
operation: "function after number", |
|
207 |
prev: {engine: '5', type: 'number'}, |
|
208 |
visual: "sin", engine: "sin", type: 'function', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
209 |
expected: [' sin( ', 'sin(', 'function', 1] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
210 |
},
|
211 |
{
|
|
212 |
operation: "function after real", |
|
213 |
prev: {engine: '5', type: 'real'}, |
|
214 |
visual: "sin", engine: "sin", type: 'function', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
215 |
expected: [' sin( ', 'sin(', 'function', 1] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
216 |
},
|
217 |
{
|
|
218 |
operation: "function after const", |
|
219 |
prev: {engine: 'e', type: 'const'}, |
|
220 |
visual: "sin", engine: "sin", type: 'function', brackets_count: 0, |
|
|
6.1.2
by Dalius
Adding multiplication is now left for engine's handling. |
221 |
expected: [' sin( ', 'sin(', 'function', 1] |
|
6.1.1
by Dalius
unit-tests for getFormulaTexts |
222 |
},
|
223 |
{
|
|
224 |
operation: "function after operation", |
|
225 |
prev: {engine: '*', type: 'operation'}, |
|
226 |
visual: "sin", engine: "sin", type: 'function', brackets_count: 0, |
|
227 |
expected: ['sin( ', 'sin(', 'function', 1] |
|
228 |
},
|
|
229 |
{
|
|
230 |
operation: "function after function", |
|
231 |
prev: {engine: 'sin(', type: 'function'}, |
|
232 |
visual: "sin", engine: "sin", type: 'function', brackets_count: 0, |
|
233 |
expected: ['sin( ', 'sin(', 'function', 1] |
|
234 |
},
|
|
235 |
]
|
|
236 |
}
|
|
237 |
||
238 |
function test_brackets(data) { |
|
239 |
compare(CALC.getFormulaTexts(data.prev, data.visual, data.engine, data.type, data.brackets_count), |
|
240 |
data.expected, |
|
241 |
data.operation); |
|
242 |
}
|
|
243 |
||
244 |
function test_numbers_and_consts(data) { |
|
245 |
compare(CALC.getFormulaTexts(data.prev, data.visual, data.engine, data.type, data.brackets_count), |
|
246 |
data.expected, |
|
247 |
data.operation); |
|
248 |
}
|
|
249 |
||
250 |
function test_operations(data) { |
|
251 |
compare(CALC.getFormulaTexts(data.prev, data.visual, data.engine, data.type, data.brackets_count), |
|
252 |
data.expected, |
|
253 |
data.operation); |
|
254 |
}
|
|
255 |
||
256 |
function test_functions(data) { |
|
257 |
compare(CALC.getFormulaTexts(data.prev, data.visual, data.engine, data.type, data.brackets_count), |
|
258 |
data.expected, |
|
259 |
data.operation); |
|
260 |
}
|
|
261 |
}
|