[arrow-rs] branch master updated: Fix test_unaligned_bit_chunk_iterator (#1297)

[al...@apache.org]

This is an automated email from the ASF dual-hosted git repository.

alamb 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 8f7c56e  Fix test_unaligned_bit_chunk_iterator (#1297)
8f7c56e is described below

commit 8f7c56e35f24580993b362e19ea7138c14824c0b
Author: Raphael Taylor-Davies <17...@users.noreply.github.com>
AuthorDate: Thu Feb 10 11:36:50 2022 +0000

    Fix test_unaligned_bit_chunk_iterator (#1297)
    
    * Fix test_unaligned_bit_chunk_iterator
    
    * Add more verification
    
    * Format
---
 arrow/src/util/bit_chunk_iterator.rs | 32 ++++++++++++++++++++++++++++----
 1 file changed, 28 insertions(+), 4 deletions(-)

diff --git a/arrow/src/util/bit_chunk_iterator.rs b/arrow/src/util/bit_chunk_iterator.rs
index 3de2e9b..db5aca2 100644
--- a/arrow/src/util/bit_chunk_iterator.rs
+++ b/arrow/src/util/bit_chunk_iterator.rs
@@ -362,7 +362,6 @@ impl ExactSizeIterator for BitChunkIterator<'_> {
 mod tests {
     use rand::prelude::*;
 
-    use crate::alloc::ALIGNMENT;
     use crate::buffer::Buffer;
     use crate::util::bit_chunk_iterator::UnalignedBitChunk;
 
@@ -466,9 +465,6 @@ mod tests {
     #[test]
     #[allow(clippy::assertions_on_constants)]
     fn test_unaligned_bit_chunk_iterator() {
-        // This test exploits the fact Buffer is at least 64-byte aligned
-        assert!(ALIGNMENT > 64);
-
         let buffer = Buffer::from(&[0xFF; 5]);
         let unaligned = UnalignedBitChunk::new(buffer.as_slice(), 0, 40);
 
@@ -520,6 +516,13 @@ mod tests {
         assert_eq!(unaligned.suffix(), None);
 
         let buffer = Buffer::from(&[0xFF; 14]);
+
+        // Verify buffer alignment
+        let (prefix, aligned, suffix) = unsafe { buffer.as_slice().align_to::<u64>() };
+        assert_eq!(prefix.len(), 0);
+        assert_eq!(aligned.len(), 1);
+        assert_eq!(suffix.len(), 6);
+
         let unaligned = UnalignedBitChunk::new(buffer.as_slice(), 0, 112);
 
         assert!(unaligned.chunks().is_empty()); // Less than 128 elements
@@ -529,6 +532,13 @@ mod tests {
         assert_eq!(unaligned.suffix(), Some((1 << 48) - 1));
 
         let buffer = Buffer::from(&[0xFF; 16]);
+
+        // Verify buffer alignment
+        let (prefix, aligned, suffix) = unsafe { buffer.as_slice().align_to::<u64>() };
+        assert_eq!(prefix.len(), 0);
+        assert_eq!(aligned.len(), 2);
+        assert_eq!(suffix.len(), 0);
+
         let unaligned = UnalignedBitChunk::new(buffer.as_slice(), 0, 128);
 
         assert_eq!(unaligned.prefix(), Some(u64::MAX));
@@ -536,6 +546,13 @@ mod tests {
         assert!(unaligned.chunks().is_empty()); // Exactly 128 elements
 
         let buffer = Buffer::from(&[0xFF; 64]);
+
+        // Verify buffer alignment
+        let (prefix, aligned, suffix) = unsafe { buffer.as_slice().align_to::<u64>() };
+        assert_eq!(prefix.len(), 0);
+        assert_eq!(aligned.len(), 8);
+        assert_eq!(suffix.len(), 0);
+
         let unaligned = UnalignedBitChunk::new(buffer.as_slice(), 0, 512);
 
         // Buffer is completely aligned and larger than 128 elements -> all in chunks array
@@ -546,6 +563,13 @@ mod tests {
         assert_eq!(unaligned.trailing_padding(), 0);
 
         let buffer = buffer.slice(1); // Offset buffer 1 byte off 64-bit alignment
+
+        // Verify buffer alignment
+        let (prefix, aligned, suffix) = unsafe { buffer.as_slice().align_to::<u64>() };
+        assert_eq!(prefix.len(), 7);
+        assert_eq!(aligned.len(), 7);
+        assert_eq!(suffix.len(), 0);
+
         let unaligned = UnalignedBitChunk::new(buffer.as_slice(), 0, 504);
 
         // Need a prefix with 1 byte of lead padding to bring the buffer into alignment