swish-0.3.0.0: tests/RDFDatatypeXsdIntegerTest.hs
--------------------------------------------------------------------------------
-- See end of this file for licence information.
--------------------------------------------------------------------------------
-- |
-- Module : RDFDatatypeXsdIntegerTest
-- Copyright : (c) 2003, Graham Klyne, 2009 Vasili I Galchin, 2011 Douglas Burke
-- License : GPL V2
--
-- Maintainer : Douglas Burke
-- Stability : experimental
-- Portability : H98
--
-- This module contains test cases for variable binding values and
-- variable binding modifier values.
--
--------------------------------------------------------------------------------
module Main where
import Swish.RDF.RDFDatatypeXsdInteger
( rdfDatatypeXsdInteger
, rdfDatatypeValXsdInteger
, typeNameXsdInteger, namespaceXsdInteger
, axiomsXsdInteger, rulesXsdInteger
, prefixXsdInteger
)
import Swish.RDF.RDFVarBinding
( RDFVarBinding )
import Swish.RDF.RDFRuleset
( RDFRule
, makeRDFGraphFromN3String
)
import Swish.RDF.RDFDatatype
( RDFDatatypeMod
, applyRDFDatatypeMod
)
import Swish.RDF.RDFGraph
( RDFLabel(..), RDFGraph
)
import Swish.RDF.ClassRestrictionRule (falseGraphStr)
import Swish.RDF.Datatype
( typeName, typeRules, typeMkRules
, getTypeAxiom, getTypeRule
, DatatypeVal(..)
, getDTMod
, DatatypeMap(..)
, DatatypeMod(..)
, nullDatatypeMod
)
import Swish.RDF.Ruleset
( Ruleset(..)
, getRulesetRule
)
import Swish.RDF.Rule
( Formula(..), Rule(..)
, nullFormula, nullRule
)
import Swish.RDF.VarBinding (makeVarBinding)
import Swish.Utils.Namespace
( Namespace(..)
, ScopedName(..)
, makeScopedName
)
import Swish.RDF.Vocabulary (namespaceDefault)
import Swish.Utils.LookupMap
( LookupMap(..)
, mapFindMaybe
)
import Swish.Utils.ListHelpers
( equiv )
import Test.HUnit
( Test(TestCase,TestList)
, Assertion
, assertBool, assertEqual, assertFailure
, runTestTT
)
import Control.Monad (unless)
import Data.Maybe (isJust, fromMaybe)
------------------------------------------------------------
-- Test case helpers
------------------------------------------------------------
assertMember :: (Eq a, Show a) => String -> a -> [a] -> Assertion
assertMember preface expected actual =
unless (expected `elem` actual ) (assertFailure msg)
where msg = (if null preface then "" else preface ++ "\n") ++
"expected: " ++ show expected ++ "\nbut got: " ++ show actual
test :: String -> Bool -> Test
test lab bv =
TestCase ( assertBool ("test:"++lab) bv )
testEq :: (Eq a, Show a) => String -> a -> a -> Test
testEq lab a1 a2 =
TestCase ( assertEqual ("testEq:"++lab) a1 a2 )
testElem :: (Eq a, Show a) => String -> a -> [a] -> Test
testElem lab a1 as =
TestCase ( assertMember ("testElem:"++lab) a1 as )
testLe :: (Ord a, Show a) => String -> Bool -> a -> a -> Test
testLe lab eq a1 a2 =
TestCase ( assertEqual ("testLe:"++lab) eq (a1<=a2) )
-- Test for Just x or Nothing
testJust :: String -> Maybe a -> Test
testJust lab av =
TestCase ( assertBool ("testJust:"++lab) (isJust av) )
testNothing :: String -> Maybe a -> Test
testNothing lab av =
TestCase ( assertBool ("testJust:"++lab) (not $ isJust av) )
-- Compare lists and lists of lists and Maybe lists for set equivalence:
data ListTest a = ListTest [a]
instance (Eq a) => Eq (ListTest a) where
(ListTest a1) == (ListTest a2) = a1 `equiv` a2
instance (Show a) => Show (ListTest a) where
show (ListTest a) = show a
data MaybeListTest a = MaybeListTest (Maybe [a])
instance (Eq a) => Eq (MaybeListTest a) where
MaybeListTest (Just a1) == MaybeListTest (Just a2) = a1 `equiv` a2
MaybeListTest Nothing == MaybeListTest Nothing = True
_ == _ = False
instance (Show a) => Show (MaybeListTest a) where
show (MaybeListTest a) = show a
testEqv :: (Eq a, Show a) => String -> [a] -> [a] -> Test
testEqv lab a1 a2 =
TestCase ( assertEqual ("testEqv:"++lab) (ListTest a1) (ListTest a2) )
testEqvEqv :: (Eq a, Show a) => String -> [[a]] -> [[a]] -> Test
testEqvEqv lab a1 a2 =
TestCase ( assertEqual ("testEqvEqv:"++lab) ma1 ma2 )
where
ma1 = ListTest $ map ListTest a1
ma2 = ListTest $ map ListTest a2
testHasEqv :: (Eq a, Show a) => String -> [a] -> [[a]] -> Test
testHasEqv lab a1 a2 =
TestCase ( assertMember ("testHasEqv:"++lab) ma1 ma2 )
where
ma1 = ListTest a1
ma2 = map ListTest a2
testMaybeEqv :: (Eq a, Show a) => String -> Maybe [a] -> Maybe [a] -> Test
testMaybeEqv lab a1 a2 =
TestCase ( assertEqual ("testMaybeEqv:"++lab) ma1 ma2 )
where
ma1 = (MaybeListTest a1)
ma2 = (MaybeListTest a2)
------------------------------------------------------------
-- Misc values
------------------------------------------------------------
xsd_int_name :: String -> ScopedName
xsd_int_name nam = ScopedName namespaceXsdInteger nam
axiomXsdIntegerDT :: ScopedName
axiomXsdIntegerDT = xsd_int_name "dt"
ruleXsdIntegerAbs, ruleXsdIntegerNeg, ruleXsdIntegerSum,
ruleXsdIntegerDiff, ruleXsdIntegerProd, ruleXsdIntegerDivMod,
ruleXsdIntegerPower, ruleXsdIntegerEq, ruleXsdIntegerNe,
ruleXsdIntegerLt, ruleXsdIntegerLe, ruleXsdIntegerGt,
ruleXsdIntegerGe :: ScopedName
ruleXsdIntegerAbs = xsd_int_name "Abs"
ruleXsdIntegerNeg = xsd_int_name "Neg"
ruleXsdIntegerSum = xsd_int_name "Sum"
ruleXsdIntegerDiff = xsd_int_name "Diff"
ruleXsdIntegerProd = xsd_int_name "Prod"
ruleXsdIntegerDivMod = xsd_int_name "DivMod"
ruleXsdIntegerPower = xsd_int_name "Power"
ruleXsdIntegerEq = xsd_int_name "Eq"
ruleXsdIntegerNe = xsd_int_name "Ne"
ruleXsdIntegerLt = xsd_int_name "Lt"
ruleXsdIntegerLe = xsd_int_name "Le"
ruleXsdIntegerGt = xsd_int_name "Gt"
ruleXsdIntegerGe = xsd_int_name "Ge"
------------------------------------------------------------
-- Basic rdfDatatypeXsdInteger tests
------------------------------------------------------------
getXsdIntegerAxiom :: ScopedName -> Formula RDFGraph
getXsdIntegerAxiom scopnam =
fromMaybe nullFormula $ getTypeAxiom scopnam rdfDatatypeXsdInteger
getXsdIntegerRule :: ScopedName -> Rule RDFGraph
getXsdIntegerRule scopnam =
fromMaybe nullRule $ getTypeRule scopnam rdfDatatypeXsdInteger
getXsdIntegerDTmod :: ScopedName -> DatatypeMod Integer RDFLabel RDFLabel
getXsdIntegerDTmod scopnam =
fromMaybe nullDatatypeMod $ getDTMod scopnam rdfDatatypeValXsdInteger
testDatatypeSuite :: Test
testDatatypeSuite =
TestList
[ testEq "testDatatype01" typeNameXsdInteger $
typeName rdfDatatypeXsdInteger
, testEq "testDatatype02" namespaceXsdInteger $
rsNamespace (typeRules rdfDatatypeXsdInteger)
, testEqv "testDatatype03" axiomsXsdInteger $
rsAxioms (typeRules rdfDatatypeXsdInteger)
, testEqv "testDatatype04" rulesXsdInteger $
rsRules (typeRules rdfDatatypeXsdInteger)
, testEq "testDatatype05" axiomXsdIntegerDT $
formName (getXsdIntegerAxiom axiomXsdIntegerDT)
, testEq "testDatatype06" ruleXsdIntegerAbs $
ruleName (getXsdIntegerRule ruleXsdIntegerAbs)
]
------------------------------------------------------------
-- Basic rdfDatatypeValXsdInteger tests
------------------------------------------------------------
testDatatypeValSuite :: Test
testDatatypeValSuite =
TestList
[ testEq "testDatatypeVal01" (Just 123) $
mapL2V (tvalMap rdfDatatypeValXsdInteger) "123"
, testEq "testDatatypeVal02" (Just 0) $
mapL2V (tvalMap rdfDatatypeValXsdInteger) "0"
, testEq "testDatatypeVal03" (Just 456) $
mapL2V (tvalMap rdfDatatypeValXsdInteger) "+000456"
, testEq "testDatatypeVal04" (Just (-987)) $
mapL2V (tvalMap rdfDatatypeValXsdInteger) "-0987"
, testEq "testDatatypeVal05" Nothing $
mapL2V (tvalMap rdfDatatypeValXsdInteger) "11x2"
, testEq "testDatatypeVal06" Nothing $
mapL2V (tvalMap rdfDatatypeValXsdInteger) " 321"
, testEq "testDatatypeVal07" Nothing $
mapL2V (tvalMap rdfDatatypeValXsdInteger) "321 "
, testEq "testDatatypeVal11" (Just "123") $
mapV2L (tvalMap rdfDatatypeValXsdInteger) 123
, testEq "testDatatypeVal12" (Just "-987") $
mapV2L (tvalMap rdfDatatypeValXsdInteger) (-987)
, testElem "testDatatypeVal21" dmodXsdIntegerAbs $
map dmName (tvalMod rdfDatatypeValXsdInteger)
, testEq "testDatatypeVal22" dmodXsdIntegerAbs $
dmName (getXsdIntegerDTmod dmodXsdIntegerAbs)
]
------------------------------------------------------------
-- Variable binding modifier tests
------------------------------------------------------------
dmodXsdIntegerAbs, dmodXsdIntegerNeg, dmodXsdIntegerSum,
dmodXsdIntegerDiff, dmodXsdIntegerProd, dmodXsdIntegerDivMod,
dmodXsdIntegerPower, dmodXsdIntegerEq, dmodXsdIntegerNe,
dmodXsdIntegerLt, dmodXsdIntegerLe, dmodXsdIntegerGt,
dmodXsdIntegerGe :: ScopedName
dmodXsdIntegerAbs = xsd_int_name "abs"
dmodXsdIntegerNeg = xsd_int_name "neg"
dmodXsdIntegerSum = xsd_int_name "sum"
dmodXsdIntegerDiff = xsd_int_name "diff"
dmodXsdIntegerProd = xsd_int_name "prod"
dmodXsdIntegerDivMod = xsd_int_name "divmod"
dmodXsdIntegerPower = xsd_int_name "power"
dmodXsdIntegerEq = xsd_int_name "eq"
dmodXsdIntegerNe = xsd_int_name "ne"
dmodXsdIntegerLt = xsd_int_name "lt"
dmodXsdIntegerLe = xsd_int_name "le"
dmodXsdIntegerGt = xsd_int_name "gt"
dmodXsdIntegerGe = xsd_int_name "ge"
testVmodN :: [RDFLabel]
-> String -> Maybe (RDFDatatypeMod Integer)
-> [RDFVarBinding] -> [RDFVarBinding]
-> Test
testVmodN vars lab (Just dmod) ibinds obinds =
testEqv lab obinds $
applyRDFDatatypeMod rdfDatatypeValXsdInteger dmod vars ibinds
testVmodN _ lab Nothing _ _ = TestCase $
assertFailure $ "testVmodN:"++lab++", null variable binding modifier"
testVmod2, testVmod3, testVmod4 ::
String -> Maybe (RDFDatatypeMod Integer)
-> [RDFVarBinding] -> [RDFVarBinding]
-> Test
testVmod2 = testVmodN [(Var "a"),(Var "b")]
testVmod3 = testVmodN [(Var "a"),(Var "b"),(Var "c")]
testVmod4 = testVmodN [(Var "a"),(Var "b"),(Var "c"),(Var "d")]
-- make various kinds of RDF variable bindings
rdfVR :: (String, ScopedName) -> (RDFLabel, RDFLabel)
rdfVR (v,u) = (Var v,Res u) -- (Variable,Resource)
rdfVB :: (String, String) -> (RDFLabel, RDFLabel)
rdfVB (v,b) = (Var v,Blank b) -- (Variable,Blank)
rdfVL :: (String, String) -> (RDFLabel, RDFLabel)
rdfVL (v,l) = (Var v,Lit l Nothing) -- (Variable,Untyped literal)
rdfVI :: (String, String) -> (RDFLabel, RDFLabel)
rdfVI (v,l) = (Var v,Lit l (Just typeNameXsdInteger))
-- (Variable,Integer literal)
makeBVR :: [(String,ScopedName)] -> RDFVarBinding
makeBVR nls = makeVarBinding $ map rdfVR nls
makeBVB :: [(String,String)] -> RDFVarBinding
makeBVB nls = makeVarBinding $ map rdfVB nls
makeBVI :: [(String,String)] -> RDFVarBinding
makeBVI nls = makeVarBinding $ map rdfVI nls
makeBVL :: [(String,String)] -> RDFVarBinding
makeBVL nls = makeVarBinding $ map rdfVL nls
-- Test null modifier
testVarModify00 :: Test
testVarModify00 = testVmod2 "testVarModify00"
(Just nullDatatypeMod)
[makeBVI [("a","123")]]
[makeBVI [("a","123")]]
-- Tests for xsd_integer:abs
testVarModifyAbs01, testVarModifyAbs02, testVarModifyAbs03,
testVarModifyAbs04, testVarModifyAbs05, testVarModifyAbs06,
testVarModifyAbs07, testVarModifyAbs08, testVarModifyAbs09,
testVarModifyAbs10 :: Test
testVarModifyAbs01 = testVmod2 "testVarModifyAbs01"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVI [("b","123")]]
[makeBVI [("a","123"),("b","123")]]
testVarModifyAbs02 = testVmod2 "testVarModifyAbs02"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVI [("b","-123")]]
[makeBVI [("a","123"),("b","-123")]]
testVarModifyAbs03 = testVmod2 "testVarModifyAbs03"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVI [("a","123"),("b","123")]]
[makeBVI [("a","123"),("b","123")]]
testVarModifyAbs04 = testVmod2 "testVarModifyAbs04"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVI [("a","123"),("b","-123")]]
[makeBVI [("a","123"),("b","-123")]]
testVarModifyAbs05 = testVmod2 "testVarModifyAbs05"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVI [("a","-123"),("b","123")]]
[]
testVarModifyAbs06 = testVmod2 "testVarModifyAbs06"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVI [("a","123"),("b","456")]]
[]
testVarModifyAbs07 = testVmod2 "testVarModifyAbs07"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVI [("c","123")]]
[]
testVarModifyAbs08 = testVmod2 "testVarModifyAbs08"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVL [("b","123")]]
[]
testVarModifyAbs09 = testVmod2 "testVarModifyAbs09"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVR [("b",makeScopedName "" "http://ex.org/" "123")]]
[]
testVarModifyAbs10 = testVmod2 "testVarModifyAbs10"
(getDTMod dmodXsdIntegerAbs rdfDatatypeValXsdInteger)
[makeBVB [("b","123")]]
[]
-- Tests for xsd_integer:neg
testVarModifyNeg01, testVarModifyNeg02, testVarModifyNeg03,
testVarModifyNeg04, testVarModifyNeg05 :: Test
testVarModifyNeg01 = testVmod2 "testVarModifyNeg01"
(getDTMod dmodXsdIntegerNeg rdfDatatypeValXsdInteger)
[makeBVI [("a","123"),("b","-123")]]
[makeBVI [("a","123"),("b","-123")]]
testVarModifyNeg02 = testVmod2 "testVarModifyNeg02"
(getDTMod dmodXsdIntegerNeg rdfDatatypeValXsdInteger)
[makeBVI [("a","-123"),("b","123")]]
[makeBVI [("a","-123"),("b","123")]]
testVarModifyNeg03 = testVmod2 "testVarModifyNeg03"
(getDTMod dmodXsdIntegerNeg rdfDatatypeValXsdInteger)
[makeBVI [("a","123"),("b","123")]]
[]
testVarModifyNeg04 = testVmod2 "testVarModifyNeg04"
(getDTMod dmodXsdIntegerNeg rdfDatatypeValXsdInteger)
[makeBVI [("b","123")]]
[makeBVI [("a","-123"),("b","123")]]
testVarModifyNeg05 = testVmod2 "testVarModifyNeg05"
(getDTMod dmodXsdIntegerNeg rdfDatatypeValXsdInteger)
[makeBVI [("a","-123")]]
[makeBVI [("a","-123"),("b","123")]]
-- Tests for xsd_integer:sum
testVarModifySum01, testVarModifySum02, testVarModifySum03,
testVarModifySum04, testVarModifySum05 :: Test
testVarModifySum01 = testVmod3 "testVarModifySum01"
(getDTMod dmodXsdIntegerSum rdfDatatypeValXsdInteger)
[makeBVI [("a","33"),("b","22"),("c","11")]]
[makeBVI [("a","33"),("b","22"),("c","11")]]
testVarModifySum02 = testVmod3 "testVarModifySum02"
(getDTMod dmodXsdIntegerSum rdfDatatypeValXsdInteger)
[makeBVI [("b","22"),("c","11")]]
[makeBVI [("a","33"),("b","22"),("c","11")]]
testVarModifySum03 = testVmod3 "testVarModifySum03"
(getDTMod dmodXsdIntegerSum rdfDatatypeValXsdInteger)
[makeBVI [("a","33"),("c","11")]]
[makeBVI [("a","33"),("b","22"),("c","11")]]
testVarModifySum04 = testVmod3 "testVarModifySum04"
(getDTMod dmodXsdIntegerSum rdfDatatypeValXsdInteger)
[makeBVI [("a","33"),("b","22")]]
[makeBVI [("a","33"),("b","22"),("c","11")]]
testVarModifySum05 = testVmod3 "testVarModifySum05"
(getDTMod dmodXsdIntegerSum rdfDatatypeValXsdInteger)
[makeBVI [("a","44"),("b","22"),("c","11")]]
[]
-- Tests for xsd_integer:diff
testVarModifyDiff01, testVarModifyDiff02, testVarModifyDiff03,
testVarModifyDiff04, testVarModifyDiff05 :: Test
testVarModifyDiff01 = testVmod3 "testVarModifyDiff01"
(getDTMod dmodXsdIntegerDiff rdfDatatypeValXsdInteger)
[makeBVI [("a","11"),("b","33"),("c","22")]]
[makeBVI [("a","11"),("b","33"),("c","22")]]
testVarModifyDiff02 = testVmod3 "testVarModifyDiff02"
(getDTMod dmodXsdIntegerDiff rdfDatatypeValXsdInteger)
[makeBVI [("b","33"),("c","22")]]
[makeBVI [("a","11"),("b","33"),("c","22")]]
testVarModifyDiff03 = testVmod3 "testVarModifyDiff03"
(getDTMod dmodXsdIntegerDiff rdfDatatypeValXsdInteger)
[makeBVI [("a","11"),("c","22")]]
[makeBVI [("a","11"),("b","33"),("c","22")]]
testVarModifyDiff04 = testVmod3 "testVarModifyDiff04"
(getDTMod dmodXsdIntegerDiff rdfDatatypeValXsdInteger)
[makeBVI [("a","11"),("b","33")]]
[makeBVI [("a","11"),("b","33"),("c","22")]]
testVarModifyDiff05 = testVmod3 "testVarModifyDiff05"
(getDTMod dmodXsdIntegerDiff rdfDatatypeValXsdInteger)
[makeBVI [("a","11"),("b","44"),("c","22")]]
[]
-- Tests for xsd_integer:prod
--
-- Note: product can also be used to test if a value is
-- an exact multiple of some other.
testVarModifyProd01, testVarModifyProd02, testVarModifyProd03,
testVarModifyProd04, testVarModifyProd05,
testVarModifyProd06 :: Test
testVarModifyProd01 = testVmod3 "testVarModifyProd01"
(getDTMod dmodXsdIntegerProd rdfDatatypeValXsdInteger)
[makeBVI [("a","6"),("b","2"),("c","3")]]
[makeBVI [("a","6"),("b","2"),("c","3")]]
testVarModifyProd02 = testVmod3 "testVarModifyProd02"
(getDTMod dmodXsdIntegerProd rdfDatatypeValXsdInteger)
[makeBVI [("b","2"),("c","3")]]
[makeBVI [("a","6"),("b","2"),("c","3")]]
testVarModifyProd03 = testVmod3 "testVarModifyProd03"
(getDTMod dmodXsdIntegerProd rdfDatatypeValXsdInteger)
[makeBVI [("a","6"),("c","3")]]
[makeBVI [("a","6"),("b","2"),("c","3")]]
testVarModifyProd04 = testVmod3 "testVarModifyProd04"
(getDTMod dmodXsdIntegerProd rdfDatatypeValXsdInteger)
[makeBVI [("a","6"),("c","3")]]
[makeBVI [("a","6"),("b","2"),("c","3")]]
testVarModifyProd05 = testVmod3 "testVarModifyProd05"
(getDTMod dmodXsdIntegerProd rdfDatatypeValXsdInteger)
[makeBVI [("a","7"),("b","2"),("c","3")]]
[]
testVarModifyProd06 = testVmod3 "testVarModifyProd06"
(getDTMod dmodXsdIntegerProd rdfDatatypeValXsdInteger)
[makeBVI [("a","7"),("b","2")]]
[]
-- Tests for xsd_integer:divmod
--
-- Note: truncates downwards, so remainder is same sign as divisor
-- cf. Haskell divMod function.
testVarModifyDivMod01, testVarModifyDivMod02, testVarModifyDivMod03,
testVarModifyDivMod04, testVarModifyDivMod05,
testVarModifyDivMod06, testVarModifyDivMod07 :: Test
testVarModifyDivMod01 = testVmod4 "testVarModifyDivMod01"
(getDTMod dmodXsdIntegerDivMod rdfDatatypeValXsdInteger)
[makeBVI [("a","2"),("b","1"),("c","7"),("d","3")]]
[makeBVI [("a","2"),("b","1"),("c","7"),("d","3")]]
testVarModifyDivMod02 = testVmod4 "testVarModifyDivMod02"
(getDTMod dmodXsdIntegerDivMod rdfDatatypeValXsdInteger)
[makeBVI [("c","7"),("d","3")]]
[makeBVI [("a","2"),("b","1"),("c","7"),("d","3")]]
testVarModifyDivMod03 = testVmod4 "testVarModifyDivMod03"
(getDTMod dmodXsdIntegerDivMod rdfDatatypeValXsdInteger)
[makeBVI [("c","-7"),("d","3")]]
[makeBVI [("a","-3"),("b","2"),("c","-7"),("d","3")]]
testVarModifyDivMod04 = testVmod4 "testVarModifyDivMod04"
(getDTMod dmodXsdIntegerDivMod rdfDatatypeValXsdInteger)
[makeBVI [("c","7"),("d","-3")]]
[makeBVI [("a","-3"),("b","-2"),("c","7"),("d","-3")]]
testVarModifyDivMod05 = testVmod4 "testVarModifyDivMod05"
(getDTMod dmodXsdIntegerDivMod rdfDatatypeValXsdInteger)
[makeBVI [("c","-7"),("d","-3")]]
[makeBVI [("a","2"),("b","-1"),("c","-7"),("d","-3")]]
testVarModifyDivMod06 = testVmod4 "testVarModifyDivMod06"
(getDTMod dmodXsdIntegerDivMod rdfDatatypeValXsdInteger)
[makeBVI [("a","2"),("b","5"),("c","7"),("d","3")]]
[]
testVarModifyDivMod07 = testVmod4 "testVarModifyDivMod07"
(getDTMod dmodXsdIntegerDivMod rdfDatatypeValXsdInteger)
[makeBVI [("a","2"),("b","1"),("d","3")]]
[]
-- Tests for xsd_integer:power
testVarModifyPower01, testVarModifyPower02, testVarModifyPower03,
testVarModifyPower04, testVarModifyPower05,
testVarModifyPower06, testVarModifyPower07,
testVarModifyPower08 :: Test
testVarModifyPower01 = testVmod3 "testVarModifyPower01"
(getDTMod dmodXsdIntegerPower rdfDatatypeValXsdInteger)
[makeBVI [("a","8"),("b","2"),("c","3")]]
[makeBVI [("a","8"),("b","2"),("c","3")]]
testVarModifyPower02 = testVmod3 "testVarModifyPower02"
(getDTMod dmodXsdIntegerPower rdfDatatypeValXsdInteger)
[makeBVI [("b","2"),("c","3")]]
[makeBVI [("a","8"),("b","2"),("c","3")]]
testVarModifyPower03 = testVmod3 "testVarModifyPower03"
(getDTMod dmodXsdIntegerPower rdfDatatypeValXsdInteger)
[makeBVI [("a","8"),("c","3")]]
[]
testVarModifyPower04 = testVmod3 "testVarModifyPower04"
(getDTMod dmodXsdIntegerPower rdfDatatypeValXsdInteger)
[makeBVI [("a","8"),("b","2")]]
[]
testVarModifyPower05 = testVmod3 "testVarModifyPower05"
(getDTMod dmodXsdIntegerPower rdfDatatypeValXsdInteger)
[makeBVI [("a","8"),("b","3"),("c","2")]]
[]
testVarModifyPower06 = testVmod3 "testVarModifyPower06"
(getDTMod dmodXsdIntegerPower rdfDatatypeValXsdInteger)
[makeBVI [("b","55"),("c","0")]]
[makeBVI [("a","1"),("b","55"),("c","0")]]
testVarModifyPower07 = testVmod3 "testVarModifyPower07"
(getDTMod dmodXsdIntegerPower rdfDatatypeValXsdInteger)
[makeBVI [("b","-2"),("c","3")]]
[makeBVI [("a","-8"),("b","-2"),("c","3")]]
testVarModifyPower08 = testVmod3 "testVarModifyPower08"
(getDTMod dmodXsdIntegerPower rdfDatatypeValXsdInteger)
[makeBVI [("b","55"),("c","-2")]]
[]
-- Tests for xsd_integer:eq
testVarModifyEq01, testVarModifyEq02, testVarModifyEq03,
testVarModifyEq04, testVarModifyEq05 :: Test
testVarModifyEq01 = testVmod2 "testVarModifyEq01"
(getDTMod dmodXsdIntegerEq rdfDatatypeValXsdInteger)
[makeBVI [("a","100"),("b","100")]]
[makeBVI [("a","100"),("b","100")]]
testVarModifyEq02 = testVmod2 "testVarModifyEq02"
(getDTMod dmodXsdIntegerEq rdfDatatypeValXsdInteger)
[makeBVI [("a","99"),("b","100")]]
[]
testVarModifyEq03 = testVmod2 "testVarModifyEq03"
(getDTMod dmodXsdIntegerEq rdfDatatypeValXsdInteger)
[makeBVI [("a","-99"),("b","-100")]]
[]
testVarModifyEq04 = testVmod2 "testVarModifyEq04"
(getDTMod dmodXsdIntegerEq rdfDatatypeValXsdInteger)
[makeBVI [("b","100")]]
[]
testVarModifyEq05 = testVmod2 "testVarModifyEq05"
(getDTMod dmodXsdIntegerEq rdfDatatypeValXsdInteger)
[makeBVI [("a","100")]]
[]
-- Tests for xsd_integer:ne
testVarModifyNe01, testVarModifyNe02, testVarModifyNe03,
testVarModifyNe04, testVarModifyNe05 :: Test
testVarModifyNe01 = testVmod2 "testVarModifyNe01"
(getDTMod dmodXsdIntegerNe rdfDatatypeValXsdInteger)
[makeBVI [("a","100"),("b","100")]]
[]
testVarModifyNe02 = testVmod2 "testVarModifyNe02"
(getDTMod dmodXsdIntegerNe rdfDatatypeValXsdInteger)
[makeBVI [("a","99"),("b","100")]]
[makeBVI [("a","99"),("b","100")]]
testVarModifyNe03 = testVmod2 "testVarModifyNe03"
(getDTMod dmodXsdIntegerNe rdfDatatypeValXsdInteger)
[makeBVI [("a","-99"),("b","-100")]]
[makeBVI [("a","-99"),("b","-100")]]
testVarModifyNe04 = testVmod2 "testVarModifyNe04"
(getDTMod dmodXsdIntegerNe rdfDatatypeValXsdInteger)
[makeBVI [("b","100")]]
[]
testVarModifyNe05 = testVmod2 "testVarModifyNe05"
(getDTMod dmodXsdIntegerNe rdfDatatypeValXsdInteger)
[makeBVI [("a","100")]]
[]
-- Tests for xsd_integer:lt
testVarModifyLt01, testVarModifyLt02, testVarModifyLt03,
testVarModifyLt04, testVarModifyLt05 :: Test
testVarModifyLt01 = testVmod2 "testVarModifyLt01"
(getDTMod dmodXsdIntegerLt rdfDatatypeValXsdInteger)
[makeBVI [("a","100"),("b","100")]]
[]
testVarModifyLt02 = testVmod2 "testVarModifyLt02"
(getDTMod dmodXsdIntegerLt rdfDatatypeValXsdInteger)
[makeBVI [("a","99"),("b","100")]]
[makeBVI [("a","99"),("b","100")]]
testVarModifyLt03 = testVmod2 "testVarModifyLt03"
(getDTMod dmodXsdIntegerLt rdfDatatypeValXsdInteger)
[makeBVI [("a","-99"),("b","-100")]]
[]
testVarModifyLt04 = testVmod2 "testVarModifyLt04"
(getDTMod dmodXsdIntegerLt rdfDatatypeValXsdInteger)
[makeBVI [("b","100")]]
[]
testVarModifyLt05 = testVmod2 "testVarModifyLt05"
(getDTMod dmodXsdIntegerLt rdfDatatypeValXsdInteger)
[makeBVI [("a","100")]]
[]
-- Tests for xsd_integer:le
testVarModifyLe01, testVarModifyLe02, testVarModifyLe03,
testVarModifyLe04, testVarModifyLe05 :: Test
testVarModifyLe01 = testVmod2 "testVarModifyLe01"
(getDTMod dmodXsdIntegerLe rdfDatatypeValXsdInteger)
[makeBVI [("a","100"),("b","100")]]
[makeBVI [("a","100"),("b","100")]]
testVarModifyLe02 = testVmod2 "testVarModifyLe02"
(getDTMod dmodXsdIntegerLe rdfDatatypeValXsdInteger)
[makeBVI [("a","99"),("b","100")]]
[makeBVI [("a","99"),("b","100")]]
testVarModifyLe03 = testVmod2 "testVarModifyLe03"
(getDTMod dmodXsdIntegerLe rdfDatatypeValXsdInteger)
[makeBVI [("a","-99"),("b","-100")]]
[]
testVarModifyLe04 = testVmod2 "testVarModifyLe04"
(getDTMod dmodXsdIntegerLe rdfDatatypeValXsdInteger)
[makeBVI [("b","100")]]
[]
testVarModifyLe05 = testVmod2 "testVarModifyLe05"
(getDTMod dmodXsdIntegerLe rdfDatatypeValXsdInteger)
[makeBVI [("a","100")]]
[]
-- Tests for xsd_integer:gt
testVarModifyGt01, testVarModifyGt02, testVarModifyGt03,
testVarModifyGt04, testVarModifyGt05 :: Test
testVarModifyGt01 = testVmod2 "testVarModifyGt01"
(getDTMod dmodXsdIntegerGt rdfDatatypeValXsdInteger)
[makeBVI [("a","100"),("b","100")]]
[]
testVarModifyGt02 = testVmod2 "testVarModifyGt02"
(getDTMod dmodXsdIntegerGt rdfDatatypeValXsdInteger)
[makeBVI [("a","99"),("b","100")]]
[]
testVarModifyGt03 = testVmod2 "testVarModifyGt03"
(getDTMod dmodXsdIntegerGt rdfDatatypeValXsdInteger)
[makeBVI [("a","-99"),("b","-100")]]
[makeBVI [("a","-99"),("b","-100")]]
testVarModifyGt04 = testVmod2 "testVarModifyGt04"
(getDTMod dmodXsdIntegerGt rdfDatatypeValXsdInteger)
[makeBVI [("b","100")]]
[]
testVarModifyGt05 = testVmod2 "testVarModifyGt05"
(getDTMod dmodXsdIntegerGt rdfDatatypeValXsdInteger)
[makeBVI [("a","100")]]
[]
-- Tests for xsd_integer:ge
testVarModifyGe01, testVarModifyGe02, testVarModifyGe03,
testVarModifyGe04, testVarModifyGe05 :: Test
testVarModifyGe01 = testVmod2 "testVarModifyGe01"
(getDTMod dmodXsdIntegerGe rdfDatatypeValXsdInteger)
[makeBVI [("a","100"),("b","100")]]
[makeBVI [("a","100"),("b","100")]]
testVarModifyGe02 = testVmod2 "testVarModifyGe02"
(getDTMod dmodXsdIntegerGe rdfDatatypeValXsdInteger)
[makeBVI [("a","99"),("b","100")]]
[]
testVarModifyGe03 = testVmod2 "testVarModifyGe03"
(getDTMod dmodXsdIntegerGe rdfDatatypeValXsdInteger)
[makeBVI [("a","-99"),("b","-100")]]
[makeBVI [("a","-99"),("b","-100")]]
testVarModifyGe04 = testVmod2 "testVarModifyGe04"
(getDTMod dmodXsdIntegerGe rdfDatatypeValXsdInteger)
[makeBVI [("b","100")]]
[]
testVarModifyGe05 = testVmod2 "testVarModifyGe05"
(getDTMod dmodXsdIntegerGe rdfDatatypeValXsdInteger)
[makeBVI [("a","100")]]
[]
-- Full suite for variable binding modifier tests
testVarModifySuite :: Test
testVarModifySuite = TestList
[ testVarModify00
, testVarModifyAbs01, testVarModifyAbs02, testVarModifyAbs03
, testVarModifyAbs04, testVarModifyAbs05, testVarModifyAbs06
, testVarModifyAbs07, testVarModifyAbs08, testVarModifyAbs09
, testVarModifyAbs10
, testVarModifyNeg01, testVarModifyNeg02, testVarModifyNeg03
, testVarModifyNeg04, testVarModifyNeg05
, testVarModifySum01, testVarModifySum02, testVarModifySum03
, testVarModifySum04, testVarModifySum05
, testVarModifyDiff01, testVarModifyDiff02, testVarModifyDiff03
, testVarModifyDiff04, testVarModifyDiff05
, testVarModifyProd01, testVarModifyProd02, testVarModifyProd03
, testVarModifyProd04, testVarModifyProd05, testVarModifyProd06
, testVarModifyDivMod01, testVarModifyDivMod02, testVarModifyDivMod03
, testVarModifyDivMod04, testVarModifyDivMod05, testVarModifyDivMod06
, testVarModifyDivMod07
, testVarModifyPower01, testVarModifyPower02, testVarModifyPower03
, testVarModifyPower04, testVarModifyPower05, testVarModifyPower06
, testVarModifyPower07, testVarModifyPower08
, testVarModifyEq01, testVarModifyEq02, testVarModifyEq03
, testVarModifyEq04, testVarModifyEq05
, testVarModifyNe01, testVarModifyNe02, testVarModifyNe03
, testVarModifyNe04, testVarModifyNe05
, testVarModifyLt01, testVarModifyLt02, testVarModifyLt03
, testVarModifyLt04, testVarModifyLt05
, testVarModifyLe01, testVarModifyLe02, testVarModifyLe03
, testVarModifyLe04, testVarModifyLe05
, testVarModifyGt01, testVarModifyGt02, testVarModifyGt03
, testVarModifyGt04, testVarModifyGt05
, testVarModifyGe01, testVarModifyGe02, testVarModifyGe03
, testVarModifyGe04, testVarModifyGe05
]
------------------------------------------------------------
-- Test rules defined for datatype
------------------------------------------------------------
mkGraph :: String -> RDFGraph
mkGraph grstr = makeRDFGraphFromN3String (prefixXsdInteger++base++grstr)
where
base = "@prefix : <"++nsURI namespaceDefault++"> . \n"
testRuleFwd :: String -> Maybe (Rule RDFGraph) -> String -> [String] -> Test
testRuleFwd lab (Just rule) antstr constrs =
let
antgr = mkGraph antstr
congrs = map mkGraph constrs
in
testEqv lab congrs $ fwdApply rule [antgr]
testRuleFwd lab Nothing _ _ = TestCase $
assertFailure $ "testRuleFwd:"++lab++", null rule supplied"
testRuleBwd :: String -> Maybe (Rule RDFGraph) -> String -> [[String]] -> Test
testRuleBwd lab (Just rule) antstr prestrss =
let
antgr = mkGraph antstr
pregrss = map (map mkGraph) prestrss
in
testEqvEqv lab pregrss $ bwdApply rule antgr
testRuleBwd lab Nothing _ _ = TestCase $
assertFailure $ "testRuleBwd:"++lab++", null rule supplied"
testRuleChk :: String -> Maybe (Rule RDFGraph) -> String -> String -> Test
testRuleChk lab (Just rule) antstr constr =
let
antgr = mkGraph antstr
congr = mkGraph constr
in
test lab $ checkInference rule [antgr] congr
testRuleChk lab Nothing _ _ = TestCase $
assertFailure $ "testRuleChk:"++lab++", null rule supplied"
xsdIntRules :: Ruleset RDFGraph
xsdIntRules = typeRules rdfDatatypeXsdInteger
{-
axdt :: Maybe (Formula RDFGraph)
axdt = getRulesetAxiom axiomXsdIntegerDT xsdIntRules
-}
ruleabs, ruleneg, rulesum, rulediff, ruleprod,
ruledivmod, rulepower, ruleeq, rulene, rulelt, rulele,
rulegt, rulege :: Maybe (Rule RDFGraph)
ruleabs = getRulesetRule ruleXsdIntegerAbs xsdIntRules
ruleneg = getRulesetRule ruleXsdIntegerNeg xsdIntRules
rulesum = getRulesetRule ruleXsdIntegerSum xsdIntRules
rulediff = getRulesetRule ruleXsdIntegerDiff xsdIntRules
ruleprod = getRulesetRule ruleXsdIntegerProd xsdIntRules
ruledivmod = getRulesetRule ruleXsdIntegerDivMod xsdIntRules
rulepower = getRulesetRule ruleXsdIntegerPower xsdIntRules
ruleeq = getRulesetRule ruleXsdIntegerEq xsdIntRules
rulene = getRulesetRule ruleXsdIntegerNe xsdIntRules
rulelt = getRulesetRule ruleXsdIntegerLt xsdIntRules
rulele = getRulesetRule ruleXsdIntegerLe xsdIntRules
rulegt = getRulesetRule ruleXsdIntegerGt xsdIntRules
rulege = getRulesetRule ruleXsdIntegerGe xsdIntRules
-- Test cases for the arithmetic functions
-- abs
abs01inp :: String
abs01inp =
"_:a a xsd_integer:Abs ; "
+++ " rdf:_2 \"1\"^^xsd:integer . "
abs01fwd :: [String]
abs01fwd =
[ "_:a rdf:_1 \"1\"^^xsd:integer . " ]
abs01bwd :: [[String]]
abs01bwd = []
abs02inp :: String
abs02inp =
"_:a a xsd_integer:Abs ; "
+++ " rdf:_2 \"-1\"^^xsd:integer . "
abs02fwd :: [String]
abs02fwd =
[ "_:a rdf:_1 \"1\"^^xsd:integer . " ]
abs02bwd :: [[String]]
abs02bwd =
[]
abs03inp :: String
abs03inp =
"_:a a xsd_integer:Abs ; "
+++ " rdf:_1 \"1\"^^xsd:integer . "
abs03fwd :: [String]
abs03fwd = []
abs03bwd :: [[String]]
abs03bwd =
[ [ "_:a a xsd_integer:Abs . "
, "_:a rdf:_2 \"1\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Abs . "
, "_:a rdf:_2 \"-1\"^^xsd:integer . "
]
]
abs04inp :: String
abs04inp =
"_:a a xsd_integer:Abs ; "
+++ " rdf:_1 \"-1\"^^xsd:integer . "
abs04fwd :: [String]
abs04fwd =
[ falseGraphStr
]
abs04bwd :: [[String]]
abs04bwd =
[ [ falseGraphStr
]
]
-- neg
neg01inp :: String
neg01inp =
"_:a a xsd_integer:Neg ; "
+++ " rdf:_2 \"1\"^^xsd:integer . "
neg01fwd :: [String]
neg01fwd =
[ "_:a rdf:_1 \"-1\"^^xsd:integer . " ]
neg01bwd :: [[String]]
neg01bwd =
[ [ "_:a a xsd_integer:Neg . "
, "_:a rdf:_1 \"-1\"^^xsd:integer . "
]
]
neg02inp :: String
neg02inp =
"_:a a xsd_integer:Neg ; "
+++ " rdf:_2 \"-2\"^^xsd:integer . "
neg02fwd :: [String]
neg02fwd =
[ "_:a rdf:_1 \"2\"^^xsd:integer . " ]
neg02bwd :: [[String]]
neg02bwd =
[ [ "_:a a xsd_integer:Neg . "
, "_:a rdf:_1 \"2\"^^xsd:integer . "
]
]
-- sum
sum01inp :: String
sum01inp =
"_:a a xsd_integer:Sum ; "
+++ " rdf:_2 \"31\"^^xsd:integer ; "
+++ " rdf:_3 \"20\"^^xsd:integer . "
sum01fwd :: [String]
sum01fwd =
[ "_:a rdf:_1 \"51\"^^xsd:integer . " ]
sum01bwd :: [[String]]
sum01bwd =
[ [ "_:a a xsd_integer:Sum . "
, "_:a rdf:_1 \"51\"^^xsd:integer . "
, "_:a rdf:_2 \"31\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Sum . "
, "_:a rdf:_1 \"51\"^^xsd:integer . "
, "_:a rdf:_3 \"20\"^^xsd:integer . "
]
]
sum02inp :: String
sum02inp =
"_:a a xsd_integer:Sum ; "
+++ " rdf:_1 \"52\"^^xsd:integer ; "
+++ " rdf:_3 \"21\"^^xsd:integer . "
sum02fwd :: [String]
sum02fwd =
[ "_:a rdf:_2 \"31\"^^xsd:integer . " ]
sum02bwd :: [[String]]
sum02bwd =
[ [ "_:a a xsd_integer:Sum . "
, "_:a rdf:_1 \"52\"^^xsd:integer . "
, "_:a rdf:_2 \"31\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Sum . "
, "_:a rdf:_2 \"31\"^^xsd:integer . "
, "_:a rdf:_3 \"21\"^^xsd:integer . "
]
]
sum03inp :: String
sum03inp =
"_:a a xsd_integer:Sum ; "
+++ " rdf:_1 \"53\"^^xsd:integer ; "
+++ " rdf:_2 \"32\"^^xsd:integer . "
sum03fwd :: [String]
sum03fwd =
[ "_:a rdf:_3 \"21\"^^xsd:integer . " ]
sum03bwd :: [[String]]
sum03bwd =
[ [ "_:a a xsd_integer:Sum . "
, "_:a rdf:_1 \"53\"^^xsd:integer . "
, "_:a rdf:_3 \"21\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Sum . "
, "_:a rdf:_2 \"32\"^^xsd:integer . "
, "_:a rdf:_3 \"21\"^^xsd:integer . "
]
]
-- diff
diff01inp :: String
diff01inp =
"_:a a xsd_integer:Diff ; "
+++ " rdf:_2 \"222\"^^xsd:integer ; "
+++ " rdf:_3 \"333\"^^xsd:integer . "
diff01fwd :: [String]
diff01fwd =
[ "_:a rdf:_1 \"-111\"^^xsd:integer . " ]
diff01bwd :: [[String]]
diff01bwd =
[ [ "_:a a xsd_integer:Diff . "
, "_:a rdf:_1 \"-111\"^^xsd:integer . "
, "_:a rdf:_2 \"222\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Diff . "
, "_:a rdf:_1 \"-111\"^^xsd:integer . "
, "_:a rdf:_3 \"333\"^^xsd:integer . "
]
]
diff02inp :: String
diff02inp =
"_:a a xsd_integer:Diff ; "
+++ " rdf:_1 \"-111\"^^xsd:integer ; "
+++ " rdf:_3 \"333\"^^xsd:integer . "
diff02fwd :: [String]
diff02fwd =
[ "_:a rdf:_2 \"222\"^^xsd:integer . " ]
diff02bwd :: [[String]]
diff02bwd =
[ [ "_:a a xsd_integer:Diff . "
, "_:a rdf:_1 \"-111\"^^xsd:integer . "
, "_:a rdf:_2 \"222\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Diff . "
, "_:a rdf:_2 \"222\"^^xsd:integer . "
, "_:a rdf:_3 \"333\"^^xsd:integer . "
]
]
diff03inp :: String
diff03inp =
"_:a a xsd_integer:Diff ; "
+++ " rdf:_1 \"-111\"^^xsd:integer ; "
+++ " rdf:_2 \"222\"^^xsd:integer . "
diff03fwd :: [String]
diff03fwd =
[ "_:a rdf:_3 \"333\"^^xsd:integer . " ]
diff03bwd :: [[String]]
diff03bwd =
[ [ "_:a a xsd_integer:Diff . "
, "_:a rdf:_1 \"-111\"^^xsd:integer . "
, "_:a rdf:_3 \"333\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Diff . "
, "_:a rdf:_2 \"222\"^^xsd:integer . "
, "_:a rdf:_3 \"333\"^^xsd:integer . "
]
]
-- prod
prod01inp :: String
prod01inp =
"_:a a xsd_integer:Prod ; "
+++ " rdf:_2 \"222\"^^xsd:integer ; "
+++ " rdf:_3 \"3\"^^xsd:integer . "
prod01fwd :: [String]
prod01fwd =
[ "_:a rdf:_1 \"666\"^^xsd:integer . " ]
prod01bwd :: [[String]]
prod01bwd =
[ [ "_:a a xsd_integer:Prod . "
, "_:a rdf:_1 \"666\"^^xsd:integer . "
, "_:a rdf:_2 \"222\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Prod . "
, "_:a rdf:_1 \"666\"^^xsd:integer . "
, "_:a rdf:_3 \"3\"^^xsd:integer . "
]
]
prod02inp :: String
prod02inp =
"_:a a xsd_integer:Prod ; "
+++ " rdf:_1 \"666\"^^xsd:integer ; "
+++ " rdf:_3 \"3\"^^xsd:integer . "
prod02fwd :: [String]
prod02fwd =
[ "_:a rdf:_2 \"222\"^^xsd:integer . " ]
prod02bwd :: [[String]]
prod02bwd =
[ [ "_:a a xsd_integer:Prod . "
, "_:a rdf:_1 \"666\"^^xsd:integer . "
, "_:a rdf:_2 \"222\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Prod . "
, "_:a rdf:_2 \"222\"^^xsd:integer . "
, "_:a rdf:_3 \"3\"^^xsd:integer . "
]
]
prod03inp :: String
prod03inp =
"_:a a xsd_integer:Prod ; "
+++ " rdf:_1 \"666\"^^xsd:integer ; "
+++ " rdf:_2 \"222\"^^xsd:integer . "
prod03fwd :: [String]
prod03fwd =
[ "_:a rdf:_3 \"3\"^^xsd:integer . " ]
prod03bwd :: [[String]]
prod03bwd =
[ [ "_:a a xsd_integer:Prod . "
, "_:a rdf:_1 \"666\"^^xsd:integer . "
, "_:a rdf:_3 \"3\"^^xsd:integer . "
]
, [ "_:a a xsd_integer:Prod . "
, "_:a rdf:_2 \"222\"^^xsd:integer . "
, "_:a rdf:_3 \"3\"^^xsd:integer . "
]
]
-- divmod
divmod01inp :: String
divmod01inp =
"_:a a xsd_integer:DivMod ; "
+++ " rdf:_3 \"33\"^^xsd:integer ; "
+++ " rdf:_4 \"5\"^^xsd:integer . "
divmod01fwd :: [String]
divmod01fwd =
[ "_:a rdf:_1 \"6\"^^xsd:integer . "
+++ "_:a rdf:_2 \"3\"^^xsd:integer . "
]
divmod01bwd :: [[String]]
divmod01bwd =
[ {- "_:a a xsd_integer:DivMod . "
, "_:a rdf:_1 \"6\"^^xsd:integer . "
, "_:a rdf:_2 \"3\"^^xsd:integer . "
, "_:a rdf:_4 \"5\"^^xsd:integer . "
-}
]
divmod02inp :: String
divmod02inp =
"_:a a xsd_integer:DivMod ; "
+++ " rdf:_1 \"6\"^^xsd:integer ; "
+++ " rdf:_2 \"3\"^^xsd:integer ; "
+++ " rdf:_4 \"5\"^^xsd:integer . "
divmod02fwd :: [String]
divmod02fwd =
[ ]
divmod02bwd :: [[String]]
divmod02bwd =
[ {- "_:a a xsd_integer:DivMod . "
, "_:a rdf:_3 \"33\"^^xsd:integer . "
, "_:a rdf:_4 \"5\"^^xsd:integer . "
-}
]
divmod03inp :: String
divmod03inp =
"_:a a xsd_integer:DivMod ; "
+++ " rdf:_3 \"-33\"^^xsd:integer ; "
+++ " rdf:_4 \"5\"^^xsd:integer . "
divmod03fwd :: [String]
divmod03fwd =
[ "_:a rdf:_1 \"-7\"^^xsd:integer . "
+++ "_:a rdf:_2 \"2\"^^xsd:integer . "
]
divmod03bwd :: [[String]]
divmod03bwd =
[ ]
-- power
power01inp :: String
power01inp =
"_:a a xsd_integer:Power ; "
+++ " rdf:_2 \"2\"^^xsd:integer ; "
+++ " rdf:_3 \"5\"^^xsd:integer . "
power01fwd :: [String]
power01fwd =
[ "_:a rdf:_1 \"32\"^^xsd:integer . " ]
power01bwd :: [[String]]
power01bwd =
[ ]
power02inp :: String
power02inp =
"_:a a xsd_integer:Power ; "
+++ " rdf:_2 \"111\"^^xsd:integer ; "
+++ " rdf:_3 \"0\"^^xsd:integer . "
power02fwd :: [String]
power02fwd =
[ "_:a rdf:_1 \"1\"^^xsd:integer . " ]
power02bwd :: [[String]]
power02bwd =
[ ]
power03inp :: String
power03inp =
"_:a a xsd_integer:Power ; "
+++ " rdf:_2 \"22\"^^xsd:integer ; "
+++ " rdf:_3 \"-33\"^^xsd:integer . "
power03fwd :: [String]
power03fwd =
[ falseGraphStr ]
power03bwd :: [[String]]
power03bwd =
[ [ falseGraphStr ]
]
-- eq
eq01inp :: String
eq01inp =
"_:a a xsd_integer:Eq ; "
+++ " rdf:_1 \"11\"^^xsd:integer ; "
+++ " rdf:_2 \"11\"^^xsd:integer . "
eq01fwd :: [String]
eq01fwd = [ ]
eq01bwd :: [[String]]
eq01bwd = [ ]
eq02inp :: String
eq02inp =
"_:a a xsd_integer:Eq ; "
+++ " rdf:_1 \"21\"^^xsd:integer ; "
+++ " rdf:_2 \"22\"^^xsd:integer . "
eq02fwd :: [String]
eq02fwd = [ falseGraphStr ]
eq02bwd :: [[String]]
eq02bwd = [ [falseGraphStr] ]
eq03inp :: String
eq03inp =
"_:a a xsd_integer:Eq ; "
+++ " rdf:_1 \"31\"^^xsd:integer ; "
+++ " rdf:_2 \"-32\"^^xsd:integer . "
eq03fwd :: [String]
eq03fwd = [ falseGraphStr ]
eq03bwd :: [[String]]
eq03bwd = [ [falseGraphStr] ]
-- ne
ne01inp :: String
ne01inp =
"_:a a xsd_integer:Ne ; "
+++ " rdf:_1 \"11\"^^xsd:integer ; "
+++ " rdf:_2 \"11\"^^xsd:integer . "
ne01fwd :: [String]
ne01fwd = [ falseGraphStr ]
ne01bwd :: [[String]]
ne01bwd = [ [falseGraphStr] ]
ne02inp :: String
ne02inp =
"_:a a xsd_integer:Ne ; "
+++ " rdf:_1 \"21\"^^xsd:integer ; "
+++ " rdf:_2 \"22\"^^xsd:integer . "
ne02fwd :: [String]
ne02fwd = [ ]
ne02bwd :: [[String]]
ne02bwd = [ ]
ne03inp :: String
ne03inp =
"_:a a xsd_integer:Ne ; "
+++ " rdf:_1 \"31\"^^xsd:integer ; "
+++ " rdf:_2 \"-32\"^^xsd:integer . "
ne03fwd :: [String]
ne03fwd = [ ]
ne03bwd :: [[String]]
ne03bwd = [ ]
-- lt
lt01inp :: String
lt01inp =
"_:a a xsd_integer:Lt ; "
+++ " rdf:_1 \"11\"^^xsd:integer ; "
+++ " rdf:_2 \"11\"^^xsd:integer . "
lt01fwd :: [String]
lt01fwd = [ falseGraphStr ]
lt01bwd :: [[String]]
lt01bwd = [ [falseGraphStr] ]
lt02inp :: String
lt02inp =
"_:a a xsd_integer:Lt ; "
+++ " rdf:_1 \"21\"^^xsd:integer ; "
+++ " rdf:_2 \"22\"^^xsd:integer . "
lt02fwd :: [String]
lt02fwd = [ ]
lt02bwd :: [[String]]
lt02bwd = [ ]
lt03inp :: String
lt03inp =
"_:a a xsd_integer:Lt ; "
+++ " rdf:_1 \"31\"^^xsd:integer ; "
+++ " rdf:_2 \"-32\"^^xsd:integer . "
lt03fwd :: [String]
lt03fwd = [ falseGraphStr ]
lt03bwd :: [[String]]
lt03bwd = [ [falseGraphStr] ]
-- le
le01inp :: String
le01inp =
"_:a a xsd_integer:Le ; "
+++ " rdf:_1 \"11\"^^xsd:integer ; "
+++ " rdf:_2 \"11\"^^xsd:integer . "
le01fwd :: [String]
le01fwd = [ ]
le01bwd :: [[String]]
le01bwd = [ ]
le02inp :: String
le02inp =
"_:a a xsd_integer:Le ; "
+++ " rdf:_1 \"21\"^^xsd:integer ; "
+++ " rdf:_2 \"22\"^^xsd:integer . "
le02fwd :: [String]
le02fwd = [ ]
le02bwd :: [[String]]
le02bwd = [ ]
le03inp :: String
le03inp =
"_:a a xsd_integer:Le ; "
+++ " rdf:_1 \"31\"^^xsd:integer ; "
+++ " rdf:_2 \"-32\"^^xsd:integer . "
le03fwd :: [String]
le03fwd = [ falseGraphStr ]
le03bwd :: [[String]]
le03bwd = [ [falseGraphStr] ]
-- gt
gt01inp :: String
gt01inp =
"_:a a xsd_integer:Gt ; "
+++ " rdf:_1 \"11\"^^xsd:integer ; "
+++ " rdf:_2 \"11\"^^xsd:integer . "
gt01fwd :: [String]
gt01fwd = [ falseGraphStr ]
gt01bwd :: [[String]]
gt01bwd = [ [falseGraphStr] ]
gt02inp :: String
gt02inp =
"_:a a xsd_integer:Gt ; "
+++ " rdf:_1 \"21\"^^xsd:integer ; "
+++ " rdf:_2 \"22\"^^xsd:integer . "
gt02fwd :: [String]
gt02fwd = [ falseGraphStr ]
gt02bwd :: [[String]]
gt02bwd = [ [falseGraphStr] ]
gt03inp :: String
gt03inp =
"_:a a xsd_integer:Gt ; "
+++ " rdf:_1 \"31\"^^xsd:integer ; "
+++ " rdf:_2 \"-32\"^^xsd:integer . "
gt03fwd :: [String]
gt03fwd = [ ]
gt03bwd :: [[String]]
gt03bwd = [ ]
-- ge
ge01inp :: String
ge01inp =
"_:a a xsd_integer:Ge ; "
+++ " rdf:_1 \"11\"^^xsd:integer ; "
+++ " rdf:_2 \"11\"^^xsd:integer . "
ge01fwd :: [String]
ge01fwd = [ ]
ge01bwd :: [[String]]
ge01bwd = [ ]
ge02inp :: String
ge02inp =
"_:a a xsd_integer:Ge ; "
+++ " rdf:_1 \"21\"^^xsd:integer ; "
+++ " rdf:_2 \"22\"^^xsd:integer . "
ge02fwd :: [String]
ge02fwd = [ falseGraphStr ]
ge02bwd :: [[String]]
ge02bwd = [ [falseGraphStr] ]
ge03inp :: String
ge03inp =
"_:a a xsd_integer:Ge ; "
+++ " rdf:_1 \"31\"^^xsd:integer ; "
+++ " rdf:_2 \"-32\"^^xsd:integer . "
ge03fwd :: [String]
ge03fwd = [ ]
ge03bwd :: [[String]]
ge03bwd = [ ]
-- Test cases from design notes
infixr 5 +++
(+++) :: String -> ShowS
(+++) str = ((str++"\n")++)
-- Make a vector of rules using the graph string below
pvRules :: [RDFRule]
-- pvRules = makeRDFDatatypeRestrictionRules rdfDatatypeValXsdInteger gr
pvRules = typeMkRules rdfDatatypeXsdInteger gr
where
gr = (mkGraph pvRulesStr)
pvRulesStr :: String
pvRulesStr =
":PassengerVehicle a rdfd:GeneralRestriction ; "
+++ " rdfd:onProperties (:totalCapacity :seatedCapacity :standingCapacity) ; "
+++ " rdfd:constraint xsd_integer:sum . "
+++ ":PassengerVehicle1 a rdfd:GeneralRestriction ; "
+++ " rdfd:onProperties (:totalCapacity :seatedCapacity :standingCapacity) ; "
+++ " rdfd:constraint xsd_integer:sum ; "
+++ " rdfd:maxCardinality \"1\"^^xsd:nonNegativeInteger . "
-- Now the test cases that use the rules created above.
pvRule0, pvRule1 :: Maybe (Rule RDFGraph)
pvRule0 = mapFindMaybe
(ScopedName namespaceDefault "PassengerVehicle")
(LookupMap pvRules)
pvRule1 = mapFindMaybe
(ScopedName namespaceDefault "PassengerVehicle1")
(LookupMap pvRules)
pv01inp :: String
pv01inp =
"_:a a :PassengerVehicle ; "
+++ " :seatedCapacity \"30\"^^xsd:integer ; "
+++ " :standingCapacity \"20\"^^xsd:integer . "
pv01fwd :: [String]
pv01fwd =
[ "_:a :totalCapacity \"50\"^^xsd:integer . " ]
pv01bwd :: [[String]]
pv01bwd =
[ [ "_:a a :PassengerVehicle . "
, "_:a :totalCapacity \"50\"^^xsd:integer . "
, "_:a :seatedCapacity \"30\"^^xsd:integer . "
]
, [ "_:a a :PassengerVehicle . "
, "_:a :totalCapacity \"50\"^^xsd:integer . "
, "_:a :standingCapacity \"20\"^^xsd:integer . "
]
]
pv02inp :: String
pv02inp =
"_:a a :PassengerVehicle ; "
+++ " :seatedCapacity \"30\"^^xsd:integer ; "
+++ " :totalCapacity \"51\"^^xsd:integer . "
+++ "_:b a :PassengerVehicle ; "
+++ " :standingCapacity \"20\"^^xsd:integer ; "
+++ " :totalCapacity \"52\"^^xsd:integer . "
pv02fwd :: [String]
pv02fwd =
[ "_:a :standingCapacity \"21\"^^xsd:integer . "
, "_:b :seatedCapacity \"32\"^^xsd:integer . "
]
pv02bwd :: [[String]]
pv02bwd =
[ [ "_:a a :PassengerVehicle . "
, "_:a :standingCapacity \"21\"^^xsd:integer . "
, "_:a :totalCapacity \"51\"^^xsd:integer . "
, "_:b a :PassengerVehicle . "
, "_:b :seatedCapacity \"32\"^^xsd:integer . "
, "_:b :totalCapacity \"52\"^^xsd:integer . "
]
, [ "_:a a :PassengerVehicle . "
, "_:a :seatedCapacity \"30\"^^xsd:integer . "
, "_:a :standingCapacity \"21\"^^xsd:integer . "
, "_:b a :PassengerVehicle . "
, "_:b :seatedCapacity \"32\"^^xsd:integer . "
, "_:b :totalCapacity \"52\"^^xsd:integer . "
]
, [ "_:a a :PassengerVehicle . "
, "_:a :standingCapacity \"21\"^^xsd:integer . "
, "_:a :totalCapacity \"51\"^^xsd:integer . "
, "_:b a :PassengerVehicle . "
, "_:b :seatedCapacity \"32\"^^xsd:integer . "
, "_:b :standingCapacity \"20\"^^xsd:integer . "
]
, [ "_:a a :PassengerVehicle . "
, "_:a :seatedCapacity \"30\"^^xsd:integer . "
, "_:a :standingCapacity \"21\"^^xsd:integer . "
, "_:b a :PassengerVehicle . "
, "_:b :seatedCapacity \"32\"^^xsd:integer . "
, "_:b :standingCapacity \"20\"^^xsd:integer . "
]
]
pv03inp :: String
pv03inp =
"_:a a :PassengerVehicle ; "
+++ " :seatedCapacity \"30\"^^xsd:integer ; "
+++ " :standingCapacity \"23\"^^xsd:integer ; "
+++ " :totalCapacity \"53\"^^xsd:integer . "
pv03fwd :: [String]
pv03fwd = []
pv04inp :: String
pv04inp =
"_:a a :PassengerVehicle ; "
+++ " :seatedCapacity \"30\"^^xsd:integer ; "
+++ " :standingCapacity \"20\"^^xsd:integer ; "
+++ " :totalCapacity \"54\"^^xsd:integer . "
pv04fwd :: [String]
pv04fwd =
[ "_:a :standingCapacity \"24\"^^xsd:integer . "
+++ "_:a :seatedCapacity \"34\"^^xsd:integer . "
+++ "_:a :totalCapacity \"50\"^^xsd:integer . "
]
pv05inp :: String
pv05inp =
"_:a a :PassengerVehicle1 ; "
+++ " :seatedCapacity \"30\"^^xsd:integer ; "
+++ " :standingCapacity \"25\"^^xsd:integer ; "
+++ " :totalCapacity \"55\"^^xsd:integer . "
pv05fwd :: [String]
pv05fwd = []
pv06inp :: String
pv06inp =
"_:a a :PassengerVehicle1 ; "
+++ " :seatedCapacity \"30\"^^xsd:integer ; "
+++ " :standingCapacity \"20\"^^xsd:integer ; "
+++ " :totalCapacity \"56\"^^xsd:integer . "
pv06fwd :: [String]
pv06fwd =
[ falseGraphStr
]
pv06bwd :: [[String]]
pv06bwd =
[ [ falseGraphStr
]
]
pv07inp :: String
pv07inp =
"_:a a :PassengerVehicle ; "
+++ " :totalCapacity \"57\"^^xsd:integer . "
pv07fwd :: [String]
pv07fwd = []
-- how come this isn't [[String]] ?
pv07bwd :: [String]
pv07bwd = []
-- Full suite for datatype rule tests
testDatatypeRuleSuite :: Test
testDatatypeRuleSuite = TestList
[ testRuleFwd "testRuleFwdAbs01" ruleabs abs01inp abs01fwd
, testRuleFwd "testRuleFwdAbs02" ruleabs abs02inp abs02fwd
, testRuleFwd "testRuleFwdAbs03" ruleabs abs03inp abs03fwd
, testRuleFwd "testRuleFwdAbs04" ruleabs abs04inp abs04fwd
, testRuleFwd "testRuleFwdNeg01" ruleneg neg01inp neg01fwd
, testRuleFwd "testRuleFwdNeg02" ruleneg neg02inp neg02fwd
, testRuleFwd "testRuleFwdSum01" rulesum sum01inp sum01fwd
, testRuleFwd "testRuleFwdSum02" rulesum sum02inp sum02fwd
, testRuleFwd "testRuleFwdSum03" rulesum sum03inp sum03fwd
, testRuleFwd "testRuleFwdDiff01" rulediff diff01inp diff01fwd
, testRuleFwd "testRuleFwdDiff02" rulediff diff02inp diff02fwd
, testRuleFwd "testRuleFwdDiff03" rulediff diff03inp diff03fwd
, testRuleFwd "testRuleFwdProd01" ruleprod prod01inp prod01fwd
, testRuleFwd "testRuleFwdProd02" ruleprod prod02inp prod02fwd
, testRuleFwd "testRuleFwdProd03" ruleprod prod03inp prod03fwd
, testRuleFwd "testRuleFwdDivMod01" ruledivmod divmod01inp divmod01fwd
, testRuleFwd "testRuleFwdDivMod02" ruledivmod divmod02inp divmod02fwd
, testRuleFwd "testRuleFwdDivMod03" ruledivmod divmod03inp divmod03fwd
, testRuleFwd "testRuleFwdPower01" rulepower power01inp power01fwd
, testRuleFwd "testRuleFwdPower02" rulepower power02inp power02fwd
, testRuleFwd "testRuleFwdPower03" rulepower power03inp power03fwd
, testRuleFwd "testRuleFwdEq01" ruleeq eq01inp eq01fwd
, testRuleFwd "testRuleFwdEq02" ruleeq eq02inp eq02fwd
, testRuleFwd "testRuleFwdEq03" ruleeq eq03inp eq03fwd
, testRuleFwd "testRuleFwdNe01" rulene ne01inp ne01fwd
, testRuleFwd "testRuleFwdNe02" rulene ne02inp ne02fwd
, testRuleFwd "testRuleFwdNe03" rulene ne03inp ne03fwd
, testRuleFwd "testRuleFwdLt01" rulelt lt01inp lt01fwd
, testRuleFwd "testRuleFwdLt02" rulelt lt02inp lt02fwd
, testRuleFwd "testRuleFwdLt03" rulelt lt03inp lt03fwd
, testRuleFwd "testRuleFwdLe01" rulele le01inp le01fwd
, testRuleFwd "testRuleFwdLe02" rulele le02inp le02fwd
, testRuleFwd "testRuleFwdLe03" rulele le03inp le03fwd
, testRuleFwd "testRuleFwdGt01" rulegt gt01inp gt01fwd
, testRuleFwd "testRuleFwdGt02" rulegt gt02inp gt02fwd
, testRuleFwd "testRuleFwdGt03" rulegt gt03inp gt03fwd
, testRuleFwd "testRuleFwdGe01" rulege ge01inp ge01fwd
, testRuleFwd "testRuleFwdGe02" rulege ge02inp ge02fwd
, testRuleFwd "testRuleFwdGe03" rulege ge03inp ge03fwd
-- backard chaining tests
, testRuleBwd "testRuleBwdAbs01" ruleabs abs01inp abs01bwd
, testRuleBwd "testRuleBwdAbs02" ruleabs abs02inp abs02bwd
, testRuleBwd "testRuleBwdAbs03" ruleabs abs03inp abs03bwd
, testRuleBwd "testRuleBwdAbs04" ruleabs abs04inp abs04bwd
, testRuleBwd "testRuleBwdNeg01" ruleneg neg01inp neg01bwd
, testRuleBwd "testRuleBwdNeg02" ruleneg neg02inp neg02bwd
, testRuleBwd "testRuleBwdSum01" rulesum sum01inp sum01bwd
, testRuleBwd "testRuleBwdSum02" rulesum sum02inp sum02bwd
, testRuleBwd "testRuleBwdSum03" rulesum sum03inp sum03bwd
, testRuleBwd "testRuleBwdDiff01" rulediff diff01inp diff01bwd
, testRuleBwd "testRuleBwdDiff02" rulediff diff02inp diff02bwd
, testRuleBwd "testRuleBwdDiff03" rulediff diff03inp diff03bwd
, testRuleBwd "testRuleBwdProd01" ruleprod prod01inp prod01bwd
, testRuleBwd "testRuleBwdProd02" ruleprod prod02inp prod02bwd
, testRuleBwd "testRuleBwdProd03" ruleprod prod03inp prod03bwd
, testRuleBwd "testRuleBwdDivMod01" ruledivmod divmod01inp divmod01bwd
, testRuleBwd "testRuleBwdDivMod02" ruledivmod divmod02inp divmod02bwd
, testRuleBwd "testRuleBwdDivMod03" ruledivmod divmod03inp divmod03bwd
, testRuleBwd "testRuleBwdPower01" rulepower power01inp power01bwd
, testRuleBwd "testRuleBwdPower02" rulepower power02inp power02bwd
, testRuleBwd "testRuleBwdPower03" rulepower power03inp power03bwd
, testRuleBwd "testRuleBwdEq01" ruleeq eq01inp eq01bwd
, testRuleBwd "testRuleBwdEq02" ruleeq eq02inp eq02bwd
, testRuleBwd "testRuleBwdEq03" ruleeq eq03inp eq03bwd
, testRuleBwd "testRuleBwdNe01" rulene ne01inp ne01bwd
, testRuleBwd "testRuleBwdNe02" rulene ne02inp ne02bwd
, testRuleBwd "testRuleBwdNe03" rulene ne03inp ne03bwd
, testRuleBwd "testRuleBwdLt01" rulelt lt01inp lt01bwd
, testRuleBwd "testRuleBwdLt02" rulelt lt02inp lt02bwd
, testRuleBwd "testRuleBwdLt03" rulelt lt03inp lt03bwd
, testRuleBwd "testRuleBwdLe01" rulele le01inp le01bwd
, testRuleBwd "testRuleBwdLe02" rulele le02inp le02bwd
, testRuleBwd "testRuleBwdLe03" rulele le03inp le03bwd
, testRuleBwd "testRuleBwdGt01" rulegt gt01inp gt01bwd
, testRuleBwd "testRuleBwdGt02" rulegt gt02inp gt02bwd
, testRuleBwd "testRuleBwdGt03" rulegt gt03inp gt03bwd
, testRuleBwd "testRuleBwdGe01" rulege ge01inp ge01bwd
, testRuleBwd "testRuleBwdGe02" rulege ge02inp ge02bwd
, testRuleBwd "testRuleBwdGe03" rulege ge03inp ge03bwd
-- test cases from design notes
, testRuleFwd "testRuleFwdPv01" pvRule0 pv01inp pv01fwd
, testRuleFwd "testRuleFwdPv02" pvRule0 pv02inp pv02fwd
, testRuleFwd "testRuleFwdPv03" pvRule0 pv03inp pv03fwd
, testRuleFwd "testRuleFwdPv04" pvRule0 pv04inp pv04fwd
, testRuleFwd "testRuleFwdPv05" pvRule1 pv05inp pv05fwd
, testRuleFwd "testRuleFwdPv06" pvRule1 pv06inp pv06fwd
, testRuleFwd "testRuleFwdPv07" pvRule0 pv07inp pv07fwd
, testRuleBwd "testRuleBwdPv01" pvRule0 pv01inp pv01bwd
, testRuleBwd "testRuleBwdPv02" pvRule0 pv02inp pv02bwd
, testRuleBwd "testRuleBwdPv06" pvRule1 pv06inp pv06bwd
, testRuleFwd "testRuleBwdPv07" pvRule0 pv07inp pv07bwd
]
------------------------------------------------------------
-- All tests
------------------------------------------------------------
allTests :: Test
allTests = TestList
[ testDatatypeSuite
, testDatatypeValSuite
, testVarModifySuite
, testDatatypeRuleSuite
]
main :: IO ()
main = runTestTT allTests >> return ()
{-
trules = runTestTT testDatatypeRuleSuite
runTestFile t = do
h <- openFile "a.tmp" WriteMode
runTestText (putTextToHandle h False) t
hClose h
tf = runTestFile
tt = runTestTT
-}
--------------------------------------------------------------------------------
--
-- Copyright (c) 2003, Graham Klyne, 2009 Vasili I Galchin, 2011 Douglas Burke
-- All rights reserved.
--
-- This file is part of Swish.
--
-- Swish is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 2 of the License, or
-- (at your option) any later version.
--
-- Swish is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with Swish; if not, write to:
-- The Free Software Foundation, Inc.,
-- 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
--
--------------------------------------------------------------------------------