/vqdr/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/vqdr/trunk

« back to all changes in this revision

Viewing changes to tests/utils/fast_number.vala

  • Committer: Gustav Hartvigsson
  • Date: 2022-05-30 18:35:38 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20220530183538-xlixbth43j8k3s42
Added NamedVector

Added Pair

Removed debugs from FastNumber

Added foreach_pop and foreach_peek to Stak.

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/utils/fast_number.vala
 
1
using GLib;
 
2
 
 
3
using Utils;
 
4
using VQDR.Expression;
 
5
 
 
6
void fast_number_test () {
 
7
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "new/raw", () => {
 
8
    FastNumber f1;
 
9
    
 
10
    
 
11
    f1 = FastNumber (1);
 
12
    if (f1.raw_number != 1000) {
 
13
      Test.fail ();
 
14
      Test.message ("Sanity1: Wrong value.");
 
15
      Test.message ("expected: 1000, got: " + f1.raw_number.to_string ());
 
16
    }
 
17
    
 
18
    f1 = FastNumber (10);
 
19
    if (f1.raw_number != 10000) {
 
20
      Test.fail ();
 
21
      Test.message ("Sanity2: Wrong value.");
 
22
      Test.message ("expected: 10000, got: " + f1.raw_number.to_string ());
 
23
    }
 
24
 
 
25
    f1 = FastNumber.from_string ("1.5");
 
26
    if (f1.raw_number != 1500) {
 
27
      Test.fail ();
 
28
      Test.message ("Sanity3: Wrong value.");
 
29
      Test.message ("expected: 1500, got: " + f1.raw_number.to_string ());
 
30
    }
 
31
    
 
32
    
 
33
    f1 = FastNumber.from_string ("10.5");
 
34
    if (f1.raw_number != 10500) {
 
35
      Test.fail ();
 
36
      Test.message ("Sanity4: Wrong value.");
 
37
      Test.message ("expected: 10500, got: " + f1.raw_number.to_string ());
 
38
    }
 
39
    
 
40
    
 
41
    f1 = FastNumber.from_string ("10.5");
 
42
    if (f1.raw_number != 10500) {
 
43
      Test.fail ();
 
44
      Test.message ("Sanity4: Wrong value.");
 
45
      Test.message ("expected: 10500, got: " + f1.raw_number.to_string ());
 
46
    }
 
47
    
 
48
  });
 
49
  
 
50
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "add", () => {
 
51
    var expected_val = 2670;
 
52
    var f1 = FastNumber (1337);
 
53
    var f2 = FastNumber (1333);
 
54
    var f3 = f1.add (f2);
 
55
    var out_num = f3.number;
 
56
    if (out_num != expected_val) {
 
57
      Test.fail ();
 
58
      Test.message ("The added numbers do not match the expected value");
 
59
      Test.message (@"Expected: $expected_val, got: $out_num.");
 
60
    }
 
61
  });
 
62
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "subtract", () => {
 
63
    var expected_val = 4;
 
64
    var f1 = FastNumber (1337);
 
65
    var f2 = FastNumber (1333);
 
66
    var f3 = f1.subtract (f2);
 
67
    var out_val = f3.number;
 
68
    if (out_val != 4) {
 
69
      Test.fail ();
 
70
      Test.message ("The subtracted numbers do not match the expected value");
 
71
      Test.message (@"Expeted: $expected_val, got: $out_val.");
 
72
    }
 
73
  });
 
74
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide", () => {
 
75
    var expected_val = 0;
 
76
    var f1 = FastNumber (1338);
 
77
    var f2 = FastNumber (2);
 
78
    FastNumber f3 = {0};
 
79
    try {
 
80
      f3 = f1.divide (f2);
 
81
      Utils.print_ln ("f3.number: %i", f3.number);
 
82
    } catch (Error e) {
 
83
      Utils.print_ln ("Error: %s\n", e.message);
 
84
    }
 
85
    var out_val = f3.number;
 
86
    if (out_val != 669) {
 
87
      Test.fail ();
 
88
      Test.message ("The added numbers do not match the expected value");
 
89
      Test.message (@"Expeted: $expected_val, got: $out_val.");
 
90
    }
 
91
  });
 
92
  
 
93
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide2", () => {
 
94
    var expected_val = 0;
 
95
    var f1 = FastNumber (4444);
 
96
    var f2 = FastNumber (1111);
 
97
    FastNumber f3 = {0};
 
98
    try {
 
99
      f3 = f1.divide (f2);
 
100
      Utils.print_ln ("f3.number: %i", f3.number);
 
101
    } catch (Error e) {
 
102
      Utils.print_ln ("Error: %s\n", e.message);
 
103
    }
 
104
    var out_val = f3.number;
 
105
    if (out_val != 4) {
 
106
      Test.fail ();
 
107
      Test.message ("The added numbers do not match the expected value");
 
108
      Test.message (@"Expeted: $expected_val, got: $out_val.");
 
109
    }
 
110
  });
 
111
  
 
112
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "multiply", () => {
 
113
    var expected_val = 4444;
 
114
    var f1 = FastNumber (1111);
 
115
    var f2 = FastNumber (4);
 
116
    var f3 = f1.multiply (f2);
 
117
    var out_val = f3.number;
 
118
    if (out_val != expected_val) {
 
119
      Test.fail ();
 
120
      Test.message ("The multiplied numbers does not match the exected value.");
 
121
      Test.message (@"expected $expected_val, got $out_val");
 
122
    }
 
123
  });
 
124
  
 
125
  
 
126
  
 
127
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number1", () => {
 
128
    var expected_val = 1000;
 
129
    var val = FastNumber.from_string ("1");
 
130
    
 
131
    var raw = val.raw_number;
 
132
    if (expected_val != raw) {
 
133
      Test.fail ();
 
134
      Test.message ("The raw numbers does not match the exected value.");
 
135
      Test.message (@"expected $expected_val, got $val");
 
136
    }
 
137
    
 
138
    for (int i = 2; i <= 25; i = i + 3) {
 
139
      val = FastNumber.from_string (i.to_string ());
 
140
    
 
141
      if ((expected_val * i) != val.raw_number) {
 
142
        Test.fail ();
 
143
        Test.message ("The raw numbers does not match the exected value.");
 
144
        Test.message (@"expected $expected_val, got $raw");
 
145
      }
 
146
    }
 
147
    
 
148
  });
 
149
  
 
150
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "to_string1", () => {
 
151
    var expected = "7.999";
 
152
    var f1 = FastNumber.from_string (expected);
 
153
    var result = f1.to_string (true);
 
154
    
 
155
    if (expected != result) {
 
156
      Test.fail ();
 
157
      Test.message (@"Wrong value: Expected $expected, Got: $result");
 
158
    }
 
159
    
 
160
    expected = "7.099";
 
161
    f1 = FastNumber.from_string (expected);
 
162
    result = f1.to_string (true);
 
163
    
 
164
    if (expected != result) {
 
165
      Test.fail ();
 
166
      Test.message (@"Wrong value: Expected $expected, Got: $result");
 
167
    }
 
168
    
 
169
    expected = "7.009";
 
170
    f1 = FastNumber.from_string (expected);
 
171
    result = f1.to_string (true);
 
172
    
 
173
    if (expected != result) {
 
174
      Test.fail ();
 
175
      Test.message (@"Wrong value: Expected $expected, Got: $result");
 
176
    }
 
177
  });
 
178
  
 
179
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number2", () => {
 
180
    var expected_val = 1128;
 
181
    var val = FastNumber.from_string ("1.128");
 
182
    
 
183
    var raw = val.raw_number;
 
184
    if (expected_val != raw) {
 
185
      Test.fail ();
 
186
      Test.message ("The raw numbers does not match the exected value.");
 
187
      Test.message (@"expected $expected_val, got $val");
 
188
    }
 
189
    
 
190
    expected_val = 5128;
 
191
    val = FastNumber.from_string ("5.128");
 
192
    
 
193
    raw = val.raw_number;
 
194
    if (expected_val != raw) {
 
195
      Test.fail ();
 
196
      Test.message ("The raw numbers does not match the exected value.");
 
197
      Test.message (@"expected $expected_val, got $val");
 
198
    }
 
199
    
 
200
    expected_val = 7128;
 
201
    val = FastNumber.from_string ("7.128");
 
202
    
 
203
    raw = val.raw_number;
 
204
    if (expected_val != raw) {
 
205
      Test.fail ();
 
206
      Test.message ("The raw numbers does not match the exected value.");
 
207
      Test.message (@"expected $expected_val, got $val");
 
208
    }
 
209
    
 
210
  });
 
211
  
 
212
  
 
213
  
 
214
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number3", () => {
 
215
    var expected_val = 15128;
 
216
    var val = FastNumber.from_string ("15.128");
 
217
    
 
218
    var raw = val.raw_number;
 
219
    if (expected_val != raw) {
 
220
      Test.fail ();
 
221
      Test.message ("The raw numbers does not match the exected value.");
 
222
      Test.message (@"expected $expected_val, got $val");
 
223
    }
 
224
  });
 
225
  
 
226
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number4", () => {
 
227
    var expected_val = 20128;
 
228
    var val = FastNumber.from_string ("20.128");
 
229
    var raw = val.raw_number;
 
230
    if (expected_val != raw) {
 
231
      Test.fail ();
 
232
      Test.message ("The raw numbers does not match the exected value.");
 
233
      Test.message (@"expected $expected_val, got $val");
 
234
    }
 
235
  });
 
236
  
 
237
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number5", () => {
 
238
    var expected_val = 222128;
 
239
    var val = FastNumber.from_string ("222.128");
 
240
    
 
241
    var raw = val.raw_number;
 
242
    if (expected_val != raw) {
 
243
      Test.fail ();
 
244
      Test.message ("The raw numbers does not match the exected value.");
 
245
      Test.message (@"expected $expected_val, got $val");
 
246
    }
 
247
  });
 
248
  
 
249
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number6", () => {
 
250
    var expected_val = 128;
 
251
    var val = FastNumber.from_string ("0.128");
 
252
    
 
253
    var raw = val.raw_number;
 
254
    if (expected_val != raw) {
 
255
      Test.fail ();
 
256
      Test.message ("The raw numbers does not match the exected value.");
 
257
      Test.message (@"expected $expected_val, got $raw");
 
258
    }
 
259
  });
 
260
  
 
261
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number7", () => {
 
262
    var expected_val = 160;
 
263
    var val = FastNumber.from_string ("0.16");
 
264
    
 
265
    var raw = val.raw_number;
 
266
    if (expected_val != raw) {
 
267
      Test.fail ();
 
268
      Test.message ("The raw numbers does not match the exected value.");
 
269
      Test.message (@"expected $expected_val, got $raw");
 
270
    }
 
271
  });
 
272
  
 
273
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number8", () => {
 
274
    var expected_val = 800;
 
275
    var val = FastNumber.from_string ("0.8");
 
276
    
 
277
    var raw = val.raw_number;
 
278
    if (expected_val != raw) {
 
279
      Test.fail ();
 
280
      Test.message ("The raw numbers does not match the exected value.");
 
281
      Test.message (@"expected $expected_val, got $raw");
 
282
    }
 
283
  });
 
284
  
 
285
  
 
286
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "float", () => {
 
287
    var expected_val = 10.128;
 
288
    var f1 = FastNumber.from_float (expected_val);
 
289
    var flt = f1.to_float ();
 
290
    if (expected_val != flt) {
 
291
      Test.fail ();
 
292
      var raw = f1.raw_number;
 
293
      Test.message ("The float was not the correct value.");
 
294
      Test.message (@"Expected $expected_val, get $flt, Internal value: $raw ");
 
295
    }
 
296
  });
 
297
  
 
298
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide/decimal1", () => {
 
299
      var expected_val = FastNumber.from_string ("1.5");
 
300
      var f1 = FastNumber (3);
 
301
      var f2 = FastNumber (2);
 
302
      
 
303
      var out_val = FastNumber (0);
 
304
      try {
 
305
       out_val = f1.divide (f2);
 
306
      } catch (GLib.Error e) {
 
307
          Test.fail ();
 
308
          Test.message ("Divide by Zero Error");
 
309
      }
 
310
      if (out_val.equals (expected_val) == false) {
 
311
        Test.fail ();
 
312
        var raw_expected = expected_val.raw_number;
 
313
        var raw_got = out_val.raw_number;
 
314
        Test.message ("Expected value did not match the got value");
 
315
        Test.message (@"Exected internal value: $raw_expected,\n" +
 
316
                      @"Internel value got: $raw_got .");
 
317
      }
 
318
  });
 
319
  
 
320
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide/decimal2", () => {
 
321
      var expected_val = FastNumber.from_string ("0.25");
 
322
      var f1 = FastNumber (1);
 
323
      var f2 = FastNumber (4);
 
324
      
 
325
      var out_val = FastNumber (0);
 
326
      try {
 
327
       out_val = f1.divide (f2);
 
328
      } catch (GLib.Error e) {
 
329
          Test.fail ();
 
330
          Test.message ("Divide by Zero Error");
 
331
      }
 
332
      if (out_val.equals (expected_val) == false) {
 
333
        Test.fail ();
 
334
        var raw_expected = expected_val.raw_number;
 
335
        var raw_got = out_val.raw_number;
 
336
        Test.message ("Expected value did not match the got value");
 
337
        Test.message (@"Exected internal value: $raw_expected,\n" +
 
338
                      @"Internel value got: $raw_got .");
 
339
      }
 
340
  });
 
341
  
 
342
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide/decimal3", () => {
 
343
      var expected_val = FastNumber.from_string ("0.09");
 
344
      var f1 = FastNumber (1);
 
345
      var f2 = FastNumber (11);
 
346
      
 
347
      var out_val = FastNumber (0);
 
348
      try {
 
349
       out_val = f1.divide (f2);
 
350
      } catch (GLib.Error e) {
 
351
          Test.fail ();
 
352
          Test.message ("Divide by Zero Error");
 
353
      }
 
354
      if (out_val.equals (expected_val) == false) {
 
355
        Test.fail ();
 
356
        var raw_expected = expected_val.raw_number;
 
357
        var raw_got = out_val.raw_number;
 
358
        Test.message ("Expected value did not match the got value");
 
359
        Test.message (@"Exected internal value: $raw_expected,\n" +
 
360
                      @"Internel value got: $raw_got .");
 
361
      }
 
362
  });
 
363
  
 
364
}