QWERTYkez.Mensura/QWERTYkez.Mensura.Tests/CollectionsDivideExtensionsTest.cs

namespace QWERTYkez.Mensura.Tests
{
    public class CollectionsDivideExtensionsTest
    {
        private const double Tolerance = 1e-12;
        private static readonly Length scalarUnit = Length.Meter;      // 1000 mm
        private static readonly double scalarDouble = 2.0;

        // Коллекции для тестирования: два элемента
        private static readonly Length[] unitsArray = [Length.Meter, Length._MilliMeter];
        private static readonly Length?[] nullableUnitsArray = [Length.Meter, null, Length._MilliMeter];
        private static readonly List<Length> unitsList = [Length.Meter, Length._MilliMeter];
        private static readonly List<Length?> nullableUnitsList = [Length.Meter, null, Length._MilliMeter];
        private static readonly double[] doubleArray = [2.0, 3.0];
        private static readonly double?[] nullableDoubleArray = [2.0, null, 3.0];

        // ====================== 1. T[] / double ======================
        [Fact]
        public void Div_TArray_Double_Returns_TArray()
        {
            var result = unitsArray.Div<Length>(scalarDouble);
            Assert.Equal(2, result.Length);
            Assert.Equal(1000 / 2.0, (double)result[0], Tolerance);
            Assert.Equal(1 / 2.0, (double)result[1], Tolerance);
        }

        // ====================== 2. T?[] / double ======================
        [Fact]
        public void Div_NullableTArray_Double_Returns_NullableTArray()
        {
            var result = nullableUnitsArray.Div<Length>(scalarDouble);
            Assert.Equal(3, result.Length);
            Assert.Equal(1000 / 2.0, (double)result[0]!, Tolerance);
            Assert.Equal(0 / 2.0, (double)result[1]!, Tolerance);
            Assert.Equal(1 / 2.0, (double)result[2]!, Tolerance);
        }

        // ====================== 3. double / T[] ======================
        [Fact]
        public void Div_Double_TArray_Returns_TArray()
        {
            var result = scalarDouble.Div<Length>(unitsArray);
            Assert.Equal(2, result.Length);
            Assert.Equal(2.0 / 1000, (double)result[0], Tolerance);
            Assert.Equal(2.0 / 1, (double)result[1], Tolerance);
        }

        // ====================== 4. double / T?[] ======================
        [Fact]
        public void Div_Double_NullableTArray_Returns_NullableTArray()
        {
            var result = scalarDouble.Div<Length>(nullableUnitsArray);
            Assert.Equal(3, result.Length);
            Assert.Equal(2.0 / 1000, (double)result[0]!, Tolerance);
            Assert.Equal(2.0 / 0, (double)result[1]!, Tolerance);
            Assert.Equal(2.0 / 1, (double)result[2]!, Tolerance);
        }

        // ====================== 5. List<T> / double ======================
        [Fact]
        public void Div_ListT_Double_Returns_ListT()
        {
            var result = unitsList.Div<Length>(scalarDouble);
            Assert.Equal(2, result.Count);
            Assert.Equal(1000 / 2.0, (double)result[0], Tolerance);
            Assert.Equal(1 / 2.0, (double)result[1], Tolerance);
        }

        // ====================== 6. List<T?> / double ======================
        [Fact]
        public void Div_ListNullableT_Double_Returns_ListNullableT()
        {
            var result = nullableUnitsList.Div<Length>(scalarDouble);
            Assert.Equal(3, result.Count);
            Assert.Equal(1000 / 2.0, (double)result[0]!, Tolerance);
            Assert.Equal(0 / 2.0, (double)result[1]!, Tolerance);
            Assert.Equal(1 / 2.0, (double)result[2]!, Tolerance);
        }

        // ====================== 7. double / List<T> ======================
        [Fact]
        public void Div_Double_ListT_Returns_ListT()
        {
            var result = scalarDouble.Div<Length>(unitsList);
            Assert.Equal(2, result.Count);
            Assert.Equal(2.0 / 1000, (double)result[0], Tolerance);
            Assert.Equal(2.0 / 1, (double)result[1], Tolerance);
        }

        // ====================== 8. double / List<T?> ======================
        [Fact]
        public void Div_Double_ListNullableT_Returns_ListNullableT()
        {
            var result = scalarDouble.Div<Length>(nullableUnitsList);
            Assert.Equal(3, result.Count);
            Assert.Equal(2.0 / 1000, (double)result[0]!, Tolerance);
            Assert.Equal(2.0 / 0, (double)result[1]!, Tolerance);
            Assert.Equal(2.0 / 1, (double)result[2]!, Tolerance);
        }

        // ====================== 9. IReadOnlyCollection<T> / double (Span) ======================
        [Fact]
        public void Div_IReadOnlyCollectionT_Double_Span()
        {
            Span<Length> dest = new Length[2];
            ((IReadOnlyCollection<Length>)unitsArray).Div(scalarDouble, dest);
            Assert.Equal(1000 / 2.0, (double)dest[0], Tolerance);
            Assert.Equal(1 / 2.0, (double)dest[1], Tolerance);
        }

        // ====================== 10. IReadOnlyCollection<T?> / double (Span) ======================
        [Fact]
        public void Div_IReadOnlyCollectionNullableT_Double_Span()
        {
            Span<Length?> dest = new Length?[3];
            ((IReadOnlyCollection<Length?>)nullableUnitsArray).Div(scalarDouble, dest);
            Assert.Equal(1000 / 2.0, (double)dest[0]!, Tolerance);
            Assert.Equal(0 / 2.0, (double)dest[1]!, Tolerance);
            Assert.Equal(1 / 2.0, (double)dest[2]!, Tolerance);
        }

        // ====================== 11. double / IReadOnlyCollection<T> (Span) ======================
        [Fact]
        public void Div_Double_IReadOnlyCollectionT_Span()
        {
            Span<Length> dest = new Length[2];
            scalarDouble.Div((IReadOnlyCollection<Length>)unitsArray, dest);
            Assert.Equal(2.0 / 1000, (double)dest[0], Tolerance);
            Assert.Equal(2.0 / 1, (double)dest[1], Tolerance);
        }

        // ====================== 12. double / IReadOnlyCollection<T?> (Span) ======================
        [Fact]
        public void Div_Double_IReadOnlyCollectionNullableT_Span()
        {
            Span<Length?> dest = new Length?[3];
            scalarDouble.Div((IReadOnlyCollection<Length?>)nullableUnitsArray, dest);
            Assert.Equal(2.0 / 1000, (double)dest[0]!, Tolerance);
            Assert.Equal(2.0 / 0, (double)dest[1]!, Tolerance);
            Assert.Equal(2.0 / 1, (double)dest[2]!, Tolerance);
        }

        // ====================== 13. IEnumerable<T> / double ======================
        [Fact]
        public void Div_IEnumerableT_Double_Returns_IEnumerableT()
        {
            var result = ((IEnumerable<Length>)unitsArray).Div<Length>(scalarDouble).ToList();
            Assert.Equal(2, result.Count);
            Assert.Equal(1000 / 2.0, (double)result[0], Tolerance);
            Assert.Equal(1 / 2.0, (double)result[1], Tolerance);
        }

        // ====================== 14. IEnumerable<T?> / double ======================
        [Fact]
        public void Div_IEnumerableNullableT_Double_Returns_IEnumerableNullableT()
        {
            var result = ((IEnumerable<Length?>)nullableUnitsArray).Div<Length>(scalarDouble).ToList();
            Assert.Equal(3, result.Count);
            Assert.Equal(1000 / 2.0, (double)result[0]!, Tolerance);
            Assert.Equal(0 / 2.0, (double)result[1]!, Tolerance);
            Assert.Equal(1 / 2.0, (double)result[2]!, Tolerance);
        }

        // ====================== 15. double / IEnumerable<T> ======================
        [Fact]
        public void Div_Double_IEnumerableT_Returns_IEnumerableT()
        {
            var result = scalarDouble.Div<Length>((IEnumerable<Length>)unitsArray).ToList();
            Assert.Equal(2, result.Count);
            Assert.Equal(2.0 / 1000, (double)result[0], Tolerance);
            Assert.Equal(2.0 / 1, (double)result[1], Tolerance);
        }

        // ====================== 16. double / IEnumerable<T?> ======================
        [Fact]
        public void Div_Double_IEnumerableNullableT_Returns_IEnumerableNullableT()
        {
            var result = scalarDouble.Div<Length>((IEnumerable<Length?>)nullableUnitsArray).ToList();
            Assert.Equal(3, result.Count);
            Assert.Equal(2.0 / 1000, (double)result[0]!, Tolerance);
            Assert.Equal(2.0 / 0, (double)result[1]!, Tolerance);
            Assert.Equal(2.0 / 1, (double)result[2]!, Tolerance);
        }

        // ====================== 17. double[] / T ======================
        [Fact]
        public void Div_DoubleArray_T_Returns_TArray()
        {
            var result = doubleArray.Div(scalarUnit);
            Assert.Equal(2, result.Length);
            Assert.Equal(2.0 / 1000, (double)result[0], Tolerance);
            Assert.Equal(3.0 / 1000, (double)result[1], Tolerance);
        }

        // ====================== 18. double?[] / T ======================
        [Fact]
        public void Div_NullableDoubleArray_T_Returns_NullableTArray()
        {
            var result = nullableDoubleArray.Div(scalarUnit);
            Assert.Equal(3, result.Length);
            Assert.Equal(2.0 / 1000, (double)result[0]!, Tolerance);
            Assert.Equal(0 / 1000, (double)result[1]!, Tolerance);
            Assert.Equal(3.0 / 1000, (double)result[2]!, Tolerance);
        }

        // ====================== 19. T / double[] ======================
        [Fact]
        public void Div_T_DoubleArray_Returns_TArray()
        {
            var result = scalarUnit.Div(doubleArray);
            Assert.Equal(2, result.Length);
            Assert.Equal(1000 / 2.0, (double)result[0], Tolerance);
            Assert.Equal(1000 / 3.0, (double)result[1], Tolerance);
        }

        // ====================== 20. T / double?[] ======================
        [Fact]
        public void Div_T_NullableDoubleArray_Returns_NullableTArray()
        {
            var result = scalarUnit.Div(nullableDoubleArray);
            Assert.Equal(3, result.Length);
            Assert.Equal(1000 / 2.0, (double)result[0]!, Tolerance);
            Assert.Equal(1000 / 0.0, (double)result[1]!, Tolerance);
            Assert.Equal(1000 / 3.0, (double)result[2]!, Tolerance);
        }

        // ====================== 21. List<double> / T ======================
        [Fact]
        public void Div_ListDouble_T_Returns_ListT()
        {
            var list = new List<double> { 2.0, 3.0 };
            var result = list.Div(scalarUnit);
            Assert.Equal(2, result.Count);
            Assert.Equal(2.0 / 1000, (double)result[0], Tolerance);
            Assert.Equal(3.0 / 1000, (double)result[1], Tolerance);
        }

        // ====================== 22. List<double?> / T ======================
        [Fact]
        public void Div_ListNullableDouble_T_Returns_ListNullableT()
        {
            var list = new List<double?> { 2.0, null, 3.0 };
            var result = list.Div(scalarUnit);
            Assert.Equal(3, result.Count);
            Assert.Equal(2.0 / 1000, (double)result[0]!, Tolerance);
            Assert.Equal(0 / 1000, (double)result[1]!, Tolerance);
            Assert.Equal(3.0 / 1000, (double)result[2]!, Tolerance);
        }

        // ====================== 23. T / List<double> ======================
        [Fact]
        public void Div_T_ListDouble_Returns_ListT()
        {
            var list = new List<double> { 2.0, 3.0 };
            var result = scalarUnit.Div(list);
            Assert.Equal(2, result.Count);
            Assert.Equal(1000 / 2.0, (double)result[0], Tolerance);
            Assert.Equal(1000 / 3.0, (double)result[1], Tolerance);
        }

        // ====================== 24. T / List<double?> ======================
        [Fact]
        public void Div_T_ListNullableDouble_Returns_ListNullableT()
        {
            var list = new List<double?> { 2.0, null, 3.0 };
            var result = scalarUnit.Div(list);
            Assert.Equal(3, result.Count);
            Assert.Equal(1000 / 2.0, (double)result[0]!, Tolerance);
            Assert.Equal(1000 / 0.0, (double)result[1]!, Tolerance);
            Assert.Equal(1000 / 3.0, (double)result[2]!, Tolerance);
        }

        // ====================== 25. T / T[] -> double[] ======================
        [Fact]
        public void Div_T_TArray_Returns_DoubleArray()
        {
            var result = scalarUnit.Div(unitsArray);
            Assert.Equal(2, result.Length);
            Assert.Equal(1000 / 1000.0, result[0], Tolerance);
            Assert.Equal(1000 / 1.0, result[1], Tolerance);
        }

        // ====================== Дополнительно: пустые коллекции, null аргументы ======================
        [Fact]
        public void Div_EmptyArray_ReturnsEmptyArray()
        {
            var empty = Array.Empty<Length>();
            var result = empty.Div<Length>(2.0);
            Assert.Empty(result);
        }
    }
}