/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-22 00:30:29 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20241222003029-k74ogrm32zobz325
[General] Split libvee into it's own library.

Show diffs side-by-side

added added

removed removed

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