You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by tu...@apache.org on 2023/04/05 15:22:16 UTC
[arrow-rs] branch master updated: feat: add tests for ArrowNativeTypeOp (#4018)
This is an automated email from the ASF dual-hosted git repository.
tustvold pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow-rs.git
The following commit(s) were added to refs/heads/master by this push:
new 2b2ce2f93 feat: add tests for ArrowNativeTypeOp (#4018)
2b2ce2f93 is described below
commit 2b2ce2f93b6c1798ef04658b286353b71d17682e
Author: Igor Izvekov <iz...@gmail.com>
AuthorDate: Wed Apr 5 18:22:10 2023 +0300
feat: add tests for ArrowNativeTypeOp (#4018)
---
arrow-array/src/arithmetic.rs | 401 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 401 insertions(+)
diff --git a/arrow-array/src/arithmetic.rs b/arrow-array/src/arithmetic.rs
index bb809507c..abeb46b99 100644
--- a/arrow-array/src/arithmetic.rs
+++ b/arrow-array/src/arithmetic.rs
@@ -380,3 +380,404 @@ macro_rules! native_type_float_op {
native_type_float_op!(f16, f16::ZERO, f16::ONE);
native_type_float_op!(f32, 0., 1.);
native_type_float_op!(f64, 0., 1.);
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_native_type_is_zero() {
+ assert!(0_i8.is_zero());
+ assert!(0_i16.is_zero());
+ assert!(0_i32.is_zero());
+ assert!(0_i64.is_zero());
+ assert!(0_i128.is_zero());
+ assert!(i256::ZERO.is_zero());
+ assert!(0_u8.is_zero());
+ assert!(0_u16.is_zero());
+ assert!(0_u32.is_zero());
+ assert!(0_u64.is_zero());
+ assert!(f16::ZERO.is_zero());
+ assert!(0.0_f32.is_zero());
+ assert!(0.0_f64.is_zero());
+ }
+
+ #[test]
+ fn test_native_type_comparison() {
+ // is_eq
+ assert!(8_i8.is_eq(8_i8));
+ assert!(8_i16.is_eq(8_i16));
+ assert!(8_i32.is_eq(8_i32));
+ assert!(8_i64.is_eq(8_i64));
+ assert!(8_i128.is_eq(8_i128));
+ assert!(i256::from_parts(8, 0).is_eq(i256::from_parts(8, 0)));
+ assert!(8_u8.is_eq(8_u8));
+ assert!(8_u16.is_eq(8_u16));
+ assert!(8_u32.is_eq(8_u32));
+ assert!(8_u64.is_eq(8_u64));
+ assert!(f16::from_f32(8.0).is_eq(f16::from_f32(8.0)));
+ assert!(8.0_f32.is_eq(8.0_f32));
+ assert!(8.0_f64.is_eq(8.0_f64));
+
+ // is_ne
+ assert!(8_i8.is_ne(1_i8));
+ assert!(8_i16.is_ne(1_i16));
+ assert!(8_i32.is_ne(1_i32));
+ assert!(8_i64.is_ne(1_i64));
+ assert!(8_i128.is_ne(1_i128));
+ assert!(i256::from_parts(8, 0).is_ne(i256::from_parts(1, 0)));
+ assert!(8_u8.is_ne(1_u8));
+ assert!(8_u16.is_ne(1_u16));
+ assert!(8_u32.is_ne(1_u32));
+ assert!(8_u64.is_ne(1_u64));
+ assert!(f16::from_f32(8.0).is_ne(f16::from_f32(1.0)));
+ assert!(8.0_f32.is_ne(1.0_f32));
+ assert!(8.0_f64.is_ne(1.0_f64));
+
+ // is_lt
+ assert!(8_i8.is_lt(10_i8));
+ assert!(8_i16.is_lt(10_i16));
+ assert!(8_i32.is_lt(10_i32));
+ assert!(8_i64.is_lt(10_i64));
+ assert!(8_i128.is_lt(10_i128));
+ assert!(i256::from_parts(8, 0).is_lt(i256::from_parts(10, 0)));
+ assert!(8_u8.is_lt(10_u8));
+ assert!(8_u16.is_lt(10_u16));
+ assert!(8_u32.is_lt(10_u32));
+ assert!(8_u64.is_lt(10_u64));
+ assert!(f16::from_f32(8.0).is_lt(f16::from_f32(10.0)));
+ assert!(8.0_f32.is_lt(10.0_f32));
+ assert!(8.0_f64.is_lt(10.0_f64));
+
+ // is_gt
+ assert!(8_i8.is_gt(1_i8));
+ assert!(8_i16.is_gt(1_i16));
+ assert!(8_i32.is_gt(1_i32));
+ assert!(8_i64.is_gt(1_i64));
+ assert!(8_i128.is_gt(1_i128));
+ assert!(i256::from_parts(8, 0).is_gt(i256::from_parts(1, 0)));
+ assert!(8_u8.is_gt(1_u8));
+ assert!(8_u16.is_gt(1_u16));
+ assert!(8_u32.is_gt(1_u32));
+ assert!(8_u64.is_gt(1_u64));
+ assert!(f16::from_f32(8.0).is_gt(f16::from_f32(1.0)));
+ assert!(8.0_f32.is_gt(1.0_f32));
+ assert!(8.0_f64.is_gt(1.0_f64));
+ }
+
+ #[test]
+ fn test_native_type_add() {
+ // add_wrapping
+ assert_eq!(8_i8.add_wrapping(2_i8), 10_i8);
+ assert_eq!(8_i16.add_wrapping(2_i16), 10_i16);
+ assert_eq!(8_i32.add_wrapping(2_i32), 10_i32);
+ assert_eq!(8_i64.add_wrapping(2_i64), 10_i64);
+ assert_eq!(8_i128.add_wrapping(2_i128), 10_i128);
+ assert_eq!(
+ i256::from_parts(8, 0).add_wrapping(i256::from_parts(2, 0)),
+ i256::from_parts(10, 0)
+ );
+ assert_eq!(8_u8.add_wrapping(2_u8), 10_u8);
+ assert_eq!(8_u16.add_wrapping(2_u16), 10_u16);
+ assert_eq!(8_u32.add_wrapping(2_u32), 10_u32);
+ assert_eq!(8_u64.add_wrapping(2_u64), 10_u64);
+ assert_eq!(
+ f16::from_f32(8.0).add_wrapping(f16::from_f32(2.0)),
+ f16::from_f32(10.0)
+ );
+ assert_eq!(8.0_f32.add_wrapping(2.0_f32), 10_f32);
+ assert_eq!(8.0_f64.add_wrapping(2.0_f64), 10_f64);
+
+ // add_checked
+ assert_eq!(8_i8.add_checked(2_i8).unwrap(), 10_i8);
+ assert_eq!(8_i16.add_checked(2_i16).unwrap(), 10_i16);
+ assert_eq!(8_i32.add_checked(2_i32).unwrap(), 10_i32);
+ assert_eq!(8_i64.add_checked(2_i64).unwrap(), 10_i64);
+ assert_eq!(8_i128.add_checked(2_i128).unwrap(), 10_i128);
+ assert_eq!(
+ i256::from_parts(8, 0)
+ .add_checked(i256::from_parts(2, 0))
+ .unwrap(),
+ i256::from_parts(10, 0)
+ );
+ assert_eq!(8_u8.add_checked(2_u8).unwrap(), 10_u8);
+ assert_eq!(8_u16.add_checked(2_u16).unwrap(), 10_u16);
+ assert_eq!(8_u32.add_checked(2_u32).unwrap(), 10_u32);
+ assert_eq!(8_u64.add_checked(2_u64).unwrap(), 10_u64);
+ assert_eq!(
+ f16::from_f32(8.0).add_checked(f16::from_f32(2.0)).unwrap(),
+ f16::from_f32(10.0)
+ );
+ assert_eq!(8.0_f32.add_checked(2.0_f32).unwrap(), 10_f32);
+ assert_eq!(8.0_f64.add_checked(2.0_f64).unwrap(), 10_f64);
+ }
+
+ #[test]
+ fn test_native_type_sub() {
+ // sub_wrapping
+ assert_eq!(8_i8.sub_wrapping(2_i8), 6_i8);
+ assert_eq!(8_i16.sub_wrapping(2_i16), 6_i16);
+ assert_eq!(8_i32.sub_wrapping(2_i32), 6_i32);
+ assert_eq!(8_i64.sub_wrapping(2_i64), 6_i64);
+ assert_eq!(8_i128.sub_wrapping(2_i128), 6_i128);
+ assert_eq!(
+ i256::from_parts(8, 0).sub_wrapping(i256::from_parts(2, 0)),
+ i256::from_parts(6, 0)
+ );
+ assert_eq!(8_u8.sub_wrapping(2_u8), 6_u8);
+ assert_eq!(8_u16.sub_wrapping(2_u16), 6_u16);
+ assert_eq!(8_u32.sub_wrapping(2_u32), 6_u32);
+ assert_eq!(8_u64.sub_wrapping(2_u64), 6_u64);
+ assert_eq!(
+ f16::from_f32(8.0).sub_wrapping(f16::from_f32(2.0)),
+ f16::from_f32(6.0)
+ );
+ assert_eq!(8.0_f32.sub_wrapping(2.0_f32), 6_f32);
+ assert_eq!(8.0_f64.sub_wrapping(2.0_f64), 6_f64);
+
+ // sub_checked
+ assert_eq!(8_i8.sub_checked(2_i8).unwrap(), 6_i8);
+ assert_eq!(8_i16.sub_checked(2_i16).unwrap(), 6_i16);
+ assert_eq!(8_i32.sub_checked(2_i32).unwrap(), 6_i32);
+ assert_eq!(8_i64.sub_checked(2_i64).unwrap(), 6_i64);
+ assert_eq!(8_i128.sub_checked(2_i128).unwrap(), 6_i128);
+ assert_eq!(
+ i256::from_parts(8, 0)
+ .sub_checked(i256::from_parts(2, 0))
+ .unwrap(),
+ i256::from_parts(6, 0)
+ );
+ assert_eq!(8_u8.sub_checked(2_u8).unwrap(), 6_u8);
+ assert_eq!(8_u16.sub_checked(2_u16).unwrap(), 6_u16);
+ assert_eq!(8_u32.sub_checked(2_u32).unwrap(), 6_u32);
+ assert_eq!(8_u64.sub_checked(2_u64).unwrap(), 6_u64);
+ assert_eq!(
+ f16::from_f32(8.0).sub_checked(f16::from_f32(2.0)).unwrap(),
+ f16::from_f32(6.0)
+ );
+ assert_eq!(8.0_f32.sub_checked(2.0_f32).unwrap(), 6_f32);
+ assert_eq!(8.0_f64.sub_checked(2.0_f64).unwrap(), 6_f64);
+ }
+
+ #[test]
+ fn test_native_type_mul() {
+ // mul_wrapping
+ assert_eq!(8_i8.mul_wrapping(2_i8), 16_i8);
+ assert_eq!(8_i16.mul_wrapping(2_i16), 16_i16);
+ assert_eq!(8_i32.mul_wrapping(2_i32), 16_i32);
+ assert_eq!(8_i64.mul_wrapping(2_i64), 16_i64);
+ assert_eq!(8_i128.mul_wrapping(2_i128), 16_i128);
+ assert_eq!(
+ i256::from_parts(8, 0).mul_wrapping(i256::from_parts(2, 0)),
+ i256::from_parts(16, 0)
+ );
+ assert_eq!(8_u8.mul_wrapping(2_u8), 16_u8);
+ assert_eq!(8_u16.mul_wrapping(2_u16), 16_u16);
+ assert_eq!(8_u32.mul_wrapping(2_u32), 16_u32);
+ assert_eq!(8_u64.mul_wrapping(2_u64), 16_u64);
+ assert_eq!(
+ f16::from_f32(8.0).mul_wrapping(f16::from_f32(2.0)),
+ f16::from_f32(16.0)
+ );
+ assert_eq!(8.0_f32.mul_wrapping(2.0_f32), 16_f32);
+ assert_eq!(8.0_f64.mul_wrapping(2.0_f64), 16_f64);
+
+ // mul_checked
+ assert_eq!(8_i8.mul_checked(2_i8).unwrap(), 16_i8);
+ assert_eq!(8_i16.mul_checked(2_i16).unwrap(), 16_i16);
+ assert_eq!(8_i32.mul_checked(2_i32).unwrap(), 16_i32);
+ assert_eq!(8_i64.mul_checked(2_i64).unwrap(), 16_i64);
+ assert_eq!(8_i128.mul_checked(2_i128).unwrap(), 16_i128);
+ assert_eq!(
+ i256::from_parts(8, 0)
+ .mul_checked(i256::from_parts(2, 0))
+ .unwrap(),
+ i256::from_parts(16, 0)
+ );
+ assert_eq!(8_u8.mul_checked(2_u8).unwrap(), 16_u8);
+ assert_eq!(8_u16.mul_checked(2_u16).unwrap(), 16_u16);
+ assert_eq!(8_u32.mul_checked(2_u32).unwrap(), 16_u32);
+ assert_eq!(8_u64.mul_checked(2_u64).unwrap(), 16_u64);
+ assert_eq!(
+ f16::from_f32(8.0).mul_checked(f16::from_f32(2.0)).unwrap(),
+ f16::from_f32(16.0)
+ );
+ assert_eq!(8.0_f32.mul_checked(2.0_f32).unwrap(), 16_f32);
+ assert_eq!(8.0_f64.mul_checked(2.0_f64).unwrap(), 16_f64);
+ }
+
+ #[test]
+ fn test_native_type_div() {
+ // div_wrapping
+ assert_eq!(8_i8.div_wrapping(2_i8), 4_i8);
+ assert_eq!(8_i16.div_wrapping(2_i16), 4_i16);
+ assert_eq!(8_i32.div_wrapping(2_i32), 4_i32);
+ assert_eq!(8_i64.div_wrapping(2_i64), 4_i64);
+ assert_eq!(8_i128.div_wrapping(2_i128), 4_i128);
+ assert_eq!(
+ i256::from_parts(8, 0).div_wrapping(i256::from_parts(2, 0)),
+ i256::from_parts(4, 0)
+ );
+ assert_eq!(8_u8.div_wrapping(2_u8), 4_u8);
+ assert_eq!(8_u16.div_wrapping(2_u16), 4_u16);
+ assert_eq!(8_u32.div_wrapping(2_u32), 4_u32);
+ assert_eq!(8_u64.div_wrapping(2_u64), 4_u64);
+ assert_eq!(
+ f16::from_f32(8.0).div_wrapping(f16::from_f32(2.0)),
+ f16::from_f32(4.0)
+ );
+ assert_eq!(8.0_f32.div_wrapping(2.0_f32), 4_f32);
+ assert_eq!(8.0_f64.div_wrapping(2.0_f64), 4_f64);
+
+ // div_checked
+ assert_eq!(8_i8.div_checked(2_i8).unwrap(), 4_i8);
+ assert_eq!(8_i16.div_checked(2_i16).unwrap(), 4_i16);
+ assert_eq!(8_i32.div_checked(2_i32).unwrap(), 4_i32);
+ assert_eq!(8_i64.div_checked(2_i64).unwrap(), 4_i64);
+ assert_eq!(8_i128.div_checked(2_i128).unwrap(), 4_i128);
+ assert_eq!(
+ i256::from_parts(8, 0)
+ .div_checked(i256::from_parts(2, 0))
+ .unwrap(),
+ i256::from_parts(4, 0)
+ );
+ assert_eq!(8_u8.div_checked(2_u8).unwrap(), 4_u8);
+ assert_eq!(8_u16.div_checked(2_u16).unwrap(), 4_u16);
+ assert_eq!(8_u32.div_checked(2_u32).unwrap(), 4_u32);
+ assert_eq!(8_u64.div_checked(2_u64).unwrap(), 4_u64);
+ assert_eq!(
+ f16::from_f32(8.0).div_checked(f16::from_f32(2.0)).unwrap(),
+ f16::from_f32(4.0)
+ );
+ assert_eq!(8.0_f32.div_checked(2.0_f32).unwrap(), 4_f32);
+ assert_eq!(8.0_f64.div_checked(2.0_f64).unwrap(), 4_f64);
+ }
+
+ #[test]
+ fn test_native_type_mod() {
+ // mod_wrapping
+ assert_eq!(9_i8.mod_wrapping(2_i8), 1_i8);
+ assert_eq!(9_i16.mod_wrapping(2_i16), 1_i16);
+ assert_eq!(9_i32.mod_wrapping(2_i32), 1_i32);
+ assert_eq!(9_i64.mod_wrapping(2_i64), 1_i64);
+ assert_eq!(9_i128.mod_wrapping(2_i128), 1_i128);
+ assert_eq!(
+ i256::from_parts(9, 0).mod_wrapping(i256::from_parts(2, 0)),
+ i256::from_parts(1, 0)
+ );
+ assert_eq!(9_u8.mod_wrapping(2_u8), 1_u8);
+ assert_eq!(9_u16.mod_wrapping(2_u16), 1_u16);
+ assert_eq!(9_u32.mod_wrapping(2_u32), 1_u32);
+ assert_eq!(9_u64.mod_wrapping(2_u64), 1_u64);
+ assert_eq!(
+ f16::from_f32(9.0).mod_wrapping(f16::from_f32(2.0)),
+ f16::from_f32(1.0)
+ );
+ assert_eq!(9.0_f32.mod_wrapping(2.0_f32), 1_f32);
+ assert_eq!(9.0_f64.mod_wrapping(2.0_f64), 1_f64);
+
+ // mod_checked
+ assert_eq!(9_i8.mod_checked(2_i8).unwrap(), 1_i8);
+ assert_eq!(9_i16.mod_checked(2_i16).unwrap(), 1_i16);
+ assert_eq!(9_i32.mod_checked(2_i32).unwrap(), 1_i32);
+ assert_eq!(9_i64.mod_checked(2_i64).unwrap(), 1_i64);
+ assert_eq!(9_i128.mod_checked(2_i128).unwrap(), 1_i128);
+ assert_eq!(
+ i256::from_parts(9, 0)
+ .mod_checked(i256::from_parts(2, 0))
+ .unwrap(),
+ i256::from_parts(1, 0)
+ );
+ assert_eq!(9_u8.mod_checked(2_u8).unwrap(), 1_u8);
+ assert_eq!(9_u16.mod_checked(2_u16).unwrap(), 1_u16);
+ assert_eq!(9_u32.mod_checked(2_u32).unwrap(), 1_u32);
+ assert_eq!(9_u64.mod_checked(2_u64).unwrap(), 1_u64);
+ assert_eq!(
+ f16::from_f32(9.0).mod_checked(f16::from_f32(2.0)).unwrap(),
+ f16::from_f32(1.0)
+ );
+ assert_eq!(9.0_f32.mod_checked(2.0_f32).unwrap(), 1_f32);
+ assert_eq!(9.0_f64.mod_checked(2.0_f64).unwrap(), 1_f64);
+ }
+
+ #[test]
+ fn test_native_type_neg() {
+ // neg_wrapping
+ assert_eq!(8_i8.neg_wrapping(), -8_i8);
+ assert_eq!(8_i16.neg_wrapping(), -8_i16);
+ assert_eq!(8_i32.neg_wrapping(), -8_i32);
+ assert_eq!(8_i64.neg_wrapping(), -8_i64);
+ assert_eq!(8_i128.neg_wrapping(), -8_i128);
+ assert_eq!(i256::from_parts(8, 0).neg_wrapping(), i256::from_i128(-8));
+ assert_eq!(8_u8.neg_wrapping(), u8::MAX - 7_u8);
+ assert_eq!(8_u16.neg_wrapping(), u16::MAX - 7_u16);
+ assert_eq!(8_u32.neg_wrapping(), u32::MAX - 7_u32);
+ assert_eq!(8_u64.neg_wrapping(), u64::MAX - 7_u64);
+ assert_eq!(f16::from_f32(8.0).neg_wrapping(), f16::from_f32(-8.0));
+ assert_eq!(8.0_f32.neg_wrapping(), -8_f32);
+ assert_eq!(8.0_f64.neg_wrapping(), -8_f64);
+
+ // neg_checked
+ assert_eq!(8_i8.neg_checked().unwrap(), -8_i8);
+ assert_eq!(8_i16.neg_checked().unwrap(), -8_i16);
+ assert_eq!(8_i32.neg_checked().unwrap(), -8_i32);
+ assert_eq!(8_i64.neg_checked().unwrap(), -8_i64);
+ assert_eq!(8_i128.neg_checked().unwrap(), -8_i128);
+ assert_eq!(
+ i256::from_parts(8, 0).neg_checked().unwrap(),
+ i256::from_i128(-8)
+ );
+ assert!(8_u8.neg_checked().is_err());
+ assert!(8_u16.neg_checked().is_err());
+ assert!(8_u32.neg_checked().is_err());
+ assert!(8_u64.neg_checked().is_err());
+ assert_eq!(
+ f16::from_f32(8.0).neg_checked().unwrap(),
+ f16::from_f32(-8.0)
+ );
+ assert_eq!(8.0_f32.neg_checked().unwrap(), -8_f32);
+ assert_eq!(8.0_f64.neg_checked().unwrap(), -8_f64);
+ }
+
+ #[test]
+ fn test_native_type_pow() {
+ // pow_wrapping
+ assert_eq!(8_i8.pow_wrapping(2_u32), 64_i8);
+ assert_eq!(8_i16.pow_wrapping(2_u32), 64_i16);
+ assert_eq!(8_i32.pow_wrapping(2_u32), 64_i32);
+ assert_eq!(8_i64.pow_wrapping(2_u32), 64_i64);
+ assert_eq!(8_i128.pow_wrapping(2_u32), 64_i128);
+ assert_eq!(
+ i256::from_parts(8, 0).pow_wrapping(2_u32),
+ i256::from_parts(64, 0)
+ );
+ assert_eq!(8_u8.pow_wrapping(2_u32), 64_u8);
+ assert_eq!(8_u16.pow_wrapping(2_u32), 64_u16);
+ assert_eq!(8_u32.pow_wrapping(2_u32), 64_u32);
+ assert_eq!(8_u64.pow_wrapping(2_u32), 64_u64);
+ assert_eq!(f16::from_f32(8.0).pow_wrapping(2_u32), f16::from_f32(64.0));
+ assert_eq!(8.0_f32.pow_wrapping(2_u32), 64_f32);
+ assert_eq!(8.0_f64.pow_wrapping(2_u32), 64_f64);
+
+ // pow_checked
+ assert_eq!(8_i8.pow_checked(2_u32).unwrap(), 64_i8);
+ assert_eq!(8_i16.pow_checked(2_u32).unwrap(), 64_i16);
+ assert_eq!(8_i32.pow_checked(2_u32).unwrap(), 64_i32);
+ assert_eq!(8_i64.pow_checked(2_u32).unwrap(), 64_i64);
+ assert_eq!(8_i128.pow_checked(2_u32).unwrap(), 64_i128);
+ assert_eq!(
+ i256::from_parts(8, 0).pow_checked(2_u32).unwrap(),
+ i256::from_parts(64, 0)
+ );
+ assert_eq!(8_u8.pow_checked(2_u32).unwrap(), 64_u8);
+ assert_eq!(8_u16.pow_checked(2_u32).unwrap(), 64_u16);
+ assert_eq!(8_u32.pow_checked(2_u32).unwrap(), 64_u32);
+ assert_eq!(8_u64.pow_checked(2_u32).unwrap(), 64_u64);
+ assert_eq!(
+ f16::from_f32(8.0).pow_checked(2_u32).unwrap(),
+ f16::from_f32(64.0)
+ );
+ assert_eq!(8.0_f32.pow_checked(2_u32).unwrap(), 64_f32);
+ assert_eq!(8.0_f64.pow_checked(2_u32).unwrap(), 64_f64);
+ }
+}