{-# LANGUAGE OverloadedStrings #-} -------------------------------------------------------------------------------- -- See end of this file for licence information. -------------------------------------------------------------------------------- -- | -- Module : N3FormatterTest -- Copyright : (c) 2003, Graham Klyne, 2009 Vasili I Galchin, 2011, 2012, 2013 Douglas Burke -- License : GPL V2 -- -- Maintainer : Douglas Burke -- Stability : experimental -- Portability : OverloadedStrings -- -- This Module defines test cases for module Parse parsing functions. -- -------------------------------------------------------------------------------- module Main where import qualified Data.Map as M import qualified Data.Set as S import qualified Data.Text as T import qualified Data.Text.Lazy as L import qualified Data.Text.Lazy.Builder as B import qualified Test.Framework as TF import Swish.GraphClass (Arc, arc) import Swish.Namespace (Namespace, makeNamespace, getNamespaceTuple, makeNSScopedName, namespaceToBuilder) import Swish.QName (LName) import Swish.RDF.Formatter.N3 (formatGraphAsLazyText, formatGraphDiag) import Swish.RDF.Parser.N3 (parseN3) import Swish.RDF.Graph ( RDFGraph, RDFTriple , RDFLabel(..), ToRDFLabel , NSGraph(..) , NamespaceMap , emptyRDFGraph, toRDFGraph, toRDFTriple , resRdfType, resRdfFirst, resRdfRest, resRdfNil , resOwlSameAs ) import Swish.RDF.Vocabulary (toLangTag, namespaceRDF, namespaceXSD) import Network.URI (URI, parseURI) import Data.Monoid (Monoid(..)) import Data.Maybe (fromJust) import Data.String (IsString(..)) import Test.HUnit ( Test(TestCase,TestList) , assertEqual ) import TestHelpers (conv, testCompareEq) -- Specialized equality comparisons testLabelEq :: String -> Bool -> RDFLabel -> RDFLabel -> Test testLabelEq = testCompareEq "testLabelEq:" testGraphEq :: String -> Bool -> RDFGraph -> RDFGraph -> Test testGraphEq = testCompareEq "testGraphEq:" ------------------------------------------------------------ -- Define some common values ------------------------------------------------------------ toURI :: String -> URI toURI = fromJust . parseURI toNS :: T.Text -> String -> Namespace toNS p = makeNamespace (Just p) . toURI toRes :: Namespace -> LName -> RDFLabel toRes ns = Res . makeNSScopedName ns base1, base2, base3, base4, basef, baseu, basem :: Namespace base1 = toNS "base1" "http://id.ninebynine.org/wip/2003/test/graph1/node#" base2 = toNS "base2" "http://id.ninebynine.org/wip/2003/test/graph2/node/" base3 = toNS "base3" "http://id.ninebynine.org/wip/2003/test/graph3/node" base4 = toNS "base4" "http://id.ninebynine.org/wip/2003/test/graph3/nodebase" basef = toNS "fbase" "file:///home/swish/photos/" baseu = toNS "ubase" "urn:one:two:3.14" basem = toNS "me" "http://example.com/ns#" s1, s2, s3, sf, su :: RDFLabel s1 = toRes base1 "s1" s2 = toRes base2 "s2" s3 = toRes base3 "s3" sf = toRes basef "me.png" su = toRes baseu "" meDepicts, meMe, meHasURN :: RDFLabel meDepicts = toRes basem "depicts" meMe = toRes basem "me" meHasURN = toRes basem "hasURN" b1, b2, b3, b4, b5, b6, b7, b8 :: RDFLabel b1 = Blank "b1" b2 = Blank "b2" b3 = Blank "b3" b4 = Blank "b4" b5 = Blank "b5" b6 = Blank "b6" b7 = Blank "b7" b8 = Blank "b8" c1, c2, c3, c4, c5, c6 :: RDFLabel c1 = Blank "c1" c2 = Blank "c2" c3 = Blank "c3" c4 = Blank "c4" c5 = Blank "c5" c6 = Blank "c6" p1, p2, p3, p21, p22, p23, p24, p25, p26 :: RDFLabel p1 = Res $ makeNSScopedName base1 "p1" p2 = Res $ makeNSScopedName base2 "p2" p3 = Res $ makeNSScopedName base3 "p3" p21 = Res $ makeNSScopedName base2 "p21" p22 = Res $ makeNSScopedName base2 "p22" p23 = Res $ makeNSScopedName base2 "p23" p24 = Res $ makeNSScopedName base2 "p24" p25 = Res $ makeNSScopedName base2 "p25" p26 = Res $ makeNSScopedName base2 "p26" o1, o2, o3 :: RDFLabel o1 = Res $ makeNSScopedName base1 "o1" o2 = Res $ makeNSScopedName base2 "o2" o3 = Res $ makeNSScopedName base3 "o3" l1txt, l2txt, l3txt, l11txt, l12txt, l13txt, l14txt :: B.Builder l1txt = "l1" l2txt = "l2-'\"line1\"'\n\nl2-'\"\"line2\"\"'" l3txt = "l3--\r\"'\\--\x0020\&--\x00A0\&--" l11txt = "lx11" l12txt = "lx12" l13txt = "lx13" l14txt = "lx14" toL :: B.Builder -> RDFLabel toL = Lit . L.toStrict . B.toLazyText l1, l2, l3, l11, l12, l13, l14 :: RDFLabel l1 = toL l1txt l2 = toL l2txt l3 = toL l3txt l11 = toL l11txt l12 = toL l12txt l13 = toL l13txt l14 = toL l14txt lfr, lfoobar :: RDFLabel lfr = LangLit "chat et chien" (fromJust $ toLangTag "fr") lfoobar = TypedLit "foo bar" (makeNSScopedName base1 "o1") f1, f2 :: RDFLabel f1 = Res $ makeNSScopedName base1 "f1" f2 = Res $ makeNSScopedName base2 "f2" v1, v2, v3, v4 :: RDFLabel v1 = Var "var1" v2 = Var "var2" v3 = Var "var3" v4 = Var "var4" ------------------------------------------------------------ -- Construct graphs for testing ------------------------------------------------------------ t01, t02, t03, t04, t05, t06, t07 :: Arc RDFLabel t01 = arc s1 p1 o1 t02 = arc s2 p1 o2 t03 = arc s3 p1 o3 t04 = arc s1 p1 l1 t05 = arc s2 p1 b1 t06 = arc s3 p1 l2 t07 = arc s3 p2 l3 nslist :: NamespaceMap nslist = M.fromList $ map getNamespaceTuple [ base1 , base2 , base3 , base4 ] g1np :: RDFGraph g1np = emptyRDFGraph { namespaces = uncurry M.singleton (getNamespaceTuple base1) , statements = S.singleton t01 } toGraph :: [Arc RDFLabel] -> RDFGraph toGraph arcs = (toRDFGraph (S.fromList arcs)) {namespaces = nslist} g1, g1b1, g1b3, g1a1, g1l1, g1l2 :: RDFGraph g1 = toGraph [t01] g1b1 = toGraph [arc b1 p1 o1] g1b3 = toGraph [arc b1 b2 b3] g1a1 = toGraph [arc (Blank "1") p1 o1] g1l1 = toGraph [arc s1 p1 l1] g1l2 = toGraph [arc s1 p1 l2] {- g1f1 = NSGraph { namespaces = nslist , formulae = M.singleton o1 (Formula o1g1) , statements = [f01] } where f01 = arc s1 p1 o1 -} g1f2, g1f3 :: RDFGraph g1f2 = NSGraph { namespaces = nslist , formulae = M.singleton b2 g1 -- $ Formula b2 g1 , statements = S.singleton $ arc s1 p1 b2 } g1f3 = NSGraph { namespaces = nslist , formulae = M.singleton b3 g1f2 -- $ Formula b3 g1f2 , statements = S.singleton $ arc s1 p1 b3 } g1fu1 :: RDFGraph g1fu1 = mempty { namespaces = M.fromList $ map getNamespaceTuple [basem, makeNamespace Nothing (toURI "file:///home/swish/photos/")] , statements = S.fromList [arc sf meDepicts meMe, arc sf meHasURN su] } ---- g2, g3, g4, g5, g6, g7 :: RDFGraph g2 = toRDFGraph $ S.fromList [t01,t02,t03] g3 = toGraph [t01,t04] g4 = toGraph [t01,t05] g5 = toGraph [t01,t02,t03,t04,t05] g6 = toGraph [t01,t06] g7 = toGraph [t01,t07] t801, t802, t807, t808, t809, t810 :: Arc RDFLabel t801 = arc s1 resRdfType o1 t802 = arc s2 resOwlSameAs o2 t807 = arc o1 p1 s1 t808 = arc s2 p1 o2 t809 = arc s1 p2 o1 t810 = arc o2 p2 s2 g8, g81, g83 :: RDFGraph g8 = toGraph [t801,t802,t807,t808,t809,t810] g81 = toGraph [t801,t802] g83 = toGraph [t807,t808,t809,t810] t911, t912, t913, t914, t921, t922, t923, t924, t925, t926, t927, t928 :: Arc RDFLabel t911 = arc s1 p1 o1 t912 = arc s1 p1 o2 t913 = arc s1 p2 o2 t914 = arc s1 p2 o3 t921 = arc s2 p1 o1 t922 = arc s2 p1 o2 t923 = arc s2 p1 o3 t924 = arc s2 p1 l1 t925 = arc s2 p2 o1 t926 = arc s2 p2 o2 t927 = arc s2 p2 o3 t928 = arc s2 p2 l1 g9 :: RDFGraph g9 = toGraph [t911,t912,t913,t914, t921,t922,t923,t924, t925,t926,t927,t928] t1011, t1012, t1013, t1014, t1021, t1022, t1023, t1024, t1025, t1026, t1027, t1028 :: Arc RDFLabel t1011 = arc s1 p1 o1 t1012 = arc o2 p1 s1 t1013 = arc s1 p2 o2 t1014 = arc o3 p2 s1 t1021 = arc s2 p1 o1 t1022 = arc s2 p1 o2 t1023 = arc s2 p1 o3 t1024 = arc s2 p1 l1 t1025 = arc o1 p2 s2 t1026 = arc o2 p2 s2 t1027 = arc o3 p2 s2 -- t1028 = arc l1 p2 s2 t1028 = arc s1 p2 s2 g10 :: RDFGraph g10 = toGraph [t1011,t1012,t1013,t1014, t1021,t1022,t1023,t1024, t1025,t1026,t1027,t1028] g11 :: RDFGraph g11 = toGraph [ arc s1 p1 v1 , arc v2 p1 o1 , arc v3 p1 v4] tx101, tx102, tx111, tx112, tx113, tx114, tx121, tx122, tx123, tx124, tx125, tx126, tx127, tx128 :: Arc RDFLabel tx101 = arc b1 resOwlSameAs s1 tx102 = arc s2 resOwlSameAs b2 tx111 = arc b1 p1 o1 tx112 = arc b1 p1 o2 tx113 = arc b1 p2 o2 tx114 = arc b1 p2 o3 tx121 = arc b2 p1 o1 tx122 = arc b2 p1 o2 tx123 = arc b2 p1 o3 tx124 = arc b2 p1 l1 tx125 = arc b2 p2 o1 tx126 = arc b2 p2 o2 tx127 = arc b2 p2 o3 tx128 = arc b2 p2 l2 x1 :: RDFGraph x1 = toGraph [tx101,tx102, tx111,tx112,tx113,tx114, tx121,tx122,tx123,tx124, tx125,tx126,tx127,tx128] tx201, tx202, tx211, tx212, tx213, tx214, tx221, tx222, tx223, tx224, tx225, tx226, tx227 :: Arc RDFLabel tx201 = arc b1 resOwlSameAs s1 tx202 = arc s2 resOwlSameAs b2 tx211 = arc b1 p1 o1 tx212 = arc o2 p1 b1 tx213 = arc b1 p2 o2 tx214 = arc o3 p2 b1 tx221 = arc b2 p1 o1 tx222 = arc b2 p1 o2 tx223 = arc b2 p1 o3 tx224 = arc b2 p1 l1 tx225 = arc o1 p2 b2 tx226 = arc o2 p2 b2 tx227 = arc o3 p2 b2 -- tx228 = arc l1 p2 b2 x2 :: RDFGraph x2 = toGraph [tx201,tx202, tx211,tx212,tx213,tx214, tx221,tx222,tx223,tx224, tx225,tx226,tx227] tx311, tx312, tx313, tx314, tx321, tx322, tx323, tx324, tx325, tx326, tx327 :: Arc RDFLabel tx311 = arc s1 p1 o1 tx312 = arc o2 p1 s1 tx313 = arc s1 p2 o2 tx314 = arc o3 p2 s1 tx321 = arc s2 p1 o1 tx322 = arc s2 p1 o2 tx323 = arc s2 p1 o3 tx324 = arc s2 p1 l1 tx325 = arc o1 p2 s2 tx326 = arc o2 p2 s2 tx327 = arc o3 p2 s2 -- tx328 = arc l1 p2 s2 x3 :: RDFGraph x3 = toGraph [tx311,tx312,tx313,tx314, tx321,tx322,tx323,tx324, tx325,tx326,tx327] tx401, tx402, tx403, tx404, tx405, tx406, tx407, tx408, tx409 :: Arc RDFLabel tx401 = arc s1 resOwlSameAs b1 tx402 = arc b1 resRdfFirst o1 tx403 = arc b1 resRdfRest b2 tx404 = arc b2 resRdfFirst o2 tx405 = arc b2 resRdfRest b3 tx406 = arc b3 resRdfFirst o3 tx407 = arc b3 resRdfRest b4 tx408 = arc b4 resRdfFirst l1 tx409 = arc b4 resRdfRest resRdfNil x4 :: RDFGraph x4 = toGraph [tx401,tx402,tx403,tx404, tx405,tx406,tx407,tx408, tx409] x5 :: RDFGraph x5 = toGraph [ arc b1 resOwlSameAs s1 , arc b1 resRdfFirst o1 , arc b1 resRdfRest b2 , arc b2 resRdfFirst o2 , arc b2 resRdfRest b3 , arc b3 resRdfFirst o3 , arc b3 resRdfRest b4 , arc b4 resRdfFirst l1 , arc b4 resRdfRest resRdfNil ] {- I was aiming for :s1 = ( :o1 b2:o2 b3:o3 "l1" ) . but really it's :s1 rdf:first ( b1:o1 b2:o2 b3:o3 "l1" ) . or something like that. different versions of cwm parse the triples differently, and it depends on the output format too (eg n3 vs ntriples). -} x6 :: RDFGraph x6 = toGraph [ arc s1 resRdfFirst o1 , arc s1 resRdfRest b2 , arc b2 resRdfFirst o2 , arc b2 resRdfRest b3 , arc b3 resRdfFirst o3 , arc b3 resRdfRest b4 , arc b4 resRdfFirst l1 , arc b4 resRdfRest resRdfNil ] x7 :: RDFGraph x7 = NSGraph { namespaces = nslist , formulae = M.singleton b1 g2 -- $ Formula b1 g2 , statements = S.singleton $ arc b1 p2 f2 } x8 :: RDFGraph x8 = NSGraph { namespaces = nslist , formulae = M.singleton f1 g2 -- $ Formula f1 g2 , statements = S.singleton $ arc f1 p2 f2 } x9 :: RDFGraph x9 = NSGraph { namespaces = nslist , formulae = M.singleton f1 g1 -- $ Formula f1 g1 , statements = S.singleton $ arc f1 p2 f2 } -- Test allocation of bnodes carries over a nested formula x12, x12fg :: RDFGraph x12 = NSGraph { namespaces = nslist , formulae = M.singleton b2 x12fg -- $ Formula b2 x12fg , statements = S.fromList [ arc s1 p1 b1 , arc b1 p1 o1 , arc b2 p2 f2 , arc s3 p3 b3 , arc b3 p3 o3 ] } x12fg = toRDFGraph $ S.fromList [ arc s2 p2 b4 , arc b4 p2 o2 ] -- List of simple anon nodes x13 :: RDFGraph x13 = toGraph [ arc s1 resRdfFirst b1 , arc s1 resRdfRest c1 , arc c1 resRdfFirst b2 , arc c1 resRdfRest c2 , arc c2 resRdfFirst b3 , arc c2 resRdfRest resRdfNil , arc b1 p1 o1 , arc b2 p1 o2 , arc b3 p1 o3 ] -- List of simple anon nodes using autogenerated bnodes x13a :: RDFGraph x13a = toGraph [ arc s1 resRdfFirst b_1 , arc s1 resRdfRest c_1 , arc c_1 resRdfFirst b_2 , arc c_1 resRdfRest c_2 , arc c_2 resRdfFirst b_3 , arc c_2 resRdfRest resRdfNil , arc b_1 p1 o1 , arc b_2 p1 o2 , arc b_3 p1 o3 ] where b_1 = Blank "1" b_2 = Blank "2" b_3 = Blank "3" c_1 = Blank "4" c_2 = Blank "5" -- List of more complex anon nodes x14 :: RDFGraph x14 = toGraph [ arc s1 resRdfFirst b1 , arc s1 resRdfRest c1 , arc c1 resRdfFirst b2 , arc c1 resRdfRest c2 , arc c2 resRdfFirst b3 , arc c2 resRdfRest resRdfNil , arc b1 p1 o1 , arc b1 p2 o1 , arc b2 p1 o2 , arc b2 p2 o2 , arc b3 p1 o3 , arc b3 p2 o3 ] -- List with nested list x15 :: RDFGraph x15 = toGraph [ arc s1 resRdfFirst b1 , arc s1 resRdfRest c1 , arc c1 resRdfFirst b2 , arc c1 resRdfRest c2 , arc c2 resRdfFirst b3 , arc c2 resRdfRest resRdfNil , arc b1 p1 o1 , arc b2 p2 c3 , arc b3 p1 o3 , arc c3 resRdfFirst b4 , arc c3 resRdfRest c4 , arc c4 resRdfFirst b5 , arc c4 resRdfRest c5 , arc c5 resRdfFirst b6 , arc c5 resRdfRest resRdfNil , arc b4 p1 o1 , arc b5 p1 o2 , arc b6 p1 o3 ] -- More complex list with nested list x16 :: RDFGraph x16 = toGraph [ arc s1 resRdfFirst b1 , arc s1 resRdfRest c1 , arc c1 resRdfFirst b2 , arc c1 resRdfRest c2 , arc c2 resRdfFirst b3 , arc c2 resRdfRest resRdfNil , arc b1 p1 o1 , arc b1 p2 o1 , arc b2 p2 c3 , arc b3 p1 o3 , arc b3 p2 o3 , arc c3 resRdfFirst b4 , arc c3 resRdfRest c4 , arc c4 resRdfFirst b5 , arc c4 resRdfRest c5 , arc c5 resRdfFirst b6 , arc c5 resRdfRest resRdfNil , arc b4 p1 o1 , arc b4 p2 o1 , arc b5 p1 o2 , arc b5 p2 o2 , arc b6 p1 o3 , arc b6 p2 o3 ] -- Troublesome example x17 :: RDFGraph x17 = toGraph [ arc s1 resRdfType o1 , arc s1 resRdfFirst b1 , arc s1 resRdfRest c1 , arc c1 resRdfFirst b2 , arc c1 resRdfRest resRdfNil , arc b1 p21 o2 , arc b1 p22 c2 , arc b2 p24 o3 , arc b2 p25 l13 , arc c2 resRdfFirst b3 , arc c2 resRdfRest c3 , arc c3 resRdfFirst l12 , arc c3 resRdfRest resRdfNil , arc b3 p23 l11 ] -- collection graphs graph_c1, graph_c1rev, graph_c2, graph_c2rev, graph_c3 :: RDFGraph graph_c1 = toGraph [arc s1 p1 resRdfNil] graph_c1rev = toGraph [arc resRdfNil p1 o1] graph_c2 = toGraph [arc s1 p1 b1, arc b1 resRdfFirst l1, arc b1 resRdfRest b2, arc b2 resRdfFirst o2, arc b2 resRdfRest b3, arc b3 resRdfFirst l2, arc b3 resRdfRest b4, arc b4 resRdfFirst o3, arc b4 resRdfRest resRdfNil] graph_c2rev = toGraph [arc b1 resRdfFirst l1, arc b1 resRdfRest b2, arc b2 resRdfFirst o2, arc b2 resRdfRest b3, arc b3 resRdfFirst l2, arc b3 resRdfRest b4, arc b4 resRdfFirst o3, arc b4 resRdfRest resRdfNil, arc b1 p1 o1] graph_c3 = toGraph [arc s1 p1 b1, arc b1 resRdfFirst l1, arc b1 resRdfRest b2, arc b2 resRdfFirst o2, arc b2 resRdfRest b3, arc b3 resRdfFirst l2, arc b3 resRdfRest b4, arc b4 resRdfFirst o3, arc b4 resRdfRest resRdfNil, arc s1 p2 resRdfNil, arc s2 p2 o2] -- bnode graphs graph_b1, graph_b1rev, graph_b2, graph_b2rev, graph_b3, graph_b4, graph_b5 :: RDFGraph graph_b1 = toRDFGraph $ S.singleton $ arc s1 p1 b1 graph_b1rev = toRDFGraph $ S.singleton $ arc b1 p1 o1 graph_b2 = toRDFGraph $ S.fromList [arc s1 p1 b1, arc b1 p2 l1, arc b1 o2 o3] graph_b2rev = toRDFGraph $ S.fromList [arc b1 p2 l1, arc b1 o2 o3, arc b1 p1 o1] graph_b3 = toRDFGraph $ S.fromList [arc s1 p1 b1, arc b1 p2 l2, arc b1 o2 o3, arc s1 p2 b2, arc s2 p2 o2] graph_b4 = toRDFGraph $ S.fromList [arc b1 resRdfType o1, arc b2 resRdfType o2] graph_b5 = toRDFGraph $ S.fromList [arc b1 resRdfType o1, arc b2 p2 o2, arc b3 resRdfType o3] -- datatype/literal graphs graph_l1, graph_l2, graph_l3, graph_l4 :: RDFGraph graph_l1 = toGraph [arc s1 p1 lfr] graph_l2 = toGraph [arc s1 p1 lfoobar] graph_l3 = let tf :: ToRDFLabel a => a -> RDFTriple tf = toRDFTriple s1 p1 arcs = [ tf True , tf (12::Int) -- so, issue over comparing -2.304e-108 and value read in from string -- due to comparing a ScopedName instance built from a RDFLabel -- as the hash used in the comparison is based on the Show value -- but then why isn't this a problem for Float , tf ((-2.304e-108)::Double) , tf (23.4::Float) ] {- gtmp = toRDFGraph arcs in gtmp { namespaces = M.insert (Just "xsd") ("http://www.w3.org/2001/XMLSchema#") (namespaces gtmp) } -} in toRDFGraph $ S.fromList arcs graph_l4 = toGraph [ toRDFTriple s1 p1 ("A string with \"quotes\"" :: RDFLabel) , toRDFTriple s2 p2 (TypedLit "A typed string with \"quotes\"" (fromString "urn:a#b")) ] ------------------------------------------------------------ -- Trivial formatter tests ------------------------------------------------------------ -- -- These are very basic tests that confirm that output for a -- simple graph corresponds exactly to some supplied string. formatTest :: String -> RDFGraph -> B.Builder -> Test formatTest lab gr out = TestList [ TestCase ( assertEqual ("formatTest:"++lab) outTxt res ) ] where outTxt = B.toLazyText out res = formatGraphAsLazyText gr diagTest :: String -> RDFGraph -> L.Text -> Test diagTest lab gr out = TestList [ TestCase ( assertEqual ("diag:text:"++lab) out resTxt ) , TestCase ( assertEqual ("diag:map:"++lab) M.empty nmap ) , TestCase ( assertEqual ("diag:gen:"++lab) 0 ngen ) , TestCase ( assertEqual ("diag:trc:"++lab) [] trc ) ] where (res,nmap,ngen,trc) = formatGraphDiag "\n" True gr resTxt = B.toLazyText res mkPrefix :: Namespace -> B.Builder mkPrefix = namespaceToBuilder prefixList :: [B.Builder] prefixList = [ mkPrefix base1 , mkPrefix base2 , mkPrefix base3 , mkPrefix base4 , mkPrefix namespaceRDF , mkPrefix namespaceXSD ] commonPrefixesN :: [Int] -> B.Builder commonPrefixesN = mconcat . map (prefixList !!) commonPrefixes :: B.Builder commonPrefixes = commonPrefixesN [0..3] commonPrefixes21, commonPrefixes321, commonPrefixes132 :: B.Builder commonPrefixes21 = commonPrefixesN [1,0] commonPrefixes321 = commonPrefixesN [2,1,0] commonPrefixes132 = commonPrefixesN [0,2,1] -- Single statement using form simpleN3Graph_g1_01 :: B.Builder simpleN3Graph_g1_01 = " .\n" -- Single statement using prefix:name form simpleN3Graph_g1_02 :: B.Builder simpleN3Graph_g1_02 = commonPrefixes `mappend` "base1:s1 base1:p1 base1:o1 .\n" -- Single blank node simpleN3Graph_g1_03 :: B.Builder simpleN3Graph_g1_03 = commonPrefixes `mappend` "[\n base1:p1 base1:o1\n] .\n" -- Single auto-allocated blank node simpleN3Graph_g1_04 :: B.Builder simpleN3Graph_g1_04 = commonPrefixes `mappend` "[\n base1:p1 base1:o1\n] .\n" -- Single literal object simpleN3Graph_g1_05 :: B.Builder simpleN3Graph_g1_05 = commonPrefixes `mappend` "base1:s1 base1:p1 \"l1\" .\n" -- Single multiline literal object simpleN3Graph_g1_06 :: B.Builder simpleN3Graph_g1_06 = commonPrefixes `mappend` "base1:s1 base1:p1 \"l2-'\\\"line1\\\"'\\n\\nl2-'\\\"\\\"line2\\\"\\\"'\" .\n" -- this 'round trips' into a triple-quoted string simpleN3Graph_g1_06_rt :: B.Builder simpleN3Graph_g1_06_rt = commonPrefixes `mappend` "base1:s1 base1:p1 \"\"\"l2-'\"line1\"'\n\nl2-'\"\"line2\"\"'\"\"\" .\n" {- -- Single statement with formula node simpleN3Graph_g1_07 = commonPrefixes ++ "base1:s1 base1:p1 base1:o1 .\n"++ "base1:o1 :-\n"++ " {\n"++ " base1:s1 base1:p1 base1:o1\n"++ " } .\n" -} -- Single statement with formula blank node simpleN3Graph_g1_08 :: B.Builder simpleN3Graph_g1_08 = mconcat [ commonPrefixes , "base1:s1 base1:p1 { \n" , " base1:s1 base1:p1 base1:o1\n" , " } .\n" ] -- Three blank nodes (or is that blind mice?) simpleN3Graph_g1_09 :: B.Builder simpleN3Graph_g1_09 = commonPrefixes `mappend` "[\n _:b2 []\n] .\n" -- Simple nested formula case simpleN3Graph_g1_10 :: B.Builder simpleN3Graph_g1_10 = mconcat [ commonPrefixes , "base1:s1 base1:p1 { \n" , " base1:s1 base1:p1 { \n" , " base1:s1 base1:p1 base1:o1\n" , " } \n" , " } .\n" ] -- try out URIs that do not use the http scheme simpleN3Graph_g1_fu1 :: B.Builder simpleN3Graph_g1_fu1 = mconcat [ "@prefix : .\n" , "@prefix me: .\n" -- , ":me.png me:depicts me:me ;\n" , " me:depicts me:me ;\n" , " me:hasURN .\n" ] {- Simple troublesome case Changed Aug 15 2013 to support rendering _:a :knows _:b . _:b :knows _:a . which, as currently implemented, loses the ability to make the simplification below. simpleN3Graph_x13a = mconcat [ commonPrefixes , "base1:s1 " , b1s , " ;\n" , " ( ", b2s, " ", b3s, " ) .\n" ] where b1s = "[\n base1:p1 base1:o1\n]" b2s = "[\n base1:p1 base2:o2\n]" b3s = "[\n base1:p1 base3:o3\n]" -} simpleN3Graph_x13a :: B.Builder simpleN3Graph_x13a = mconcat [ commonPrefixes , "base1:s1 " , b1n , " ;\n ( ", b2n, " ", b3n, " ) .\n" , b1n, " base1:p1 base1:o1 .\n" , b2n, " base1:p1 base2:o2 .\n" , b3n, " base1:p1 base3:o3 .\n" ] where b1n = "_:swish1" b2n = "_:swish2" b3n = "_:swish3" {- Simple collection tests; may replicate some of the previous tests. -} simpleN3Graph_c1 :: B.Builder simpleN3Graph_c1 = commonPrefixes `mappend` "base1:s1 base1:p1 () .\n" simpleN3Graph_c1rev :: B.Builder simpleN3Graph_c1rev = commonPrefixes `mappend` "() base1:p1 base1:o1 .\n" collItems :: B.Builder collItems = mconcat [ "( \"l1\" base2:o2 \"\"\"" , l2txt , "\"\"\" base3:o3 )" ] simpleN3Graph_c2 :: B.Builder simpleN3Graph_c2 = mconcat [ commonPrefixes , "base1:s1 base1:p1 " , collItems , " .\n" ] simpleN3Graph_c2rev :: B.Builder simpleN3Graph_c2rev = mconcat [ commonPrefixes , collItems, " base1:p1 base1:o1 .\n" ] simpleN3Graph_c3 :: B.Builder simpleN3Graph_c3 = mconcat [ commonPrefixes , "base1:s1 base1:p1 ", collItems, " ;\n" , " base2:p2 () .\n" , "base2:s2 base2:p2 base2:o2 .\n" ] {- Simple bnode tests; may replicate some of the previous tests. -} simpleN3Graph_b1 :: B.Builder simpleN3Graph_b1 = commonPrefixesN [0] `mappend` "base1:s1 base1:p1 [] .\n" simpleN3Graph_b1rev :: B.Builder simpleN3Graph_b1rev = commonPrefixesN [0] `mappend` "[\n base1:p1 base1:o1\n] .\n" {- See discussion of simpleN3Graph_x13a for why this has been changed simpleN3Graph_b2 = commonPrefixesN [0,1,2] `mappend` "base1:s1 base1:p1 [\n base2:o2 base3:o3 ;\n base2:p2 \"l1\"\n] .\n" -} simpleN3Graph_b2 :: B.Builder simpleN3Graph_b2 = commonPrefixesN [0,1,2] `mappend` "base1:s1 base1:p1 _:b1 .\n_:b1 base2:o2 base3:o3 ;\n base2:p2 \"l1\" .\n" simpleN3Graph_b2rev :: B.Builder simpleN3Graph_b2rev = commonPrefixesN [0,1,2] `mappend` "[\n base1:p1 base1:o1 ;\n base2:o2 base3:o3 ;\n base2:p2 \"l1\"\n] .\n" {- See discussion of simpleN3Graph_x13a for why this has been changed simpleN3Graph_b3 = mconcat [ commonPrefixesN [0,1,2] , "base1:s1 base1:p1 [\n base2:o2 base3:o3 ;\n base2:p2 \"\"\"", l2txt, "\"\"\"\n] ;\n" , " base2:p2 [] .\n" , "base2:s2 base2:p2 base2:o2 .\n" ] -} simpleN3Graph_b3 :: B.Builder simpleN3Graph_b3 = mconcat [ commonPrefixesN [0,1,2] , "base1:s1 base1:p1 _:b1 ;\n" , " base2:p2 [] .\n" , "base2:s2 base2:p2 base2:o2 .\n" , "_:b1 base2:o2 base3:o3 ;\n base2:p2 \"\"\"", l2txt, "\"\"\" .\n" ] simpleN3Graph_b4 :: B.Builder simpleN3Graph_b4 = mconcat [ commonPrefixesN [0,1,4] , "[\n a base1:o1\n] .\n" , "[\n a base2:o2\n] .\n" ] simpleN3Graph_b5 :: B.Builder simpleN3Graph_b5 = mconcat [ commonPrefixesN [0,1,2,4] , "[\n a base1:o1\n] .\n" , "[\n base2:p2 base2:o2\n] .\n" , "[\n a base3:o3\n] .\n" ] {- Simple datatype/language tests; may replicate some of the previous tests. -} simpleN3Graph_l1 :: B.Builder simpleN3Graph_l1 = commonPrefixes `mappend` "base1:s1 base1:p1 \"chat et chien\"@fr .\n" simpleN3Graph_l2 :: B.Builder simpleN3Graph_l2 = commonPrefixes `mappend` "base1:s1 base1:p1 \"foo bar\"^^base1:o1 .\n" simpleN3Graph_l3 :: B.Builder simpleN3Graph_l3 = mconcat [ commonPrefixesN [0, 5] , "\n" -- TODO: why do we need this newline? , "base1:s1 base1:p1 -2.304e-108,\n" , " 12,\n" , " \"2.34E1\"^^xsd:float, true .\n" ] simpleN3Graph_l4 :: B.Builder simpleN3Graph_l4 = mconcat [ commonPrefixes , "base1:s1 base1:p1 \"\"\"A string with \"quotes\\\"\"\"\" .\n" , "base2:s2 base2:p2 \"\"\"A typed string with \"quotes\\\"\"\"\"^^ .\n" ] trivialTestSuite :: Test trivialTestSuite = TestList [ -- formatTest "trivialTest01" g1np simpleN3Graph_g1_01 - no longer valid as now add in a prefix/namespace declaration formatTest "trivialTest02" g1 simpleN3Graph_g1_02 , formatTest "trivialTest03" g1b1 simpleN3Graph_g1_03 , formatTest "trivialTest04" g1a1 simpleN3Graph_g1_04 , formatTest "trivialTest05" g1l1 simpleN3Graph_g1_05 , formatTest "trivialTest06" g1l2 simpleN3Graph_g1_06_rt -- trivialTest07 = formatTest "trivialTest07" g1f1 simpleN3Graph_g1_07 -- formula is a named node , formatTest "trivialTest08" g1f2 simpleN3Graph_g1_08 , formatTest "trivialTest09" g1b3 simpleN3Graph_g1_09 , formatTest "trivialTest10" g1f3 simpleN3Graph_g1_10 , formatTest "trivialTest13a" x13a simpleN3Graph_x13a , formatTest "trivialTestfu1" g1fu1 simpleN3Graph_g1_fu1 , formatTest "trivialTestc1" graph_c1 simpleN3Graph_c1 , formatTest "trivialTestc2" graph_c2 simpleN3Graph_c2 , formatTest "trivialTestc3" graph_c3 simpleN3Graph_c3 , formatTest "trivialTestc1rev" graph_c1rev simpleN3Graph_c1rev , formatTest "trivialTestc2rev" graph_c2rev simpleN3Graph_c2rev , formatTest "trivialTestb1" graph_b1 simpleN3Graph_b1 , formatTest "trivialTestb2" graph_b2 simpleN3Graph_b2 , formatTest "trivialTestb3" graph_b3 simpleN3Graph_b3 , formatTest "trivialTestb4" graph_b4 simpleN3Graph_b4 , formatTest "trivialTestb5" graph_b5 simpleN3Graph_b5 , formatTest "trivialTestb1rev" graph_b1rev simpleN3Graph_b1rev , formatTest "trivialTestb2rev" graph_b2rev simpleN3Graph_b2rev , formatTest "lit1" graph_l1 simpleN3Graph_l1 , formatTest "lit2" graph_l2 simpleN3Graph_l2 , formatTest "lit3" graph_l3 simpleN3Graph_l3 , formatTest "lit4" graph_l4 simpleN3Graph_l4 , formatTest "trivialTestx4" x4 exoticN3Graph_x4 , formatTest "trivialTestx5" x5 exoticN3Graph_x5 , formatTest "trivialTestx7" x7 exoticN3Graph_x7 ] ------------------------------------------------------------ -- Parser tests to cross-check round-trip testing ------------------------------------------------------------ parseTest :: String -> B.Builder -> RDFGraph -> String -> Test parseTest lab inp gr er = TestList [ TestCase ( assertEqual ("parseTestError:"++lab) er pe ) , TestCase ( assertEqual ("parseTestGraph:"++lab) gr pg ) ] where (pe,pg) = case parseN3 (B.toLazyText inp) Nothing of Right g -> ("", g) Left s -> (s, emptyRDFGraph) noError, errorText :: String noError = "" errorText = "*" parseTestSuite :: Test parseTestSuite = TestList [ parseTest "01" simpleN3Graph_g1_01 g1np noError , parseTest "02" simpleN3Graph_g1_02 g1 noError , parseTest "03" simpleN3Graph_g1_03 g1b1 noError , parseTest "04" simpleN3Graph_g1_04 g1a1 noError , parseTest "05" simpleN3Graph_g1_05 g1l1 noError , parseTest "06" simpleN3Graph_g1_06 g1l2 noError , parseTest "06rt" simpleN3Graph_g1_06_rt g1l2 noError -- parseTest07 = parseTest "07" simpleN3Graph_g1_07 g1f1 noError -- formula is a named node , parseTest "08" simpleN3Graph_g1_08 g1f2 noError ] ------------------------------------------------------------ -- Repeat above tests using parser and graph-comparison ------------------------------------------------------------ -- -- This establishes a framework that will be used for -- more complex tests that are less susceptible to trivial -- formatting differences. The idea is to generate output -- that can be parsed to obtain an equivalent graph. roundTripTest :: String -> RDFGraph -> Test roundTripTest lab gr = TestList [ TestCase ( assertEqual ("RoundTrip:gr:"++lab) gr pg ) , TestCase ( assertEqual ("RoundTrip:er:"++lab) "" pe ) -- , TestCase ( assertEqual ("Formatted:"++lab) "" out ) ] where out = formatGraphAsLazyText gr (pe,pg) = case parseN3 out Nothing of Right g -> ("", g) Left s -> (s, mempty) -- Full round trip from graph source. This test may pick up some errors -- the bnode generation logic that are not tested by hand-assembled graph -- data structures. fullRoundTripTest :: String -> B.Builder -> Test fullRoundTripTest lab grstr = TestList [ TestCase ( assertEqual ("FullRoundTrip:gr:"++lab) gr pg ) , TestCase ( assertEqual ("FullRoundTrip:er:"++lab) "" pe ) -- , TestCase ( assertEqual ("FullRoundTrip:"++lab) "" out ) ] where grtxt = B.toLazyText grstr (_,gr) = case parseN3 grtxt Nothing of Right g -> ("", g) Left s -> (s, mempty) out = formatGraphAsLazyText gr (pe,pg) = case parseN3 out Nothing of Right g -> ("", g) Left s -> (s, mempty) roundTripTestSuite :: Test roundTripTestSuite = TestList [ roundTripTest "01" g1np , roundTripTest "02" g1 , roundTripTest "03" g1b1 , roundTripTest "04" g1a1 , roundTripTest "05" g1l1 , roundTripTest "06" g1l2 , roundTripTest "l1" graph_l1 , roundTripTest "l2" graph_l2 , roundTripTest "l3" graph_l3 , roundTripTest "l4" graph_l4 -- roundTripTest07 = roundTripTest "07" g1f1 -- formula is a named node , roundTripTest "08" g1f2 , fullRoundTripTest "11" simpleN3Graph_g1_01 , fullRoundTripTest "12" simpleN3Graph_g1_02 , fullRoundTripTest "13" simpleN3Graph_g1_03 , fullRoundTripTest "14" simpleN3Graph_g1_04 , fullRoundTripTest "15" simpleN3Graph_g1_05 , fullRoundTripTest "16rt" simpleN3Graph_g1_06_rt -- roundTripTest17 = fullRoundTripTest "17" simpleN3Graph_g1_07 -- TODO: :- with named node for formula , fullRoundTripTest "18" simpleN3Graph_g1_08 , fullRoundTripTest "fu1" simpleN3Graph_g1_fu1 , fullRoundTripTest "l1" simpleN3Graph_l1 , fullRoundTripTest "l2" simpleN3Graph_l2 , fullRoundTripTest "l3" simpleN3Graph_l3 , fullRoundTripTest "l4" simpleN3Graph_l4 ] ------------------------------------------------------------ -- Simple formatter tests ------------------------------------------------------------ -- -- These are simple tests that format and re-parse a graph, -- and make sure that the result graph compares the same as -- the original. Therefore, depends on a trusted parser and -- graph compare function. simpleTest :: String -> RDFGraph -> Test simpleTest lab = roundTripTest ("SimpleTest:"++lab) simpleTestSuite :: Test simpleTestSuite = TestList [ simpleTest "01" g2 , simpleTest "02" g3 , simpleTest "03" g4 , simpleTest "04" g5 , simpleTest "05" g6 , simpleTest "06" g7 , simpleTest "07" g8 , simpleTest "08" g81 , simpleTest "10" g83 , simpleTest "11" g9 , simpleTest "12" g10 , simpleTest "13" g11 ] ------------------------------------------------------------ -- Exotic parser tests ------------------------------------------------------------ -- -- These tests cover various forms of anonymous nodes -- [...], lists and formulae. -- -- does a round-trip test starting with the exoticTest :: String -> RDFGraph -> Test exoticTest lab gr = TestList [ TestCase ( assertEqual ("ExoticTest:gr:"++lab) gr pg ) , TestCase ( assertEqual ("ExoticTest:er:"++lab) "" pe ) -- , TestCase ( assertEqual ("ExoticTest:"++lab) "" out ) ] where out = formatGraphAsLazyText gr (pe,pg) = case parseN3 out Nothing of Right g -> ("", g) Left s -> (s, mempty) -- Simple anon nodes, with semicolons and commas exoticN3Graph_x1 :: B.Builder exoticN3Graph_x1 = mconcat [ commonPrefixes , " [ base1:p1 base1:o1 ; \n" , " base1:p1 base2:o2 ; \n" , " base2:p2 base2:o2 ; \n" , " base2:p2 base3:o3 ] = base1:s1 . \n" , " base2:s2 = \n" , " [ base1:p1 base1:o1 , \n" , " base2:o2 , \n" , " base3:o3 , \n" , " \"l1\" ; \n" , " base2:p2 base1:o1 , \n" , " base2:o2 , \n" , " base3:o3 , \n" , " \"\"\"", l2txt, "\"\"\" ] . \n" ] -- Simple anon nodes, with 'is ... of' and semicolons and commas exoticN3Graph_x2 :: B.Builder exoticN3Graph_x2 = mconcat [ commonPrefixes , " [ @has base1:p1 base1:o1 ; \n" , " @is base1:p1 @of base2:o2 ; \n" , " @has base2:p2 base2:o2 ; \n" , " @is base2:p2 @of base3:o3 ] = base1:s1 . \n" , " base2:s2 = \n" , " [ @has base1:p1 base1:o1 , \n" , " base2:o2 , \n" , " base3:o3 , \n" , " \"l1\" ; \n" , " @is base2:p2 @of base1:o1 , \n" , " base2:o2 , \n" , " base3:o3 ] . \n" ] -- Simple anon nodes, attached to identified node {- exoticN3Graph_x3 = commonPrefixes ++ " base1:s1 :- \n" ++ " [ has base1:p1 of base1:o1 ; \n" ++ " is base1:p1 of base2:o2 ; \n" ++ " has base2:p2 of base2:o2 ; \n" ++ " is base2:p2 of base3:o3 ] . \n" ++ " base2:s2 :- \n" ++ " [ has base1:p1 of base1:o1 , \n" ++ " base2:o2 , \n" ++ " base3:o3 , \n" ++ " \"l1\" ; \n" ++ " is base2:p2 of base1:o1 , \n" ++ " base2:o2 , \n" ++ " base3:o3 ] . \n" -- " \"l1\" ] . \n" -} -- List nodes, with and without :- exoticN3Graph_x4 :: B.Builder exoticN3Graph_x4 = commonPrefixes `mappend` "base1:s1 = ( base1:o1 base2:o2 base3:o3 \"l1\" ) .\n" exoticN3Graph_x5 :: B.Builder exoticN3Graph_x5 = commonPrefixes `mappend` "( base1:o1 base2:o2 base3:o3 \"l1\" ) = base1:s1 .\n" {- exoticN3Graph_x6 = commonPrefixes ++ " base1:s1 :- (base1:o1 base2:o2 base3:o3 \"l1\") .\n" -} -- Formula nodes exoticN3Graph_x7 :: B.Builder exoticN3Graph_x7 = mconcat [ commonPrefixes , " { \n" , " base1:s1 base1:p1 base1:o1 .\n" , " base2:s2 base1:p1 base2:o2 .\n" , " base3:s3 base1:p1 base3:o3\n" , " } base2:p2 base2:f2 .\n" ] -- as above with the trailing . in the formula exoticN3Graph_x7a :: B.Builder exoticN3Graph_x7a = mconcat [ commonPrefixes , " { \n" , " base1:s1 base1:p1 base1:o1 .\n" , " base2:s2 base1:p1 base2:o2 .\n" , " base3:s3 base1:p1 base3:o3 .\n" , " } base2:p2 base2:f2 ." ] {- exoticN3Graph_x8 = commonPrefixes ++ " base1:f1 :- \n" ++ " { base1:s1 base1:p1 base1:o1 . \n" ++ " base2:s2 base1:p1 base2:o2 . \n" ++ " base3:s3 base1:p1 base3:o3 . } ; \n" ++ " base2:p2 base2:f2 . " -} {- exoticN3Graph_x9 = commonPrefixes ++ " base1:f1 :- \n" ++ " { base1:s1 base1:p1 base1:o1 . } ; \n" ++ " base2:p2 base2:f2 . " -} -- Test allocation of bnodes over a nested formula exoticN3Graph_x12 :: B.Builder exoticN3Graph_x12 = mconcat [ commonPrefixes , " base1:s1 base1:p1 [ base1:p1 base1:o1 ] . \n" , " { base2:s2 base2:p2 [ base2:p2 base2:o2 ] . } \n" , " base2:p2 base2:f2 . \n" , " base3:s3 base3:p3 [ base3:p3 base3:o3 ] ." ] -- List of bnodes {- exoticN3Graph_x13 = commonPrefixes ++ " base1:s1 :- \n" ++ " ( [base1:p1 base1:o1] \n" ++ " [base1:p1 base2:o2] \n" ++ " [base1:p1 base3:o3] ) .\n" -} {- TODO Hmm, what does the input graph really mean? can we test the following somewhere (do we already?) exoticN3Graph_x13 = commonPrefixes ++ " base1:s1 = \n" ++ " ( [base1:p1 base1:o1] \n" ++ " [base1:p1 base2:o2] \n" ++ " [base1:p1 base3:o3] ) .\n" -} -- List of more complex bnodes {- exoticN3Graph_x14 = commonPrefixes ++ " base1:s1 :- \n" ++ " ( [base1:p1 base1:o1; base2:p2 base1:o1] \n" ++ " [base1:p1 base2:o2; base2:p2 base2:o2] \n" ++ " [base1:p1 base3:o3; base2:p2 base3:o3] ) .\n" -} exoticN3Graph_x14 :: B.Builder exoticN3Graph_x14 = mconcat [ commonPrefixes , " base1:s1 = \n" , " ( [base1:p1 base1:o1; base2:p2 base1:o1] \n" , " [base1:p1 base2:o2; base2:p2 base2:o2] \n" , " [base1:p1 base3:o3; base2:p2 base3:o3] ) .\n" ] -- List with nested list {- exoticN3Graph_x15 = commonPrefixes ++ " base1:s1 :- \n" ++ " ( [base1:p1 base1:o1] \n"++ " [base2:p2 \n" ++ " ( [base1:p1 base1:o1] \n" ++ " [base1:p1 base2:o2] \n" ++ " [base1:p1 base3:o3] ) ] \n"++ " [base1:p1 base3:o3] ) .\n" -} -- More complex list with nested list {- exoticN3Graph_x16 = commonPrefixes ++ " base1:s1 :- \n" ++ " ( [base1:p1 base1:o1; base2:p2 base1:o1] \n"++ " [base2:p2 \n" ++ " ( [base1:p1 base1:o1; base2:p2 base1:o1] \n" ++ " [base1:p1 base2:o2; base2:p2 base2:o2] \n" ++ " [base1:p1 base3:o3; base2:p2 base3:o3] ) ] \n"++ " [base1:p1 base3:o3; base2:p2 base3:o3] ) .\n" -} -- Troublesome example {- exoticN3Graph_x17 = commonPrefixes ++ "base1:s1 a base1:o1 ; :- \n" ++ " ( [ base2:p21 base2:o2 ; \n" ++ " base2:p22 ( [ base2:p23 \"lx11\" ] \"lx12\" ) ] \n" ++ " [ base2:p24 base3:o3 ; base2:p25 \"lx13\" ] \n" ++ " ) . \n" -} -- Null prefixes {- exoticN3Graph_x18 = commonPrefixes ++ "@prefix : <#> . " ++ ":s1 a :o1 ; :- \n" ++ " ( [ :p21 :o2 ; \n" ++ " :p22 ( [ :p23 \"lx11\" ] \"lx12\" ) ] \n" ++ " [ :p24 :o3 ; :p25 \"lx13\" ] \n" ++ " ) . \n" -} -- Check graph sources parse to expected values exoticTestSuite :: Test exoticTestSuite = TestList [ parseTest "exoticParseTest01" exoticN3Graph_x1 x1 noError , parseTest "exoticParseTest02" exoticN3Graph_x2 x2 noError -- exoticParseTest03 = parseTest "exoticParseTest03" exoticN3Graph_x3 x3 noError , parseTest "exoticParseTest04" exoticN3Graph_x4 x4 noError , parseTest "exoticParseTest05" exoticN3Graph_x5 x5 noError -- exoticParseTest06 = parseTest "exoticParseTest06" exoticN3Graph_x6 x6 noError , parseTest "exoticParseTest07" exoticN3Graph_x7 x7 noError , parseTest "exoticParseTest07a" exoticN3Graph_x7a x7 noError -- exoticParseTest08 = parseTest "exoticParseTest08" exoticN3Graph_x8 x8 noError -- exoticParseTest09 = parseTest "exoticParseTest09" exoticN3Graph_x9 x9 noError , parseTest "exoticParseTest12" exoticN3Graph_x12 x12 noError -- exoticParseTest13 = parseTest "exoticParseTest13" exoticN3Graph_x13 x13 noError -- exoticParseTest14 = parseTest "exoticParseTest14" exoticN3Graph_x14 x14 noError -- TODO: re-instate? -- exoticParseTest15 = parseTest "exoticParseTest15" exoticN3Graph_x15 x15 noError -- exoticParseTest16 = parseTest "exoticParseTest16" exoticN3Graph_x16 x16 noError -- exoticParseTest17 = parseTest "exoticParseTest17" exoticN3Graph_x17 x17 noError , exoticTest "01" x1 , exoticTest "02" x2 , exoticTest "03" x3 , exoticTest "04" x4 , exoticTest "05" x5 , exoticTest "06" x6 , exoticTest "07" x7 -- exoticTest08 = exoticTest "08" x8 -- TODO: serialisation uses :- with a named node -- exoticTest09 = exoticTest "09" x9 -- TODO: serialisation uses :- with a named node , testGraphEq "exoticTest10" False x7 x8 , testGraphEq "exoticTest11" False x8 x9 , exoticTest "12" x12 , exoticTest "13" x13 , exoticTest "13a" x13a , exoticTest "14" x14 , exoticTest "15" x15 , exoticTest "16" x16 , exoticTest "17" x17 , fullRoundTripTest "Exotic01" exoticN3Graph_x1 , fullRoundTripTest "Exotic02" exoticN3Graph_x2 -- exoticRoundTripTest03 = fullRoundTripTest "Exotic03" exoticN3Graph_x3 , fullRoundTripTest "Exotic04" exoticN3Graph_x4 , fullRoundTripTest "Exotic05" exoticN3Graph_x5 -- exoticRoundTripTest06 = fullRoundTripTest "Exotic06" exoticN3Graph_x6 , fullRoundTripTest "Exotic07" exoticN3Graph_x7 -- exoticRoundTripTest08 = fullRoundTripTest "Exotic08" exoticN3Graph_x8 -- exoticRoundTripTest09 = fullRoundTripTest "Exotic09" exoticN3Graph_x9 , fullRoundTripTest "Exotic12" exoticN3Graph_x12 , fullRoundTripTest "Exotic14" exoticN3Graph_x14 -- exoticRoundTripTest15 = fullRoundTripTest "Exotic15" exoticN3Graph_x15 -- exoticRoundTripTest16 = fullRoundTripTest "Exotic16" exoticN3Graph_x16 -- exoticRoundTripTest17 = fullRoundTripTest "Exotic17" exoticN3Graph_x17 -- exoticRoundTripTest18 = fullRoundTripTest "Exotic18" exoticN3Graph_x18 ] ------------------------------------------------------------ -- All tests ------------------------------------------------------------ allTests :: [TF.Test] allTests = [ conv "trivial" trivialTestSuite , conv "parse" parseTestSuite , conv "roundtrip" roundTripTestSuite , conv "simple" simpleTestSuite , conv "exotic" exoticTestSuite ] main :: IO () main = TF.defaultMain allTests -------------------------------------------------------------------------------- -- -- Copyright (c) 2003, Graham Klyne, 2009 Vasili I Galchin, -- 2011, 2012, 2013 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 -- --------------------------------------------------------------------------------