/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-06-01 12:44:04 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20220601124404-mpv4761nr16f0duq
run_gdb.sh +x

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