Fix Slice implentation and add Unit tests

Author: igajurelNCQA

Cql/CoreTests/PrimitiveTests.cs

@@ -3539,5 +3539,190 @@ public void QuantityToString()
             var s = ops.ConvertQuantityToString(new CqlQuantity(125, "cm"));
             s.Should().Be("125 'cm'");
         }
+
+        #region Slice tests
+
+        /* Refer http://cql.hl7.org/09-b-cqlreference.html for operation details on Skip, Tail and Take cql operators 
+         * These CQL operators uses Slice semantics from http://cql.hl7.org/04-logicalspecification.html#slice
+        */
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void Skip2()
+        {
+            //The Skip operator returns the elements in the list, skipping the first number elements. 
+            //define "Skip2": Skip({ 1, 2, 3, 4, 5 }, 2) // { 3, 4, 5 }
+            var rtx = GetNewContext();
+            var inputList = new List<int> { 1, 2, 3, 4, 5 };
+            var expectedList = new List<int> { 3, 4, 5 };
+            var slicedList = rtx.Operators.Slice(inputList, 2, null);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void SkipNull()
+        {
+            //If the number of elements is null, the result is the entire list, no elements are skipped.
+            //define "SkipNull": Skip({ 1, 3, 5 }, null) // { 1, 3, 5 }
+            var rtx = GetNewContext();
+            var inputList = new List<int> { 1, 3, 5 };
+            var expectedList = new List<int> { 1, 3, 5 };
+            var slicedList = rtx.Operators.Slice(inputList, null, null);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void SkipEmpty()
+        {
+            //If the number of elements is less than zero, the result is an empty list.
+            //define "SkipEmpty": Skip({ 1, 3, 5 }, -1) // { }
+            var rtx = GetNewContext();
+            var inputList = new List<int> { 1, 3, 5 };
+            var expectedList = new List<int> { };
+            var slicedList = rtx.Operators.Slice(inputList, -1, null);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void SkipIsNull()
+        {
+            //If the source list is null, the result is null.
+            //define "SkipIsNull": Skip(null, 2)
+            var rtx = GetNewContext();
+            var inputList = null as List<int>;
+            var expectedList = null as List<int>;
+            var slicedList = rtx.Operators.Slice(inputList, 2, null);
+            Assert.IsNull(slicedList);
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void Tail234()
+        {
+            //The Tail operator returns all but the first element from the given list. 
+            //define "Tail234": Tail({ 1, 2, 3, 4 }) // { 2, 3, 4 }
+            var rtx = GetNewContext();
+            var inputList = new List<int> { 1, 2, 3, 4 };
+            var expectedList = new List<int> { 2, 3, 4 };
+            var slicedList = rtx.Operators.Slice(inputList, 1, null);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void TailEmpty()
+        {
+            //If the list is empty, the result is empty.
+            //define "TailEmpty": Tail({ }) // { }
+            var rtx = GetNewContext();
+            var inputList = new List<int> { };
+            var expectedList = new List<int> { };
+            var slicedList = rtx.Operators.Slice(inputList, 1, null);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void TailIsNull()
+        {
+            //If the source list is null, the result is null.
+            //define "TailIsNull": Tail(null)
+            var rtx = GetNewContext();
+            var inputList = null as List<int>;
+            var expectedList = null as List<int>;
+            var slicedList = rtx.Operators.Slice(inputList, 1, null);
+            Assert.IsNull(slicedList);
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void Take2()
+        {
+            //The Take operator returns the first number elements from the given list.
+            //define "Take2": Take({ 1, 2, 3, 4 }, 2) // { 1, 2 }
+            var rtx = GetNewContext();
+            var inputList = new List<int> { 1, 2, 3, 4 };
+            var expectedList = new List<int> { 1, 2 };
+            var slicedList = rtx.Operators.Slice(inputList, 0, 2);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void TakeTooMany()
+        {
+            //If the list has less than number elements, the result only contains the elements in the list.
+            //define "TakeTooMany": Take({ 1, 2 }, 3) // { 1, 2 }
+            var rtx = GetNewContext();
+            var inputList = new List<int> { 1, 2 };
+            var expectedList = new List<int> { 1, 2 };
+            var slicedList = rtx.Operators.Slice(inputList, 0, 3);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void TakeEmpty()
+        {
+            //If number is null, or 0 or less, the result is an empty list.
+            //define "TakeEmpty": Take({ 1, 2, 3, 4 }, null) // { }
+            var rtx = GetNewContext();
+            var inputList = new List<int> { 1, 2, 3, 4 };
+            var expectedList = new List<int> { };
+            var slicedList = rtx.Operators.Slice(inputList, 0, 0);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void TakeIsNull()
+        {
+            //If the source list is null, the result is null.
+            //define "TakeIsNull": Take(null, 2)
+            var rtx = GetNewContext();
+            var inputList = null as List<int>;
+            var expectedList = null as List<int>;
+            var slicedList = rtx.Operators.Slice(inputList, 0, 2);
+            Assert.IsNull(slicedList);
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void Slice_array_source()
+        {
+            //Testing array as a source for Slice operator
+            var rtx = GetNewContext();
+            var inputSource = new[] { 1, 2, 3, 4 };
+            var expectedList = new List<int> { 1, 2 };
+            var slicedList = rtx.Operators.Slice(inputSource, 0, 2);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        [TestCategory("SliceTests")]
+        [TestMethod]
+        public void Slice_linkedList_source()
+        {
+            // Testing LinkedList as a source for Slice operator
+            var rtx = GetNewContext();
+            var inputSource = new LinkedList<int>(new[] { 1, 2, 3, 4 });
+            var expectedList = new List<int> { 1, 2 };
+            var slicedList = rtx.Operators.Slice(inputSource, 0, 2);
+            Assert.IsNotNull(slicedList);
+            CollectionAssert.AreEqual(expectedList, slicedList.ToList());
+        }
+
+        #endregion
     }
 }

Cql/Cql.Runtime/Operators/CqlOperators.ListOperators.cs

@@ -1047,26 +1047,23 @@ internal partial class CqlOperators
         {
             if (source == null)
                 return null;
-            if ((startIndex == null && endIndex == null) || !source.Any())
-            {
-                return [];
-            }
-            var si = startIndex ?? 0;
-            if (source is List<T> list)
+
+            if (!source.Any())
+                return Enumerable.Empty<T>();
+
+            if (startIndex == null && endIndex == null)
+                return source;
+
+            if (startIndex < 0 || endIndex <= 0)
+                return Enumerable.Empty<T>();
+
+            if (endIndex == null)
             {
-                var lcm1 = list.Count - 1;
-                var ei = Math.Min(endIndex ?? lcm1, lcm1);
-                var count = ei - si + 1;
-                var slice = list.GetRange(si, count);
-                return slice;
+                return source.Skip(startIndex ?? 0).ToList();
             }
             else
             {
-                var skip = source.Skip(si);
-                var result = new List<T>();
-                foreach (var item in skip.Take(endIndex ?? int.MaxValue))
-                    result.Add(item);
-                return result;
+                return source.Skip(startIndex ?? 0).Take((endIndex ?? 0) - (startIndex ?? 0)).ToList();
             }
         }