← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/librdf-query-perl/oneiric

« back to all changes in this revision

Viewing changes to t/serialize.t

  • Committer: Bazaar Package Importer
  • Author(s): Jonas Smedegaard
  • Date: 2011-03-05 17:57:31 UTC
  • Revision ID: james.westby@ubuntu.com-20110305175731-rpdd1euwhz03au01
Tags: upstream-2.905
Import upstream version 2.905

Show diffs side-by-side

added added

removed removed

Lines of Context:
t/serialize.t
 
1
#!/usr/bin/perl
 
2
use strict;
 
3
use warnings;
 
4
no warnings 'redefine';
 
5
 
 
6
use lib qw(. t);
 
7
BEGIN { require "models.pl"; }
 
8
 
 
9
use Test::Exception;
 
10
use Test::More tests => 33;
 
11
 
 
12
use_ok( 'RDF::Query' );
 
13
 
 
14
################################################################################
 
15
### AS_SPARQL TESTS
 
16
 
 
17
{
 
18
        my $sparql      = <<"END";
 
19
PREFIX ex: <http://example.com/>
 
20
SELECT ?x (SUM(?o) AS ?sum) WHERE {
 
21
        ?x ex:price ?o
 
22
}
 
23
GROUP BY ?x
 
24
HAVING (SUM(?o) > 5)
 
25
ORDER BY ?sum
 
26
END
 
27
        my $query       = new RDF::Query ( $sparql );
 
28
        my $string      = $query->as_sparql;
 
29
        $string         =~ s/\s+/ /gms;
 
30
        is( $string, "PREFIX ex: <http://example.com/> SELECT ?x (SUM(?o) AS ?sum) WHERE { ?x ex:price ?o . } GROUP BY ?x HAVING (SUM(?o) > 5) ORDER BY ?sum", 'sparql to sparql aggregate' );
 
31
}
 
32
 
 
33
{
 
34
        my $rdql        = qq{SELECT ?person WHERE (?person foaf:name "Gregory Todd Williams") USING foaf FOR <http://xmlns.com/foaf/0.1/>};
 
35
        my $query       = new RDF::Query ( $rdql, undef, undef, 'rdql' );
 
36
        my $string      = $query->as_sparql;
 
37
        $string         =~ s/\s+/ /gms;
 
38
        is( $string, 'PREFIX foaf: <http://xmlns.com/foaf/0.1/> PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> SELECT * WHERE { ?person foaf:name "Gregory Todd Williams" . }', 'rdql to sparql' );
 
39
}
 
40
 
 
41
{
 
42
        my $sparql      = "PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?name WHERE { ?person a foaf:Person; foaf:name ?name } ORDER BY ?name";
 
43
        my $query       = new RDF::Query ( $sparql );
 
44
        my $string      = $query->as_sparql;
 
45
        $string         =~ s/\s+/ /gms;
 
46
        is( $string, "PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?name WHERE { ?person a foaf:Person . ?person foaf:name ?name . } ORDER BY ?name", 'sparql to sparql' );
 
47
}
 
48
 
 
49
{
 
50
        my $sparql      = 'PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?p WHERE { ?p a foaf:Person ; foaf:homepage ?homepage . FILTER( REGEX( STR(?homepage), "^http://www.rpi.edu/.+") ) }';
 
51
        my $query       = new RDF::Query ( $sparql );
 
52
        my $string      = $query->as_sparql;
 
53
        $string         =~ s/\s+/ /gms;
 
54
        is( $string, 'PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?p WHERE { ?p a foaf:Person . ?p foaf:homepage ?homepage . FILTER( REGEX(STR(?homepage), "^http://www.rpi.edu/.+") ) . }', 'sparql to sparql with regex filter' );
 
55
};
 
56
 
 
57
{
 
58
        my $sparql      = "PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?name WHERE { ?person a foaf:Person; foaf:name ?name . FILTER( ?name < 'Greg' ) }";
 
59
        my $query       = new RDF::Query ( $sparql );
 
60
        my $string      = $query->as_sparql;
 
61
        $string         =~ s/\s+/ /gms;
 
62
        is( $string, 'PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?name WHERE { ?person a foaf:Person . ?person foaf:name ?name . FILTER( (?name < "Greg") ) . }', 'sparql to sparql with less-than filter' );
 
63
}
 
64
 
 
65
{
 
66
        my $sparql      = "PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?name WHERE { ?person a foaf:Person; foaf:name ?name } ORDER BY ?name LIMIT 5 OFFSET 5";
 
67
        my $query       = new RDF::Query ( $sparql );
 
68
        my $string      = $query->as_sparql;
 
69
        $string         =~ s/\s+/ /gms;
 
70
        is( $string, "PREFIX foaf: <http://xmlns.com/foaf/0.1/> SELECT ?name WHERE { ?person a foaf:Person . ?person foaf:name ?name . } ORDER BY ?name OFFSET 5 LIMIT 5", 'sparql to sparql with slice' );
 
71
}
 
72
 
 
73
{
 
74
        my $query       = new RDF::Query ( <<"END", undef, undef, 'rdql' );
 
75
                SELECT ?person
 
76
                WHERE (?person foaf:name "Gregory Todd Williams")
 
77
                USING foaf FOR <http://xmlns.com/foaf/0.1/>
 
78
END
 
79
        my $sparql      = $query->as_sparql;
 
80
        my $query2      = RDF::Query->new( $sparql );
 
81
        my $again       = $query2->as_sparql;
 
82
        is( $sparql, $again, 'as_sparql: rdql round trip: select' );
 
83
}
 
84
 
 
85
{
 
86
        my $rquery      = new RDF::Query ( <<"END", undef, undef, 'rdql' );
 
87
                SELECT ?person
 
88
                WHERE (?person foaf:name "Gregory Todd Williams")
 
89
                USING foaf FOR <http://xmlns.com/foaf/0.1/>
 
90
END
 
91
        my $squery      = new RDF::Query ( <<"END", undef, undef, 'sparql' );
 
92
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
93
                PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
 
94
                SELECT ?person
 
95
                WHERE { ?person foaf:name "Gregory Todd Williams" }
 
96
END
 
97
        is( $squery->as_sparql, $rquery->as_sparql, 'as_sparql: rdql-sparql equality' );
 
98
}
 
99
 
 
100
{
 
101
        my $query       = new RDF::Query ( <<"END" );
 
102
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
103
                CONSTRUCT { ?p foaf:name ?name }
 
104
                WHERE  { ?p foaf:firstname ?name }
 
105
END
 
106
        my $sparql      = $query->as_sparql;
 
107
        my $again       = RDF::Query->new( $sparql )->as_sparql;
 
108
        is( $sparql, $again, 'as_sparql: sparql round trip: construct' );
 
109
}
 
110
 
 
111
{
 
112
        my $query       = new RDF::Query ( <<"END" );
 
113
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
114
                DESCRIBE ?p
 
115
                WHERE  { ?p foaf:name ?name }
 
116
END
 
117
        my $sparql      = $query->as_sparql;
 
118
        my $again       = RDF::Query->new( $sparql )->as_sparql;
 
119
        is( $sparql, $again, 'as_sparql: sparql round trip: describe' );
 
120
}
 
121
 
 
122
{
 
123
        my $query       = new RDF::Query ( <<"END" );
 
124
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
125
                ASK
 
126
                WHERE  { [ foaf:name "Gregory Todd Williams" ] }
 
127
END
 
128
        my $sparql      = $query->as_sparql;
 
129
        my $again       = RDF::Query->new( $sparql )->as_sparql;
 
130
        is( $sparql, $again, 'as_sparql: sparql round trip: ask' );
 
131
}
 
132
 
 
133
{
 
134
        my $query       = new RDF::Query ( <<"END" );
 
135
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
136
                SELECT ?name
 
137
                FROM NAMED <http://example.com/>
 
138
                WHERE  {
 
139
                        GRAPH ?g {
 
140
                                [ foaf:name "Gregory Todd Williams" ]
 
141
                        }
 
142
                }
 
143
END
 
144
        my $sparql      = $query->as_sparql;
 
145
        my $again       = RDF::Query->new( $sparql )->as_sparql;
 
146
        is( $sparql, $again, 'as_sparql: sparql round trip: select with named graph' );
 
147
}
 
148
 
 
149
{
 
150
        my $query       = new RDF::Query ( <<"END", undef, undef, 'sparql11' );
 
151
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
152
                SELECT *
 
153
                WHERE {
 
154
                        { ?person foaf:name ?name } UNION { ?person foaf:nick ?name }
 
155
                }
 
156
END
 
157
        my $sparql      = $query->as_sparql;
 
158
        my $query2      = RDF::Query->new( $sparql );
 
159
        my $again       = $query2->as_sparql;
 
160
        is( $sparql, $again, 'as_sparql: union' );
 
161
}
 
162
 
 
163
{
 
164
        my $query       = new RDF::Query ( <<"END" );
 
165
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
166
                SELECT ?person
 
167
                WHERE {
 
168
                        ?person foaf:name ?name .
 
169
                        FILTER( !BOUND(?name) )
 
170
                }
 
171
END
 
172
        my $sparql      = $query->as_sparql;
 
173
        my $again       = RDF::Query->new( $sparql )->as_sparql;
 
174
        is( $sparql, $again, 'as_sparql: select with filter !BOUND' );
 
175
}
 
176
 
 
177
{
 
178
        my $query       = new RDF::Query ( <<"END" );
 
179
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
180
                SELECT DISTINCT ?name
 
181
                WHERE {
 
182
                        ?person foaf:name ?name .
 
183
                }
 
184
END
 
185
        my $sparql      = $query->as_sparql;
 
186
        my $qagain      = RDF::Query->new( $sparql );
 
187
        my $again       = $qagain->as_sparql;
 
188
        is( $sparql, $again, 'as_sparql: select DISTINCT' );
 
189
}
 
190
 
 
191
################################################################################
 
192
### SSE TESTS
 
193
 
 
194
{
 
195
        my $query       = new RDF::Query ( <<"END" );
 
196
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
197
                SELECT ?person
 
198
                WHERE { ?person foaf:name "Gregory Todd Williams" }
 
199
END
 
200
        my $sse = $query->sse;
 
201
        is( _CLEAN_WS($sse), '(prefix ((foaf: <http://xmlns.com/foaf/0.1/>)) (project (?person) (BGP (triple ?person foaf:name "Gregory Todd Williams"))))', 'sse: select' );
 
202
#       my $alg = RDF::Query::Algebra->from_sse( my $string = $sse );
 
203
#       is( _CLEAN_WS($alg->sse), _CLEAN_WS($sse), 'sse: re-serialization of expression' );
 
204
}
 
205
 
 
206
{
 
207
        my $query       = new RDF::Query ( <<"END" );
 
208
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
209
                SELECT ?name
 
210
                FROM NAMED <http://example.com/>
 
211
                WHERE  {
 
212
                        GRAPH ?g {
 
213
                                [ foaf:name "Gregory Todd Williams" ]
 
214
                        }
 
215
                }
 
216
END
 
217
        my $sse = $query->sse;
 
218
        is( _CLEAN_WS($sse), '(prefix ((foaf: <http://xmlns.com/foaf/0.1/>)) (project (?name) (namedgraph ?g (BGP (triple _:a1 foaf:name "Gregory Todd Williams")))))', 'sse: select with named graph' );
 
219
}
 
220
 
 
221
{
 
222
        my $query       = new RDF::Query ( <<"END" );
 
223
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
224
                PREFIX dc: <http://purl.org/dc/elements/1.1/>
 
225
                SELECT ?name
 
226
                WHERE  {
 
227
                        { [ foaf:name ?name ] }
 
228
                        UNION
 
229
                        { [ dc:title ?name ] }
 
230
                }
 
231
END
 
232
        my $sse = $query->sse;
 
233
        is( _CLEAN_WS($sse), '(prefix ((dc: <http://purl.org/dc/elements/1.1/>) (foaf: <http://xmlns.com/foaf/0.1/>)) (project (?name) (union (BGP (triple _:a1 foaf:name ?name)) (BGP (triple _:a2 dc:title ?name)))))', 'sse: select with union' );
 
234
}
 
235
 
 
236
{
 
237
        my $query       = new RDF::Query ( <<"END" );
 
238
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
239
                SELECT ?person
 
240
                WHERE {
 
241
                        ?person foaf:name ?name .
 
242
                        FILTER( ?name < "Greg" )
 
243
                }
 
244
END
 
245
        my $sse         = $query->sse;
 
246
        is( _CLEAN_WS($sse), '(prefix ((foaf: <http://xmlns.com/foaf/0.1/>)) (project (?person) (filter (< ?name "Greg") (BGP (triple ?person foaf:name ?name)))))', 'sse: select with filter <' );
 
247
}
 
248
 
 
249
{
 
250
        my $query       = new RDF::Query ( <<"END" );
 
251
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
252
                SELECT ?person
 
253
                WHERE {
 
254
                        ?person foaf:name ?name .
 
255
                        FILTER( !BOUND(?name) )
 
256
                }
 
257
END
 
258
        my $sse         = $query->sse;
 
259
        is( _CLEAN_WS($sse), '(prefix ((foaf: <http://xmlns.com/foaf/0.1/>)) (project (?person) (filter (! (bound ?name)) (BGP (triple ?person foaf:name ?name)))))', 'sse: select with filter !BOUND' );
 
260
}
 
261
 
 
262
{
 
263
        my $query       = new RDF::Query ( <<"END" );
 
264
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
265
                SELECT ?person
 
266
                WHERE {
 
267
                        ?person foaf:name ?name .
 
268
                        FILTER( REGEX(?name, "Greg") )
 
269
                }
 
270
END
 
271
        my $sse         = $query->sse;
 
272
        is( _CLEAN_WS($sse), '(prefix ((foaf: <http://xmlns.com/foaf/0.1/>)) (project (?person) (filter (regex ?name "Greg") (BGP (triple ?person foaf:name ?name)))))', 'sse: select with filter regex' );
 
273
}
 
274
 
 
275
{
 
276
        my $query       = new RDF::Query ( <<"END", undef, undef, 'sparql11' );
 
277
                PREFIX foaf: <http://xmlns.com/foaf/0.1/>
 
278
                SELECT *
 
279
                WHERE {
 
280
                        { ?person foaf:name ?name } UNION { ?person foaf:nick ?name }
 
281
                }
 
282
END
 
283
        my $sse         = $query->sse;
 
284
        is( _CLEAN_WS($sse), '(prefix ((foaf: <http://xmlns.com/foaf/0.1/>)) (project (?person ?name) (union (BGP (triple ?person foaf:name ?name)) (BGP (triple ?person foaf:nick ?name)))))', 'sse: select with filter regex' );
 
285
}
 
286
 
 
287
{
 
288
        my $query       = new RDF::Query ( <<"END" );
 
289
                BASE <http://xmlns.com/>
 
290
                PREFIX foaf: </foaf/0.1/>
 
291
                SELECT ?person
 
292
                WHERE { ?person foaf:name "Gregory Todd Williams" }
 
293
END
 
294
        my $sse = $query->sse;
 
295
        is( _CLEAN_WS($sse), '(base <http://xmlns.com/> (prefix ((foaf: <http://xmlns.com/foaf/0.1/>)) (project (?person) (BGP (triple ?person foaf:name "Gregory Todd Williams")))))', 'sse: select' );
 
296
}
 
297
 
 
298
{
 
299
        my $query       = new RDF::Query ( <<"END", { update => 1 } );
 
300
                LOAD <documentURI> INTO GRAPH <uri>
 
301
END
 
302
        my $sse = $query->sse;
 
303
        is( _CLEAN_WS($sse), '(load <documentURI> <uri>)', 'sse: load' );
 
304
}
 
305
 
 
306
{
 
307
        my $query       = new RDF::Query ( <<"END", { update => 1 } );
 
308
                LOAD <documentURI> ;
 
309
                SELECT * WHERE { ?s ?p ?o }
 
310
END
 
311
        my $sse = $query->sse;
 
312
        is( _CLEAN_WS($sse), '(sequence (load <documentURI>) (project (?s ?p ?o) (BGP (triple ?s ?p ?o))))', 'sse: sequence' );
 
313
}
 
314
 
 
315
{
 
316
        my $sse = '(triple _:a foaf:name "foo\\\\\\tbar\\nbaz"^^<foo://bar>)';
 
317
        my $ctx = { namespaces => { foaf => 'http://xmlns.com/foaf/0.1/' } };
 
318
        my $st  = RDF::Query::Algebra::Triple->from_sse( my $string = $sse, $ctx );
 
319
        is( $st->sse( $ctx ), $sse, 'sse: parse triple' );
 
320
}
 
321
 
 
322
{
 
323
        my $sse = '(BGP (triple _:a foaf:name "foo\\\\\\tbar\\nbaz"^^<foo://bar>))';
 
324
        my $ctx = { namespaces => { foaf => 'http://xmlns.com/foaf/0.1/' } };
 
325
        my $bgp = RDF::Query::Algebra->from_sse( my $string = $sse, $ctx );
 
326
        isa_ok( $bgp, 'RDF::Query::Algebra::BasicGraphPattern' );
 
327
        is( _CLEAN_WS($bgp->sse( $ctx )), $sse, 'sse: parse BGP' );
 
328
}
 
329
 
 
330
################################################################################
 
331
### VARIABLEBINDINGS TESTS
 
332
{
 
333
        my $a           = RDF::Query::Node::Literal->new('a');
 
334
        my $b           = RDF::Query::Node::Resource->new('http://b/');
 
335
        my $c           = RDF::Query::Node::Blank->new('c');
 
336
        
 
337
        {
 
338
                my $binding     = RDF::Query::VariableBindings->new({ 'a' => $a });
 
339
                is( "$binding", '{ a="a" }', 'variable binding (literal)' );
 
340
        }
 
341
        
 
342
        {
 
343
                my $binding     = RDF::Query::VariableBindings->new({ 'b' => $b });
 
344
                is( "$binding", '{ b=<http://b/> }', 'variable binding (resource)' );
 
345
        }
 
346
        
 
347
        {
 
348
                my $binding     = RDF::Query::VariableBindings->new({ 'c' => $c });
 
349
                is( "$binding", '{ c=(c) }', 'variable binding (blank)' );
 
350
        }
 
351
        
 
352
        {
 
353
                my $binding     = RDF::Query::VariableBindings->new({ 'a' => $a, b => undef, c => $c });
 
354
                is( "$binding", '{ a="a", b=(), c=(c) }', 'variable binding (literal, blank, (undef))' );
 
355
        }
 
356
}
 
357
 
 
358
 
 
359
sub _CLEAN_WS {
 
360
        my $string      = shift;
 
361
        for ($string) {
 
362
                s/\s+/ /g;
 
363
                1 while s/[)]\s+[)]/))/g;
 
364
        }
 
365
        return $string;
 
366
}
 
367
__END__