Moved tests to integration tests

src/alloc/mod.rs

@@ -131,56 +131,3 @@ pub unsafe fn reallocate<T: NativeType>(
         handle_alloc_error(Layout::from_size_align_unchecked(new_size, ALIGNMENT))
     })
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_allocate_dangling() {
-        let p = allocate_aligned::<u32>(0);
-        assert_eq!(0, (p.as_ptr() as usize) % ALIGNMENT);
-    }
-
-    #[test]
-    fn test_allocate() {
-        let p = allocate_aligned::<u32>(1024);
-        assert_eq!(0, (p.as_ptr() as usize) % ALIGNMENT);
-        unsafe { free_aligned(p, 1024) };
-    }
-
-    #[test]
-    fn test_allocate_zeroed() {
-        let p = allocate_aligned_zeroed::<u32>(1024);
-        assert_eq!(0, (p.as_ptr() as usize) % ALIGNMENT);
-        unsafe { free_aligned(p, 1024) };
-    }
-
-    #[test]
-    fn test_reallocate_from_zero() {
-        let ptr = allocate_aligned::<u32>(0);
-        let ptr = unsafe { reallocate(ptr, 0, 512) };
-        unsafe { free_aligned(ptr, 512) };
-    }
-
-    #[test]
-    fn test_reallocate_from_alloc() {
-        let ptr = allocate_aligned::<u32>(32);
-        let ptr = unsafe { reallocate(ptr, 32, 64) };
-        unsafe { free_aligned(ptr, 64) };
-    }
-
-    #[test]
-    fn test_reallocate_smaller() {
-        let ptr = allocate_aligned::<u32>(32);
-        let ptr = unsafe { reallocate(ptr, 32, 16) };
-        unsafe { free_aligned(ptr, 16) };
-    }
-
-    #[test]
-    fn test_reallocate_to_zero() {
-        let ptr = allocate_aligned::<u32>(32);
-        let ptr = unsafe { reallocate(ptr, 32, 0) };
-        assert_eq!(ptr, unsafe { dangling() });
-    }
-}

src/array/binary/from.rs

@@ -87,18 +87,3 @@ where
 
     (null.into(), offsets.into(), values.into())
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::array::Array;
-
-    use super::*;
-
-    #[test]
-    fn test_from() {
-        let array = BinaryArray::<i32>::from(&[Some(b"hello".as_ref()), Some(b" ".as_ref()), None]);
-
-        let a = array.validity().as_ref().unwrap();
-        assert_eq!(a, &Bitmap::from([true, true, false]));
-    }
-}

src/array/binary/mod.rs

@@ -146,52 +146,3 @@ unsafe impl<O: Offset> GenericBinaryArray<O> for BinaryArray<O> {
         self.offsets()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::iter::FromIterator;
-
-    #[test]
-    fn basics() {
-        let data = vec![Some(b"hello".to_vec()), None, Some(b"hello2".to_vec())];
-
-        let array = BinaryArray::<i32>::from_iter(data);
-
-        assert_eq!(array.value(0), b"hello");
-        assert_eq!(array.value(1), b"");
-        assert_eq!(array.value(2), b"hello2");
-        assert_eq!(unsafe { array.value_unchecked(2) }, b"hello2");
-        assert_eq!(array.values().as_slice(), b"hellohello2");
-        assert_eq!(array.offsets().as_slice(), &[0, 5, 5, 11]);
-        assert_eq!(
-            array.validity(),
-            &Some(Bitmap::from_u8_slice(&[0b00000101], 3))
-        );
-        assert!(array.is_valid(0));
-        assert!(!array.is_valid(1));
-        assert!(array.is_valid(2));
-
-        let array2 = BinaryArray::<i32>::from_data(
-            array.offsets().clone(),
-            array.values().clone(),
-            array.validity().clone(),
-        );
-        assert_eq!(array, array2);
-
-        let array = array.slice(1, 2);
-        assert_eq!(array.value(0), b"");
-        assert_eq!(array.value(1), b"hello2");
-        // note how this keeps everything: the offsets were sliced
-        assert_eq!(array.values().as_slice(), b"hellohello2");
-        assert_eq!(array.offsets().as_slice(), &[5, 5, 11]);
-    }
-
-    #[test]
-    fn empty() {
-        let array = BinaryArray::<i32>::new_empty();
-        assert_eq!(array.values().as_slice(), b"");
-        assert_eq!(array.offsets().as_slice(), &[0]);
-        assert_eq!(array.validity(), &None);
-    }
-}

src/array/boolean/from.rs

@@ -71,26 +71,3 @@ impl<Ptr: std::borrow::Borrow<Option<bool>>> FromIterator<Ptr> for BooleanArray
         MutableBooleanArray::from_iter(iter).into()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::Array;
-    use crate::error::Result;
-
-    #[test]
-    fn from_trusted_len_iter() -> Result<()> {
-        let iter = std::iter::repeat(true).take(2).map(Some);
-        let a = BooleanArray::from_trusted_len_iter(iter);
-        assert_eq!(a.len(), 2);
-        Ok(())
-    }
-
-    #[test]
-    fn from_iter() -> Result<()> {
-        let iter = std::iter::repeat(true).take(2).map(Some);
-        let a = BooleanArray::from_iter(iter);
-        assert_eq!(a.len(), 2);
-        Ok(())
-    }
-}

src/array/boolean/mod.rs

@@ -130,41 +130,3 @@ impl<P: AsRef<[Option<bool>]>> From<P> for BooleanArray {
         Self::from_trusted_len_iter(slice.as_ref().iter().map(|x| x.as_ref()))
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn basics() {
-        let data = vec![Some(true), None, Some(false)];
-
-        let array: BooleanArray = data.into_iter().collect();
-
-        assert!(array.value(0));
-        assert!(!array.value(1));
-        assert!(!array.value(2));
-        assert_eq!(array.values(), &Bitmap::from_u8_slice(&[0b00000001], 3));
-        assert_eq!(
-            array.validity(),
-            &Some(Bitmap::from_u8_slice(&[0b00000101], 3))
-        );
-        assert!(array.is_valid(0));
-        assert!(!array.is_valid(1));
-        assert!(array.is_valid(2));
-
-        let array2 = BooleanArray::from_data(array.values().clone(), array.validity().clone());
-        assert_eq!(array, array2);
-
-        let array = array.slice(1, 2);
-        assert!(!array.value(0));
-        assert!(!array.value(1));
-    }
-
-    #[test]
-    fn empty() {
-        let array = BooleanArray::new_empty();
-        assert_eq!(array.values().len(), 0);
-        assert_eq!(array.validity(), &None);
-    }
-}

src/array/boolean/mutable.rs

@@ -360,34 +360,3 @@ impl TryExtend<Option<bool>> for MutableBooleanArray {
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn push() {
-        let mut a = MutableBooleanArray::new();
-        a.push(Some(true));
-        a.push(None);
-        assert_eq!(a.len(), 2);
-        assert!(a.is_valid(0));
-        assert!(!a.is_valid(1));
-
-        assert_eq!(a.values(), &MutableBitmap::from([true, false]));
-    }
-
-    #[test]
-    fn from_trusted_len_iter() {
-        let iter = std::iter::repeat(true).take(2).map(Some);
-        let a = MutableBooleanArray::from_trusted_len_iter(iter);
-        assert_eq!(a.len(), 2);
-    }
-
-    #[test]
-    fn from_iter() {
-        let iter = std::iter::repeat(true).take(2).map(Some);
-        let a = MutableBooleanArray::from_iter(iter);
-        assert_eq!(a.len(), 2);
-    }
-}

src/array/dictionary/mutable.rs

@@ -152,47 +152,3 @@ where
         Ok(())
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::{MutableBinaryArray, MutableUtf8Array};
-
-    #[test]
-    fn primitive() -> Result<()> {
-        let data = vec![Some(1), Some(2), Some(1)];
-
-        let mut a = MutableDictionaryArray::<i32, MutablePrimitiveArray<i32>>::new();
-        a.try_extend(data)?;
-        assert_eq!(a.len(), 3);
-        assert_eq!(a.values().len(), 2);
-        Ok(())
-    }
-
-    #[test]
-    fn utf8_natural() -> Result<()> {
-        let data = vec![Some("a"), Some("b"), Some("a")];
-
-        let mut a = MutableDictionaryArray::<i32, MutableUtf8Array<i32>>::new();
-        a.try_extend(data)?;
-
-        assert_eq!(a.len(), 3);
-        assert_eq!(a.values().len(), 2);
-        Ok(())
-    }
-
-    #[test]
-    fn binary_natural() -> Result<()> {
-        let data = vec![
-            Some("a".as_bytes()),
-            Some("b".as_bytes()),
-            Some("a".as_bytes()),
-        ];
-
-        let mut a = MutableDictionaryArray::<i32, MutableBinaryArray<i32>>::new();
-        a.try_extend(data)?;
-        assert_eq!(a.len(), 3);
-        assert_eq!(a.values().len(), 2);
-        Ok(())
-    }
-}