--------------------------------------------------------------------------------
--  See end of this file for licence information.
--------------------------------------------------------------------------------
-- |
--  Module      :  N3ParserTest
--  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 module "N3Parser".
--
--------------------------------------------------------------------------------

module Main where

import Swish.RDF.N3Parser
    ( parseN3fromString, parseN3
    , parseTextFromString, parseAltFromString
    , parseNameFromString, parsePrefixFromString
    , parseAbsURIrefFromString, parseLexURIrefFromString
    , parseURIref2FromString
    )

import Swish.RDF.RDFGraph
    ( RDFGraph, RDFLabel(..), NSGraph(..)
    -- LookupNamespace(..), Namespace
    , emptyNamespaceMap
    , LookupFormula(..), emptyFormulaMap
    , emptyRDFGraph, toRDFGraph
      -- Export selected RDFLabel values
    , res_rdf_type, res_rdf_first, res_rdf_rest, res_rdf_nil
    , res_owl_sameAs, res_log_implies
    )

import Swish.Utils.Namespace
    ( Namespace(..)
    , nullNamespace
    , ScopedName(..)
    , makeScopedName
    , nullScopedName
    , makeUriScopedName
    )

import Swish.RDF.Vocabulary
    ( namespaceRDF
    , langName
    , rdf_XMLLiteral
    )

import Swish.Utils.QName (QName, qnameFromURI)
import Swish.Utils.LookupMap (LookupMap(..))

import Swish.RDF.GraphClass (Arc, arc) 

import Test.HUnit (Test(TestCase,TestList), assertEqual, runTestTT)

import Data.List (intercalate)

------------------------------------------------------------
--  Generic item parsing test wrapper
------------------------------------------------------------

type ParseFromString a = String -> (Either String a)

parseItemTest :: (Eq a, Show a) => ParseFromString a -> a
                 -> String -> String -> a -> String -> Test
parseItemTest ifroms def lab inp val err =
    TestList
      [ TestCase ( assertEqual ("parseItemError:"++lab) fixerr pe )
      , TestCase ( assertEqual ("parseItemValue:"++lab) val pv )
      ]
    where
        (pe,pv) = case ifroms inp of
            Left  e -> (e,def)
            Right v -> (noError,v)
        fixerr = if err /= noError then pe else noError

noError, errorText :: String
noError   = ""
errorText = "*"

------------------------------------------------------------
--  Common test wrappers
------------------------------------------------------------

testLabelEq :: String -> Bool -> RDFLabel -> RDFLabel -> Test
testLabelEq lab eq n1 n2 =
    TestCase ( assertEqual ("testLabelEq:"++lab) eq (n1==n2) )

testGraphEq :: String -> Bool -> RDFGraph -> RDFGraph -> Test
testGraphEq lab eq gg1 gg2 =
    TestCase ( assertEqual ("testGraphEq:"++lab) eq (gg1==gg2) )

parseTest :: String -> String -> 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 parseN3fromString inp of
            Right g -> ("",g)
            Left  s -> (s,emptyRDFGraph)

parseTestB :: QName -> String -> String -> RDFGraph -> String -> Test
parseTestB base lab inp gr er =
    TestList
      [ TestCase ( assertEqual ("parseTestError<base>:"++lab) er pe )
      , TestCase ( assertEqual ("parseTestGraph<base>:"++lab) gr pg )
      ]
    where
        (pe,pg) = case parseN3 inp (Just base) of
            Right g -> ("",g)
            Left  s -> (s,emptyRDFGraph)

------------------------------------------------------------
--  Test simple character parsing
------------------------------------------------------------

parseCharTest :: String -> String
                 -> String -> String -> String -> Test
parseCharTest c = parseItemTest (parseTextFromString c) ""

parseAltTest :: String -> String
                -> String -> String -> String -> String -> Test
parseAltTest cc1 cc2 = parseItemTest (parseAltFromString cc1 cc2) ""

charInp01, char01 :: String
charInp01 = ":"
char01    = ":"

charInp02, char02 :: String
charInp02 = "<>"
char02    = "<>"

charInp03 :: String
charInp03 = "<="

charTestSuite :: Test
charTestSuite = TestList
  [ parseCharTest char01 "parseCharTest01" charInp01 char01 noError
  , parseCharTest char02 "parseCharTest02" charInp02 char02 noError
  , parseAltTest char01 char02 "parseCharTest03" charInp01 char01 noError
  , parseAltTest char01 char02 "parseCharTest04" charInp02 char02 noError
  , parseAltTest char01 char02 "parseCharTest04" charInp03 "" errorText
  ]

------------------------------------------------------------
--  Test simple name parsing
------------------------------------------------------------

parseNameTest :: String -> String -> String -> String -> Test
parseNameTest = parseItemTest parseNameFromString ""

nameTestSuite :: Test
nameTestSuite = TestList
  [ parseNameTest "parseNameTest01" "name" "name" ""
  , parseNameTest "parseNameTest02" "rdf" "rdf" ""
  ]

------------------------------------------------------------
--  Test simple prefix parsing
------------------------------------------------------------

parsePrefixTest :: String -> String -> Namespace -> String -> Test
parsePrefixTest = parseItemTest parsePrefixFromString nullNamespace

prefix01, prefix02 :: Namespace
prefix01 = Namespace "pref" "pref:"
prefix02 = Namespace "rdf" $ nsURI namespaceRDF

prefixTestSuite :: Test
prefixTestSuite = TestList
  [ parsePrefixTest "parsePrefixTest01" "pref" prefix01 ""
  , parsePrefixTest "parsePrefixTest02" "rdf" prefix02 ""
  ]

------------------------------------------------------------
--  Test absolute URIref parsing
------------------------------------------------------------

parseAbsUriRefTest :: String -> String -> String -> String -> Test
parseAbsUriRefTest = parseItemTest parseAbsURIrefFromString ""

parseLexUriRefTest :: String -> String -> String -> String -> Test
parseLexUriRefTest = parseItemTest parseLexURIrefFromString ""

absUriRefInp01, absUriRefInp01s, absUriRef01 :: String
absUriRefInp01  = "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>"
absUriRefInp01s = "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type> "
absUriRef01     = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type"

absUriRefInp02, absUriRefInp02s, absUriRef02 :: String
absUriRefInp02  = "<http://id.ninebynine.org/wip/2003/test/graph1/node#s1>"
absUriRefInp02s = "<http://id.ninebynine.org/wip/2003/test/graph1/node#s1> "
absUriRef02     = "http://id.ninebynine.org/wip/2003/test/graph1/node#s1"

absUriRefTestSuite :: Test
absUriRefTestSuite = TestList
  [ parseAbsUriRefTest "parseAbsUriRefTest01" absUriRefInp01 absUriRef01 ""
  , parseAbsUriRefTest "parseAbsUriRefTest02" absUriRefInp02 absUriRef02 ""
  , parseLexUriRefTest "parseAbsUriRefTest03" absUriRefInp01s absUriRef01 ""
  , parseLexUriRefTest "parseAbsUriRefTest04" absUriRefInp02s absUriRef02 ""
  ]

------------------------------------------------------------
--  Test simple URIref parsing
------------------------------------------------------------

parseUriRef2Test :: String -> String -> ScopedName -> String -> Test
parseUriRef2Test = parseItemTest parseURIref2FromString nullScopedName

uriRef01 :: String
uriRef01 = "rdf:type "

sname01 :: ScopedName
sname01  = ScopedName namespaceRDF "type"

uriRef02 :: String
uriRef02 = "<http://id.ninebynine.org/wip/2003/test/graph1/node#s1> "

sname02 :: ScopedName
sname02  =
    makeScopedName "" "http://id.ninebynine.org/wip/2003/test/graph1/node#" "s1"

uriRef2TestSuite :: Test
uriRef2TestSuite = TestList
  [ parseUriRef2Test "parseUriRef2Test01" uriRef01 sname01 ""
  , parseUriRef2Test "parseUriRef2Test02" uriRef02 sname02 ""
  ]

------------------------------------------------------------
--  Define some common values
------------------------------------------------------------

baseFile :: String
baseFile = "file:///dev/null"

dqn :: QName
dqn = qnameFromURI baseFile

dbase, base1, base2, base3, base4, basea :: Namespace
dbase = Namespace ""      (baseFile ++ "#")
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"
basea = Namespace "a" "http://example.org/basea#"

u1 :: RDFLabel
u1 = Res $ ScopedName base1 ""

ds1, ds2, ds3 :: RDFLabel
ds1 = Res $ ScopedName dbase "s1"
ds2 = Res $ ScopedName dbase "s2"
ds3 = Res $ ScopedName dbase "s3"

dp1, dp2, dp3 :: RDFLabel
dp1 = Res $ ScopedName dbase "p1"
dp2 = Res $ ScopedName dbase "p2"
dp3 = Res $ ScopedName dbase "p3"

do1, do2, do3 :: RDFLabel
do1 = Res $ ScopedName dbase "o1"
do2 = Res $ ScopedName dbase "o2"
do3 = Res $ ScopedName dbase "o3"

s1, s2, s3, sa :: RDFLabel
s1 = Res $ ScopedName base1 "s1"
s2 = Res $ ScopedName base2 "s2"
s3 = Res $ ScopedName base3 "s3"
sa = Res $ ScopedName basea "a"

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, pa :: RDFLabel
p1 = Res $ ScopedName base1 "p1" 
p2 = Res $ ScopedName base2 "p2" 
p3 = Res $ ScopedName base3 "p3" 
pa = Res $ ScopedName basea "b" 

o1, o2, o3, oa :: RDFLabel
o1 = Res $ ScopedName base1 "o1"
o2 = Res $ ScopedName base2 "o2"
o3 = Res $ ScopedName base3 "o3"
oa = Res $ ScopedName basea "c"

l1, l2, l3 :: RDFLabel
l1 = Lit "l1"  Nothing
l2 = Lit "l2-'\"line1\"'\n\nl2-'\"\"line2\"\"'" Nothing
l3 = Lit "l3--\r\"'\\--\x0020\&--\x00A0\&--" Nothing

lfr, lxml, lfrxml :: RDFLabel
lfr    = Lit "chat"          (Just $ langName "fr")
lxml   = Lit "<br/>"         (Just rdf_XMLLiteral )
lfrxml = Lit "<em>chat</em>" (Just rdf_XMLLiteral )

bTrue, bFalse :: RDFLabel
bTrue  = Lit "true"  $ Just $ ScopedName (Namespace "xsd" "http://www.w3.org/2001/XMLSchema#") "boolean"
bFalse = Lit "false" $ Just $ ScopedName (Namespace "xsd" "http://www.w3.org/2001/XMLSchema#") "boolean"

f1, f2 :: RDFLabel
f1 = Res $ ScopedName base1 "f1"
f2 = Res $ ScopedName base2 "f2" 

v1, v2, v3, v4 :: RDFLabel
v1 = Var "var1"
v2 = Var "var2"
v3 = Var "var3"
v4 = Var "var4"

------------------------------------------------------------
--  Construct graphs for testing
------------------------------------------------------------

t01 , t01b, t02, t03, t04, t05, t06, t07 :: Arc RDFLabel
t01  = arc s1 p1 o1
t01b = arc b1 b2 b3
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

makeNewPrefixNamespace :: (String,Namespace) -> Namespace
makeNewPrefixNamespace (pre,ns) = Namespace pre (nsURI ns)

dg1 :: RDFGraph
dg1 = toRDFGraph [arc ds1 dp1 do1]

dg2 :: RDFGraph
dg2 = toRDFGraph
      [ arc xa1 xb1 xc1
      , arc xa2 xb2 xc2
      , arc xa3 xb3 xc3
      , arc xa4 xb4 xc4
      , arc xa5 xb5 xc5
      ]
  where
    -- the document base is set to file:///dev/null to begin with
    mU = Res . makeUriScopedName 
    xa1 = mU "file:///dev/a1"
    xb1 = mU "file:///dev/b1"
    xc1 = mU "file:///dev/c1"
    xa2 = mU "http://example.org/ns/a2"
    xb2 = mU "http://example.org/ns/b2"
    xc2 = mU "http://example.org/ns/c2"
    xa3 = mU "http://example.org/ns/foo/a3"
    xb3 = mU "http://example.org/ns/foo/b3"
    xc3 = mU "http://example.org/ns/foo/c3"
    
    ns4 = Namespace "" "http://example.org/ns/foo/bar#"
    ns5 = Namespace "" "http://example.org/ns2#"
    mUN a b = Res (ScopedName a b)
    xa4 = mUN ns4 "a4"
    xb4 = mUN ns4 "b4"
    xc4 = mUN ns4 "c4"
    xa5 = mUN ns5 "a5"
    xb5 = mUN ns5 "b5"
    xc5 = mUN ns5 "c5"

nslist :: LookupMap Namespace
nslist = LookupMap $ map makeNewPrefixNamespace
    [ ("base1",base1)
    , ("base2",base2)
    , ("base3",base3)
    , ("base4",base4)
    ]

toGraph :: [Arc RDFLabel] -> RDFGraph
toGraph stmts = NSGraph { namespaces = nslist
                        , formulae   = emptyFormulaMap
                        , statements = stmts
                        }

g1 :: RDFGraph
g1 = toGraph [t01]

g1a :: RDFGraph
g1a = toGraph [arc sa pa oa] 

g1_31 :: RDFGraph
g1_31 = toGraph [arc u1 u1 u1]

g1b :: RDFGraph
g1b = toGraph [t01b]

g2 :: RDFGraph
g2 = toGraph [t01,t02,t03]

g3 :: RDFGraph
g3 = toGraph [t01,t04]

g4 :: RDFGraph
g4 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t01,t05]
        }

g5 :: RDFGraph
g5 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t01,t02,t03,t04,t05]
        }

g6 :: RDFGraph
g6 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t01,t06]
        }

g7 :: RDFGraph
g7 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t01,t07]
        }

t801, t802, t807, t808, t811, t812 :: Arc RDFLabel
t801 = arc s1 res_rdf_type       o1
t802 = arc s2 res_owl_sameAs     o2
t807 = arc o1 p1 s1
t808 = arc s2 p1 o2
t811 = arc s1 res_log_implies o1
t812 = arc o2 res_log_implies s2

g8 :: RDFGraph
g8 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t801,t802,t807,t808,t811,t812]
        }

g81 :: RDFGraph
g81 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t801,t802]
        }

g83 :: RDFGraph
g83 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t807,t808,t811,t812]
        }

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 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [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

g10 :: RDFGraph
g10 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t1011,t1012,t1013,t1014,
                        t1021,t1022,t1023,t1024,
                        t1025,t1026,t1027,t1028]
        }

t1111, t1112, t1113 :: Arc RDFLabel
t1111 = arc s1 p1 v1
t1112 = arc v2 p1 o1
t1113 = arc v3 p1 v4

g11 :: RDFGraph
g11 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t1111,t1112,t1113]
        }

t1211, t1221, t1222, t1223, t1224 :: Arc RDFLabel
t1211 = arc b1 p1 o1
t1221 = arc b2 res_rdf_first v1
t1222 = arc b2 res_rdf_rest  b3
t1223 = arc b3 res_rdf_first v2
t1224 = arc b3 res_rdf_rest  res_rdf_nil

g12 :: RDFGraph
g12 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t1211,t1221,t1222,t1223,t1224]
        }

t1711, t1722, t1733 :: Arc RDFLabel
t1711 = arc s1 p1 lfr
t1722 = arc s2 p2 lxml
t1733 = arc s3 p3 lfrxml

g17 :: RDFGraph
g17 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [t1711,t1722,t1733]
        }

tx101, tx102, tx111, tx112, tx113, tx114, tx121, tx122, tx123,
  tx124, tx125, tx126, tx127, tx128 :: Arc RDFLabel
tx101 = arc b1 res_owl_sameAs s1
tx102 = arc s2 res_owl_sameAs 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 l1

x1 :: RDFGraph
x1 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [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, tx228 :: Arc RDFLabel
tx201 = arc b1 res_owl_sameAs s1
tx202 = arc s2 res_owl_sameAs 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 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx201,tx202,
                        tx211,tx212,tx213,tx214,
                        tx221,tx222,tx223,tx224,
                        tx225,tx226,tx227,tx228]
        }

tx311, tx312, tx313, tx314, tx321, tx322, tx323,
  tx324, tx325, tx326, tx327, tx328 :: 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 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx311,tx312,tx313,tx314,
                        tx321,tx322,tx323,tx324,
                        tx325,tx326,tx327,tx328]
        }

tx401, tx402, tx403, tx404, tx405, tx406, tx407,
  tx408, tx409 :: Arc RDFLabel
tx401 = arc s1 res_owl_sameAs b1
tx402 = arc b1 res_rdf_first  o1
tx403 = arc b1 res_rdf_rest   b2
tx404 = arc b2 res_rdf_first  o2
tx405 = arc b2 res_rdf_rest   b3
tx406 = arc b3 res_rdf_first  o3
tx407 = arc b3 res_rdf_rest   b4
tx408 = arc b4 res_rdf_first  l1
tx409 = arc b4 res_rdf_rest   res_rdf_nil

x4 :: RDFGraph
x4 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx401,tx402,tx403,tx404,
                        tx405,tx406,tx407,tx408,
                        tx409]
        }

tx501, tx502, tx503, tx504, tx505, tx506, tx507,
  tx508, tx509 :: Arc RDFLabel
tx501 = arc b1 res_owl_sameAs s1
tx502 = arc b1 res_rdf_first  o1
tx503 = arc b1 res_rdf_rest   b2
tx504 = arc b2 res_rdf_first  o2
tx505 = arc b2 res_rdf_rest   b3
tx506 = arc b3 res_rdf_first  o3
tx507 = arc b3 res_rdf_rest   b4
tx508 = arc b4 res_rdf_first  l1
tx509 = arc b4 res_rdf_rest   res_rdf_nil

x5 :: RDFGraph
x5 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx501,tx502,tx503,tx504,
                        tx505,tx506,tx507,tx508,
                        tx509]
        }

tx601, tx602, tx603, tx604, tx605, tx606, tx607,
  tx608 :: Arc RDFLabel
tx601 = arc s1 res_rdf_first o1
tx602 = arc s1 res_rdf_rest  b2
tx603 = arc b2 res_rdf_first o2
tx604 = arc b2 res_rdf_rest  b3
tx605 = arc b3 res_rdf_first o3
tx606 = arc b3 res_rdf_rest  b4
tx607 = arc b4 res_rdf_first l1
tx608 = arc b4 res_rdf_rest  res_rdf_nil

x6 :: RDFGraph
x6 = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx601,tx602,tx603,tx604,
                        tx605,tx606,tx607,tx608]
        }

tx701 :: Arc RDFLabel
tx701 = arc b1 p2 f2

x7 :: RDFGraph
x7    = NSGraph
        { namespaces = nslist
        , formulae   = LookupMap [Formula b1 g2]
        , statements = [tx701]
        }

tx801 :: Arc RDFLabel
tx801 = arc f1 p2 f2

x8 :: RDFGraph
x8    = NSGraph
        { namespaces = nslist
        , formulae   = LookupMap [Formula f1 g2]
        , statements = [tx801]
        }

x9 :: RDFGraph
x9    = NSGraph
        { namespaces = nslist
        , formulae   = LookupMap [Formula f1 g1]
        , statements = [tx801]
        }

--  Test allocation of bnodes carries over a nested formula

tx1201, tx1202, tx1203, tx1204, tx1205, 
  tx1211, tx1212 :: Arc RDFLabel
tx1201 = arc s1 p1 b1
tx1202 = arc b1 p1 o1
tx1203 = arc b2 p2 f2
tx1204 = arc s3 p3 b3
tx1205 = arc b3 p3 o3
tx1211 = arc s2 p2 b4
tx1212 = arc b4 p2 o2

x12fg :: RDFGraph
x12fg  = NSGraph
        { namespaces = emptyNamespaceMap
        , formulae   = emptyFormulaMap
        , statements = [tx1211,tx1212]
        }
        
x12 :: RDFGraph
x12    = NSGraph
        { namespaces = nslist
        , formulae   = LookupMap [Formula b2 x12fg]
        , statements = [tx1201,tx1202,tx1203,tx1204,tx1205]
        }

--  List of simple anon nodes

tx1301, tx1302, tx1303, tx1304, tx1305, tx1306, tx1307,
  tx1308, tx1309 :: Arc RDFLabel
tx1301 = arc s1 res_rdf_first b1
tx1302 = arc s1 res_rdf_rest  c1
tx1303 = arc c1 res_rdf_first b2
tx1304 = arc c1 res_rdf_rest  c2
tx1305 = arc c2 res_rdf_first b3
tx1306 = arc c2 res_rdf_rest  res_rdf_nil
tx1307 = arc b1 p1 o1
tx1308 = arc b2 p1 o2
tx1309 = arc b3 p1 o3

x13 :: RDFGraph
x13    = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx1301,tx1302,tx1303,tx1304,tx1305,tx1306,
                        tx1307,tx1308,tx1309]
        }

--  List of more complex anon nodes

tx1401, tx1402, tx1403, tx1404, tx1405, tx1406, tx1407,
  tx1408, tx1409, tx1410, tx1411, tx1412 :: Arc RDFLabel
tx1401 = arc s1 res_rdf_first b1
tx1402 = arc s1 res_rdf_rest  c1
tx1403 = arc c1 res_rdf_first b2
tx1404 = arc c1 res_rdf_rest  c2
tx1405 = arc c2 res_rdf_first b3
tx1406 = arc c2 res_rdf_rest  res_rdf_nil
tx1407 = arc b1 p1 o1
tx1408 = arc b1 p2 o1
tx1409 = arc b2 p1 o2
tx1410 = arc b2 p2 o2
tx1411 = arc b3 p1 o3
tx1412 = arc b3 p2 o3

x14 :: RDFGraph
x14    = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx1401,tx1402,tx1403,tx1404,tx1405,tx1406,
                        tx1407,tx1408,tx1409,tx1410,tx1411,tx1412]
        }

--  List with nested list

tx1501, tx1502, tx1503, tx1504, tx1505, tx1506, tx1507,
  tx1508, tx1509 :: Arc RDFLabel
tx1501 = arc s1 res_rdf_first b1
tx1502 = arc s1 res_rdf_rest  c1
tx1503 = arc c1 res_rdf_first b2
tx1504 = arc c1 res_rdf_rest  c2
tx1505 = arc c2 res_rdf_first b3
tx1506 = arc c2 res_rdf_rest  res_rdf_nil
tx1507 = arc b1 p1 o1
tx1508 = arc b2 p2 c3
tx1509 = arc b3 p1 o3

tx1521, tx1522, tx1523, tx1524, tx1525, tx1526, tx1527,
  tx1528, tx1529 :: Arc RDFLabel
tx1521 = arc c3 res_rdf_first b4
tx1522 = arc c3 res_rdf_rest  c4
tx1523 = arc c4 res_rdf_first b5
tx1524 = arc c4 res_rdf_rest  c5
tx1525 = arc c5 res_rdf_first b6
tx1526 = arc c5 res_rdf_rest  res_rdf_nil
tx1527 = arc b4 p1 o1
tx1528 = arc b5 p1 o2
tx1529 = arc b6 p1 o3

x15 :: RDFGraph
x15    = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx1501,tx1502,tx1503,tx1504,tx1505,tx1506,
                        tx1507,tx1508,tx1509,
                        tx1521,tx1522,tx1523,tx1524,tx1525,tx1526,
                        tx1527,tx1528,tx1529]
        }

--  More complex list with nested list

tx1601, tx1602, tx1603, tx1604, tx1605, tx1606, tx1607,
  tx1608, tx1609, tx1610, tx1611 :: Arc RDFLabel
tx1601 = arc s1 res_rdf_first b1
tx1602 = arc s1 res_rdf_rest  c1
tx1603 = arc c1 res_rdf_first b2
tx1604 = arc c1 res_rdf_rest  c2
tx1605 = arc c2 res_rdf_first b3
tx1606 = arc c2 res_rdf_rest  res_rdf_nil
tx1607 = arc b1 p1 o1
tx1608 = arc b1 p2 o1
tx1609 = arc b2 p2 c3
tx1610 = arc b3 p1 o3
tx1611 = arc b3 p2 o3

tx1621, tx1622, tx1623, tx1624, tx1625, tx1626, tx1627,
  tx1628, tx1629, tx1630, tx1631, tx1632 :: Arc RDFLabel
tx1621 = arc c3 res_rdf_first b4
tx1622 = arc c3 res_rdf_rest  c4
tx1623 = arc c4 res_rdf_first b5
tx1624 = arc c4 res_rdf_rest  c5
tx1625 = arc c5 res_rdf_first b6
tx1626 = arc c5 res_rdf_rest  res_rdf_nil
tx1627 = arc b4 p1 o1
tx1628 = arc b4 p2 o1
tx1629 = arc b5 p1 o2
tx1630 = arc b5 p2 o2
tx1631 = arc b6 p1 o3
tx1632 = arc b6 p2 o3

x16 :: RDFGraph
x16    = NSGraph
        { namespaces = nslist
        , formulae   = emptyFormulaMap
        , statements = [tx1601,tx1602,tx1603,tx1604,tx1605,tx1606,
                        tx1607,tx1608,tx1609,tx1610,tx1611,
                        tx1621,tx1622,tx1623,tx1624,tx1625,tx1626,
                        tx1627,tx1628,tx1629,tx1630,tx1631,tx1632]
        }

kg1 :: RDFGraph
kg1 = toRDFGraph
      [ arc b a c ]
  where
    -- the document base is set to file:///dev/null to begin with
    ns = Namespace "" (baseFile ++ "#")
    mUN = Res . ScopedName ns
    a = mUN "a"
    b = mUN "b"
    c = mUN "c"

------------------------------------------------------------
--  Simple parser tests
------------------------------------------------------------

-- check default base
simpleN3Graph_dg_01 :: String
simpleN3Graph_dg_01 =
    ":s1 :p1 :o1 ."

-- from the turtle documentation
simpleN3Graph_dg_02 :: String
simpleN3Graph_dg_02 =
  "# this is a complete turtle document\n" ++
  "# In-scope base URI is the document URI at this point\n" ++
  "<a1> <b1> <c1> .\n" ++
  "@base <http://example.org/ns/> .\n" ++
  "# In-scope base URI is http://example.org/ns/ at this point\n" ++
  "<a2> <http://example.org/ns/b2> <c2> .\n" ++
  "@base <foo/> .\n" ++
  "# In-scope base URI is http://example.org/ns/foo/ at this point\n" ++
  "<a3> <b3> <c3> .\n" ++
  "@prefix : <bar#> .\n" ++
  ":a4 :b4 :c4 .\n" ++
  "@prefix : <http://example.org/ns2#> .\n" ++
  ":a5 :b5 :c5 .\n"

commonPrefixes :: String
commonPrefixes =
    "@prefix base1 : <" ++ nsURI base1 ++ "> . \n" ++
    "@prefix base2 : <" ++ nsURI base2 ++ "> . \n" ++
    "@prefix base3 : <" ++ nsURI base3 ++ "> . \n"

--  Single statement using <uri> form
simpleN3Graph_g1_01 :: String
simpleN3Graph_g1_01 =
    " <http://id.ninebynine.org/wip/2003/test/graph1/node/s1> " ++
    " <http://id.ninebynine.org/wip/2003/test/graph1/node/p1> " ++
    " <http://id.ninebynine.org/wip/2003/test/graph1/node/o1> . "

--  Single statement using prefix:name form
simpleN3Graph_g1_02 :: String
simpleN3Graph_g1_02 =
    "@prefix base1 : <" ++ nsURI base1 ++ "> ." ++
    " base1:s1 base1:p1 base1:o1 . "

--  Single statement using prefix:name form
--  (this was added to check that the parser did not
--   think we meant 'a:a a :b .' here)
--
simpleN3Graph_g1_02a :: String
simpleN3Graph_g1_02a =
    "@prefix a: <" ++ nsURI basea ++ "> ." ++
    "a:a a:b a:c ."

--  Single statement using :name form
simpleN3Graph_g1_03 :: String
simpleN3Graph_g1_03 =
    "@prefix : <" ++ nsURI base1 ++ "> .\n" ++
    " :s1 :p1 :o1 . "

--  Turtle supports ':' but (apparently) not N3, but try
--  and support it.
--
simpleN3Graph_g1_03_1 :: String
simpleN3Graph_g1_03_1 =
    "@prefix : <" ++ nsURI base1 ++ "> .\n" ++
    " : : :."

simpleN3Graph_g1_03_2 :: String
simpleN3Graph_g1_03_2 =
    "@prefix b: <" ++ nsURI base1 ++ "> .\n" ++
    "b: b: b:. "

--  Single statement using relative URI form
simpleN3Graph_g1_04 :: String
simpleN3Graph_g1_04 =
    "@base <" ++ nsURI base1 ++ "> .\n" ++
    " <s1> <p1> <o1> . "

--  Single statement using blank nodes
simpleN3Graph_g1_05 :: String
simpleN3Graph_g1_05 =
    "@base <" ++ nsURI base1 ++ "> .\n" ++
    " _:b1 _:b2 _:b3 . "

--  Single statement with junk following
simpleN3Graph_g1_06 :: String
simpleN3Graph_g1_06 =
    "@prefix base1 : <" ++ nsURI base1 ++ "> ." ++
    " base1:s1 base1:p1 base1:o1 . " ++
    " **** "

--  Multiple statements
simpleN3Graph_g2 :: String
simpleN3Graph_g2 =
    commonPrefixes ++
    " base1:s1 base1:p1 base1:o1 . \n" ++
    " base2:s2 base1:p1 base2:o2 . \n" ++
    " base3:s3 base1:p1 base3:o3 . \n"

--  Graph with literal
simpleN3Graph_g3 :: String
simpleN3Graph_g3 =
    commonPrefixes ++
    " base1:s1 base1:p1 base1:o1 . \n" ++
    " base1:s1 base1:p1 \"l1\" . \n"

--  Graph with nodeid
simpleN3Graph_g4 :: String
simpleN3Graph_g4 =
    commonPrefixes ++
    " base1:s1 base1:p1 base1:o1 . \n" ++
    " base2:s2 base1:p1 _:b1 . \n"

--  Graph with literal and nodeid
simpleN3Graph_g5 :: String
simpleN3Graph_g5 =
    commonPrefixes ++
    " base1:s1 base1:p1 base1:o1 . \n" ++
    " base2:s2 base1:p1 base2:o2 . \n" ++
    " base3:s3 base1:p1 base3:o3 . \n" ++
    " base1:s1 base1:p1 \"l1\" . \n"   ++
    " base2:s2 base1:p1 _:b1 . \n"

--  Triple-quoted literal
simpleN3Graph_g6 :: String
simpleN3Graph_g6 =
    commonPrefixes ++
    " base1:s1 base1:p1 base1:o1 . \n" ++
    " base3:s3 base1:p1 \"\"\"l2-'\"line1\"'\n\nl2-'\"\"line2\"\"'\"\"\" . \n"

--  String escapes
simpleN3Graph_g7 :: String
simpleN3Graph_g7 =
    commonPrefixes ++
    " base1:s1 base1:p1 base1:o1 . \n" ++
    " base3:s3 base2:p2 " ++
    " \"l3--\\r\\\"\\'\\\\--\\u0020--\\U000000A0--\" " ++
    " . \n"

--  Different verb forms
simpleN3Graph_g8 :: String
simpleN3Graph_g8 =
    commonPrefixes ++
    " base1:s1 a base1:o1 . \n" ++
    " base2:s2 = base2:o2 . \n" ++
    " base1:s1 @is  base1:p1 @of base1:o1 . \n" ++
    " base2:s2 @has base1:p1 base2:o2 . \n" ++
    " base1:s1 => base1:o1 . \n" ++
    " base2:s2 <= base2:o2 . \n"

simpleN3Graph_g8b :: String
simpleN3Graph_g8b =
    commonPrefixes ++
    " base1:s1 a base1:o1 . \n" ++
    " base2:s2 = base2:o2 . \n" ++
    " base1:s1 is  base1:p1 of base1:o1 . \n" ++
    " base2:s2 @has base1:p1 base2:o2 . \n" ++
    " base1:s1 => base1:o1 . \n" ++
    " base2:s2 <= base2:o2 . \n"

simpleN3Graph_g81 :: String
simpleN3Graph_g81 =
    commonPrefixes ++
    " base1:s1 a base1:o1 . \n" ++
    " base2:s2 = base2:o2 . \n"

simpleN3Graph_g83 :: String
simpleN3Graph_g83 =
    commonPrefixes ++
    " base1:s1 @is  base1:p1 @of base1:o1 . \n" ++
    " base2:s2 @has base1:p1 base2:o2 . \n" ++
    " base1:s1 => base1:o1 . \n" ++
    " base2:s2 <= base2:o2 . \n"

simpleN3Graph_g83b :: String
simpleN3Graph_g83b =
    commonPrefixes ++
    " base1:s1 is  base1:p1 of base1:o1 . \n" ++
    " base2:s2 @has base1:p1 base2:o2 . \n" ++
    " base1:s1 => base1:o1 . \n" ++
    " base2:s2 <= base2:o2 . \n"

--  Semicolons and commas
simpleN3Graph_g9 :: String
simpleN3Graph_g9 =
    commonPrefixes ++
    " base1:s1 base1:p1 base1:o1 ; \n" ++
    "          base1:p1 base2:o2 ; \n" ++
    "          base2:p2 base2:o2 ; \n" ++
    "          base2:p2 base3:o3 . \n" ++
    " base2:s2 base1:p1 base1:o1 , \n" ++
    "                   base2:o2 , \n" ++
    "                   base3:o3 , \n" ++
    "                   \"l1\"   ; \n" ++
    "          base2:p2 base1:o1 , \n" ++
    "                   base2:o2 , \n" ++
    "                   base3:o3 , \n" ++
    "                   \"l1\"   . \n"

-- ensure you can end a property list with a semicolon
simpleN3Graph_g9b :: String
simpleN3Graph_g9b =
    commonPrefixes ++
    " base1:s1 base1:p1 base1:o1 ; \n" ++
    "          base1:p1 base2:o2 ; \n" ++
    "          base2:p2 base2:o2 ; \n" ++
    "          base2:p2 base3:o3;. \n" ++
    " base2:s2 base1:p1 base1:o1 , \n" ++
    "                   base2:o2 , \n" ++
    "                   base3:o3 , \n" ++
    "                   \"l1\"   ; \n" ++
    "          base2:p2 base1:o1 , \n" ++
    "                   base2:o2 , \n" ++
    "                   base3:o3 , \n" ++
    "                   \"l1\"   ;. \n"

--  'is ... of' and semicolons and commas
simpleN3Graph_g10 :: String
simpleN3Graph_g10 =
    commonPrefixes ++
    " base1:s1 @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 . \n" ++
    " base2:s2 @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" ++
    "                          \"l1\"   . \n"

--  Simple statements using ?var form
simpleN3Graph_g11 :: String
simpleN3Graph_g11 =
    "@prefix base1 : <" ++ nsURI base1 ++ "> . \n" ++
    " base1:s1 base1:p1 ?var1 . \n"          ++
    " ?var2 base1:p1 base1:o1 . \n"          ++
    " ?var3 base1:p1 ?var4 .    \n"

--  Bare anonymous nodes
simpleN3Graph_g12 :: String
simpleN3Graph_g12 =
    "@prefix base1 : <" ++ nsURI base1 ++ "> . \n" ++
    " [ base1:p1 base1:o1 ] .  \n"          ++
    " ( ?var1 ?var2 ) .    \n"

--  Literals with dataype and language
simpleN3Graph_g17 :: String
simpleN3Graph_g17 =
    commonPrefixes ++
    " base1:s1 base1:p1 \"chat\"@fr . \n "                          ++
    " base2:s2 base2:p2 \"<br/>\"^^rdf:XMLLiteral . \n "            ++
    " base3:s3 base3:p3 \"<em>chat</em>\"^^rdf:XMLLiteral . \n "

emsg16 :: String
emsg16 = intercalate "\n" [
  "",
  "@prefix base1 : <http://id.ninebynine.org/wip/2003/test/graph1/node/> . base1:s1 base1:p1 base1:o1 .  **** ",
  "                                                                                                      ^",
  "(line 1, column 103 indicated by the '^' sign above):",
  "",
  "unexpected \"*\"",
  "expecting declaration, \"@\", pathitem or end of input"
  ]


simpleTestSuite :: Test
simpleTestSuite = TestList
  [ parseTestB dqn "simpleTestd01" simpleN3Graph_dg_01 dg1  noError
  , parseTestB dqn "simpleTestd02" simpleN3Graph_dg_02 dg2  noError
  , parseTest "simpleTest011" simpleN3Graph_g1_01 g1  noError
  , parseTest "simpleTest012" simpleN3Graph_g1_02 g1  noError
  , parseTest "simpleTest012a" simpleN3Graph_g1_02a g1a  noError
  , parseTest "simpleTest013" simpleN3Graph_g1_03 g1  noError
  , parseTest "simpleTest013_1" simpleN3Graph_g1_03_1 g1_31  noError
  , parseTest "simpleTest013_2" simpleN3Graph_g1_03_2 g1_31  noError
  , parseTest "simpleTest014" simpleN3Graph_g1_04 g1  noError
  , parseTest "simpleTest015" simpleN3Graph_g1_05 g1b noError
  , parseTest "simpleTest016" simpleN3Graph_g1_06 emptyRDFGraph emsg16
  , parseTest "simpleTest03"  simpleN3Graph_g2    g2  noError
  , parseTest "simpleTest04"  simpleN3Graph_g3    g3  noError
  , parseTest "simpleTest05"  simpleN3Graph_g4    g4  noError
  , parseTest "simpleTest06"  simpleN3Graph_g5    g5  noError
  , parseTest "simpleTest07"  simpleN3Graph_g6    g6  noError
  , parseTest "simpleTest08"  simpleN3Graph_g7    g7  noError
  , parseTest "simpleTest09"  simpleN3Graph_g8    g8  noError
  , parseTest "simpleTest09b" simpleN3Graph_g8b   g8  noError
  , parseTest "simpleTest10"  simpleN3Graph_g81   g81 noError
  , parseTest "simpleTest12"  simpleN3Graph_g83   g83 noError
  , parseTest "simpleTest12b" simpleN3Graph_g83b  g83 noError
  , parseTest "simpleTest13"  simpleN3Graph_g9    g9  noError
  , parseTest "simpleTest13b" simpleN3Graph_g9b   g9  noError
  , parseTest "simpleTest14"  simpleN3Graph_g10   g10 noError
  , parseTest "simpleTest15"  simpleN3Graph_g11   g11 noError
  , parseTest "simpleTest16"  simpleN3Graph_g12   g12 noError
  , parseTest "simpleTest17"  simpleN3Graph_g17   g17 noError
  ]

------------------------------------------------------------
--  Literal parser tests
------------------------------------------------------------
--
--  Expand upon the literal testing done above
--

litN3Graph_g1 :: String
litN3Graph_g1 =
    commonPrefixes ++
    " base1:s1 base1:p1 \"true\"^^<http://www.w3.org/2001/XMLSchema#boolean>.\n" ++
    " base2:s2 base2:p2 \"false\"^^<http://www.w3.org/2001/XMLSchema#boolean>.\n" ++
    " base3:s3 base3:p3 \"true\"^^<http://www.w3.org/2001/XMLSchema#boolean>.\n"
    
litN3Graph_g2 :: String
litN3Graph_g2 =
    commonPrefixes ++
    " base1:s1 base1:p1 @true.\n" ++
    " base2:s2 base2:p2 @false.\n" ++
    " base3:s3 base3:p3 true.\n"
    
lit_g1 :: RDFGraph
lit_g1 = toGraph [ arc s1 p1 bTrue
                 , arc s2 p2 bFalse
                 , arc s3 p3 bTrue
                 ]

litTestSuite :: Test
litTestSuite = TestList
  [ parseTest "litTest01" litN3Graph_g1 lit_g1  noError
  , parseTest "litTest02" litN3Graph_g2 lit_g1  noError
  ]

------------------------------------------------------------
--  Exotic parser tests
------------------------------------------------------------
--
--  These tests cover various forms of anonymous nodes
--  [...], lists and formula. together with uses of ':-'
--

--  Simple anon nodes, with semicolons and commas
exoticN3Graph_x1 :: String
exoticN3Graph_x1 =
    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" ++
    "            \"l1\"   ] . \n"

-- check semi-colons at end of property list
exoticN3Graph_x1b :: String
exoticN3Graph_x1b =
    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" ++
    "            \"l1\" ;  ] ;. \n"

--  Simple anon nodes, with 'is ... of' and semicolons and commas
exoticN3Graph_x2 :: String
exoticN3Graph_x2 =
    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" ++
    "                     \"l1\"   ] . \n"


--  List nodes

exoticN3Graph_x4 :: String
exoticN3Graph_x4 =
    commonPrefixes ++
    " base1:s1 = (base1:o1 base2:o2 base3:o3 \"l1\") .\n"

exoticN3Graph_x5 :: String
exoticN3Graph_x5 =
    commonPrefixes ++
    " (base1:o1 base2:o2 base3:o3 \"l1\") = base1:s1 .\n"

--  Formula nodes, with and without :-

exoticN3Graph_x7 :: String
exoticN3Graph_x7 =
    commonPrefixes ++
    " { 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 . "

--  Test allocation of bnodes carries over a nested formula
exoticN3Graph_x12 :: String
exoticN3Graph_x12 =
    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 ] ."

exoticTestSuite :: Test
exoticTestSuite = 
  TestList
  [ parseTest "exoticTest01"  exoticN3Graph_x1   x1  noError
  , parseTest "exoticTest01b" exoticN3Graph_x1b  x1  noError
  , parseTest "exoticTest02"  exoticN3Graph_x2   x2  noError
  , parseTest "exoticTest04" exoticN3Graph_x4  x4  noError
  , parseTest "exoticTest05" exoticN3Graph_x5  x5  noError
  , parseTest "exoticTest07" exoticN3Graph_x7  x7  noError
  , parseTest "exoticTest12" exoticN3Graph_x12 x12 noError
  , testGraphEq "exoticTest20" False x7 x8
  , testGraphEq "exoticTest21" False x8 x9
  ]

keywordN3Graph_01 :: String
keywordN3Graph_01 = 
  "@keywords .\n" ++
  "b a c . "

-- a modification of simpleN3Graph_g8
keywordN3Graph_02 :: String
keywordN3Graph_02 = 
    commonPrefixes ++
    "@keywords a , is, of ,has.\n" ++
    " base1:s1 a base1:o1 . \n" ++
    " base2:s2 = base2:o2 . \n" ++
    " base1:s1 is  base1:p1 of base1:o1 . \n" ++
    " base2:s2 has base1:p1 base2:o2 . \n" ++
    " base1:s1 => base1:o1 . \n" ++
    " base2:s2 <= base2:o2 . \n"

-- a modification of simpleN3Graph_g83
keywordN3Graph_03 :: String
keywordN3Graph_03 = 
    commonPrefixes ++
    "@keywords of.\n" ++
    " base1:s1 @is  base1:p1 of base1:o1 . \n" ++
    " base2:s2 @has base1:p1 base2:o2 . \n" ++
    " base1:s1 => base1:o1 . \n" ++
    " base2:s2 <= base2:o2 . \n"

keywordTestSuite :: Test
keywordTestSuite = TestList
  [ parseTestB dqn "keywordTest01" keywordN3Graph_01  kg1  noError
  , parseTest "keywordTest02"      keywordN3Graph_02  g8  noError
  , parseTest "keywordTest03"      keywordN3Graph_03  g83 noError
  ]
    
------------------------------------------------------------
--  Test parser failure
------------------------------------------------------------
--
--  Very limited at the moment.
--

failTest :: String -> String -> String -> Test
failTest lbl gr pe = parseTest lbl gr emptyRDFGraph pe

failN3Graph_g1 :: String
failN3Graph_g1 =
    commonPrefixes ++
    " base1:s1 base2:p2 unknown3:o3 . "

fail1 :: String
fail1 = intercalate "\n" [
         "",
         "@prefix base3 : <http://id.ninebynine.org/wip/2003/test/graph3/node> . ",
         " base1:s1 base2:p2 unknown3:o3 . ",
         "                            ^",
         "(line 4, column 29 indicated by the '^' sign above):",
         "",
         "unexpected Prefix 'unknown3:' not bound."
        ]

failTestSuite :: Test
failTestSuite = TestList
  [ failTest "failTest01" failN3Graph_g1 fail1
  ]

------------------------------------------------------------
--  All tests
------------------------------------------------------------

allTests :: Test
allTests = TestList
  [ charTestSuite
  , nameTestSuite
  , prefixTestSuite
  , absUriRefTestSuite
  , uriRef2TestSuite
  , simpleTestSuite
  , litTestSuite
  , exoticTestSuite
  , keywordTestSuite
  , failTestSuite
  ]

main :: IO ()
main = runTestTT allTests >> return ()

--------------------------------------------------------------------------------
--
--  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
--
--------------------------------------------------------------------------------