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

  • Committer: Gustav Hartvigsson
  • Date: 2024-12-21 23:51:45 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20241221235145-4metak6z6u6vf6b0
[General] Major refactoring. Utils -> Vee nenaming.
Todo: Split libvee into a different library??

Also: Fixed spelling mistakes.

Show diffs side-by-side

added added

removed removed

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