/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: 2021-11-16 12:44:52 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20211116124452-g9245bvzwcyy9wk9
Added licencing information.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
using GLib;
2
2
 
3
 
using Vee;
 
3
using Utils;
 
4
using VQDR.Expression;
4
5
 
5
6
void fast_number_test () {
6
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "new/raw", () => {
 
7
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "new/raw", () => {
7
8
    FastNumber f1;
8
9
    
9
10
    
46
47
    
47
48
  });
48
49
  
49
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "add", () => {
 
50
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "add", () => {
50
51
    var expected_val = 2670;
51
52
    var f1 = FastNumber (1337);
52
53
    var f2 = FastNumber (1333);
58
59
      Test.message (@"Expected: $expected_val, got: $out_num.");
59
60
    }
60
61
  });
61
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "subtract", () => {
 
62
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "subtract", () => {
62
63
    var expected_val = 4;
63
64
    var f1 = FastNumber (1337);
64
65
    var f2 = FastNumber (1333);
67
68
    if (out_val != 4) {
68
69
      Test.fail ();
69
70
      Test.message ("The subtracted numbers do not match the expected value");
70
 
      Test.message (@"Experted: $expected_val, got: $out_val.");
 
71
      Test.message (@"Expeted: $expected_val, got: $out_val.");
71
72
    }
72
73
  });
73
 
 
74
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "divide", () => {
75
 
    var expected_val = 669;
 
74
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide", () => {
 
75
    var expected_val = 0;
76
76
    var f1 = FastNumber (1338);
77
77
    var f2 = FastNumber (2);
78
78
    FastNumber f3 = {0};
79
79
    try {
80
80
      f3 = f1.divide (f2);
81
 
      Vee.print_ln ("f3.number: %i", f3.number);
 
81
      Utils.print_ln ("f3.number: %i", f3.number);
82
82
    } catch (Error e) {
83
 
      Vee.print_ln ("Error: %s\n", e.message);
 
83
      Utils.print_ln ("Error: %s\n", e.message);
84
84
    }
85
85
    var out_val = f3.number;
86
 
    if (out_val != expected_val) {
 
86
    if (out_val != 669) {
87
87
      Test.fail ();
88
88
      Test.message ("The added numbers do not match the expected value");
89
 
      Test.message (@"Experted: $expected_val, got: $out_val.");
90
 
      Test.message (@"Raw value: $(f3.raw_number)");
 
89
      Test.message (@"Expeted: $expected_val, got: $out_val.");
91
90
    }
92
91
  });
93
 
 
94
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "divide2", () => {
95
 
    var expected_val = 4;
 
92
  
 
93
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide2", () => {
 
94
    var expected_val = 0;
96
95
    var f1 = FastNumber (4444);
97
96
    var f2 = FastNumber (1111);
98
97
    FastNumber f3 = {0};
99
98
    try {
100
99
      f3 = f1.divide (f2);
101
 
      Vee.print_ln ("f3.number: %i", f3.number);
 
100
      Utils.print_ln ("f3.number: %i", f3.number);
102
101
    } catch (Error e) {
103
 
      Vee.print_ln ("Error: %s\n", e.message);
 
102
      Utils.print_ln ("Error: %s\n", e.message);
104
103
    }
105
104
    var out_val = f3.number;
106
 
    if (out_val != expected_val) {
 
105
    if (out_val != 4) {
107
106
      Test.fail ();
108
107
      Test.message ("The added numbers do not match the expected value");
109
 
      Test.message (@"Experted: $expected_val, got: $out_val.");
110
 
      Test.message (@"Raw value: $(f3.raw_number)");
 
108
      Test.message (@"Expeted: $expected_val, got: $out_val.");
111
109
    }
112
110
  });
113
111
  
114
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "multiply", () => {
 
112
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "multiply", () => {
115
113
    var expected_val = 4444;
116
114
    var f1 = FastNumber (1111);
117
115
    var f2 = FastNumber (4);
119
117
    var out_val = f3.number;
120
118
    if (out_val != expected_val) {
121
119
      Test.fail ();
122
 
      Test.message ("The multiplied numbers does not match the expected value.");
 
120
      Test.message ("The multiplied numbers does not match the exected value.");
123
121
      Test.message (@"expected $expected_val, got $out_val");
124
122
    }
125
123
  });
126
124
  
127
125
  
128
126
  
129
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "parse_raw_number1", () => {
 
127
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number1", () => {
130
128
    var expected_val = 1000;
131
129
    var val = FastNumber.from_string ("1");
132
130
    
133
131
    var raw = val.raw_number;
134
132
    if (expected_val != raw) {
135
133
      Test.fail ();
136
 
      Test.message ("The raw numbers does not match the expected value.");
 
134
      Test.message ("The raw numbers does not match the exected value.");
137
135
      Test.message (@"expected $expected_val, got $val");
138
136
    }
139
137
    
142
140
    
143
141
      if ((expected_val * i) != val.raw_number) {
144
142
        Test.fail ();
145
 
        Test.message ("The raw numbers does not match the expected value.");
 
143
        Test.message ("The raw numbers does not match the exected value.");
146
144
        Test.message (@"expected $expected_val, got $raw");
147
145
      }
148
146
    }
149
147
    
150
148
  });
151
149
  
152
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "to_string1", () => {
 
150
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "to_string1", () => {
153
151
    var expected = "7.999";
154
152
    var f1 = FastNumber.from_string (expected);
155
153
    var result = f1.to_string (true);
178
176
    }
179
177
  });
180
178
  
181
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "parse_raw_number2", () => {
 
179
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number2", () => {
182
180
    var expected_val = 1128;
183
181
    var val = FastNumber.from_string ("1.128");
184
182
    
185
183
    var raw = val.raw_number;
186
184
    if (expected_val != raw) {
187
185
      Test.fail ();
188
 
      Test.message ("The raw numbers does not match the expected value.");
 
186
      Test.message ("The raw numbers does not match the exected value.");
189
187
      Test.message (@"expected $expected_val, got $val");
190
188
    }
191
189
    
195
193
    raw = val.raw_number;
196
194
    if (expected_val != raw) {
197
195
      Test.fail ();
198
 
      Test.message ("The raw numbers does not match the expected value.");
 
196
      Test.message ("The raw numbers does not match the exected value.");
199
197
      Test.message (@"expected $expected_val, got $val");
200
198
    }
201
199
    
205
203
    raw = val.raw_number;
206
204
    if (expected_val != raw) {
207
205
      Test.fail ();
208
 
      Test.message ("The raw numbers does not match the expected value.");
 
206
      Test.message ("The raw numbers does not match the exected value.");
209
207
      Test.message (@"expected $expected_val, got $val");
210
208
    }
211
209
    
213
211
  
214
212
  
215
213
  
216
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "parse_raw_number3", () => {
 
214
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number3", () => {
217
215
    var expected_val = 15128;
218
216
    var val = FastNumber.from_string ("15.128");
219
217
    
220
218
    var raw = val.raw_number;
221
219
    if (expected_val != raw) {
222
220
      Test.fail ();
223
 
      Test.message ("The raw numbers does not match the expected value.");
 
221
      Test.message ("The raw numbers does not match the exected value.");
224
222
      Test.message (@"expected $expected_val, got $val");
225
223
    }
226
224
  });
227
225
  
228
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "parse_raw_number4", () => {
 
226
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number4", () => {
229
227
    var expected_val = 20128;
230
228
    var val = FastNumber.from_string ("20.128");
231
229
    var raw = val.raw_number;
232
230
    if (expected_val != raw) {
233
231
      Test.fail ();
234
 
      Test.message ("The raw numbers does not match the expected value.");
 
232
      Test.message ("The raw numbers does not match the exected value.");
235
233
      Test.message (@"expected $expected_val, got $val");
236
234
    }
237
235
  });
238
236
  
239
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "parse_raw_number5", () => {
 
237
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number5", () => {
240
238
    var expected_val = 222128;
241
239
    var val = FastNumber.from_string ("222.128");
242
240
    
243
241
    var raw = val.raw_number;
244
242
    if (expected_val != raw) {
245
243
      Test.fail ();
246
 
      Test.message ("The raw numbers does not match the expected value.");
 
244
      Test.message ("The raw numbers does not match the exected value.");
247
245
      Test.message (@"expected $expected_val, got $val");
248
246
    }
249
247
  });
250
248
  
251
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "parse_raw_number6", () => {
 
249
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number6", () => {
252
250
    var expected_val = 128;
253
251
    var val = FastNumber.from_string ("0.128");
254
252
    
255
253
    var raw = val.raw_number;
256
254
    if (expected_val != raw) {
257
255
      Test.fail ();
258
 
      Test.message ("The raw numbers does not match the expected value.");
 
256
      Test.message ("The raw numbers does not match the exected value.");
259
257
      Test.message (@"expected $expected_val, got $raw");
260
258
    }
261
259
  });
262
260
  
263
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "parse_raw_number7", () => {
 
261
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number7", () => {
264
262
    var expected_val = 160;
265
263
    var val = FastNumber.from_string ("0.16");
266
264
    
267
265
    var raw = val.raw_number;
268
266
    if (expected_val != raw) {
269
267
      Test.fail ();
270
 
      Test.message ("The raw numbers does not match the expected value.");
 
268
      Test.message ("The raw numbers does not match the exected value.");
271
269
      Test.message (@"expected $expected_val, got $raw");
272
270
    }
273
271
  });
274
272
  
275
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "parse_raw_number8", () => {
 
273
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "parse_raw_number8", () => {
276
274
    var expected_val = 800;
277
275
    var val = FastNumber.from_string ("0.8");
278
276
    
279
277
    var raw = val.raw_number;
280
278
    if (expected_val != raw) {
281
279
      Test.fail ();
282
 
      Test.message ("The raw numbers does not match the expected value.");
 
280
      Test.message ("The raw numbers does not match the exected value.");
283
281
      Test.message (@"expected $expected_val, got $raw");
284
282
    }
285
283
  });
286
284
  
287
285
  
288
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "float", () => {
 
286
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "float", () => {
289
287
    var expected_val = 10.128;
290
288
    var f1 = FastNumber.from_float (expected_val);
291
289
    var flt = f1.to_float ();
297
295
    }
298
296
  });
299
297
  
300
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "divide/decimal1", () => {
 
298
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide/decimal1", () => {
301
299
      var expected_val = FastNumber.from_string ("1.5");
302
300
      var f1 = FastNumber (3);
303
301
      var f2 = FastNumber (2);
314
312
        var raw_expected = expected_val.raw_number;
315
313
        var raw_got = out_val.raw_number;
316
314
        Test.message ("Expected value did not match the got value");
317
 
        Test.message (@"Expected internal value: $raw_expected,\n" +
318
 
                      @"Internal value got: $raw_got .");
 
315
        Test.message (@"Exected internal value: $raw_expected,\n" +
 
316
                      @"Internel value got: $raw_got .");
319
317
      }
320
318
  });
321
319
  
322
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "divide/decimal2", () => {
 
320
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide/decimal2", () => {
323
321
      var expected_val = FastNumber.from_string ("0.25");
324
322
      var f1 = FastNumber (1);
325
323
      var f2 = FastNumber (4);
336
334
        var raw_expected = expected_val.raw_number;
337
335
        var raw_got = out_val.raw_number;
338
336
        Test.message ("Expected value did not match the got value");
339
 
        Test.message (@"Expected internal value: $raw_expected,\n" +
340
 
                      @"Internal value got: $raw_got .");
 
337
        Test.message (@"Exected internal value: $raw_expected,\n" +
 
338
                      @"Internel value got: $raw_got .");
341
339
      }
342
340
  });
343
341
  
344
 
  Test.add_func (VEE_TEST_FAST_NUMBER_PREFIX + "divide/decimal3", () => {
 
342
  Test.add_func (UTIL_TEST_FAST_NUMBER_PREFIX + "divide/decimal3", () => {
345
343
      var expected_val = FastNumber.from_string ("0.09");
346
344
      var f1 = FastNumber (1);
347
345
      var f2 = FastNumber (11);
358
356
        var raw_expected = expected_val.raw_number;
359
357
        var raw_got = out_val.raw_number;
360
358
        Test.message ("Expected value did not match the got value");
361
 
        Test.message (@"Expected internal value: $raw_expected,\n" +
362
 
                      @"Internal value got: $raw_got .");
 
359
        Test.message (@"Exected internal value: $raw_expected,\n" +
 
360
                      @"Internel value got: $raw_got .");
363
361
      }
364
362
  });
365
363