resolved all the comments

Author: medhatiwari

src/MongoDB.Bson/IO/BinaryPrimitivesCompat.cs

@@ -43,29 +43,8 @@ public static float ReadSingleLittleEndian(ReadOnlySpan<byte> source)
                 throw new ArgumentOutOfRangeException(nameof(source), "Source span is too small to contain a float.");
             }
 
-            // Manually construct a 32-bit integer from 4 bytes in Little Endian order.
-            // BSON mandates that all multibyte values-including float32-must be encoded
-            // using Little Endian byte order, regardless of the system architecture.
-            //
-            // This method ensures platform-agnostic behavior by explicitly assembling
-            // the bytes in the correct order, rather than relying on the system's native endianness.
-            //
-            // Given a byte sequence [a, b, c, d], representing a float encoded in Little Endian,
-            // the expression below constructs the 32-bit integer as:
-            //     intValue = a + (b << 8) + (c << 16) + (d << 24)
-            //
-            // This preserves the intended bit pattern when converting back to float using
-            // BitConverter.Int32BitsToSingle.
-            //
-            // Example:
-            //   A float value of 1.0f is represented in IEEE-754 binary32 format as:
-            //       [0x00, 0x00, 0x80, 0x3F]  (Little Endian)
-            //   On a Big Endian system, naive interpretation would yield an incorrect value,
-            //   but this method assembles the int as:
-            //       0x00 + (0x00 << 8) + (0x80 << 16) + (0x3F << 24) = 0x3F800000,
-            //   which correctly maps to 1.0f.
-            //
-            // This guarantees BSON-compliant serialization across all platforms.
+            // Constructs a 32-bit float from 4 Little Endian bytes in a platform-agnostic way.
+            // Ensures correct bit pattern regardless of system endianness.
             int intValue =
                 source[0] |
                 (source[1] << 8) |
@@ -97,9 +76,6 @@ public static void WriteSingleLittleEndian(Span<byte> destination, float value)
 #endif
         }
 
-        // This layout trick allows safely reinterpreting float as int and vice versa.
-        // It ensures identical memory layout for both fields, used for low-level bit conversion
-        // in environments like net472 which lack BitConverter.SingleToInt32Bits and its inverse.
         [StructLayout(LayoutKind.Explicit)]
         private struct FloatIntUnion
         {

src/MongoDB.Bson/Serialization/BinaryVectorReader.cs

@@ -42,12 +42,6 @@ public static (TItem[] Items, byte Padding, BinaryVectorDataType VectorDataType)
             switch (vectorDataType)
             {
                 case BinaryVectorDataType.Float32:
-
-                    if ((vectorDataBytes.Span.Length & 3) != 0)
-                    {
-                        throw new FormatException("Data length of binary vector of type Float32 must be a multiple of 4 bytes.");
-                    }
-
                     var floatArray = ReadSinglesArrayLittleEndian(vectorDataBytes.Span);
                     items = (TItem[])(object)floatArray;
                     break;
@@ -124,15 +118,17 @@ private static float[] ReadSinglesArrayLittleEndian(ReadOnlySpan<byte> span)
             {
                 throw new FormatException("Data length of binary vector of type Float32 must be a multiple of 4 bytes.");
             }
-            int count = span.Length / 4;
-            float[] result = new float[count];
+
+            float[] result;
             if (BitConverter.IsLittleEndian)
             {
-                MemoryMarshal.Cast<byte, float>(span).CopyTo(result);
+                result = MemoryMarshal.Cast<byte, float>(span).ToArray();
             }
             else
             {
-                for (int i = 0; i < count; i++)
+                var count = span.Length / 4;
+		 result = new float[count];
+		 for (int i = 0; i < count; i++)
                 {
                     result[i] = BinaryPrimitivesCompat.ReadSingleLittleEndian(span.Slice(i * 4, 4));
                 }

src/MongoDB.Bson/Serialization/BinaryVectorWriter.cs

@@ -36,18 +36,17 @@ public static byte[] WriteToBytes<TItem>(BinaryVector<TItem> binaryVector)
         public static byte[] WriteToBytes<TItem>(ReadOnlySpan<TItem> vectorData, BinaryVectorDataType binaryVectorDataType, byte padding)
             where TItem : struct
         {
-            byte[] resultBytes;
-
             switch (binaryVectorDataType)
             {
                 case BinaryVectorDataType.Float32:
-                    var length = vectorData.Length * sizeof(float);
-                    resultBytes = new byte[2 + length];
-                    resultBytes[0] = (byte)binaryVectorDataType;
-                    resultBytes[1] = padding;
+		     byte[] result;
+                    var length = vectorData.Length * 4; 
+                    result = new byte[2 + length];
+                    result[0] = (byte)binaryVectorDataType;
+                    result[1] = padding;
 
                     var floatSpan = MemoryMarshal.Cast<TItem, float>(vectorData);
-                    Span<byte> floatOutput = resultBytes.AsSpan(2);
+                    var floatOutput = result.AsSpan(2);
 
                     if (BitConverter.IsLittleEndian)
                     {
@@ -61,7 +60,7 @@ public static byte[] WriteToBytes<TItem>(ReadOnlySpan<TItem> vectorData, BinaryV
                         }
                     }
 
-                    return resultBytes;
+                    return result;
 
                 case BinaryVectorDataType.Int8:
                 case BinaryVectorDataType.PackedBit:

tests/MongoDB.Bson.Tests/IO/BinaryPrimitivesCompatTests.cs

@@ -1,11 +1,65 @@
+/* Copyright 2010-present MongoDB Inc.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
 using System;
 using Xunit;
+using FluentAssertions;
 using MongoDB.Bson.IO;
 
 namespace MongoDB.Bson.Tests.IO
 {
     public class BinaryPrimitivesCompatTests
     {
+        [Fact]
+        public void ReadSingleLittleEndian_should_read_correctly()
+        {
+            var bytes = new byte[] { 0x00, 0x00, 0x80, 0x3F }; // 1.0f in little endian
+            var result = BinaryPrimitivesCompat.ReadSingleLittleEndian(bytes);
+            result.Should().Be(1.0f);
+        }
+
+        [Fact]
+        public void ReadSingleLittleEndian_should_throw_on_insufficient_length()
+        {
+            var shortBuffer = new byte[3];
+            var exception = Record.Exception(() =>
+                BinaryPrimitivesCompat.ReadSingleLittleEndian(shortBuffer));
+
+            exception.Should().BeOfType<ArgumentOutOfRangeException>();
+            exception.Message.Should().Contain("length");
+        }
+
+        [Fact]
+        public void WriteSingleLittleEndian_should_throw_on_insufficient_length()
+        {
+            var shortBuffer = new byte[3];
+            var exception = Record.Exception(() =>
+                BinaryPrimitivesCompat.WriteSingleLittleEndian(shortBuffer, 1.23f));
+
+            exception.Should().BeOfType<ArgumentOutOfRangeException>();
+            exception.Message.Should().Contain("length");
+        }
+
+        [Fact]
+        public void WriteSingleLittleEndian_should_write_correctly()
+        {
+            Span<byte> buffer = new byte[4];
+            BinaryPrimitivesCompat.WriteSingleLittleEndian(buffer, 1.0f);
+            buffer.ToArray().Should().Equal(0x00, 0x00, 0x80, 0x3F); // 1.0f little-endian
+        }
+
         [Theory]
         [InlineData(0f)]
         [InlineData(1.0f)]
@@ -31,22 +85,5 @@ public void WriteAndReadSingleLittleEndian_should_roundtrip_correctly(float valu
                 Assert.Equal(value, result);
             }
         }
-
-        [Fact]
-        public void ReadSingleLittleEndian_should_throw_on_insufficient_length()
-        {
-            var shortBuffer = new byte[3];
-            Assert.Throws<ArgumentOutOfRangeException>(() =>
-                BinaryPrimitivesCompat.ReadSingleLittleEndian(shortBuffer));
-        }
-
-        [Fact]
-        public void WriteSingleLittleEndian_should_throw_on_insufficient_length()
-        {
-            var shortBuffer = new byte[3];
-            Assert.Throws<ArgumentOutOfRangeException>(() =>
-                BinaryPrimitivesCompat.WriteSingleLittleEndian(shortBuffer, 1.23f));
-        }
     }
 }
-

tests/MongoDB.Bson.Tests/Serialization/Serializers/BinaryVectorSerializerTests.cs

@@ -371,7 +371,7 @@ private static (T[], byte[] VectorBson) GetTestData<T>(BinaryVectorDataType data
                     .ToArray());
                 var elementsBytesLittleEndian = BitConverter.IsLittleEndian
                     ? MemoryMarshal.Cast<T, byte>(elementsSpan)
-                    : ToLittleEndian(elementsSpan, dataType);
+                    : BigEndianToLittleEndian(elementsSpan, dataType);
 
                 byte[] vectorBsonData = [(byte)dataType, bitsPadding, .. elementsBytesLittleEndian];
                 return (elementsSpan.ToArray(), vectorBsonData);
@@ -415,31 +415,34 @@ private static IBsonSerializer CreateBinaryVectorSerializer<T>(BinaryVectorDataT
             return serializer;
         }
 
-        public class BinaryVectorNoAttributeHolder
-        {
-            public BinaryVectorInt8 ValuesInt8 { get; set; }
-        
-            public BinaryVectorPackedBit ValuesPackedBit { get; set; }
-
-            public BinaryVectorFloat32 ValuesFloat { get; set; }
-        }
-
-        private static byte[] ToLittleEndian<T>(ReadOnlySpan<T> span, BinaryVectorDataType dataType) where T : struct
+        private static byte[] BigEndianToLittleEndian<T>(ReadOnlySpan<T> span, BinaryVectorDataType dataType) where T : struct
         {
             // Types that do NOT need conversion safe on BE
             if (dataType == BinaryVectorDataType.Int8 || dataType == BinaryVectorDataType.PackedBit)
             {
                 return MemoryMarshal.Cast<T, byte>(span).ToArray();
             }
-            int elementSize = Marshal.SizeOf<T>();
+
+            var elementSize = Marshal.SizeOf<T>();
             byte[] result = new byte[span.Length * elementSize];
+
             for (int i = 0; i < span.Length; i++)
             {
                 byte[] bytes = BitConverter.GetBytes((dynamic)span[i]);
                 Array.Reverse(bytes); // Ensure LE order
                 Buffer.BlockCopy(bytes, 0, result, i * elementSize, elementSize);
             }
+
             return result;
         }
+
+        public class BinaryVectorNoAttributeHolder
+        {
+            public BinaryVectorInt8 ValuesInt8 { get; set; }
+        
+            public BinaryVectorPackedBit ValuesPackedBit { get; set; }
+
+            public BinaryVectorFloat32 ValuesFloat { get; set; }
+        }
     }
 }