*/ 1 . BIND(?s+1 AS ?x) } UNION { GRAPH 1 } } }');
like($a->as_string, qr/Project.*Union.*Extend.*BGP.*Graph.*BGP/s);
}
{
my $a = Attean->get_parser('SPARQL')->parse('SELECT * WHERE { { ?s 1 } MINUS { ?s "foo"@en , ?o, , ?o, '''hello!''' OPTIONAL { ?s 1, 2 .\n";
open(my $fh, '<', \$turtle);
my $parser = Attean->get_parser('Turtle')->new();
my $iter = $parser->parse_iter_from_io($fh);
does_ok($iter, 'Attean::API::Iterator');
is($iter->next->object->value, '1');
is($iter->next->object->value, '2');
is($iter->next, undef);
}
{
my $map = URI::NamespaceMap->new();
my $parser = Attean->get_parser('Turtle')->new( namespaces => $map );
my $content = <<'END';
@prefix ex: [, ]*[?]o/, 'construct pattern');
like($c->as_string, qr/[?]s "foo"@en "foo"@en }');
};
subtest 'expected tokens: 1-triple BGP tokens' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $a = Attean::Algebra::BGP->new(triples => [$t]);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
expect_token_stream($i, [IRI, IRI, STRING1D, DOT]);
ws_is($a->as_sparql, ' "1" .');
};
subtest 'expected tokens: 2-BGP join tokens' => sub {
my $t = triplepattern(variable('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Join->new( children => [$bgp, $bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s "1" . ?s "1" . }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, DOT, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, '{ ?s "1" . ?s "1" . }');
};
subtest 'expected tokens: 2-triple BGP tokens with language and datatype' => sub {
my $t = triplepattern(variable('s'), iri('p'), Attean::Literal->new(value => '1', datatype => iri('http://example.org/type')));
my $u = triplepattern(variable('s'), iri('q'), Attean::Literal->new(value => 'hello', language => 'en-US'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t, $u]);
my $a = Attean::Algebra::Join->new( children => [$bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s "1"^^ "1" . }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, HATHAT, IRI, DOT, VAR, IRI, STRING1D, LANG, DOT, RBRACE]);
ws_is($a->as_sparql, '{ ?s "1"^^ "1" }
expect_token_stream($i, [KEYWORD, KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'SELECT DISTINCT * WHERE { "1" . }');
};
subtest 'expected tokens: reduced/bgp' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Reduced->new( children => [$bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT REDUCED * WHERE { "1" }
expect_token_stream($i, [KEYWORD, KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'SELECT REDUCED * WHERE { "1" . }');
};
subtest 'expected tokens: bgp/limit' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Slice->new( children => [$bgp], limit => 5 );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT * WHERE { "1" } LIMIT 5
expect_token_stream($i, [KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE, KEYWORD, INTEGER]);
ws_is($a->as_sparql, 'SELECT * WHERE { "1" . } LIMIT 5');
};
subtest 'expected tokens: bgp/slice' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Slice->new( children => [$bgp], limit => 5, offset => 5 );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT * WHERE { "1" } LIMIT 5 OFFSET 5
expect_token_stream($i, [KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE, KEYWORD, INTEGER, KEYWORD, INTEGER]);
ws_is($a->as_sparql, 'SELECT * WHERE { "1" . } LIMIT 5 OFFSET 5');
};
subtest 'expected tokens: distinct/bgp/slice' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $dist = Attean::Algebra::Distinct->new( children => [$bgp] );
my $a = Attean::Algebra::Slice->new( children => [$dist], limit => 5, offset => 5 );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT DISTINCT * WHERE { "1" } LIMIT 5 OFFSET 5
expect_token_stream($i, [KEYWORD, KEYWORD, STAR, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE, KEYWORD, INTEGER, KEYWORD, INTEGER]);
ws_is($a->as_sparql, 'SELECT DISTINCT * WHERE { "1" . } LIMIT 5 OFFSET 5');
};
subtest 'property paths' => sub {
subtest 'expected tokens: predicate path' => sub {
my $p1 = iri('p1');
my $a = Attean::Algebra::PredicatePath->new( predicate => $p1 );
my $i = $a->sparql_tokens;
expect_token_stream($i, [IRI]);
subtest 'predicate path' => sub {
my $p = Attean::Algebra::Path->new( path => $a, subject => iri('s'), object => iri('o') );
ws_is($p->as_sparql, ' "1" . }
expect_token_stream($i, [KEYWORD, IRI, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'GRAPH "1" . }');
};
subtest 'expected tokens: service tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triple(iri('s'), iri('p'), literal('1'))]);
my $g = iri('http://example.org/sparql');
my $a = Attean::Algebra::Service->new( children => [$bgp], endpoint => $g );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SERVICE "1" . }
expect_token_stream($i, [KEYWORD, IRI, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'SERVICE "1" . }');
};
subtest 'expected tokens: union tokens' => sub {
my $lhs = Attean::Algebra::BGP->new(triples => [triple(iri('s'), iri('p'), literal('1'))]);
my $rhs = Attean::Algebra::BGP->new(triples => [triple(iri('s'), iri('p'), literal('2'))]);
my $a = Attean::Algebra::Union->new( children => [$lhs, $rhs] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
expect_token_stream($i, [LBRACE, IRI, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, IRI, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, '{ "1" . } UNION { "2" . }');
};
subtest 'expected tokens: minus tokens' => sub {
my $lhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $rhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('2'))]);
my $a = Attean::Algebra::Minus->new( children => [$lhs, $rhs] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s "1" . } MINUS { ?s "2" . }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, '{ ?s "1" . } MINUS { ?s "2" . }');
};
subtest 'expected tokens: optional tokens' => sub {
my $lhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $rhs = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('2'))]);
my $a = Attean::Algebra::LeftJoin->new( children => [$lhs, $rhs] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# { ?s "1" . } OPTIONAL { ?s "1" . }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, '{ ?s "1" . } OPTIONAL { ?s "2" . }');
};
subtest 'expected tokens: table tokens' => sub {
my @rows;
push(@rows, Attean::Result->new( bindings => { 's' => iri('http://example.org/') }));
push(@rows, Attean::Result->new( bindings => { 's' => literal('sparql') }));
my $a = Attean::Algebra::Table->new(variables => [variable('s')], rows => \@rows);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# VALUES (?s) { ( "1" . } OPTIONAL { ?s "1" . FILTER(ISIRI(?s)) }
expect_token_stream($i, [LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, KEYWORD, LPAREN, KEYWORD, LPAREN, VAR, RPAREN, RPAREN, RBRACE]);
ws_is($a->as_sparql, '{ ?s "1" . } OPTIONAL { ?s "2" . FILTER(ISIRI(?s)) }');
};
subtest 'expected tokens: project' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $a = Attean::Algebra::Project->new( children => [$bgp], variables => [variable('p')] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT ?p WHERE { ?s "1" . }
expect_token_stream($i, [KEYWORD, VAR, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'SELECT ?p WHERE { ?s "1" . }');
};
subtest 'expected tokens: comparator tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $expr = Attean::ValueExpression->new( value => variable('s') );
my $a = Attean::Algebra::Comparator->new(ascending => 0, expression => $expr);
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# DESC(?s)
expect_token_stream($i, [KEYWORD, LPAREN, VAR, RPAREN]);
};
subtest 'expected tokens: comparator tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $expr = Attean::ValueExpression->new( value => variable('s') );
my $cmp = Attean::Algebra::Comparator->new(ascending => 0, expression => $expr);
my $a = Attean::Algebra::OrderBy->new( children => [$bgp], comparators => [$cmp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT * WHERE { ?s "1" . } ORDER BY DESC(?s)
expect_token_stream($i, [KEYWORD, STAR, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, KEYWORD, KEYWORD, LPAREN, VAR, RPAREN]);
};
subtest 'expected tokens: ASK tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $a = Attean::Algebra::Ask->new( children => [$bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# ASK { ?s "1" . }
expect_token_stream($i, [KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'ASK { ?s "1" . }');
};
subtest 'expected tokens: CONSTRUCT tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $t = triplepattern(variable('s'), iri('q'), literal('2'));
my $a = Attean::Algebra::Construct->new( children => [$bgp], triples => [$t] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# CONSTRUCT { ?s "1" . }
expect_token_stream($i, [KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'CONSTRUCT { ?s "1" . }');
};
subtest 'expected tokens: DESCRIBE tokens' => sub {
my $bgp = Attean::Algebra::BGP->new(triples => [triplepattern(variable('s'), iri('p'), literal('1'))]);
my $a = Attean::Algebra::Describe->new( children => [$bgp], terms => [variable('s'), iri('q')] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# DESCRIBE ?s "1" . }
expect_token_stream($i, [KEYWORD, VAR, IRI, KEYWORD, LBRACE, VAR, IRI, STRING1D, DOT, RBRACE]);
ws_is($a->as_sparql, 'DESCRIBE ?s 2 } } ORDER BY ?s');
like($a->as_string, qr/Query.*Reduced.*Project.*Order.*Service.*Path/s);
}
{
my $a = Attean->get_parser('SPARQL')->parse('SELECT * WHERE { { ?s
2 } }');
like($a->as_string, qr/Query.*Project.*Minus.*BGP.*BGP/s);
}
{
my $a = Attean->get_parser('SPARQL')->parse('SELECT * WHERE { ?s
2 } VALUES (?z) { ("abc") ("def") }');
like($a->as_string, qr/Query.*Project.*Join.*BGP.*Table/s);
}
{
local($TODO) = 'Fix as_string serialization of CONSTRUCT algebras (#97)';
my $a = Attean->get_parser('SPARQL')->parse('CONSTRUCT { ?s ?p 1 } WHERE { ?s ?p 2 }');
like($a->as_string, qr/Query.*Construct.*BGP/s);
like($a->as_string, qr/Triple/s);
}
};
subtest 'Modify' => sub {
my $a = Attean->get_parser('SPARQL')->parse_update('INSERT { ?s ?p 1 } WHERE { ?s ?p 2 }');
is_deeply([$a->in_scope_variables], []);
like($a->as_string, qr/Update.*Insert.*Data/s);
};
subtest 'Add' => sub {
my $a = Attean->get_parser('SPARQL')->parse_update('ADD GRAPH
a , "xyz",
, "xyz",
?x } FILTER(!BOUND(?x)) } LIMIT 5 OFFSET 5");
does_ok($q, 'Attean::API::Algebra');
isa_ok($q, 'Attean::Algebra::Query');
my $s = $q->child;
isa_ok($s, 'Attean::Algebra::Slice');
}
{
my $data = "ASK { ?s ?p ?o FILTER(?o > -2.0 && ?o < +3e0 ) }";
open(my $fh, '<', \$data);
my $parser = Attean->get_parser('SPARQL')->new();
my $iter = $parser->parse_iter_from_io($fh);
does_ok($iter, 'Attean::API::Iterator');
my $q = $iter->next;
does_ok($q, 'Attean::API::Algebra');
my $a = $q->child;
isa_ok($a, 'Attean::Algebra::Ask');
}
{
my $map = URI::NamespaceMap->new();
my $parser = Attean->get_parser('SPARQL')->new( namespaces => $map );
my $content = <<'END';
PREFIX ex:
ex:p "\\"", '\\'', '\\u706b\\U0000661F' \\u007d];
open(my $fh, '<:encoding(UTF-8)', \$sparql);
my $l = AtteanX::Parser::SPARQLLex->new();
my $iter = $l->parse_iter_from_io($fh);
expect($iter->next, KEYWORD, ['ASK']);
expect($iter->next, LBRACE, ['{'],);
expect($iter->next, IRI, ['s'], 'subject');
expect($iter->next, PREFIXNAME, ['ex:', 'p'], 'predicate');
expect($iter->next, STRING1D, ['"'], 'double quote');
expect($iter->next, COMMA, [',']);
expect($iter->next, STRING1S, ["'"], 'single quote');
expect($iter->next, COMMA, [',']);
expect($iter->next, STRING1S, ["火星"], 'unicode \\u and \\U escapes');
expect($iter->next, RBRACE, ['}'], 'escaped closing brace');
};
subtest 'custom function' => sub {
my $sparql = q[PREFIX ex: ex:p "\\"", '\\'', '\\u706b\\U0000661F' .];
open(my $fh, '<:encoding(UTF-8)', \$turtle);
my $l = AtteanX::Parser::Turtle::Lexer->new($fh);
expect($l->get_token, IRI, ['s'], 'subject');
expect($l->get_token, PREFIXNAME, ['ex:', 'p'], 'predicate');
expect($l->get_token, STRING1D, ['"'], 'double quote');
expect($l->get_token, COMMA, [',']);
expect($l->get_token, STRING1S, ["'"], 'single quote');
expect($l->get_token, COMMA, [',']);
expect($l->get_token, STRING1S, ["火星"], 'unicode \\u and \\U escapes');
};
subtest 'parse_term_from_bytes' => sub {
my $parser = Attean->get_parser('Turtle')->new();
my $turtle = '"""hello"""@en';
my $term = $parser->parse_term_from_bytes($turtle);
does_ok($term, 'Attean::API::Literal');
is($term->value, 'hello');
is($term->language, 'en');
};
done_testing();
sub expect {
my $token = shift;
my $type = shift;
my $values = shift;
my $name = shift // '';
if (length($name)) {
$name = "${name}: ";
}
is($token->type, $type, "${name}token type");
is_deeply($token->args, $values, "${name}token values");
}
Attean-0.017/t/parser.t 000644 000765 000024 00000006030 12705564261 014757 0 ustar 00greg staff 000000 000000 use v5.14;
use autodie;
use utf8;
use Test::Modern;
use Test::Exception;
use FindBin qw($Bin);
use File::Glob qw(bsd_glob);
use File::Spec;
use Attean;
my $p = Attean->get_parser('Turtle');
is($p, 'AtteanX::Parser::Turtle');
subtest 'all acceptable parsers' => sub {
my $accept = Attean->acceptable_parsers();
ok(length($accept), 'got accept header value');
# check to make sure some of the default parsers are present:
like($accept, qr'text/turtle');
like($accept, qr'application/rdf[+]xml');
like($accept, qr'text/tab-separated-values');
};
subtest 'acceptable PULL parsers' => sub {
my $accept = Attean->acceptable_parsers(prefer => q[pull]);
# check to make sure some of the default parsers are present:
like($accept, qr'application/n-quads');
like($accept, qr'application/n-triples');
like($accept, qr'text/tab-separated-values');
unlike($accept, qr'application/rdf[+]xml');
};
subtest 'acceptable PUSH parsers' => sub {
my $accept = Attean->acceptable_parsers(prefer => q[Attean::API::PushParser]);
# check to make sure some of the default parsers are present:
like($accept, qr'text/turtle');
like($accept, qr'application/rdf[+]xml');
like($accept, qr'application/sparql-results[+]xml');
unlike($accept, qr'application/n-quads');
unlike($accept, qr'application/n-triples');
unlike($accept, qr'text/tab-separated-values');
};
subtest 'acceptable ATONCE parsers' => sub {
my $accept = Attean->acceptable_parsers(prefer => q[AtOnce]);
like($accept, qr'application/sparql-results[+]json');
unlike($accept, qr'text/turtle');
unlike($accept, qr'application/n-quads');
unlike($accept, qr'application/n-triples');
};
subtest 'acceptable SPARQL RESULT parsers' => sub {
my $accept = Attean->acceptable_parsers(handles => q[result]);
like($accept, qr'application/sparql-results[+]json');
like($accept, qr'application/sparql-results[+]xml');
like($accept, qr'text/tab-separated-values');
unlike($accept, qr'text/turtle');
unlike($accept, qr'application/rdf[+]xml');
unlike($accept, qr'application/n-quads');
unlike($accept, qr'application/n-triples');
};
subtest 'acceptable TRIPLE parsers' => sub {
my $accept = Attean->acceptable_parsers(handles => q[Attean::API::Triple]);
like($accept, qr'application/n-quads');
like($accept, qr'application/n-triples');
like($accept, qr'application/octet-stream');
like($accept, qr'application/x-turtle');
like($accept, qr'application/turtle');
like($accept, qr'text/turtle');
like($accept, qr'application/rdf[+]xml');
unlike($accept, qr'application/sparql-results[+]json');
unlike($accept, qr'application/sparql-results[+]xml');
unlike($accept, qr'text/tab-separated-values');
};
subtest 'parser access by filename' => sub {
my $pclass = Attean->get_parser(filename => 'foo.nt');
is($pclass, 'AtteanX::Parser::NTriples');
};
subtest 'parser access by media type' => sub {
my $pclass = Attean->get_parser(media_type => 'application/n-triples');
is($pclass, 'AtteanX::Parser::NTriples');
};
dies_ok {
Attean->get_parser(foo => 'bar');
} 'bad get_parser argument dies';
done_testing();
Attean-0.017/t/plan.t 000644 000765 000024 00000004113 12725723146 014416 0 ustar 00greg staff 000000 000000 use v5.14;
use autodie;
use utf8;
use Test::Modern;
use Test::Exception;
use Digest::SHA qw(sha1_hex);
use Attean;
use Attean::RDF;
use AtteanX::Store::Memory;
package TestPlanner {
use Moo;
extends 'Attean::QueryPlanner';
with 'Attean::API::NaiveJoinPlanner';
}
my $p = TestPlanner->new();
my $store = AtteanX::Store::Memory->new();
my $model = Attean::MutableQuadModel->new( store => $store );
my $graph = iri('http://example.org/');
my $t = triplepattern(variable('s'), iri('p'), literal('1'));
my $u = triplepattern(variable('s'), iri('p'), variable('o'));
my $v = triplepattern(variable('s'), iri('q'), blank('xyz'));
my $w = triplepattern(variable('a'), iri('b'), iri('c'));
my $x = triplepattern(variable('a'), variable('b'), iri('c'));
sub test_triples_for_connected_plan {
my $triples = shift;
my $connected = shift;
my $note = shift;
my $bgp = Attean::Algebra::BGP->new(triples => $triples);
my $plan = $p->plan_for_algebra($bgp, $model, [$graph]);
my $ok = $plan->subplans_of_type_are_variable_connected('Attean::Plan::Quad');
$ok = not($ok) unless ($connected);
ok($ok, $note);
}
test_triples_for_connected_plan([], 1, 'Empty BGP');
test_triples_for_connected_plan([$t], 1, '1-triple BGP');
test_triples_for_connected_plan([$t, $u], 1, '2-triple BGP');
test_triples_for_connected_plan([$w, $x], 1, '2-triple BGP');
test_triples_for_connected_plan([$t, $u, $v], 1, '3-triple BGP');
test_triples_for_connected_plan([$t, $u, $v, $w], 0, '4-triple BGP');
test_triples_for_connected_plan([$x, $t, $u, $v, $w], 0, '5-triple BGP');
subtest 'Construct' => sub {
my $t = Attean::Plan::Quad->new( subject => variable('s'), predicate => iri('p'), object => variable('o'), graph => iri('g'), distinct => 1, ordered => []);
my $u = triplepattern(variable('s'), iri('q'), variable('o'));
my $c = Attean::Plan::Construct->new(triples => [$u], children => [$t], distinct => 0, ordered => []);
like($c->as_string, qr/Construct/s);
like($c->as_string, qr/Quad.*[?]s[, ]* [?]o/, 'construct template');
};
done_testing();
Attean-0.017/t/plans.t 000644 000765 000024 00000006153 12715007025 014575 0 ustar 00greg staff 000000 000000 =pod
=encoding utf-8
=head1 PURPOSE
Tests for various plans
=cut
use v5.14;
use autodie;
use utf8;
use feature "state";
use Test::Modern;
use Test::Exception;
use Digest::SHA qw(sha1_hex);
use Attean;
use Attean::RDF;
use Attean::Plan::Iterator;
my $ci = Attean::CodeIterator->new(
generator => sub {
state $i = 0;
return undef if ($i > 2);
return Attean::Result->new(bindings => { 'o' => literal($i++) });
},
item_type => 'Attean::API::Result',
variables => ['o']
);
isa_ok($ci, 'Attean::CodeIterator');
my @values = map { Attean::Result->new(bindings => { 'o' => literal($_) }) } (1,2,3);
my $li = Attean::ListIterator->new(
values => \@values,
item_type => 'Attean::API::Result',
variables => ['o']
);
isa_ok($li, 'Attean::ListIterator');
#subtest 'CodeIterator without size' => sub
{
my $plan = Attean::Plan::Iterator->new(
variables => [variable('o')],
iterator => $ci,
distinct => 0,
ordered => []
);
isa_ok($plan, 'Attean::Plan::Iterator');
does_ok($plan, 'Attean::API::Plan');
can_ok($plan, 'iterator');
ok(! $plan->has_size_estimate, 'Has no size estimate');
is($plan->as_string, "- Iterator (?o)\n", 'Correct serialization');
};
#subtest 'CodeIterator with size' => sub
{
my $plan = Attean::Plan::Iterator->new(
variables => [variable('o')],
iterator => $ci,
distinct => 0,
size_estimate => 2,
ordered => []
);
isa_ok($plan, 'Attean::Plan::Iterator');
does_ok($plan, 'Attean::API::Plan');
can_ok($plan, 'iterator');
ok($plan->has_size_estimate, 'Has size estimate');
is($plan->size_estimate, 2, 'Correct returned estimate');
is($plan->as_string, "- Iterator (?o with 2 elements)\n", 'Correct serialization');
};
{
my $plan = Attean::Plan::Iterator->new(
variables => [variable('o')],
iterator => $li,
distinct => 0,
ordered => []
);
isa_ok($plan, 'Attean::Plan::Iterator');
does_ok($plan, 'Attean::API::Plan');
can_ok($plan, 'iterator');
is($plan->size_estimate, 3, 'Correct returned estimate');
ok($plan->has_size_estimate, 'Has size estimate for ListIterator');
is($plan->as_string, "- Iterator (?o with 3 elements)\n", 'Correct serialization');
};
{
my $plan = Attean::Plan::Iterator->new(
variables => [variable('o')],
iterator => $li,
distinct => 0,
size_estimate => 4,
ordered => []
);
isa_ok($plan, 'Attean::Plan::Iterator');
does_ok($plan, 'Attean::API::Plan');
can_ok($plan, 'iterator');
ok($plan->has_size_estimate, 'Has size estimate for ListIterator');
is($plan->size_estimate, 4, 'Correct returned estimate when overriding');
is($plan->as_string, "- Iterator (?o with 4 elements)\n", 'Correct serialization');
};
{
my $li = Attean::ListIterator->new(
values => \@values,
item_type => 'Attean::API::Result',
variables => ['o']
);
$li->next;
my $store = Attean->get_store('Memory')->new();
my $model = Attean::MutableQuadModel->new( store => $store );
my $plan = Attean::Plan::Iterator->new(
variables => [variable('o')],
iterator => $li,
distinct => 0,
ordered => []
);
my $c = $plan->impl($model);
isa_ok($c, 'CODE');
my $i = $c->();
does_ok($i, 'Attean::API::Iterator');
my @r = $i->elements;
is(scalar(@r), 3);
};
done_testing;
Attean-0.017/t/serializer-canonicalntriples.t 000644 000765 000024 00000003444 12706047320 021341 0 ustar 00greg staff 000000 000000 use Test::Modern;
use Test::Exception;
use v5.14;
use warnings;
no warnings 'redefine';
use Attean;
use Attean::RDF;
use Encode;
use Type::Tiny::Role;
my $constraint = 'Attean::API::Triple';
my $p = iri('http://example.org/p');
my $ser = Attean->get_serializer('CanonicalNTriples')->new();
does_ok($ser, 'Attean::API::Serializer');
does_ok($ser, 'Attean::API::TripleSerializer');
isa_ok($ser, 'AtteanX::Serializer::NTriples');
{
my $t1 = triple(blank('x'), $p, Attean::Literal->integer(1));
my $t2 = triple(blank('x'), $p, Attean::Literal->integer(2));
my @triples = ($t1, $t2);
my $expected = <<"END";
_:v001
"hello"@en-US . }');
};
subtest 'expected tokens: distinct/bgp' => sub {
my $t = triple(iri('s'), iri('p'), literal('1'));
my $bgp = Attean::Algebra::BGP->new(triples => [$t]);
my $a = Attean::Algebra::Distinct->new( children => [$bgp] );
my $i = $a->sparql_tokens;
does_ok($i, 'Attean::API::Iterator');
# SELECT DISTINCT * WHERE {
!( ^ ^( (^( (^( (^( "2" } WHERE { ?s
"2" . } WHERE { ?s
WHERE { ?s