-------------------------------------------------------------------------------- -- $Id: RDFGraphTest.hs,v 1.32 2004/01/07 19:49:13 graham Exp $ -- -- Copyright (c) 2003, G. KLYNE. All rights reserved. -- See end of this file for licence information. -------------------------------------------------------------------------------- -- | -- Module : RDFGraphTest -- Copyright : (c) 2003, Graham Klyne -- License : GPL V2 -- -- Maintainer : Graham Klyne -- Stability : provisional -- Portability : H98 -- -- This module contains test cases for module RDFGraph. -- -------------------------------------------------------------------------------- -- WNH RIP OUT module Swish.HaskellRDF.RDFGraphTest where import Swish.HaskellUtils.FunctorM ( FunctorM(..) ) import Swish.HaskellUtils.LookupMap ( LookupMap(..) , mapFind, mapFindMaybe, mapContains ) import Swish.HaskellUtils.ListHelpers ( equiv ) import Swish.HaskellRDF.GraphClass ( Label(..), Arc, arcSubj, arcPred, arcObj, arc ) import Swish.HaskellUtils.Namespace ( Namespace(..) , ScopedName(..) , makeQNameScopedName , nullScopedName , makeUriScopedName ) import Swish.HaskellUtils.QName ( QName(..) , newQName, qnameFromPair, qnameFromURI , getNamespace, getLocalName, getQNameURI , splitURI ) import Swish.HaskellRDF.RDFGraph ( RDFTriple, RDFGraph, RDFLabel(..), NSGraph(..) , isLiteral, isUntypedLiteral, isTypedLiteral, isXMLLiteral , isDatatyped, isMemberProp , isUri, isBlank, isQueryVar, makeBlank , getScopedName -- , LookupNamespace(..), Namespace , NamespaceMap, emptyNamespaceMap , LookupFormula(..), Formula, FormulaMap, emptyFormulaMap , setArcs, getArcs, addArc, add, delete, extract, labels, merge , allLabels, remapLabels, remapLabelList , setNamespaces, getNamespaces , setFormulae, getFormulae, setFormula, getFormula , emptyRDFGraph, toRDFGraph , newNode, newNodes , grMatchMap, grEq ) import Swish.HaskellRDF.Vocabulary ( namespaceRDF {- , namespaceRDFS , namespaceRDFD , namespaceRDFC , namespaceRDFO , namespaceXSD , namespaceXsdType , namespaceOWL , namespaceMATH , namespaceLOG , namespaceDAML -} , namespaceLang, langName, langTag, isLang , rdf_type , rdf_first, rdf_rest, rdf_nil, rdf_XMLLiteral , rdfs_member , rdfd_GeneralRestriction , rdfd_onProperties, rdfd_constraint, rdfd_maxCardinality , owl_sameAs , operator_plus, operator_minus, operator_slash, operator_star ) import System.IO ( Handle, IOMode(WriteMode) , openFile, hClose, hPutStr, hPutStrLn ) import Data.List ( elemIndex ) import Data.Maybe ( fromJust ) import Test.HUnit ( Test(TestCase,TestList,TestLabel) , assertBool, assertEqual, assertString , runTestTT, runTestText, putTextToHandle ) ------------------------------------------------------------ -- Common definitions ------------------------------------------------------------ testEq :: (Eq a, Show a) => String -> a -> a -> Test testEq lab a1 a2 = TestCase ( assertEqual ("testEq:"++lab) a1 a2 ) ------------------------------------------------------------ -- Test language tag comparisons ------------------------------------------------------------ type Lang = Maybe ScopedName lt0 = Nothing lt1 = Just (langName "en") lt2 = Just (langName "EN") lt3 = Just (langName "fr") lt4 = Just (langName "FR") lt5 = Just (langName "en-us") lt6 = Just (langName "en-US") lt7 = Just (langName "EN-us") lt8 = Just (langName "EN-US") langlist = [ ("lt0",lt0), ("lt1",lt1), ("lt2",lt2), ("lt3",lt3), ("lt4",lt4), ("lt5",lt5), ("lt6",lt6), ("lt7",lt7), ("lt8",lt8) ] langeqlist = [ ("lt1","lt2"), ("lt3","lt4"), ("lt5","lt6"), ("lt5","lt7"), ("lt5","lt8"), ("lt6","lt7"), ("lt6","lt8"), ("lt7","lt8") ] testLangEq :: String -> Bool -> Lang -> Lang -> Test testLangEq lab eq l1 l2 = TestCase ( assertEqual ("testLangEq:"++lab) eq (l1==l2) ) testLangEqSuite = TestList [ testLangEq (testLab l1 l2) (testEq l1 l2) t1 t2 | (l1,t1) <- langlist , (l2,t2) <- langlist ] where testLab l1 l2 = l1 ++ "-" ++ l2 testEq l1 l2 = (l1 == l2) || (l1,l2) `elem` langeqlist || (l2,l1) `elem` langeqlist ------------------------------------------------------------ -- Define some common values ------------------------------------------------------------ base1 = Namespace "base1" "http://id.ninebynine.org/wip/2003/test/graph1/node#" base2 = Namespace "base2" "http://id.ninebynine.org/wip/2003/test/graph2/node/" base3 = Namespace "base3" "http://id.ninebynine.org/wip/2003/test/graph3/node" base4 = Namespace "base4" "http://id.ninebynine.org/wip/2003/test/graph3/nodebase" qb1s1 = ScopedName base1 "s1" qb2s2 = ScopedName base2 "s2" qb3s3 = ScopedName base3 "s3" qb3 = ScopedName base3 "" qb3bm = ScopedName base3 "basemore" qb4m = ScopedName base4 "more" s1 = Res qb1s1 :: RDFLabel s2 = Res qb2s2 :: RDFLabel s3 = Res qb3s3 :: RDFLabel s4 = Res qb3 :: RDFLabel s5 = Blank "s5" :: RDFLabel s6 = Res qb3bm :: RDFLabel s7 = Res qb4m :: RDFLabel s8 = Blank "s8" :: RDFLabel qb1st1 = ScopedName base1 "st1" qb2st2 = ScopedName base2 "st2" qb3st3 = ScopedName base3 "st3" st1 = Res qb1st1 :: RDFLabel st2 = Res qb2st2 :: RDFLabel st3 = Res qb3st3 :: RDFLabel bb = Blank "bb" :: RDFLabel bb0 = Blank "bb0" :: RDFLabel b1 = Blank "b1" :: RDFLabel b2 = Blank "b2" :: RDFLabel b3 = Blank "b3" :: RDFLabel b4 = Blank "b4" :: RDFLabel b5 = Blank "b5" :: RDFLabel b6 = Blank "b6" :: RDFLabel b7 = Blank "b7" :: RDFLabel b8 = Blank "b8" :: RDFLabel b9 = Blank "b9" :: RDFLabel b10 = Blank "b10" :: RDFLabel c1 = Blank "c1" :: RDFLabel c2 = Blank "c2" :: RDFLabel c3 = Blank "c3" :: RDFLabel c4 = Blank "c4" :: RDFLabel ba1 = Blank "_1" :: RDFLabel ba2 = Blank "_2" :: RDFLabel ba3 = Blank "_3" :: RDFLabel ba4 = Blank "_4" :: RDFLabel bn3 = Blank "3" :: RDFLabel bn4 = Blank "4" :: RDFLabel bn5 = Blank "5" :: RDFLabel bn6 = Blank "6" :: RDFLabel qb1p1 = ScopedName base1 "p1" qb2p2 = ScopedName base2 "p2" qb3p3 = ScopedName base3 "p3" qb4p4 = ScopedName base3 "p4" qb1o1 = ScopedName base1 "o1" qb2o2 = ScopedName base2 "o2" qb3o3 = ScopedName base3 "o3" p1 = Res qb1p1 :: RDFLabel p2 = Res qb2p2 :: RDFLabel p3 = Res qb3p3 :: RDFLabel p4 = Res qb4p4 :: RDFLabel o1 = Res qb1o1 :: RDFLabel o2 = Res qb2o2 :: RDFLabel o3 = Res qb3o3 :: RDFLabel o4 = Res qb3 :: RDFLabel o5 = Blank "o5" :: RDFLabel o6 = Blank "s5" :: RDFLabel qb1t1 = ScopedName base1 "type1" qb1t2 = ScopedName base1 "type2" l1 = Lit "l1" Nothing :: RDFLabel l2 = Lit "l2" (Just (langName "en")) :: RDFLabel l3 = Lit "l2" (Just (langName "fr")) :: RDFLabel l4 = Lit "l4" (Just qb1t1) :: RDFLabel l5 = Lit "l4" (Just qb1t1) :: RDFLabel -- (Lang "en") l6 = Lit "l4" (Just qb1t1) :: RDFLabel -- (Lang "fr") l7 = Lit "l4" (Just qb1t2) :: RDFLabel l8 = Lit "l4" (Just qb1t2) :: RDFLabel -- (Lang "en") l9 = Lit "l4" (Just qb1t2) :: RDFLabel -- (Lang "fr") l10 = Lit "l10" (Just rdf_XMLLiteral) :: RDFLabel l11 = Lit "l10" (Just rdf_XMLLiteral) :: RDFLabel -- (Lang "en") l12 = Lit "l10" (Just rdf_XMLLiteral) :: RDFLabel -- (Lang "fr") v1 = Var "v1" :: RDFLabel v2 = Var "v2" :: RDFLabel v3 = Var "v3" :: RDFLabel v4 = Var "v4" :: RDFLabel vb3 = Blank "v3" :: RDFLabel vb4 = Blank "v4" :: RDFLabel -- Test cases for isMemberProp qcm1 = ScopedName namespaceRDF "_1" qcm2 = ScopedName namespaceRDF "_234567" qnm1 = ScopedName namespaceRDF "987" qnm2 = ScopedName namespaceRDF "_987a65" cm1 = Res qcm1 :: RDFLabel cm2 = Res qcm2 :: RDFLabel nm1 = Res qnm1 :: RDFLabel nm2 = Res qnm2 :: RDFLabel ------------------------------------------------------------ -- RDFLabel construction and equality tests ------------------------------------------------------------ testLabelEq :: String -> Bool -> RDFLabel -> RDFLabel -> Test testLabelEq lab eq n1 n2 = TestCase ( assertEqual ("testLabelEq:"++lab) eq (n1==n2) ) nodelist = [ ("s1",s1), ("s2",s2), ("s3",s3), ("s4",s4), ("s5",s5) , ("s6",s6), ("s7",s7), ("s8",s8) , ("b1",b1), ("b2",b2), ("b3",b3), ("b4",b4) , ("p1",p1), ("p2",p2), ("p3",p3), ("p4",p4) , ("o1",o1), ("o2",o2), ("o3",o3), ("o4",o4), ("o5",o5) , ("l1",l1), ("l2",l2), ("l3",l3) , ("l4",l4), ("l5",l5), ("l6",l6) , ("l7",l7), ("l8",l8), ("l9",l9) , ("l10",l10), ("l11",l11), ("l12",l12) , ("v1",v1), ("v2",v2) ] nodeeqlist = [ ("s4","o4") , ("s5","o6") , ("s6","s7") , ("l4","l5") , ("l4","l6") , ("l5","l6") , ("l7","l8") , ("l7","l9") , ("l8","l9") , ("l10","l11") , ("l10","l12") , ("l11","l12") ] testNodeEqSuite = TestList [ testLabelEq (testLab l1 l2) (testEq l1 l2) n1 n2 | (l1,n1) <- nodelist , (l2,n2) <- nodelist ] where testLab l1 l2 = l1 ++ "-" ++ l2 testEq l1 l2 = (l1 == l2) || (l1,l2) `elem` nodeeqlist || (l2,l1) `elem` nodeeqlist ------------------------------------------------------------ -- RDFLabel classification tests ------------------------------------------------------------ testClass :: String -> (RDFLabel -> Bool) -> RDFLabel -> Bool -> Test testClass lab clsf nod eq = TestCase ( assertEqual ("testClass:"++lab) eq (clsf nod) ) testClass01 = testClass "testClass01" isUri s1 True testClass02 = testClass "testClass02" isUri s5 False testClass03 = testClass "testClass03" isUri ba1 False testClass04 = testClass "testClass04" isUri l1 False testClass05 = testClass "testClass05" isUri l10 False testClass06 = testClass "testClass06" isUri cm1 True testClass07 = testClass "testClass07" isUri nm1 True testClass08 = testClass "testClass08" isUri v1 False testClass10 = testClass "testClass10" isLiteral s1 False testClass11 = testClass "testClass11" isLiteral s5 False testClass12 = testClass "testClass12" isLiteral ba1 False testClass13 = testClass "testClass13" isLiteral l1 True testClass14 = testClass "testClass14" isLiteral l4 True testClass15 = testClass "testClass15" isLiteral l5 True testClass16 = testClass "testClass16" isLiteral l10 True testClass17 = testClass "testClass17" isLiteral l11 True testClass18 = testClass "testClass18" isLiteral cm1 False testClass19 = testClass "testClass19" isLiteral v1 False testClass20 = testClass "testClass20" isTypedLiteral s1 False testClass21 = testClass "testClass21" isTypedLiteral s5 False testClass22 = testClass "testClass22" isTypedLiteral ba1 False testClass23 = testClass "testClass23" isTypedLiteral l1 False testClass24 = testClass "testClass24" isTypedLiteral l2 False testClass25 = testClass "testClass25" isTypedLiteral l4 True testClass26 = testClass "testClass26" isTypedLiteral l5 True testClass27 = testClass "testClass27" isTypedLiteral l10 True testClass28 = testClass "testClass28" isTypedLiteral l11 True testClass29 = testClass "testClass29" isTypedLiteral v1 False testClass30 = testClass "testClass30" isUntypedLiteral s1 False testClass31 = testClass "testClass31" isUntypedLiteral s5 False testClass32 = testClass "testClass32" isUntypedLiteral ba1 False testClass33 = testClass "testClass33" isUntypedLiteral l1 True testClass34 = testClass "testClass34" isUntypedLiteral l2 True testClass35 = testClass "testClass35" isUntypedLiteral l4 False testClass36 = testClass "testClass36" isUntypedLiteral l5 False testClass37 = testClass "testClass37" isUntypedLiteral l10 False testClass38 = testClass "testClass38" isUntypedLiteral l11 False testClass39 = testClass "testClass39" isUntypedLiteral v1 False testClass40 = testClass "testClass40" isXMLLiteral s1 False testClass41 = testClass "testClass41" isXMLLiteral s5 False testClass42 = testClass "testClass42" isXMLLiteral ba1 False testClass43 = testClass "testClass43" isXMLLiteral l1 False testClass44 = testClass "testClass44" isXMLLiteral l2 False testClass45 = testClass "testClass45" isXMLLiteral l4 False testClass46 = testClass "testClass46" isXMLLiteral l5 False testClass47 = testClass "testClass47" isXMLLiteral l10 True testClass48 = testClass "testClass48" isXMLLiteral l11 True testClass49 = testClass "testClass49" isXMLLiteral v1 False altIsXmlLit = isDatatyped rdf_XMLLiteral testClass50 = testClass "testClass50" altIsXmlLit s1 False testClass51 = testClass "testClass51" altIsXmlLit s5 False testClass52 = testClass "testClass52" altIsXmlLit ba1 False testClass53 = testClass "testClass53" altIsXmlLit l1 False testClass54 = testClass "testClass54" altIsXmlLit l2 False testClass55 = testClass "testClass55" altIsXmlLit l4 False testClass56 = testClass "testClass56" altIsXmlLit l5 False testClass57 = testClass "testClass57" altIsXmlLit l10 True testClass58 = testClass "testClass58" altIsXmlLit l11 True testClass60 = testClass "testClass60" isMemberProp s1 False testClass61 = testClass "testClass61" isMemberProp s5 False testClass62 = testClass "testClass62" isMemberProp ba1 False testClass63 = testClass "testClass63" isMemberProp l1 False testClass64 = testClass "testClass64" isMemberProp l10 False testClass65 = testClass "testClass65" isMemberProp cm1 True testClass66 = testClass "testClass66" isMemberProp cm2 True testClass67 = testClass "testClass67" isMemberProp nm1 False testClass68 = testClass "testClass68" isMemberProp nm2 False testClass70 = testClass "testClass70" isBlank s7 False testClass71 = testClass "testClass71" isBlank s5 True testClass72 = testClass "testClass72" isBlank ba1 True testClass73 = testClass "testClass73" isBlank l1 False testClass74 = testClass "testClass74" isBlank l4 False testClass75 = testClass "testClass75" isBlank l5 False testClass76 = testClass "testClass76" isBlank l10 False testClass77 = testClass "testClass77" isBlank l11 False testClass78 = testClass "testClass78" isBlank cm1 False testClass79 = testClass "testClass79" isBlank v1 False testClass80 = testClass "testClass80" isQueryVar s8 False testClass81 = testClass "testClass81" isQueryVar s5 False testClass82 = testClass "testClass82" isQueryVar ba1 False testClass83 = testClass "testClass83" isQueryVar l1 False testClass84 = testClass "testClass84" isQueryVar l4 False testClass85 = testClass "testClass85" isQueryVar l5 False testClass86 = testClass "testClass86" isQueryVar l10 False testClass87 = testClass "testClass87" isQueryVar l11 False testClass88 = testClass "testClass88" isQueryVar cm1 False testClass89 = testClass "testClass89" isQueryVar v1 True testNodeClassSuite = TestList [ testClass01, testClass02, testClass03, testClass04 , testClass05, testClass06, testClass07, testClass08 , testClass10, testClass11, testClass12, testClass13, testClass14 , testClass15, testClass16, testClass17, testClass18, testClass19 , testClass20, testClass21, testClass22, testClass23, testClass24 , testClass25, testClass26, testClass27, testClass28, testClass29 , testClass30, testClass31, testClass32, testClass33, testClass34 , testClass35, testClass36, testClass37, testClass38, testClass39 , testClass40, testClass41, testClass42, testClass43, testClass44 , testClass45, testClass46, testClass47, testClass48, testClass49 , testClass50, testClass51, testClass52, testClass53, testClass54 , testClass55, testClass56, testClass57, testClass58 , testClass60, testClass61, testClass62, testClass63, testClass64 , testClass65, testClass66, testClass67, testClass68 , testClass70, testClass71, testClass72, testClass73, testClass74 , testClass75, testClass76, testClass77, testClass78, testClass79 , testClass80, testClass81, testClass82, testClass83, testClass84 , testClass85, testClass86, testClass87, testClass88, testClass89 ] ------------------------------------------------------------ -- RDFLabel local part separation and recombination tests ------------------------------------------------------------ testLocalEq :: String -> String -> String -> Test testLocalEq lab l1 l2 = TestCase ( assertEqual ("testLocalEq:"++lab) l1 l2 ) testLocalLabEq :: String -> RDFLabel -> RDFLabel -> Test testLocalLabEq lab l1 l2 = TestCase ( assertEqual ("testLocalEq:"++lab) l1 l2 ) testNodeLocal01 = testLocalEq "01" "b1" (getLocal b1) testNodeLocal02 = testLocalEq "02" "b2" (getLocal b2) testNodeLocal03 = testLocalEq "03" "?v1" (getLocal v1) testNodeLocal04 = testLocalEq "04" "?v2" (getLocal v2) testNodeLocal05 = testLocalLabEq "05" b1 (makeLabel "b1") testNodeLocal06 = testLocalLabEq "06" b2 (makeLabel "b2") testNodeLocal07 = testLocalLabEq "07" v1 (makeLabel "?v1") testNodeLocal08 = testLocalLabEq "08" v2 (makeLabel "?v2") testNodeLocalSuite = TestList [ testNodeLocal01 , testNodeLocal02 , testNodeLocal03 , testNodeLocal04 , testNodeLocal05 , testNodeLocal06 , testNodeLocal07 , testNodeLocal08 ] ------------------------------------------------------------ -- Node generation tests ------------------------------------------------------------ testNodeEq :: String -> RDFLabel -> RDFLabel -> Test testNodeEq lab l1 l2 = TestCase ( assertEqual ("testNodeEq:"++lab) l1 l2 ) tnn01 = (newNode v1 [b1,b3,v1,v2]) tnn02 = (newNode b1 [b1,b3,v1,v2]) tnn03 = (newNodes b1 [b1,b3,v1,v2])!!0 tnn04 = (newNodes b1 [b1,b3,v1,v2])!!1 tnn05 = (newNodes b1 [b1,b3,v1,v2])!!2 tnn06 = (newNodes s1 [b1,b3,v1,v2,tnns3])!!0 tnn07 = (newNodes s1 [b1,b3,v1,v2,tnns3])!!1 tnn08 = (newNodes s1 [b1,b3,v1,v2,tnns3])!!2 tnn09 = (newNodes l1 [b1,b3,v1,v2,tnns3])!!2 tnns1 = Blank "Res_s1" tnns2 = Blank "Res_s2" tnns3 = Blank "Res_s3" tnns4 = Blank "Res_s4" tnnl1 = Blank "Lit_2" testNewNode01 = testNodeEq "testNewNode01" v3 tnn01 testNewNode02 = testNodeEq "testNewNode02" b2 tnn02 testNewNode03 = testNodeEq "testNewNode03" b2 tnn03 testNewNode04 = testNodeEq "testNewNode04" b4 tnn04 testNewNode05 = testNodeEq "testNewNode05" b5 tnn05 testNewNode06 = testNodeEq "testNewNode06" tnns1 tnn06 testNewNode07 = testNodeEq "testNewNode07" tnns2 tnn07 testNewNode08 = testNodeEq "testNewNode08" tnns4 tnn08 testNewNode09 = testNodeEq "testNewNode09" tnnl1 tnn09 testNewNodeSuite = TestList [ testNewNode01 , testNewNode02 , testNewNode03 , testNewNode04 , testNewNode05 , testNewNode06 , testNewNode07 , testNewNode08 , testNewNode09 ] ------------------------------------------------------------ -- RDFLabel ordering tests ------------------------------------------------------------ testLabelOrd :: String -> Ordering -> RDFLabel -> RDFLabel -> Test testLabelOrd lab order n1 n2 = TestCase ( assertEqual ("testLabelOrd:"++lab++"["++(show n1)++","++(show n2)++"]") order (compare n1 n2) ) nodeorder = -- literals [ "l1" , "l11", "l12", "l10" , "l2", "l3" , "l5", "l6", "l4", "l8", "l9", "l7" -- variables , "v1", "v2" -- URIs , "o1", "p1", "s1" , "o2", "p2", "s2" , "s4", "o4", "s6", "s7" , "o3", "p3", "p4", "s3" -- blank nodes , "b1", "b2", "b3", "b4" , "o5", "s5", "s8" ] testNodeOrdSuite = TestList [ testLabelOrd (testLab l1 l2) (testOrd l1 l2) n1 n2 | (l1,n1) <- nodelist , (l2,n2) <- nodelist ] where testLab l1 l2 = l1 ++ "-" ++ l2 testOrd l1 l2 | testEq l1 l2 = EQ | otherwise = compare (fromJust $ elemIndex l1 nodeorder) (fromJust $ elemIndex l2 nodeorder) testEq l1 l2 = (l1 == l2) || (l1,l2) `elem` nodeeqlist || (l2,l1) `elem` nodeeqlist ------------------------------------------------------------ -- Other RDFLabel tests ------------------------------------------------------------ testLabelName01 = testEq "testLabelName01" (getScopedName s1) qb1s1 testLabelName02 = testEq "testLabelName02" (getScopedName b1) nullScopedName testLabelName03 = testEq "testLabelName03" (getScopedName l1) nullScopedName testLabelName04 = testEq "testLabelName04" (getScopedName v1) nullScopedName testLabelOtherSuite = TestList [ testLabelName01, testLabelName02, testLabelName03, testLabelName04 ] ------------------------------------------------------------ -- Statement construction and equality tests ------------------------------------------------------------ testStmtEq :: String -> Bool -> RDFTriple -> RDFTriple -> Test testStmtEq lab eq t1 t2 = TestCase ( assertEqual ("testStmtEq:"++lab) eq (t1==t2) ) slist = [ ("s1",s1), ("s4",s4), ("s5",s5), ("s6",s6), ("s7",s7) ] plist = [ ("p1",p1) ] olist = [ ("o1",o1), ("o4",o4), ("o5",o5), ("l1",l1), ("l4",l4), ("l7",l7), ("l8",l8), ("l10",l10) ] tlist = [ (lab s p o,trp s p o) | s <- slist, p <- plist, o <- olist ] where lab (s,_) (p,_) (o,_) = s++"."++p++"."++o trp (_,s) (_,p) (_,o) = arc s p o stmteqlist = [ ("s6.p1.l1", "s7.p1.l1"), ("s6.p1.l4", "s7.p1.l4"), ("s6.p1.l7", "s7.p1.l7"), ("s6.p1.l7", "s7.p1.l8"), ("s6.p1.l8", "s7.p1.l7"), ("s6.p1.l8", "s7.p1.l8"), ("s6.p1.l10","s7.p1.l10"), ("s6.p1.o1", "s7.p1.o1"), ("s6.p1.o4", "s7.p1.o4"), ("s6.p1.o5", "s7.p1.o5"), ("s1.p1.l7", "s1.p1.l8"), ("s4.p1.l7", "s4.p1.l8"), ("s5.p1.l7", "s5.p1.l8"), ("s6.p1.l7", "s6.p1.l8"), ("s7.p1.l7", "s7.p1.l8") ] testStmtEqSuite = TestList [ testStmtEq (testLab l1 l2) (testEq l1 l2) t1 t2 | (l1,t1) <- tlist , (l2,t2) <- tlist ] where testLab l1 l2 = l1 ++ "-" ++ l2 testEq l1 l2 = (l1 == l2) || (l1,l2) `elem` stmteqlist || (l2,l1) `elem` stmteqlist ------------------------------------------------------------ -- Graph construction and equality tests ------------------------------------------------------------ testGraphEq :: String -> Bool -> RDFGraph -> RDFGraph -> Test testGraphEq lab eq g1 g2 = -- Set test False to get extra trace info about graph differences -- Some tests will fail with this setting, so revert to True to -- get test result. if True then TestCase ( assertEqual ("testGraphEq:"++lab) eq (g1==g2) ) else TestList [ TestCase ( assertEqual ("testGraphEq:"++lab) eq (g1==g2) ) , TestCase ( assertEqual ("testGraphEq:"++lab) g1 g2 ) ] testGraphEqM :: String -> Bool -> Maybe RDFGraph -> Maybe RDFGraph -> Test testGraphEqM lab eq g1 g2 = TestCase ( assertEqual ("testGraphEq:"++lab) eq (g1==g2) ) t01 = arc s1 p1 o1 t02 = arc s2 p1 o2 t03 = arc s3 p1 o3 t04 = arc s1 p1 l1 t05 = arc s2 p1 l4 t06 = arc s3 p1 l10 t10 = arc s1 p1 b1 t11 = arc b1 p2 b2 t12 = arc b2 p3 o1 t20 = arc s1 p1 b3 t21 = arc b3 p2 b4 t22 = arc b4 p3 o1 tt01 = arc st1 p1 o1 tt02 = arc st2 p1 o2 tt03 = arc st3 p1 o3 tt04 = arc st1 p1 l1 tt05 = arc st2 p1 l4 tt06 = arc st3 p1 l10 makeNewPrefixNamespace :: (String,Namespace) -> Namespace makeNewPrefixNamespace (pre,ns) = Namespace pre (nsURI ns) nslist = LookupMap $ map makeNewPrefixNamespace [ ("base1",base1) , ("base2",base2) , ("base3",base3) , ("base4",base4) ] nslistalt = LookupMap $ map makeNewPrefixNamespace [ ("altbase1",base1) , ("altbase2",base2) , ("altbase3",base3) ] g1 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t01] } gt1 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tt01] } -- Check for nonsensitivety of graph equility to namespace differences: g1alt = NSGraph { namespaces = nslistalt , formulae = emptyFormulaMap , statements = [t01] } -- Construct version of g1 using just URIs uris1 = makeUriScopedName "http://id.ninebynine.org/wip/2003/test/graph1/node#s1" urip1 = makeUriScopedName "http://id.ninebynine.org/wip/2003/test/graph1/node#p1" urio1 = makeUriScopedName "http://id.ninebynine.org/wip/2003/test/graph1/node#o1" tu01 = arc (Res uris1) (Res urip1) (Res urio1) g1uri = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tu01] } g2 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t01,t02,t03,t04,t05,t06] } gt2 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tt01,tt02,tt03,tt04,tt05,tt06] } g3 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t06,t05,t04,t03,t02,t01] } gt3 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tt06,tt05,tt04,tt03,tt02,tt01] } g4 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t01,t02,t03,t04,t05,t06,t10,t11,t12] } g5 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t01,t02,t03,t04,t05,t06,t20,t21,t22] } g6 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t01,t02,t03,t04,t05,t06,t10,t11,t12,t20,t21,t22] } g7 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t01,t02] } g8 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t02,t01] } g9 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t03,t02,t01] } g9a = addArc t03 g8 g10 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [t02,t02,t01] } g10a = addArc t02 g8 glist = [ ("g1",g1), ("g1alt",g1alt), ("g1uri",g1uri) , ("g2",g2), ("g3",g3), ("g4",g4), ("g5",g5), ("g6",g6) , ("g7",g7), ("g8",g8), ("g9",g9), ("g10",g10) , ("g9a",g9a), ("g10a",g10a) ] grapheqlist = [ ("g1","g1alt") , ("g1","g1uri") , ("g1alt","g1uri") , ("g2","g3") , ("g4","g5") , ("g7","g8") , ("g7","g10") , ("g7","g10a") , ("g8","g10") , ("g8","g10a") , ("g9","g9a") , ("g10","g10a") ] testGraphEqSuite = TestList [ testGraphEq (testLab l1 l2) (testEq l1 l2) g1 g2 | (l1,g1) <- glist , (l2,g2) <- glist ] where testLab l1 l2 = l1 ++ "-" ++ l2 testEq l1 l2 = (l1 == l2) || (l1,l2) `elem` grapheqlist || (l2,l1) `elem` grapheqlist -- Selected tests for debugging geq12 = testGraphEq "g1-g2" False g1 g2 geq21 = testGraphEq "g2-g1" False g2 g1 geq22 = testGraphEq "g2-g2" True g2 g2 geq23 = testGraphEq "g2-g3" True g2 g3 geq14 = testGraphEq "g1-g4" False g1 g4 geq24 = testGraphEq "g2-g4" False g2 g4 geq77 = testGraphEq "g7-g7" True g7 g7 geq78 = testGraphEq "g7-g8" True g7 g8 geq87 = testGraphEq "g8-g7" True g8 g7 geq99a = testGraphEq "g9-g9a" True g9 g9a geq1010a = testGraphEq "g10-g10a" True g10 g10a testGraphEqSelSuite = TestList [ geq12 , geq21 , geq22 , geq23 , geq14 , geq24 , geq77 , geq78 , geq87 , geq99a , geq1010a ] ------------------------------------------------------------ -- Test updating formulae ------------------------------------------------------------ testFormulaLookup :: String -> FormulaMap RDFLabel -> RDFLabel -> Maybe RDFGraph -> Test testFormulaLookup lab fs fl gr = TestCase ( assertEqual ("testFormulaLookup:"++lab) gr jfg ) where jfg = mapFindMaybe fl fs testMaybeEq :: (Eq a, Show a) => String -> Maybe a -> Maybe a -> Test testMaybeEq lab m1 m2 = TestCase ( assertEqual ("testMaybeEq:"++lab) m1 m2 ) g1f1 = g1 f1 = getFormulae g1f1 testGraphFormula01a = testFormulaLookup "01a" f1 s1 Nothing testGraphFormula01b = testFormulaLookup "01b" f1 s2 Nothing testGraphFormula01c = testFormulaLookup "01c" f1 s3 Nothing fm2 = LookupMap [Formula s2 g2] g1f2 = setFormulae fm2 g1f1 f2 = getFormulae g1f2 testGraphFormula02a = testFormulaLookup "02a" f2 s1 Nothing testGraphFormula02b = testFormulaLookup "02b" f2 s2 (Just g2) testGraphFormula02c = testFormulaLookup "02c" f2 s3 Nothing fm3 = LookupMap [Formula s1 g1,Formula s2 g2,Formula s3 g3] g1f3 = setFormulae fm3 g1f1 f3 = getFormulae g1f3 testGraphFormula03a = testFormulaLookup "03a" f3 s1 (Just g1) testGraphFormula03b = testFormulaLookup "03b" f3 s2 (Just g2) testGraphFormula03c = testFormulaLookup "03c" f3 s3 (Just g3) fm4 = LookupMap [Formula s1 g1,Formula s2 g3,Formula s3 g3] g1f4 = setFormulae fm4 g1f1 f4 = getFormulae g1f4 testGraphFormula04a = testFormulaLookup "04a" f4 s1 (Just g1) testGraphFormula04b = testFormulaLookup "04b" f4 s2 (Just g3) testGraphFormula04c = testFormulaLookup "04c" f4 s3 (Just g3) fm5 = LookupMap [Formula s1 g1,Formula s2 g4,Formula s3 g6] g1f5 = setFormulae fm5 g1f1 f5 = getFormulae g1f5 testGraphFormula05a = testFormulaLookup "05a" f5 s1 (Just g1) testGraphFormula05b = testFormulaLookup "05b" f5 s2 (Just g4) testGraphFormula05c = testFormulaLookup "05c" f5 s3 (Just g6) fm6 = LookupMap [Formula s1 g1,Formula s2 g5,Formula s3 g6] g1f6 = setFormulae fm6 g1f1 f6 = getFormulae g1f6 testGraphFormula06a = testFormulaLookup "06a" f6 s1 (Just g1) testGraphFormula06b = testFormulaLookup "06b" f6 s2 (Just g5) testGraphFormula06c = testFormulaLookup "06c" f6 s3 (Just g6) fm7 = LookupMap [Formula s1 g1,Formula s2 g7,Formula s3 g6] g1f7 = setFormulae fm7 g1f1 f7 = getFormulae g1f7 testGraphFormula07a = testFormulaLookup "07a" f7 s1 (Just g1) testGraphFormula07b = testFormulaLookup "07b" f7 s2 (Just g7) testGraphFormula07c = testFormulaLookup "07c" f7 s3 (Just g6) -- Same pattern as 1-3, but using base graph with more nodes used: -- The graph comparison results are expected to be different, -- because of formulae associated with nodes actually used in the -- graph g2f1 = g2 f8 = getFormulae g2f1 testGraphFormula08a = testFormulaLookup "08a" f8 s1 Nothing testGraphFormula08b = testFormulaLookup "08b" f8 s2 Nothing testGraphFormula08c = testFormulaLookup "08c" f8 s3 Nothing g2f2 = setFormulae fm2 g2f1 f9 = getFormulae g2f2 testGraphFormula09a = testFormulaLookup "09a" f9 s1 Nothing testGraphFormula09b = testFormulaLookup "09b" f9 s2 (Just g2) testGraphFormula09c = testFormulaLookup "09c" f9 s3 Nothing g2f3 = setFormulae fm3 g2f1 f10 = getFormulae g2f3 testGraphFormula10a = testFormulaLookup "10a" f10 s1 (Just g1) testGraphFormula10b = testFormulaLookup "10b" f10 s2 (Just g2) testGraphFormula10c = testFormulaLookup "10c" f10 s3 (Just g3) -- Comparison of graphs containing formulae. -- The intent is that graphs are matched if there is a bijection, -- where the matched nodes are associated with matching formulae. -- Definitions of formulae not used in the graphs don't affect the -- match result. testGraphFormula11a = testGraphEq "g1f1-g1f1" True g1f1 g1f1 testGraphFormula11b = testGraphEq "g1f1-g1f2" True g1f1 g1f2 testGraphFormula11c = testGraphEq "g1f1-g1f3" False g1f1 g1f3 testGraphFormula12a = testGraphEq "g1f2-g1f1" True g1f2 g1f1 testGraphFormula12b = testGraphEq "g1f2-g1f2" True g1f2 g1f2 testGraphFormula12c = testGraphEq "g1f2-g1f3" False g1f2 g1f3 testGraphFormula13a = testGraphEq "g1f3-g1f1" False g1f3 g1f1 testGraphFormula13b = testGraphEq "g1f3-g1f2" False g1f3 g1f2 testGraphFormula13c = testGraphEq "g1f3-g1f3" True g1f3 g1f3 testGraphFormula14a = testGraphEq "g1f4-g1f3" True g1f4 g1f3 testGraphFormula14b = testGraphEq "g1f4-g1f4" True g1f4 g1f4 testGraphFormula14c = testGraphEq "g1f4-g1f5" True g1f4 g1f5 testGraphFormula15a = testGraphEq "g1f5-g1f5" True g1f5 g1f5 testGraphFormula15b = testGraphEq "g1f5-g1f6" True g1f5 g1f6 testGraphFormula15c = testGraphEq "g1f5-g1f7" True g1f5 g1f7 testGraphFormula16a = testGraphEq "g1f6-g1f5" True g1f6 g1f5 testGraphFormula16b = testGraphEq "g1f6-g1f6" True g1f6 g1f6 testGraphFormula16c = testGraphEq "g1f6-g1f7" True g1f6 g1f7 testGraphFormula17a = testGraphEq "g1f7-g1f5" True g1f7 g1f5 testGraphFormula17b = testGraphEq "g1f7-g1f6" True g1f7 g1f6 testGraphFormula17c = testGraphEq "g1f7-g1f7" True g1f7 g1f7 testGraphFormula18a = testGraphEq "g2f1-g2f1" True g2f1 g2f1 testGraphFormula18b = testGraphEq "g2f1-g2f2" False g2f1 g2f2 testGraphFormula18c = testGraphEq "g2f1-g2f3" False g2f1 g2f3 testGraphFormula19a = testGraphEq "g2f2-g2f1" False g2f2 g2f1 testGraphFormula19b = testGraphEq "g2f2-g2f2" True g2f2 g2f2 testGraphFormula19c = testGraphEq "g2f2-g2f3" False g2f2 g2f3 testGraphFormula20a = testGraphEq "g2f3-g2f1" False g2f3 g2f1 testGraphFormula20b = testGraphEq "g2f3-g2f2" False g2f3 g2f2 testGraphFormula20c = testGraphEq "g2f3-g2f3" True g2f3 g2f3 -- Test methods to set/access an individual formula in a graph g1f21 = setFormula (Formula s1 g7) g1f2 f21 = getFormulae g1f21 testGraphFormula21a = testFormulaLookup "21a" f21 s1 (Just g7) testGraphFormula21b = testFormulaLookup "21b" f21 s2 (Just g2) testGraphFormula21c = testFormulaLookup "21c" f21 s3 Nothing g1f22 = setFormula (Formula s1 g1) g1f21 f22 = getFormulae g1f22 testGraphFormula22a = testFormulaLookup "22a" f22 s1 (Just g1) testGraphFormula22b = testFormulaLookup "22b" f22 s2 (Just g2) testGraphFormula22c = testFormulaLookup "22c" f22 s3 Nothing f23a = getFormula g1f22 s1 f23b = getFormula g1f22 s2 f23c = getFormula g1f22 s3 testGraphFormula23a = testMaybeEq "23a" f23a (Just g1) testGraphFormula23b = testMaybeEq "23b" f23b (Just g2) testGraphFormula23c = testMaybeEq "23c" f23c Nothing testGraphFormulaSuite = TestLabel "TestFormulae" $ TestList [ testGraphFormula01a, testGraphFormula01b, testGraphFormula01c , testGraphFormula02a, testGraphFormula02b, testGraphFormula02c , testGraphFormula03a, testGraphFormula03b, testGraphFormula03c , testGraphFormula04a, testGraphFormula04b, testGraphFormula04c , testGraphFormula05a, testGraphFormula05b, testGraphFormula05c , testGraphFormula06a, testGraphFormula06b, testGraphFormula06c , testGraphFormula07a, testGraphFormula07b, testGraphFormula07c , testGraphFormula08a, testGraphFormula08b, testGraphFormula08c , testGraphFormula09a, testGraphFormula09b, testGraphFormula09c , testGraphFormula10a, testGraphFormula10b, testGraphFormula10c , testGraphFormula11a, testGraphFormula11b, testGraphFormula11c , testGraphFormula12a, testGraphFormula12b, testGraphFormula12c , testGraphFormula13a, testGraphFormula13b, testGraphFormula13c , testGraphFormula14a, testGraphFormula14b, testGraphFormula14c , testGraphFormula15a, testGraphFormula15b, testGraphFormula15c , testGraphFormula16a, testGraphFormula16b, testGraphFormula16c , testGraphFormula17a, testGraphFormula17b, testGraphFormula17c , testGraphFormula18a, testGraphFormula18b, testGraphFormula18c , testGraphFormula19a, testGraphFormula19b, testGraphFormula19c , testGraphFormula20a, testGraphFormula20b, testGraphFormula20c , testGraphFormula21a, testGraphFormula21b, testGraphFormula21c , testGraphFormula22a, testGraphFormula22b, testGraphFormula22c , testGraphFormula23a, testGraphFormula23b, testGraphFormula23c ] ------------------------------------------------------------ -- Test fmap translations of graphs, including formulae ------------------------------------------------------------ translate lab | lab == s1 = st1 | lab == s2 = st2 | lab == s3 = st3 | otherwise = lab translateM lab | lab == s1 = Just st1 | lab == s2 = Just st2 | lab == s3 = Just st3 | isBlank lab = Nothing | otherwise = Just lab gt1f1a = gt1 gt1f1b = fmap translate g1f1 ft1 = getFormulae gt1f1b testGraphTranslate01a = testGraphEq "gt1f1a-gt1f1b" True gt1f1a gt1f1b testGraphTranslate01b = testFormulaLookup "GraphTranslate01b" ft1 st1 Nothing testGraphTranslate01c = testFormulaLookup "GraphTranslate01c" ft1 st2 Nothing testGraphTranslate01d = testFormulaLookup "GraphTranslate01d" ft1 st3 Nothing testGraphTranslate01e = testEq "gt1f1a-gt1f1b" gt1f1a gt1f1b ftm2 = LookupMap [Formula st2 gt2] gt1f2a = setFormulae ftm2 gt1 gt1f2b = fmap translate g1f2 ft2 = getFormulae gt1f2b testGraphTranslate02a = testGraphEq "gt1f2a-gt1f2b" True gt1f2a gt1f2b testGraphTranslate02b = testFormulaLookup "GraphTranslate02b" ft2 st1 Nothing testGraphTranslate02c = testFormulaLookup "GraphTranslate02c" ft2 st2 (Just gt2) testGraphTranslate02d = testFormulaLookup "GraphTranslate02d" ft2 st3 Nothing ftm3 = LookupMap [Formula st1 gt1,Formula st2 gt2,Formula st3 gt3] gt1f3a = setFormulae ftm3 gt1 gt1f3b = fmap translate g1f3 ft3 = getFormulae gt1f3b testGraphTranslate03a = testGraphEq "gt1f3a-gt1f3b" True gt1f3a gt1f3b testGraphTranslate03b = testFormulaLookup "GraphTranslate03b" ft3 st1 (Just gt1) testGraphTranslate03c = testFormulaLookup "GraphTranslate03c" ft3 st2 (Just gt2) testGraphTranslate03d = testFormulaLookup "GraphTranslate03d" ft3 st3 (Just gt3) gt2f1a = gt2 gt2f1b = fmap translate g2f1 ft4 = getFormulae gt2f1b testGraphTranslate04a = testGraphEq "gt2f1a-gt2f1b" True gt2f1a gt2f1b testGraphTranslate04b = testFormulaLookup "GraphTranslate04b" ft4 st1 Nothing testGraphTranslate04c = testFormulaLookup "GraphTranslate04c" ft4 st2 Nothing testGraphTranslate04d = testFormulaLookup "GraphTranslate04d" ft4 st3 Nothing gt2f2a = setFormulae ftm2 gt2 gt2f2b = fmap translate g2f2 ft5 = getFormulae gt2f2b testGraphTranslate05a = testGraphEq "gt2f2a-gt2f2b" True gt2f2a gt2f2b testGraphTranslate05b = testFormulaLookup "GraphTranslate05b" ft5 st1 Nothing testGraphTranslate05c = testFormulaLookup "GraphTranslate05c" ft5 st2 (Just gt2) testGraphTranslate05d = testFormulaLookup "GraphTranslate05d" ft5 st3 Nothing gt2f3a = setFormulae ftm3 gt2 gt2f3b = fmap translate g2f3 ft6 = getFormulae gt2f3b testGraphTranslate06a = testGraphEq "gt2f3a-gt2f3b" True gt2f3a gt2f3b testGraphTranslate06b = testFormulaLookup "GraphTranslate06b" ft6 st1 (Just gt1) testGraphTranslate06c = testFormulaLookup "GraphTranslate06c" ft6 st2 (Just gt2) testGraphTranslate06d = testFormulaLookup "GraphTranslate06d" ft6 st3 (Just gt3) -- Monadic translate tests, using Maybe Monad gt1f1aM = Just gt1 gt1f1bM = fmapM translateM g1f1 ft1M = getFormulae $ fromJust gt1f1bM testGraphTranslate07a = testGraphEqM "gt1f1aM-gt1f1bM" True gt1f1aM gt1f1bM testGraphTranslate07b = testFormulaLookup "GraphTranslate07b" ft1M st1 Nothing testGraphTranslate07c = testFormulaLookup "GraphTranslate07c" ft1M st2 Nothing testGraphTranslate07d = testFormulaLookup "GraphTranslate07d" ft1M st3 Nothing testGraphTranslate07e = testEq "gt1f1aM-gt1f1bM" gt1f1aM gt1f1bM gt1f2aM = Just gt1f2a gt1f2bM = fmapM translateM g1f2 ft2M = getFormulae $ fromJust gt1f2bM testGraphTranslate08a = testGraphEqM "gt1f2aM-gt1f2bM" True gt1f2aM gt1f2bM testGraphTranslate08b = testFormulaLookup "GraphTranslate08b" ft2M st1 Nothing testGraphTranslate08c = testFormulaLookup "GraphTranslate08c" ft2M st2 (Just gt2) testGraphTranslate08d = testFormulaLookup "GraphTranslate08d" ft2M st3 Nothing testGraphTranslate08e = testEq "gt1f2aM-gt1f2bM" gt1f2aM gt1f1bM gt1f5M = fmapM translateM g1f5 testGraphTranslate09a = testEq "GraphTranslate09a" Nothing gt1f5M testGraphTranslateSuite = TestLabel "TestTranslate" $ TestList [ testGraphTranslate01a , testGraphTranslate01b, testGraphTranslate01c, testGraphTranslate01d , testGraphTranslate01e , testGraphTranslate02a , testGraphTranslate02b, testGraphTranslate02c, testGraphTranslate02d , testGraphTranslate03a , testGraphTranslate03b, testGraphTranslate03c, testGraphTranslate03d , testGraphTranslate04a , testGraphTranslate04b, testGraphTranslate04c, testGraphTranslate04d , testGraphTranslate05a , testGraphTranslate05b, testGraphTranslate05c, testGraphTranslate05d , testGraphTranslate06a , testGraphTranslate06b, testGraphTranslate06c, testGraphTranslate06d , testGraphTranslate07a , testGraphTranslate07b, testGraphTranslate07c, testGraphTranslate07d , testGraphTranslate07e , testGraphTranslate08a , testGraphTranslate08b, testGraphTranslate08c, testGraphTranslate08d , testGraphTranslate08e , testGraphTranslate09a ] ------------------------------------------------------------ -- Test merge with conflicting bnodes, including formulae ------------------------------------------------------------ testMerge :: String -> RDFGraph -> RDFGraph -> RDFGraph -> Test testMerge lab g1 g2 gr = TestCase ( assertEquiv ("testMerge:"++lab) gr (merge g1 g2) ) where grequiv g1 g2 = (getArcs g1) `equiv` (getArcs g2) assertEquiv lab g1 g2 = assertString $ if grequiv g1 g2 then "" else lab++"\nExpected: "++(show g1)++"\nObtained: "++(show g2) testEquiv :: (Eq a) => String -> [a] -> [a] -> Test testEquiv lab l1 l2 = TestCase $ assertBool lab (l1 `equiv` l2) tm01 = arc s1 p1 b1 tm02 = arc b1 p1 o2 tm03 = arc b1 p1 o3 tm04 = arc b2 p2 b3 tm05 = arc b3 p2 b4 tm06 = arc bb p2 b5 tm07 = arc s2 p3 v1 tm08 = arc s3 p3 v2 tm09 = arc s4 p1 c1 tm10 = arc c2 p1 o4 tm11 = arc s4 p2 ba1 tm12 = arc ba2 p2 o4 tm13 = arc s4 p2 bn3 tm14 = arc bn4 p2 o4 tm21 = arc s1 p1 b6 tm22 = arc b6 p1 o2 tm23 = arc b6 p1 o3 tm24 = arc b7 p2 b8 tm25 = arc b8 p2 b9 tm26 = arc bb0 p2 b10 tm27 = arc s2 p3 v3 tm28 = arc s3 p3 v4 tm29 = arc s4 p1 c3 tm30 = arc c4 p1 o4 tm31 = arc s4 p2 ba3 tm32 = arc ba4 p2 o4 tm33 = arc s4 p2 bn5 tm34 = arc bn6 p2 o4 tm41 = arc s1 p1 b2 tm42 = arc b2 p1 o2 tm43 = arc b2 p1 o3 tm44 = arc b4 p2 b5 tm41a = arc s1 p1 b4 tm44a = arc b5 p2 b6 tm67 = arc s2 p3 v3 tm68 = arc s3 p3 v4 tm69 = arc s4 p1 c3 tm70 = arc c4 p1 o4 tm71 = arc s4 p2 ba3 tm72 = arc ba4 p2 o4 tm73 = arc s4 p2 bn5 tm74 = arc bn6 p2 o4 gm1 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm01,tm02,tm03,tm04,tm05,tm06,tm07,tm08 ,tm09,tm10,tm11,tm12,tm13,tm14 ] } gm11 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm01,tm02,tm03,tm04,tm05,tm06,tm07,tm08 ,tm09,tm10,tm11,tm12,tm13,tm14 ,tm21,tm22,tm23,tm24,tm25,tm26,tm27,tm28 ,tm29,tm30,tm31,tm32,tm33,tm34 ] } gm2 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm01] } gm2f = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm41] } gm22 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm01,tm41] } gm3 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm04] } gm3f = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm44] } gm33 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm04,tm44] } gm4 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm01,tm04] } gm44 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm01,tm04,tm41a,tm44a] } gm5 = NSGraph { namespaces = nslist , formulae = LookupMap [Formula b1 gm2] , statements = [tm01,tm02,tm03] } gm55 = NSGraph { namespaces = nslist , formulae = LookupMap [Formula b1 gm2,Formula b2 gm2f] , statements = [tm01,tm02,tm03,tm41,tm42,tm43] } gm6 = NSGraph { namespaces = nslist , formulae = LookupMap [Formula ba1 gm2,Formula bn3 gm3] , statements = [tm07,tm08,tm09,tm10,tm11,tm12,tm13,tm14] } gm66 = NSGraph { namespaces = nslist , formulae = LookupMap [Formula ba1 gm2,Formula bn3 gm3 ,Formula ba3 gm2f,Formula bn5 gm3f ] , statements = [tm07,tm08,tm09,tm10,tm11,tm12,tm13,tm14 ,tm67,tm68,tm69,tm70,tm71,tm72,tm73,tm74 ] } tm81 = arc b1 p1 v1 tm82 = arc b2 p2 v2 tm811 = arc b1 p1 v3 tm821 = arc b2 p2 v4 tm812 = arc b1 p1 vb3 tm822 = arc b2 p2 vb4 gm81 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm81,tm82] } gm82 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm811,tm821] } gm82a = remapLabels [v1,v2] [v1,v2,b1,b2] id gm81 gm82b1 = remapLabelList [v1,v2] [v1,v2,b1,b2] gm82b2 = [(v1,v3),(v2,v4)] gm83 = NSGraph { namespaces = nslist , formulae = emptyFormulaMap , statements = [tm811,tm821] } gm83a = remapLabels [v1,v2] [v1,v2,b1,b2] makeBlank gm81 gm84 = NSGraph { namespaces = nslist , formulae = LookupMap [Formula b1 gm81,Formula v2 gm81] , statements = [tm81,tm82] } gm85 = NSGraph { namespaces = nslist , formulae = LookupMap [Formula b1 gm82,Formula v4 gm82] , statements = [tm811,tm821] } gm85a = remapLabels [v1,v2] [v1,v2,b1,b2] id gm84 gm86 = NSGraph { namespaces = nslist , formulae = LookupMap [Formula b1 gm82,Formula vb4 gm82] , statements = [tm812,tm822] } gm86a = remapLabels [v1,v2] [v1,v2,b1,b2] makeBlank gm84 testMerge01 = testMerge "01" gm1 gm1 gm11 testMerge02 = testMerge "02" gm2 gm2 gm22 testMerge03 = testMerge "03" gm3 gm3 gm33 testMerge04 = testMerge "04" gm4 gm4 gm44 testMerge05 = testMerge "05" gm5 gm5 gm55 testMerge06 = testMerge "06" gm6 gm6 gm66 testRemap07 = testGraphEq "Remap07" True gm82 gm82a testRemapList07 = testEquiv "testRemapList07" gm82b2 gm82b1 testRemap08 = testGraphEq "Remap08" True gm83 gm83a testRemap09 = testGraphEq "Remap09" True gm85 gm85a testRemap10 = testGraphEq "Remap10" True gm86 gm86a testMergeSuite = TestList [ testMerge01 , testMerge02 , testMerge03 , testMerge04 , testMerge05 , testMerge06 , testRemap07 , testRemapList07 , testRemap08 , testRemap09 , testRemap10 ] ------------------------------------------------------------ -- All tests ------------------------------------------------------------ allTests = TestList [ testLangEqSuite , testNodeEqSuite , testNodeClassSuite , testNodeLocalSuite , testNewNodeSuite , testNodeOrdSuite , testLabelOtherSuite , testStmtEqSuite , testGraphEqSuite , testGraphEqSelSuite , testGraphFormulaSuite , testGraphTranslateSuite , testMergeSuite ] main = runTestTT allTests runTestFile t = do h <- openFile "a.tmp" WriteMode runTestText (putTextToHandle h False) t hClose h tf = runTestFile tt = runTestTT geq = testGraphEqSuite nord = testNodeOrdSuite gtr = testGraphTranslateSuite gmm g1 g2 = grMatchMap g1 g2 -------------------------------------------------------------------------------- -- -- Copyright (c) 2003, G. KLYNE. 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 -- -------------------------------------------------------------------------------- -- $Source: /file/cvsdev/HaskellRDF/RDFGraphTest.hs,v $ -- $Author: graham $ -- $Revision: 1.32 $ -- $Log: RDFGraphTest.hs,v $ -- Revision 1.32 2004/01/07 19:49:13 graham -- Reorganized RDFLabel details to eliminate separate language field, -- and to use ScopedName rather than QName. -- Removed some duplicated functions from module Namespace. -- -- Revision 1.31 2004/01/06 13:53:10 graham -- Created consolidated test harness (SwishTestAll.hs) -- -- Revision 1.30 2003/12/04 02:53:27 graham -- More changes to LookupMap functions. -- SwishScript logic part complete, type-checks OK. -- -- Revision 1.29 2003/11/24 17:20:34 graham -- Separate module Vocabulary from module Namespace. -- -- Revision 1.28 2003/11/24 15:46:04 graham -- Rationalize N3Parser and N3Formatter to use revised vocabulary -- terms defined in Namespace.hs -- -- Revision 1.27 2003/11/13 01:13:48 graham -- Reworked ruleset to use ScopedName lookup. -- Various minor fixes. -- -- Revision 1.26 2003/10/01 00:36:25 graham -- Added RDFGraph method to test for container membership property label. -- Added RDFQuery filter function to select container membership properties. -- -- Revision 1.25 2003/09/24 18:50:52 graham -- Revised module format to be Haddock compatible. -- -- Revision 1.24 2003/09/24 13:36:42 graham -- QName handling separated from RDFGraph module, and -- QName splitting moved from URI module to QName module. -- -- Revision 1.23 2003/07/02 21:27:30 graham -- Graph closure with instance rule tested. -- About to change ProofTest for graph forward chaining to return -- a single result graph. -- -- Revision 1.22 2003/07/01 14:20:30 graham -- Added instance entailment to proof check module. -- -- Revision 1.21 2003/06/30 19:07:00 graham -- Instance entailment, subgraph entailment and simple entailment -- tests now working. -- -- Revision 1.20 2003/06/17 15:43:35 graham -- remapNodes now accepts a node-mapping function rather than just -- a Boolean to control conversion of query variable nodes to blank -- nodes, and who knows what else. -- -- Revision 1.19 2003/06/13 21:40:08 graham -- Graph closure forward chaining works. -- Backward chaining generates existentials. -- Some problems with query logic for backward chaining. -- -- Revision 1.18 2003/06/12 00:49:05 graham -- Basic query processor runs test cases OK. -- Proof framework compiles, not yet tested. -- -- Revision 1.17 2003/06/10 17:38:34 graham -- Remove some unneeded calss constraints from data type declarations -- Reworked NSGraph to be an instance of Functor, replacing function -- gmap with fmap. Graph formulae are still not handled well: the data types -- will need re-working so that a "Formula lb" type constructor can be -- introduced having the correct (* -> *) kind to be a Functor. -- -- Revision 1.16 2003/06/03 19:24:13 graham -- Updated all source modules to cite GNU Public Licence -- -- Revision 1.15 2003/05/29 13:04:42 graham -- All tests now compile and pass as stand-alone programs compiled -- using GHC. Added batch files to compile programs and run tests. -- -- Revision 1.14 2003/05/29 00:57:37 graham -- Resolved swish performance problem, which turned out to an inefficient -- method used by the parser to add arcs to a graph. -- -- Revision 1.13 2003/05/27 19:15:50 graham -- Graph merge (with blank node renaming) complete and passes tests. -- -- Revision 1.12 2003/05/26 22:30:36 graham -- Working on graph merge. -- Added methods to Graph class for manipulating variable node. -- Need to get RDFGraph to compile. And test. -- -- Revision 1.11 2003/05/23 19:33:36 graham -- Added and tested RDF graph label translation functions -- -- Revision 1.10 2003/05/14 16:50:32 graham -- Graph matching seems solid now: -- RDFGraphTest and N3ParserTest pass all tests -- Updated TODO file with comments from code -- -- Revision 1.9 2003/05/08 18:55:36 graham -- Updated graph matching module to deal consistently -- with graphs containing formulae. All graph tests now -- run OK, but the GraphMatch module is a mess and -- desperately needs restructuring. Also, graph matching -- performance needs to be improved. -- -- Revision 1.8 2003/05/07 23:58:09 graham -- More restructuring. -- RDFGraphTest runs OK. -- N3ParserTest needs to be updated to use new structure for formulae. -- -- Revision 1.7 2003/05/07 19:25:00 graham -- Restructured formula handling in RDF graph -- -- Revision 1.6 2003/04/24 23:41:39 graham -- Added Ord class membership to graph nodes -- Added empty lookup table definition -- Started on N3 formatter module -- -- Revision 1.5 2003/04/17 00:35:39 graham -- Added module N3ParserTest -- N3parser is mostly working -- Formulae remain to test -- -- Revision 1.4 2003/04/15 21:40:54 graham -- N3Parser compiles -- Some small changes to RDFGraph -- Added some QName methods -- -- Revision 1.3 2003/04/10 20:08:39 graham -- Reorganized RDFGraph naming (RDFGraphTest OK) -- Progressing N3Parser -- -- Revision 1.2 2003/04/10 15:06:30 graham -- RDFGraph now passes all test cases -- -- Revision 1.1 2003/03/28 21:50:22 graham -- Graph equality coded and nearly working -- -- Revision 1.1 2003/03/12 23:00:43 graham -- Graph model coded and working, except for graph isomorphism test. --