Fix test bugs

The test cases incorrectly assumed that makeArray initializes elements on
the mutable backends and that fromList is defined for size 0.
This commit updates the test suite to account for these issues by:

 - Removing tests that makeArray initializes elements for mutable backends
 - Using replicate and fromList in splitMid tests to initialize elements
 - Copying arrays when testing the commutativity of swaps
 - Removing 0 from the range of fromList calls

There is still one failing test. This is the test for swapping the same index,
which only fails on the prim-mutable-arrays backend.

Author: Mikah-Kainen

tests/ArrayTests.hs

@@ -47,24 +47,13 @@ arrayTests = testGroup "Array Tests"
 --------------------------------------------------------------------------------
 testMakeArray :: TestTree
 testMakeArray = testGroup "MakeArray Tests"
-  [ caseTests
--- TODO: property tests should work for mutable backends too (?)
-#ifndef MUTABLE_ARRAYS
-  , propertyTests
-#endif
-  , invalidOperationTests
-  ] where
+  [ caseTests, propertyTests , invalidOperationTests ] where
 
   -- The case tests for the MakeArray function.
   -- Tests that arrays of size 0 and 1 have the proper size and elements.
   caseTests :: TestTree
   caseTests = testGroup "MakeArray Case Tests"
-    [ testEmptyArray
--- TODO: the below should work for mutable backends too (?)
-#ifndef MUTABLE_ARRAYS
-    , testSizeOneArray
-#endif
-    ]
+    [ testEmptyArray, testSizeOneArray ]
     where
 
     -- Testing the output of an empty array.
@@ -79,8 +68,11 @@ testMakeArray = testGroup "MakeArray Tests"
       QC.forAll QC.arbitrary $ \(randomElement :: Int) ->
           let customArr = CustomArray.makeArray 1 randomElement
               standardArr = makeStandardArray 1 randomElement
-          in CustomArray.size customArr QC.=== 1 QC..&. CustomArray.toList customArr QC.=== StandardArray.elems standardArr
-
+          in CustomArray.size customArr QC.=== 1 
+-- The mutable backend doesn't initialize array elements, StandardArray(Data.Array) does
+#ifndef MUTABLE_ARRAYS
+          QC..&. CustomArray.toList customArr QC.=== StandardArray.elems standardArr
+#endif
 
   -- The property tests for the makeArray function.
   -- Tests that random arrays have proper size and elements.
@@ -94,7 +86,11 @@ testMakeArray = testGroup "MakeArray Tests"
       QC.forAll ((,) <$> QC.chooseInt (0, mediumNumber) <*> QC.arbitrary) $ \(randomSize :: Int, randomElement :: Int) ->
           let customArr = CustomArray.makeArray randomSize randomElement
               standardArr = makeStandardArray randomSize randomElement
-          in CustomArray.size customArr QC.=== randomSize QC..&. CustomArray.toList customArr QC.=== StandardArray.elems standardArr
+          in CustomArray.size customArr QC.=== randomSize 
+-- The mutable backend doesn't initialize array elements, StandardArray(Data.Array) does
+#ifndef MUTABLE_ARRAYS
+          QC..&. CustomArray.toList customArr QC.=== StandardArray.elems standardArr
+#endif
 
   -- The tests for exception cases of the MakeArray functions.
   -- Tests that negative size arrays can't be made.
@@ -260,8 +256,7 @@ testSwap = testGroup "Swap Tests" [ caseTests, performanceTests, propertyTests ]
     , testValuesSwapped2
     , testValuesSwapped3
     , testValuesSwapped4
--- TODO: the below should work for mutable backends too
-#ifndef MUTABLE_ARRAYS
+#ifndef PRIM_MUTABLE_ARRAYS
     , testSwapSameIndex
 #endif
     ] where
@@ -285,12 +280,14 @@ testSwap = testGroup "Swap Tests" [ caseTests, performanceTests, propertyTests ]
     testSwapSameIndex :: TestTree
     testSwapSameIndex = testCase "Test Swapping Same Index" $ do
       let arr = CustomArray.makeArray 5 (1 :: Int)
-      let swappedArr = CustomOperations.swap arr 2 2
+          swappedArr = CustomOperations.swap arr 2 2
       assertEqual "Array should remain unchanged" 1 (CustomArray.get swappedArr 2)
 
   -- Test performance for swap.
   performanceTests :: TestTree
-  performanceTests = testGroup "Swap Performance Tests" [ testLargeArraySwap ] where
+  performanceTests = testGroup "Swap Performance Tests" [ 
+      testLargeArraySwap 
+    ] where
     largeInt = 1000000 * performanceTestMultiplier
 
     -- Test performance of creating and splitting a large.
@@ -304,7 +301,7 @@ testSwap = testGroup "Swap Tests" [ caseTests, performanceTests, propertyTests ]
   -- The property tests for the split function.
   propertyTests :: TestTree
   propertyTests = testGroup "Swap Property Tests" [
-    testSwapCommutative
+      testSwapCommutative
     ] where
 
     -- Generates random arrays to test that swap is commutative.
@@ -326,25 +323,25 @@ testSwap = testGroup "Swap Tests" [ caseTests, performanceTests, propertyTests ]
 -- TODO: Missing performance and property tests.
 --------------------------------------------------------------------------------
 testSplit :: TestTree
-testSplit = testGroup "Test Split" [ caseTests ] where
+testSplit = testGroup "Test Split" [
+    caseTests
+  ] where
 
   -- The case tests for the split function.
   caseTests :: TestTree
   caseTests = testGroup "Split Case Tests" [
--- TODO: the below should work for mutable backends too
-#ifndef MUTABLE_ARRAYS
       testSplitMid
-    ,
-#endif
-      testSplitEmpty
+    , testSplitEmpty
     ] where
 
     -- Testing after splitting an array in the middle the sizes of the left and right are correct.
     -- and the contents of the left and right don't change.
     -- Hardcoded array size and values.
     testSplitMid :: TestTree
     testSplitMid = testCase "Test Split Mid" $ do
-      let arr = CustomArray.makeArray 6 (1 :: Int)
+      --let arr = CustomArray.makeArray 6 (1 :: Int)
+      let list = replicate 6 (1 :: Int)
+          arr = CustomArray.fromList list
       let (leftArr, rightArr) = CustomOperations.splitMid arr
       assertEqual "Left array size should be 3" 3 (CustomArray.size leftArr)
       assertEqual "Right array size should be 3" 3 (CustomArray.size rightArr)

tests/Infra.hs

@@ -25,7 +25,7 @@ import           Data.List (sort)
 
 instance (QC.Arbitrary a, CustomArray.HasPrim a, Random a) => QC.Arbitrary (CustomArray.Array a) where
     arbitrary = do
-        size <- QC.chooseInt (0, 1000)  -- hardcode as needed
+        size <- QC.chooseInt (1, 1000)  -- hardcode as needed. fromList is not defined for size 0.
         elements <- QC.vectorOf size QC.arbitrary
         return $ CustomArray.fromList elements
 

tests/Properties.hs

@@ -18,7 +18,8 @@ type LinearSort = CustomArray.Array Int -. CustomArray.Array Int
 -- Define the commutative property for swap.
 swapCommutativeProperty :: (QC.Arbitrary a, CustomArray.HasPrim a, Show a, Eq a) => CustomArray.Array a -> Int -> Int -> QC.Property
 swapCommutativeProperty arr i j =
-  i /= j QC.==> CustomArray.toList (CustomOperations.swap arr i j) QC.=== CustomArray.toList (CustomOperations.swap arr j i)
+  let arrCopy = CustomArray.fromList (CustomArray.toList arr) in
+  i /= j QC.==> CustomArray.toList (CustomOperations.swap arrCopy i j) QC.=== CustomArray.toList (CustomOperations.swap arr j i)
 
 -- Property: Function correctly sorts all elements.
 sortsCorrectlyProperty :: ([Int] -> [Int]) -> [Int] -> Bool