test: Add seed reproducibility, exception, and core-op property tests

- Random: fixed-seed reproducibility (setSeed + two-engine), different
  seeds diverge, distribution shape/range checks.
- Exception (new spec): toAFExceptionType maps all documented AFErr codes
  + unknown->UnhandledError; a matmul dim mismatch surfaces as a typed
  AFException across the FFI boundary.
- BLAS: property tests for transpose involution, A*I=A, (A^T B^T)^T = B A.
- Algorithm: property tests for ascending/descending sort vs Data.List.

Note: written against source signatures but not yet compile-verified
(local GHC 9.14.1 fails dependency resolution).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dmjio

arrayfire.cabal

@@ -172,6 +172,7 @@ test-suite test
     ArrayFire.BackendSpec
     ArrayFire.DataSpec
     ArrayFire.DeviceSpec
+    ArrayFire.ExceptionSpec
     ArrayFire.FeaturesSpec
     ArrayFire.GraphicsSpec
     ArrayFire.ImageSpec

test/ArrayFire/AlgorithmSpec.hs

@@ -1,8 +1,12 @@
-{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications    #-}
 module ArrayFire.AlgorithmSpec where
 
-import qualified ArrayFire       as A
+import qualified ArrayFire             as A
+import qualified Data.List            as L
 import           Test.Hspec
+import           Test.Hspec.QuickCheck (prop)
+import           Test.QuickCheck       ((==>))
 
 spec :: Spec
 spec =
@@ -281,3 +285,15 @@ spec =
       let arr = A.vector @Double 5 [3, 1, 4, 1, 5]
       A.imaxAll arr `shouldBe` (5.0, 0.0, 4)
 
+    describe "sort (property)" $ do
+      -- An ascending sort must return exactly the multiset of inputs in
+      -- non-decreasing order — i.e. agree element-for-element with Data.List.
+      prop "ascending sort agrees with Data.List.sort" $ \(xs :: [Double]) ->
+        not (null xs) ==>
+          A.toList (A.sort (A.vector (length xs) xs) 0 True) == L.sort xs
+
+      -- Descending sort is the reverse ordering.
+      prop "descending sort is the reverse ordering" $ \(xs :: [Double]) ->
+        not (null xs) ==>
+          A.toList (A.sort (A.vector (length xs) xs) 0 False) == L.sortBy (flip compare) xs
+

test/ArrayFire/BLASSpec.hs

@@ -1,10 +1,23 @@
-{-# LANGUAGE TypeApplications #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications    #-}
 module ArrayFire.BLASSpec where
 
 import ArrayFire    hiding (not)
 
 import Data.Complex
 import Test.Hspec
+import Test.Hspec.QuickCheck (prop)
+
+-- | Build a 4x4 'Double' matrix from an arbitrary (possibly short) list,
+-- padding with zeros so the shape is always well-defined.
+mat4 :: [Double] -> Array Double
+mat4 xs = mkArray [4,4] (take 16 (xs ++ repeat 0))
+
+-- | Element-wise closeness, tolerant of floating-point rounding in BLAS.
+closeList :: [Double] -> [Double] -> Bool
+closeList as bs =
+  length as == length bs &&
+  and (zipWith (\a b -> abs (a - b) <= 1e-9 + 1e-6 * max (abs a) (abs b)) as bs)
 
 spec :: Spec
 spec =
@@ -50,3 +63,23 @@ spec =
       let a = matrix @Double (2,2) [[1,2],[3,4]]
           b = matrix @Double (2,2) [[5,6],[7,8]]
       gemm None None 1.0 a b `shouldBe` matrix @Double (2,2) [[23,34],[31,46]]
+
+    describe "algebraic properties" $ do
+      -- Transposition only moves data, so double-transpose is exactly the
+      -- identity (no floating-point rounding involved).
+      prop "transpose is an involution" $ \(xs :: [Double]) ->
+        let m = mat4 xs
+        in toList (transpose (transpose m False) False) == toList m
+
+      -- Multiplying by the identity matrix recovers the original.
+      prop "A * I = A" $ \(xs :: [Double]) ->
+        let a = mat4 xs
+        in closeList (toList ((a `matmul` identity [4,4]) None None)) (toList a)
+
+      -- (A^T B^T)^T = B A : transpose distributes over a product (reversed).
+      prop "(A^T B^T)^T = B A" $ \(xs :: [Double]) (ys :: [Double]) ->
+        let a   = mat4 xs
+            b   = mat4 ys
+            lhs = transpose ((transpose a False `matmul` transpose b False) None None) False
+            rhs = (b `matmul` a) None None
+        in closeList (toList lhs) (toList rhs)

test/ArrayFire/ExceptionSpec.hs

@@ -0,0 +1,47 @@
+{-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TypeApplications    #-}
+module ArrayFire.ExceptionSpec where
+
+import           Control.Exception          (evaluate, try)
+import qualified ArrayFire                  as A
+import           ArrayFire.Exception
+import           ArrayFire.Internal.Defines (AFErr (..))
+import           Test.Hspec
+
+spec :: Spec
+spec = describe "Exception spec" $ do
+
+  -- The error-code → constructor table is the heart of the FFI error path;
+  -- a wrong entry silently mislabels every failure of that kind.
+  describe "toAFExceptionType" $ do
+
+    it "maps every documented AFErr code to its constructor" $
+      map (toAFExceptionType . AFErr)
+        [101,102,103,201,202,203,204,205,207,208,301,302,303,401,402,501,502,503,998,999]
+        `shouldBe`
+        [ NoMemoryError, DriverError, RuntimeError, InvalidArrayError, ArgError
+        , SizeError, TypeError, DiffTypeError, BatchError, DeviceError
+        , NotSupportedError, NotConfiguredError, NonFreeError, NoDblError
+        , NoGfxError, LoadLibError, LoadSymError, BackendMismatchError
+        , InternalError, UnknownError
+        ]
+
+    it "maps unrecognized codes to UnhandledError" $ do
+      toAFExceptionType (AFErr 0)     `shouldBe` UnhandledError
+      toAFExceptionType (AFErr 12345) `shouldBe` UnhandledError
+
+  -- End-to-end: a genuine ArrayFire failure must cross the FFI boundary as a
+  -- typed 'AFException', not a crash or an opaque error.
+  describe "library errors surface as AFException" $
+
+    it "a matmul dimension mismatch throws a typed AFException" $ do
+      let a = A.mkArray @Double [2,3] [1..6]   -- 2x3
+          b = A.mkArray @Double [2,2] [1..4]   -- 2x2  (inner dims 3 /= 2)
+      r <- try (evaluate (A.getElements (A.matmul a b A.None A.None)))
+             :: IO (Either AFException Int)
+      case r of
+        Right n ->
+          expectationFailure ("expected an AFException, but got " ++ show n)
+        Left (AFException ty code _msg) -> do
+          ty   `shouldSatisfy` (`elem` [SizeError, ArgError])
+          code `shouldSatisfy` (> 0)

test/ArrayFire/RandomSpec.hs

@@ -2,13 +2,13 @@
 module ArrayFire.RandomSpec where
 
 import ArrayFire
-import Control.Monad
 
 import Test.Hspec
 
 spec :: Spec
-spec =
-  describe "Random engine spec" $ do
+spec = describe "Random spec" $ do
+
+  describe "random engine" $ do
     it "Should create random engine" $ do
       (`shouldBe` Philox)
          =<< getRandomEngineType
@@ -27,4 +27,49 @@ spec =
        setSeed 100
        (`shouldBe` 100) =<< getSeed
 
+  -- Reproducibility is the contract that makes randomness usable in tests and
+  -- science: a fixed seed must yield a fixed stream.
+  describe "seed reproducibility" $ do
+
+    it "global setSeed makes randu reproducible" $ do
+      setSeed 1234
+      a1 <- toList <$> randu @Float [256]
+      setSeed 1234
+      a2 <- toList <$> randu @Float [256]
+      a2 `shouldBe` a1
+
+    it "global setSeed makes randn reproducible" $ do
+      setSeed 9876
+      a1 <- toList <$> randn @Double [256]
+      setSeed 9876
+      a2 <- toList <$> randn @Double [256]
+      a2 `shouldBe` a1
+
+    it "two engines with the same seed + type draw the same stream" $ do
+      e1 <- createRandomEngine 42 Philox
+      e2 <- createRandomEngine 42 Philox
+      a1 <- toList <$> randomUniform @Float [256] e1
+      a2 <- toList <$> randomUniform @Float [256] e2
+      a2 `shouldBe` a1
+
+    it "engines with different seeds draw different streams" $ do
+      e1 <- createRandomEngine 1 Philox
+      e2 <- createRandomEngine 2 Philox
+      a1 <- toList <$> randomUniform @Float [256] e1
+      a2 <- toList <$> randomUniform @Float [256] e2
+      a2 `shouldNotBe` a1
+
+  describe "distribution shape & range" $ do
+
+    it "randu produces the requested dimensions" $ do
+      a <- randu @Float [3,4]
+      getDims a `shouldBe` (3,4,1,1)
+
+    it "randn produces the requested dimensions" $ do
+      a <- randn @Double [5,2,3]
+      getDims a `shouldBe` (5,2,3,1)
 
+    it "uniform draws lie in [0,1)" $ do
+      setSeed 7
+      xs <- toList <$> randu @Float [4096]
+      xs `shouldSatisfy` all (\x -> x >= 0 && x < 1)