/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: 2020-06-07 18:48:24 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20200607184824-jf14f7a1b1di2i2q
* Initial code - far from done

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
 
}