/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/fast_number.vala

  • Committer: Gustav Hartvigsson
  • Date: 2021-09-16 18:17:41 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20210916181741-9t8ba6lmbxty621o
EOF
Re-Wrote FastNumber

Dealinng with users being able to set their own decmial
part of the number is not viable. So don't let the user
do it.

Show diffs side-by-side

added added

removed removed

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