RecordKeyDecimalTests.cs

Go to the documentation of this file.

using System;
using System.Reflection;
using Xunit;

namespace Kinetica.Tests.UnitTests
{
    [Trait("Category", "WireFormat")]
    [Trait("Category", "RecordKey")]
    public class RecordKeyDecimalTests
    {
        // Get the RecordKey type via reflection since it's internal
        private static readonly Type RecordKeyType = typeof(kinetica.Kinetica).Assembly
            .GetType("kinetica.Utils.RecordKey");

        private object CreateRecordKey(int bufferSize)
        {
            return Activator.CreateInstance(RecordKeyType, bufferSize)!;
        }

        private void InvokeAddDecimal(object key, string value, int precision, int scale)
        {
            var method = RecordKeyType.GetMethod("addDecimal", new[] { typeof(string), typeof(int), typeof(int) });
            method!.Invoke(key, new object[] { value, precision, scale });
        }

        private byte[] GetBuffer(object key)
        {
            var field = RecordKeyType.GetField("buffer", BindingFlags.NonPublic | BindingFlags.Instance);
            return (byte[])field!.GetValue(key)!;
        }

        private int GetCurrentSize(object key)
        {
            var field = RecordKeyType.GetField("current_size", BindingFlags.NonPublic | BindingFlags.Instance);
            return (int)field!.GetValue(key)!;
        }

        [Fact]
        public void AddDecimal_8Byte_WithSimpleValue_StoresCorrectly()
        {
            // Arrange: 8-byte decimal with precision 18, scale 4
            var key = CreateRecordKey(8);

            // Act: Add decimal value "123.45"
            InvokeAddDecimal(key, "123.45", 18, 4);

            // Assert: Buffer should be 8 bytes with scaled value
            var buffer = GetBuffer(key);
            Assert.Equal(8, GetCurrentSize(key));

            // 123.45 with scale 4 = 1234500 (as long in little-endian)
            long expected = 1234500L;
            long actual = BitConverter.ToInt64(buffer, 0);
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void AddDecimal_8Byte_WithNegativeValue_StoresCorrectly()
        {
            // Arrange: 8-byte decimal with precision 18, scale 4
            var key = CreateRecordKey(8);

            // Act: Add negative decimal value "-987.6543"
            InvokeAddDecimal(key, "-987.6543", 18, 4);

            // Assert: Buffer should contain correct negative scaled value
            var buffer = GetBuffer(key);
            Assert.Equal(8, GetCurrentSize(key));

            // -987.6543 with scale 4 = -9876543 (as long)
            long expected = -9876543L;
            long actual = BitConverter.ToInt64(buffer, 0);
            Assert.Equal(expected, actual);
        }

        [Fact]
        public void AddDecimal_8Byte_WithNull_StoresZeros()
        {
            // Arrange
            var key = CreateRecordKey(8);

            // Act: Add null value
            InvokeAddDecimal(key, null!, 18, 4);

            // Assert: All bytes should be zero
            var buffer = GetBuffer(key);
            Assert.Equal(8, GetCurrentSize(key));
            Assert.Equal(0L, BitConverter.ToInt64(buffer, 0));
        }

        [Fact]
        public void AddDecimal_12Byte_WithSimpleValue_StoresCorrectly()
        {
            // Arrange: 12-byte decimal with precision 38, scale 10
            var key = CreateRecordKey(12);

            // Act: Add decimal value "12345.678901"
            InvokeAddDecimal(key, "12345.678901", 38, 10);

            // Assert: Buffer should be 12 bytes
            var buffer = GetBuffer(key);
            Assert.Equal(12, GetCurrentSize(key));

            // Value should be non-zero (actual encoding depends on BigInteger)
            bool hasNonZero = false;
            for (int i = 0; i < 12; i++)
            {
                if (buffer[i] != 0)
                {
                    hasNonZero = true;
                    break;
                }
            }
            Assert.True(hasNonZero, "12-byte decimal should have non-zero content");
        }

        [Fact]
        public void AddDecimal_12Byte_WithNull_StoresZeros()
        {
            // Arrange
            var key = CreateRecordKey(12);

            // Act: Add null/empty value
            InvokeAddDecimal(key, "", 38, 10);

            // Assert: All 12 bytes should be zero
            var buffer = GetBuffer(key);
            Assert.Equal(12, GetCurrentSize(key));

            for (int i = 0; i < 12; i++)
            {
                Assert.Equal(0, buffer[i]);
            }
        }

        [Fact]
        public void AddDecimal_12Byte_WithLargeValue_StoresCorrectly()
        {
            // Arrange: 12-byte decimal with precision 38
            var key = CreateRecordKey(12);

            // Act: Add a large value that needs more than 8 bytes
            InvokeAddDecimal(key, "9999999999999999999.9999999999", 38, 10);

            // Assert: Buffer should be 12 bytes
            var buffer = GetBuffer(key);
            Assert.Equal(12, GetCurrentSize(key));

            // The value should use multiple bytes due to its magnitude
            bool hasHighBytes = buffer[8] != 0 || buffer[9] != 0 || buffer[10] != 0 || buffer[11] != 0;
            // For large numbers, we expect some high bytes to be set
            // This is a weak test, but verifies the 12-byte path is being used
        }

        [Fact]
        public void AddDecimal_12Byte_WithNegativeValue_StoresCorrectly()
        {
            // Arrange: 12-byte decimal with precision > 18
            var key = CreateRecordKey(12);

            // Act: Add negative value
            InvokeAddDecimal(key, "-12345.678901", 38, 10);

            // Assert: Buffer should be 12 bytes
            var buffer = GetBuffer(key);
            Assert.Equal(12, GetCurrentSize(key));

            // For negative numbers, high bytes should be 0xFF (sign extension)
            // Check that we have sign extension in the upper bytes
            bool hasSignExtension = buffer[11] == 0xFF;
            Assert.True(hasSignExtension, "Negative 12-byte decimal should have sign extension");
        }

        [Fact]
        public void AddDecimal_PrecisionBoundary_At18_Uses8Bytes()
        {
            // Arrange: Exactly at the boundary (precision = 18)
            var key = CreateRecordKey(8);

            // Act
            InvokeAddDecimal(key, "12345.6789", 18, 4);

            // Assert: Should successfully store in 8 bytes
            Assert.Equal(8, GetCurrentSize(key));
        }

        [Fact]
        public void AddDecimal_PrecisionBoundary_At19_Uses12Bytes()
        {
            // Arrange: Just over the boundary (precision = 19)
            var key = CreateRecordKey(12);

            // Act
            InvokeAddDecimal(key, "12345.6789", 19, 4);

            // Assert: Should use 12 bytes
            Assert.Equal(12, GetCurrentSize(key));
        }
    }
}