packages feed

pykinos-core-0.1.0.2: test/Spec.hs

{-# LANGUAGE BangPatterns #-}
module Main (main) where

import System.Exit (exitFailure)
import Pykinos.Bitset.Roaring
import Pykinos.IntMap.ART
import Pykinos.Mutable.SwissTable
import Pykinos.Schema.HiddenClass
import qualified Data.Text as T
import Control.Monad.ST (runST)
import Pykinos.Tree.BPlus
import Pykinos.Tree.FAST

assertBool :: String -> Bool -> IO ()
assertBool name cond =
  if cond
    then putStrLn $ "  [PASS] " ++ name
    else do
      putStrLn $ "  [FAIL] " ++ name
      exitFailure

main :: IO ()
main = do
  putStrLn "=== [pykinos-core-test] Running Roaring & ART Test Suite ==="

  -- 1. Roaring Basic Operations
  let s0 = emptyRoaring
  assertBool "s0 is null" (nullRoaring s0)

  let s1 = singletonRoaring 42
  assertBool "s1 not null" (not (nullRoaring s1))
  assertBool "s1 contains 42" (memberRoaring 42 s1)
  assertBool "s1 does not contain 43" (not (memberRoaring 43 s1))

  -- 2. Roaring Dense Array / Bitmap Promotion (> 4096 entries in a single 16-bit block)
  let denseList = [0 .. 4500]
      sDense = fromListRoaring denseList
  assertBool "sDense contains 0" (memberRoaring 0 sDense)
  assertBool "sDense contains 4500" (memberRoaring 4500 sDense)
  assertBool "sDense does not contain 4501" (not (memberRoaring 4501 sDense))

  -- 3. Roaring Union, Intersect, Difference
  let setA = fromListRoaring [1, 2, 3, 100, 70000]
      setB = fromListRoaring [3, 4, 5, 100, 70001]
      uSet = unionRoaring setA setB
      iSet = intersectRoaring setA setB
      dSet = differenceRoaring setA setB

  assertBool "union contains 1" (memberRoaring 1 uSet)
  assertBool "union contains 5" (memberRoaring 5 uSet)
  assertBool "union contains 70000 and 70001" (memberRoaring 70000 uSet && memberRoaring 70001 uSet)
  assertBool "intersect contains 3 and 100" (memberRoaring 3 iSet && memberRoaring 100 iSet)
  assertBool "intersect does not contain 1" (not (memberRoaring 1 iSet))
  assertBool "diff contains 1, 2, 70000" (memberRoaring 1 dSet && memberRoaring 2 dSet && memberRoaring 70000 dSet)
  assertBool "diff does not contain 3 or 100" (not (memberRoaring 3 dSet) && not (memberRoaring 100 dSet))

  -- 4. ART IntMap Operations across Node sizes
  let m0 = emptyART :: ARTIntMap String
      m4 = foldr (\k acc -> artInsert k ("val-" ++ show k) acc) m0 [1..4]
  assertBool "m4 lookup 1" (artLookup 1 m4 == Just "val-1")
  assertBool "m4 lookup 4" (artLookup 4 m4 == Just "val-4")
  assertBool "m4 lookup 5 is Nothing" (artLookup 5 m4 == Nothing)

  let m16 = foldr (\k acc -> artInsert k ("val-" ++ show k) acc) m4 [5..16]
  assertBool "m16 lookup 16" (artLookup 16 m16 == Just "val-16")
  assertBool "m16 lookup 10" (artLookup 10 m16 == Just "val-10")

  let m48 = foldr (\k acc -> artInsert k ("val-" ++ show k) acc) m16 [17..48]
  assertBool "m48 lookup 48" (artLookup 48 m48 == Just "val-48")

  let m256 = foldr (\k acc -> artInsert k ("val-" ++ show k) acc) m48 [49..100]
  assertBool "m256 lookup 100" (artLookup 100 m256 == Just "val-100")
  assertBool "m256 member 75" (artMember 75 m256)
  assertBool "m256 member 101 False" (not (artMember 101 m256))

  let mDel = artDelete 50 m256
  assertBool "mDel lookup 50 is Nothing" (artLookup 50 mDel == Nothing)
  assertBool "mDel lookup 49 still Just" (artLookup 49 mDel == Just "val-49")

  let kSet = artKeysSet mDel
  assertBool "kSet contains 49" (memberRoaring 49 kSet)
  assertBool "kSet does not contain 50" (not (memberRoaring 50 kSet))

  -- 5. BPlusMap Tests (splits across multi-level blocks)
  let bp0 = emptyBPlus :: BPlusMap Int String
      bp100 = foldr (\k acc -> insertBPlus k ("v" ++ show k) acc) bp0 [1..100]
  assertBool "bp100 size is 100" (bpmSize bp100 == 100)
  assertBool "bp100 lookup 1" (lookupBPlus 1 bp100 == Just "v1")
  assertBool "bp100 lookup 50" (lookupBPlus 50 bp100 == Just "v50")
  assertBool "bp100 lookup 100" (lookupBPlus 100 bp100 == Just "v100")
  assertBool "bp100 lookup 101 is Nothing" (lookupBPlus 101 bp100 == Nothing)

  let ascList = toAscListBPlus bp100
  assertBool "ascList has 100 items" (length ascList == 100)
  assertBool "ascList is sorted" (map fst ascList == [1..100])

  -- 6. FASTMap Tests (Eytzinger Cache-line acceleration)
  let fast100 = freezeFAST bp100
  assertBool "fast100 size is 100" (sizeFAST fast100 == 100)
  assertBool "fast100 lookup 1" (lookupFAST 1 fast100 == Just "v1")
  assertBool "fast100 lookup 50" (lookupFAST 50 fast100 == Just "v50")
  assertBool "fast100 lookup 100" (lookupFAST 100 fast100 == Just "v100")
  assertBool "fast100 lookup 101 is Nothing" (lookupFAST 101 fast100 == Nothing)

  
  -- 7. SwissTable128 Tests (SWAR 128-bit hash-consing)
  let (id0, id1, id0_again) = runST $ do
        tbl <- newSwissTable128 32
        let (kLo1, kHi1) = packNfNode128 1 0 10 20 30
            (kLo2, kHi2) = packNfNode128 2 0 40 50 60
        i0 <- lookupOrInsert128 tbl kLo1 kHi1
        i1 <- lookupOrInsert128 tbl kLo2 kHi2
        i0' <- lookupOrInsert128 tbl kLo1 kHi1
        pure (i0, i1, i0')
  assertBool "id0 is 0" (id0 == 0)
  assertBool "id1 is 1" (id1 == 1)
  assertBool "id0_again matches id0" (id0_again == 0)

  
  -- 8. HiddenClass & Lexicon Tests
  let lx = buildLexicon [T.pack "beta", T.pack "alpha", T.pack "gamma"]
  assertBool "alpha fid is 0" (lookupFieldId lx (T.pack "alpha") == Just (FieldId 0))
  assertBool "beta fid is 1" (lookupFieldId lx (T.pack "beta") == Just (FieldId 1))
  assertBool "gamma fid is 2" (lookupFieldId lx (T.pack "gamma") == Just (FieldId 2))

  putStrLn "=== [pykinos-core-test] ALL 33 PROPERTIES AND UNIT CHECKS PASSED ==="