1use tracing::warn;
2
3use super::DataValue;
4
5impl std::ops::Add<&DataValue> for &DataValue {
6 type Output = DataValue;
7 fn add(self, other: &DataValue) -> DataValue {
8 use DataValue::*;
9 match self {
10 U8(i) => match other {
11 U8(j) => U8(i + j),
12 I32(j) => I32(*i as i32 + j),
13 I64(j) => I64(*i as i64 + j),
14 F32(j) => F32(*i as f32 + j),
15 F64(j) => F64(*i as f64 + j),
16 U128(j) => U128(*i as u128 + *j),
17 I128(j) => I128(*i as i128 + *j),
18 _ => Null,
19 },
20 I32(i) => match other {
21 U8(j) => I32(i + *j as i32),
22 I32(j) => I32(i + j),
23 U32(j) => I32(i + *j as i32),
24 U64(j) => U64(*i as u64 + j),
25 I64(j) => I64(*i as i64 + j),
26 F32(j) => F32(*i as f32 + j),
27 F64(j) => F64(*i as f64 + j),
28 U128(j) => U128(*i as u128 + *j),
29 I128(j) => I128(*i as i128 + *j),
30 _ => Null,
31 },
32 I64(i) => match other {
33 U8(j) => I64(i + *j as i64),
34 I32(j) => I64(i + *j as i64),
35 U32(j) => I64(i + *j as i64),
36 U64(j) => I64(i + *j as i64),
37 I64(j) => I64(i + j),
38 F32(j) => F32(*i as f32 + j),
39 F64(j) => F64(*i as f64 + j),
40 U128(j) => U128(*i as u128 + *j),
41 I128(j) => I128(*i as i128 + *j),
42 _ => Null,
43 },
44 U32(i) => match other {
45 U8(j) => U32(i + *j as u32),
46 I32(j) => U32(i + *j as u32),
47 U32(j) => U32(i + j),
48 U64(j) => U64(*i as u64 + j),
49 I64(j) => I64(*i as i64 + j),
50 F32(j) => F32(*i as f32 + j),
51 F64(j) => F64(*i as f64 + j),
52 U128(j) => U128(*i as u128 + *j),
53 I128(j) => I128(*i as i128 + *j),
54 _ => Null,
55 },
56 U64(i) => match other {
57 U8(j) => U64(i + *j as u64),
58 I32(j) => U64(i + *j as u64),
59 U32(j) => U64(i + *j as u64),
60 U64(j) => U64(i + j),
61 F32(j) => F32(*i as f32 + j),
62 F64(j) => F64(*i as f64 + j),
63 U128(j) => U128(*i as u128 + *j),
64 I128(j) => I128(*i as i128 + *j),
65 _ => Null,
66 },
67 F32(i) => match other {
68 I32(j) => F32(i + *j as f32),
69 U32(j) => F32(i + *j as f32),
70 F32(j) => F32(i + j),
71 F64(j) => F64(*i as f64 + j),
72 U128(j) => U128(*i as u128 + *j),
73 I128(j) => I128(*i as i128 + *j),
74 _ => Null,
75 },
76 F64(i) => match other {
77 U8(j) => F64(i + *j as f64),
78 I32(j) => F64(i + *j as f64),
79 U32(j) => F64(i + *j as f64),
80 U64(j) => F64(i + *j as f64),
81 F32(j) => F64(i + *j as f64),
82 F64(j) => F64(i + j),
83 U128(j) => U128(*i as u128 + *j),
84 I128(j) => I128(*i as i128 + *j),
85 _ => Null,
86 },
87 U128(i) => match other {
88 U8(j) => U128(i + *j as u128),
89 I32(j) => U128(i + *j as u128),
90 U32(j) => U128(i + *j as u128),
91 U64(j) => U128(i + *j as u128),
92 F32(j) => U128(i + *j as u128),
93 F64(j) => U128(i + *j as u128),
94 U128(j) => U128(*i + *j),
95 I128(j) => I128(*i as i128 + *j),
96 _ => Null,
97 },
98 I128(i) => match other {
99 U8(j) => I128(i + *j as i128),
100 I32(j) => I128(i + *j as i128),
101 U32(j) => I128(i + *j as i128),
102 U64(j) => I128(i + *j as i128),
103 F32(j) => I128(i + *j as i128),
104 F64(j) => I128(i + *j as i128),
105 U128(j) => U128(*i as u128 + *j),
106 I128(j) => I128(*i + *j),
107 _ => Null,
108 },
109 String(i) => match other {
110 String(j) => String(format!("{}{}", i, j).into()),
111 _ => Null,
112 },
113 Bytes(i) => match other {
114 String(j) => Bytes([i, j.as_bytes()].concat()),
115 Bytes(j) => Bytes([i.as_slice(), j.as_slice()].concat()),
116 _ => Null,
117 },
118 e => {
119 warn!("Cannot add {e:?} with {other:?}");
120 Null
121 }
122 }
123 }
124}
125
126impl std::ops::Add<DataValue> for DataValue {
127 type Output = DataValue;
128 fn add(self, other: DataValue) -> DataValue {
129 &self + &other
130 }
131}
132
133impl std::ops::Sub<&DataValue> for &DataValue {
134 type Output = DataValue;
135 fn sub(self, other: &DataValue) -> DataValue {
136 use DataValue::*;
137 match self {
138 U8(i) => match other {
139 U8(j) => F32(*i as f32 - *j as f32),
140 U32(j) => F32(*i as f32 - *j as f32),
141 I32(j) => F32(*i as f32 - *j as f32),
142 I64(j) => F64(*i as f64 - *j as f64),
143 U64(j) => F64(*i as f64 - *j as f64),
144 F32(j) => F32(*i as f32 - j),
145 F64(j) => F64(*i as f64 - j),
146 U128(j) => U128((*i as u128).saturating_sub(*j)),
147 I128(j) => I128(*i as i128 - *j),
148 _ => Null,
149 },
150 I32(i) => match other {
151 U8(j) => F32(*i as f32 - *j as f32),
152 U32(j) => F32(*i as f32 - *j as f32),
153 I32(j) => F32(*i as f32 - *j as f32),
154 I64(j) => F64(*i as f64 - *j as f64),
155 U64(j) => F64(*i as f64 - *j as f64),
156 F32(j) => F32(*i as f32 - j),
157 F64(j) => F64(*i as f64 - j),
158 U128(j) => U128((*i as u128).saturating_sub(*j)),
159 I128(j) => I128(*i as i128 - *j),
160 _ => Null,
161 },
162 I64(i) => match other {
163 U8(j) => F32(*i as f32 - *j as f32),
164 U32(j) => F32(*i as f32 - *j as f32),
165 I32(j) => F32(*i as f32 - *j as f32),
166 I64(j) => F64(*i as f64 - *j as f64),
167 U64(j) => F64(*i as f64 - *j as f64),
168 F32(j) => F32(*i as f32 - j),
169 F64(j) => F64(*i as f64 - j),
170 U128(j) => U128((*i as u128).saturating_sub(*j)),
171 I128(j) => I128(*i as i128 - *j),
172 _ => Null,
173 },
174 U32(i) => match other {
175 U8(j) => F32(*i as f32 - *j as f32),
176 U32(j) => F32(*i as f32 - *j as f32),
177 I32(j) => F32(*i as f32 - *j as f32),
178 I64(j) => F64(*i as f64 - *j as f64),
179 U64(j) => F64(*i as f64 - *j as f64),
180 F32(j) => F32(*i as f32 - j),
181 F64(j) => F64(*i as f64 - j),
182 U128(j) => U128((*i as u128).saturating_sub(*j)),
183 I128(j) => I128(*i as i128 - *j),
184 _ => Null,
185 },
186 U64(i) => match other {
187 U8(j) => F32(*i as f32 - *j as f32),
188 U32(j) => F32(*i as f32 - *j as f32),
189 I32(j) => F32(*i as f32 - *j as f32),
190 I64(j) => F64(*i as f64 - *j as f64),
191 U64(j) => F64(*i as f64 - *j as f64),
192 F32(j) => F32(*i as f32 - j),
193 F64(j) => F64(*i as f64 - j),
194 U128(j) => U128((*i as u128).saturating_sub(*j)),
195 I128(j) => I128(*i as i128 - *j),
196 _ => Null,
197 },
198 F32(i) => match other {
199 U8(j) => F32(*i - *j as f32),
200 U32(j) => F32(*i - *j as f32),
201 I32(j) => F32(*i - *j as f32),
202 I64(j) => F64(*i as f64 - *j as f64),
203 U64(j) => F64(*i as f64 - *j as f64),
204 F32(j) => F32(i - j),
205 F64(j) => F64(*i as f64 - j),
206 U128(j) => U128((*i as u128).saturating_sub(*j)),
207 I128(j) => I128(*i as i128 - *j),
208 _ => Null,
209 },
210 F64(i) => match other {
211 U8(j) => F32(*i as f32 - *j as f32),
212 U32(j) => F32(*i as f32 - *j as f32),
213 I32(j) => F32(*i as f32 - *j as f32),
214 I64(j) => F64(*i - *j as f64),
215 U64(j) => F64(*i - *j as f64),
216 F32(j) => F32(*i as f32 - j),
217 F64(j) => F64(i - j),
218 U128(j) => U128((*i as u128).saturating_sub(*j)),
219 I128(j) => I128(*i as i128 - *j),
220 _ => Null,
221 },
222 U128(i) => match other {
223 U8(j) => U128(i - *j as u128),
224 I32(j) => U128(i - *j as u128),
225 U32(j) => U128(i - *j as u128),
226 U64(j) => U128(i - *j as u128),
227 F32(j) => U128(i - *j as u128),
228 F64(j) => U128(i - *j as u128),
229 U128(j) => U128((*i).saturating_sub(*j)),
230 I128(j) => I128(*i as i128 - *j),
231 _ => Null,
232 },
233 I128(i) => match other {
234 U8(j) => I128(i - *j as i128),
235 I32(j) => I128(i - *j as i128),
236 U32(j) => I128(i - *j as i128),
237 U64(j) => I128(i - *j as i128),
238 F32(j) => I128(i - *j as i128),
239 F64(j) => I128(i - *j as i128),
240 U128(j) => U128((*i as u128).saturating_sub(*j)),
241 I128(j) => I128(*i - *j),
242 _ => Null,
243 },
244 e => {
245 warn!("Cannot sub {e:?} with {other:?}");
246 Null
247 }
248 }
249 }
250}
251
252impl std::ops::Sub<DataValue> for DataValue {
253 type Output = DataValue;
254 fn sub(self, other: DataValue) -> DataValue {
255 &self - &other
256 }
257}
258
259impl std::ops::Mul<&DataValue> for &DataValue {
260 type Output = DataValue;
261 fn mul(self, other: &DataValue) -> DataValue {
262 use DataValue::*;
263 match self {
264 U8(i) => match other {
265 U8(j) => F32(*i as f32 * *j as f32),
266 U32(j) => F32(*i as f32 * *j as f32),
267 I32(j) => F32(*i as f32 * *j as f32),
268 I64(j) => F64(*i as f64 * *j as f64),
269 U64(j) => F64(*i as f64 * *j as f64),
270 F32(j) => F32(*i as f32 * j),
271 F64(j) => F64(*i as f64 * j),
272 U128(j) => F64(*i as f64 * *j as f64),
273 I128(j) => F64(*i as f64 * *j as f64),
274 _ => Null,
275 },
276 I32(i) => match other {
277 U8(j) => F32(*i as f32 * *j as f32),
278 U32(j) => F32(*i as f32 * *j as f32),
279 I32(j) => F32(*i as f32 * *j as f32),
280 I64(j) => F64(*i as f64 * *j as f64),
281 U64(j) => F64(*i as f64 * *j as f64),
282 F32(j) => F32(*i as f32 * j),
283 F64(j) => F64(*i as f64 * j),
284 U128(j) => F64(*i as f64 * *j as f64),
285 I128(j) => F64(*i as f64 * *j as f64),
286 _ => Null,
287 },
288 I64(i) => match other {
289 U8(j) => F32(*i as f32 * *j as f32),
290 U32(j) => F32(*i as f32 * *j as f32),
291 I32(j) => F32(*i as f32 * *j as f32),
292 I64(j) => F64(*i as f64 * *j as f64),
293 U64(j) => F64(*i as f64 * *j as f64),
294 F32(j) => F32(*i as f32 * j),
295 F64(j) => F64(*i as f64 * j),
296 U128(j) => F64(*i as f64 * *j as f64),
297 I128(j) => F64(*i as f64 * *j as f64),
298 _ => Null,
299 },
300 U32(i) => match other {
301 U8(j) => F32(*i as f32 * *j as f32),
302 U32(j) => F32(*i as f32 * *j as f32),
303 I32(j) => F32(*i as f32 * *j as f32),
304 I64(j) => F64(*i as f64 * *j as f64),
305 U64(j) => F64(*i as f64 * *j as f64),
306 F32(j) => F32(*i as f32 * j),
307 F64(j) => F64(*i as f64 * j),
308 U128(j) => F64(*i as f64 * *j as f64),
309 I128(j) => F64(*i as f64 * *j as f64),
310 _ => Null,
311 },
312 U64(i) => match other {
313 U8(j) => F32(*i as f32 * *j as f32),
314 U32(j) => F32(*i as f32 * *j as f32),
315 I32(j) => F32(*i as f32 * *j as f32),
316 I64(j) => F64(*i as f64 * *j as f64),
317 U64(j) => F64(*i as f64 * *j as f64),
318 F32(j) => F32(*i as f32 * j),
319 F64(j) => F64(*i as f64 * j),
320 U128(j) => F64(*i as f64 * *j as f64),
321 I128(j) => F64(*i as f64 * *j as f64),
322 _ => Null,
323 },
324 F32(i) => match other {
325 U8(j) => F32(*i * *j as f32),
326 U32(j) => F32(*i * *j as f32),
327 I32(j) => F32(*i * *j as f32),
328 I64(j) => F64(*i as f64 * *j as f64),
329 U64(j) => F64(*i as f64 * *j as f64),
330 F32(j) => F32(i * j),
331 F64(j) => F64(*i as f64 * j),
332 U128(j) => F64(*i as f64 * *j as f64),
333 I128(j) => F64(*i as f64 * *j as f64),
334 _ => Null,
335 },
336 F64(i) => match other {
337 U8(j) => F32(*i as f32 * *j as f32),
338 U32(j) => F32(*i as f32 * *j as f32),
339 I32(j) => F32(*i as f32 * *j as f32),
340 I64(j) => F64(*i * *j as f64),
341 U64(j) => F64(*i * *j as f64),
342 F32(j) => F32(*i as f32 * j),
343 F64(j) => F64(i * j),
344 U128(j) => F64(*i * *j as f64),
345 I128(j) => F64(*i * *j as f64),
346 _ => Null,
347 },
348 U128(i) => match other {
349 U8(j) => F64(*i as f64 * *j as f64),
350 I32(j) => F64(*i as f64 * *j as f64),
351 U32(j) => F64(*i as f64 * *j as f64),
352 U64(j) => F64(*i as f64 * *j as f64),
353 F32(j) => F64(*i as f64 * *j as f64),
354 F64(j) => F64(*i as f64 * *j),
355 U128(j) => F64(*i as f64 * *j as f64),
356 I128(j) => F64(*i as f64 * *j as f64),
357 _ => Null,
358 },
359 I128(i) => match other {
360 U8(j) => F64(*i as f64 * *j as f64),
361 I32(j) => F64(*i as f64 * *j as f64),
362 U32(j) => F64(*i as f64 * *j as f64),
363 U64(j) => F64(*i as f64 * *j as f64),
364 F32(j) => F64(*i as f64 * *j as f64),
365 F64(j) => F64(*i as f64 * *j),
366 U128(j) => F64(*i as f64 * *j as f64),
367 I128(j) => F64(*i as f64 * *j as f64),
368 _ => Null,
369 },
370 e => {
371 warn!("Cannot sub {e:?} with {other:?}");
372 Null
373 }
374 }
375 }
376}
377
378impl std::ops::Mul<DataValue> for DataValue {
379 type Output = DataValue;
380 fn mul(self, other: DataValue) -> DataValue {
381 &self * &other
382 }
383}
384
385impl std::ops::Div<&DataValue> for &DataValue {
386 type Output = DataValue;
387 fn div(self, other: &DataValue) -> DataValue {
388 use DataValue::*;
389 match self {
390 U8(i) => match other {
391 U8(j) => F32(*i as f32 / *j as f32),
392 U32(j) => F32(*i as f32 / *j as f32),
393 I32(j) => F32(*i as f32 / *j as f32),
394 I64(j) => F64(*i as f64 / *j as f64),
395 U64(j) => F64(*i as f64 / *j as f64),
396 F32(j) => F32(*i as f32 / j),
397 F64(j) => F64(*i as f64 / j),
398 U128(j) => F64(*i as f64 * *j as f64),
399 I128(j) => F64(*i as f64 * *j as f64),
400 _ => Null,
401 },
402 I32(i) => match other {
403 U8(j) => F32(*i as f32 / *j as f32),
404 U32(j) => F32(*i as f32 / *j as f32),
405 I32(j) => F32(*i as f32 / *j as f32),
406 I64(j) => F64(*i as f64 / *j as f64),
407 U64(j) => F64(*i as f64 / *j as f64),
408 F32(j) => F32(*i as f32 / j),
409 F64(j) => F64(*i as f64 / j),
410 U128(j) => F64(*i as f64 * *j as f64),
411 I128(j) => F64(*i as f64 * *j as f64),
412 _ => Null,
413 },
414 I64(i) => match other {
415 U8(j) => F32(*i as f32 / *j as f32),
416 U32(j) => F32(*i as f32 / *j as f32),
417 I32(j) => F32(*i as f32 / *j as f32),
418 I64(j) => F64(*i as f64 / *j as f64),
419 U64(j) => F64(*i as f64 / *j as f64),
420 F32(j) => F32(*i as f32 / j),
421 F64(j) => F64(*i as f64 / j),
422 U128(j) => F64(*i as f64 * *j as f64),
423 I128(j) => F64(*i as f64 * *j as f64),
424 _ => Null,
425 },
426 U32(i) => match other {
427 U8(j) => F32(*i as f32 / *j as f32),
428 U32(j) => F32(*i as f32 / *j as f32),
429 I32(j) => F32(*i as f32 / *j as f32),
430 I64(j) => F64(*i as f64 / *j as f64),
431 U64(j) => F64(*i as f64 / *j as f64),
432 F32(j) => F32(*i as f32 / j),
433 F64(j) => F64(*i as f64 / j),
434 U128(j) => F64(*i as f64 * *j as f64),
435 I128(j) => F64(*i as f64 * *j as f64),
436 _ => Null,
437 },
438 U64(i) => match other {
439 U8(j) => F32(*i as f32 / *j as f32),
440 U32(j) => F32(*i as f32 / *j as f32),
441 I32(j) => F32(*i as f32 / *j as f32),
442 I64(j) => F64(*i as f64 / *j as f64),
443 U64(j) => F64(*i as f64 / *j as f64),
444 F32(j) => F32(*i as f32 / j),
445 F64(j) => F64(*i as f64 / j),
446 U128(j) => F64(*i as f64 * *j as f64),
447 I128(j) => F64(*i as f64 * *j as f64),
448 _ => Null,
449 },
450 F32(i) => match other {
451 U8(j) => F32(*i / *j as f32),
452 U32(j) => F32(*i / *j as f32),
453 I32(j) => F32(*i / *j as f32),
454 I64(j) => F64(*i as f64 / *j as f64),
455 U64(j) => F64(*i as f64 / *j as f64),
456 F32(j) => F32(i / j),
457 F64(j) => F64(*i as f64 / j),
458 U128(j) => F64(*i as f64 * *j as f64),
459 I128(j) => F64(*i as f64 * *j as f64),
460 _ => Null,
461 },
462 F64(i) => match other {
463 U8(j) => F32(*i as f32 / *j as f32),
464 U32(j) => F32(*i as f32 / *j as f32),
465 I32(j) => F32(*i as f32 / *j as f32),
466 I64(j) => F64(*i / *j as f64),
467 U64(j) => F64(*i / *j as f64),
468 F32(j) => F32(*i as f32 / j),
469 F64(j) => F64(i / j),
470 U128(j) => F64(*i * *j as f64),
471 I128(j) => F64(*i * *j as f64),
472 _ => Null,
473 },
474 U128(i) => match other {
475 U8(j) => F64(*i as f64 / *j as f64),
476 I32(j) => F64(*i as f64 / *j as f64),
477 U32(j) => F64(*i as f64 / *j as f64),
478 U64(j) => F64(*i as f64 / *j as f64),
479 F32(j) => F64(*i as f64 / *j as f64),
480 F64(j) => F64(*i as f64 / *j),
481 U128(j) => F64(*i as f64 / *j as f64),
482 I128(j) => F64(*i as f64 / *j as f64),
483 _ => Null,
484 },
485 I128(i) => match other {
486 U8(j) => F64(*i as f64 / *j as f64),
487 I32(j) => F64(*i as f64 / *j as f64),
488 U32(j) => F64(*i as f64 / *j as f64),
489 U64(j) => F64(*i as f64 / *j as f64),
490 F32(j) => F64(*i as f64 / *j as f64),
491 F64(j) => F64(*i as f64 / *j),
492 U128(j) => F64(*i as f64 / *j as f64),
493 I128(j) => F64(*i as f64 / *j as f64),
494 _ => Null,
495 },
496 e => {
497 warn!("Cannot sub {e:?} with {other:?}");
498 Null
499 }
500 }
501 }
502}
503
504impl std::ops::Div<DataValue> for DataValue {
505 type Output = DataValue;
506 fn div(self, other: DataValue) -> DataValue {
507 &self / &other
508 }
509}
510
511impl std::ops::AddAssign<&DataValue> for DataValue {
512 fn add_assign(&mut self, other: &DataValue) {
513 *self = &*self + other;
514 }
515}
516
517impl std::ops::SubAssign<&DataValue> for DataValue {
518 fn sub_assign(&mut self, other: &DataValue) {
519 *self = &*self - other;
520 }
521}
522
523impl std::ops::MulAssign<&DataValue> for DataValue {
524 fn mul_assign(&mut self, other: &DataValue) {
525 *self = &*self * other;
526 }
527}
528
529impl std::ops::DivAssign<&DataValue> for DataValue {
530 fn div_assign(&mut self, other: &DataValue) {
531 *self = &*self / other;
532 }
533}
534
535#[cfg(test)]
536mod test {
537 use super::*;
538 #[test]
539 fn add_datavalue_same() {
540 let a = DataValue::U32(1);
541 let b = DataValue::U32(2);
542 let c = a + b;
543 assert_eq!(c, DataValue::U32(3));
544 let a = DataValue::U64(1);
545 let b = DataValue::U64(2);
546 let c = a + b;
547 assert_eq!(c, DataValue::U64(3));
548 let a = DataValue::F32(1f32);
549 let b = DataValue::F32(2f32);
550 let c = a + b;
551 assert_eq!(c, DataValue::F32(3f32));
552 let a = DataValue::F64(1f64);
553 let b = DataValue::F64(2f64);
554 let c = a + b;
555 assert_eq!(c, DataValue::F64(3f64));
556 let a = DataValue::I32(1);
557 let b = DataValue::I32(2);
558 let c = a + b;
559 assert_eq!(c, DataValue::I32(3));
560 let a = DataValue::I64(1);
561 let b = DataValue::I64(2);
562 let c = a + b;
563 assert_eq!(c, DataValue::I64(3));
564 let a = DataValue::String("1".into());
565 let b = DataValue::String("2".into());
566 let c = a + b;
567 assert_eq!(c, DataValue::String("12".into()));
568 let a = DataValue::Bytes(vec![1u8]);
569 let b = DataValue::Bytes(vec![2u8]);
570 let c = a + b;
571 assert_eq!(c, DataValue::Bytes(vec![1u8, 2u8]));
572 let a = DataValue::I128(1);
573 let b = DataValue::I128(2);
574 let c = a + b;
575 assert_eq!(c, DataValue::I128(3));
576 let a = DataValue::U128(1);
577 let b = DataValue::U128(2);
578 let c = b + a;
579 assert_eq!(c, DataValue::U128(3));
580 }
581
582 #[test]
583 fn sub_datavalue_same() {
584 let a = DataValue::U32(1);
585 let b = DataValue::U32(2);
586 let c = a - b;
587 assert_eq!(c, DataValue::F32(-1f32));
588 let a = DataValue::U64(1);
589 let b = DataValue::U64(2);
590 let c = a - b;
591 assert_eq!(c, DataValue::F64(-1f64));
592 let a = DataValue::F32(1f32);
593 let b = DataValue::F32(2f32);
594 let c = a - b;
595 assert_eq!(c, DataValue::F32(-1f32));
596 let a = DataValue::F64(1f64);
597 let b = DataValue::F64(2f64);
598 let c = a - b;
599 assert_eq!(c, DataValue::F64(-1f64));
600 let a = DataValue::I32(1);
601 let b = DataValue::I32(2);
602 let c = a - b;
603 assert_eq!(c, DataValue::F32(-1f32));
604 let a = DataValue::I64(1);
605 let b = DataValue::I64(2);
606 let c = a - b;
607 assert_eq!(c, DataValue::F64(-1f64));
608 let a = DataValue::String("1".into());
609 let b = DataValue::String("2".into());
610 let c = a - b;
611 assert_eq!(c, DataValue::Null);
612 let a = DataValue::Bytes(vec![1u8]);
613 let b = DataValue::Bytes(vec![2u8]);
614 let c = a - b;
615 assert_eq!(c, DataValue::Null);
616 let a = DataValue::I128(1);
617 let b = DataValue::I128(2);
618 let c = a - b;
619 assert_eq!(c, DataValue::I128(-1));
620 let a = DataValue::U128(1);
621 let b = DataValue::U128(2);
622 let c = b - a;
623 assert_eq!(c, DataValue::U128(1));
624 }
625
626 #[test]
627 fn div_datavalue_same() {
628 let a = DataValue::U32(1);
629 let b = DataValue::U32(2);
630 let c = a / b;
631 assert_eq!(c, DataValue::F32(0.5f32));
632 let a = DataValue::U64(1);
633 let b = DataValue::U64(2);
634 let c = a / b;
635 assert_eq!(c, DataValue::F64(0.5f64));
636 let a = DataValue::F32(1f32);
637 let b = DataValue::F32(2f32);
638 let c = a / b;
639 assert_eq!(c, DataValue::F32(0.5f32));
640 let a = DataValue::F64(1f64);
641 let b = DataValue::F64(2f64);
642 let c = a / b;
643 assert_eq!(c, DataValue::F64(0.5f64));
644 let a = DataValue::I32(1);
645 let b = DataValue::I32(2);
646 let c = a / b;
647 assert_eq!(c, DataValue::F32(0.5f32));
648 let a = DataValue::I64(1);
649 let b = DataValue::I64(2);
650 let c = a / b;
651 assert_eq!(c, DataValue::F64(0.5f64));
652 let a = DataValue::String("1".into());
653 let b = DataValue::String("2".into());
654 let c = a / b;
655 assert_eq!(c, DataValue::Null);
656 let a = DataValue::Bytes(vec![1u8]);
657 let b = DataValue::Bytes(vec![2u8]);
658 let c = a / b;
659 assert_eq!(c, DataValue::Null);
660 let a = DataValue::I128(1);
661 let b = DataValue::I128(2);
662 let c = a / b;
663 assert_eq!(c, DataValue::F64(0.5f64));
664 let a = DataValue::U128(1);
665 let b = DataValue::U128(2);
666 let c = a / b;
667 assert_eq!(c, DataValue::F64(0.5f64));
668 }
669
670 #[test]
671 fn mul_datavalue_same() {
672 let a = DataValue::U32(1);
673 let b = DataValue::U32(2);
674 let c = a * b;
675 assert_eq!(c, DataValue::F32(2f32));
676 let a = DataValue::U64(1);
677 let b = DataValue::U64(2);
678 let c = a * b;
679 assert_eq!(c, DataValue::F64(2f64));
680 let a = DataValue::F32(1f32);
681 let b = DataValue::F32(2f32);
682 let c = a * b;
683 assert_eq!(c, DataValue::F32(2f32));
684 let a = DataValue::F64(1f64);
685 let b = DataValue::F64(2f64);
686 let c = a * b;
687 assert_eq!(c, DataValue::F64(2f64));
688 let a = DataValue::I32(1);
689 let b = DataValue::I32(2);
690 let c = a * b;
691 assert_eq!(c, DataValue::F32(2f32));
692 let a = DataValue::I64(1);
693 let b = DataValue::I64(2);
694 let c = a * b;
695 assert_eq!(c, DataValue::F64(2f64));
696 let a = DataValue::String("1".into());
697 let b = DataValue::String("2".into());
698 let c = a * b;
699 assert_eq!(c, DataValue::Null);
700 let a = DataValue::Bytes(vec![1u8]);
701 let b = DataValue::Bytes(vec![2u8]);
702 let c = a * b;
703 assert_eq!(c, DataValue::Null);
704 let a = DataValue::I128(1);
705 let b = DataValue::I128(2);
706 let c = a * b;
707 assert_eq!(c, DataValue::F64(2f64));
708 let a = DataValue::U128(1);
709 let b = DataValue::U128(2);
710 let c = a * b;
711 assert_eq!(c, DataValue::F64(2f64));
712 }
713 use rstest::*;
714 #[rstest]
715 #[case(
716 vec![
717 DataValue::U32(1),
718 DataValue::I32(2),
719 DataValue::U64(3),
720 DataValue::I64(4),
721 DataValue::F32(5f32),
722 DataValue::F64(6f64),
723 DataValue::U128(7),
724 DataValue::I128(8),
725 DataValue::U8(1)
726 ],
727 vec![
728 DataValue::U32(1),
729 DataValue::I32(2),
730 DataValue::U64(3),
731 DataValue::I64(4),
732 DataValue::F32(5f32),
733 DataValue::F64(6f64),
734 DataValue::U128(7),
735 DataValue::I128(8),
736 DataValue::U8(1)
737 ]
738 )]
739 fn operations(#[case] a: Vec<DataValue>, #[case] b: Vec<DataValue>) {
740 for a_in in a.iter() {
741 for b_in in b.iter() {
742 assert_eq!(a_in + b_in, a_in + b_in);
743 assert_eq!(a_in - b_in, a_in - b_in);
744 assert_eq!(a_in * b_in, a_in * b_in);
745 assert_eq!(a_in / b_in, a_in / b_in);
746
747 let mut aa_in = a_in.clone();
748 aa_in += b_in;
749 assert_eq!(aa_in, a_in + b_in);
750 let mut aa_in = a_in.clone();
751 aa_in -= b_in;
752 assert_eq!(aa_in, a_in - b_in);
753 let mut aa_in = a_in.clone();
754 aa_in *= b_in;
755 assert_eq!(aa_in, a_in * b_in);
756 let mut aa_in = a_in.clone();
757 aa_in /= b_in;
758 assert_eq!(aa_in, a_in / b_in);
759 }
760 }
761 }
762}