TESTS

2026-06-12 23:34:00 +07:00
parent 790a5f8e10
commit d7e9bb7b5b
27 changed files with 1167 additions and 1020 deletions
--- a/QWERTYkez.Mensura.Tests/CollectionsDivideExtensionsTest.cs
+++ b/QWERTYkez.Mensura.Tests/CollectionsDivideExtensionsTest.cs
@@ -0,0 +1,292 @@
+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);
+        }
+    }
+}