http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/DatasetClauseTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/DatasetClauseTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/DatasetClauseTest.java new file mode 100644 index 0000000..76d27c3 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/DatasetClauseTest.java @@ -0,0 +1,150 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.clauses; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; +import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; +import org.apache.jena.arq.querybuilder.clauses.DatasetClause; +import org.apache.jena.arq.querybuilder.handlers.DatasetHandler; +import org.junit.After; +import org.xenei.junit.contract.Contract; +import org.xenei.junit.contract.ContractTest; +import org.xenei.junit.contract.IProducer; + +import com.hp.hpl.jena.graph.NodeFactory; +import com.hp.hpl.jena.sparql.core.Var; + +@Contract(DatasetClause.class) +public class DatasetClauseTest<T extends DatasetClause<?>> extends + AbstractClauseTest { + + // the producer we will user + private IProducer<T> producer; + + @Contract.Inject + // define the method to set producer. + public final void setProducer(IProducer<T> producer) { + this.producer = producer; + } + + protected final IProducer<T> getProducer() { + return producer; + } + + @After + public final void cleanupDatasetClauseTest() { + getProducer().cleanUp(); // clean up the producer for the next run + } + + @ContractTest + public void testFromNamed() { + DatasetClause<?> datasetClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = datasetClause.fromNamed("name"); + String[] s = byLine(builder); + assertContains("FROM NAMED <name>", s); + builder = datasetClause.fromNamed("name2"); + s = byLine(builder); + assertContains("FROM NAMED <name>", s); + assertContains("FROM NAMED <name2>", s); + } + + @ContractTest + public void testFromNamedCollection() { + String[] names = { "name", "name2" }; + DatasetClause<?> datasetClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = datasetClause.fromNamed(Arrays + .asList(names)); + String[] s = byLine(builder); + assertContains("FROM NAMED <name>", s); + assertContains("FROM NAMED <name2>", s); + } + + @ContractTest + public void testFrom() { + DatasetClause<?> datasetClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = datasetClause.from("name"); + String[] s = byLine(builder); + assertContains("FROM <name>", s); + builder = datasetClause.from("name2"); + s = byLine(builder); + assertContains("FROM <name2>", s); + } + + @ContractTest + public void testGetDatasetHandler() { + DatasetClause<?> datasetClause = getProducer().newInstance(); + DatasetHandler dsHandler = datasetClause.getDatasetHandler(); + assertNotNull(dsHandler); + } + + @ContractTest + public void testAll() { + DatasetClause<?> datasetClause = getProducer().newInstance(); + datasetClause.fromNamed("name"); + datasetClause.fromNamed("name2"); + AbstractQueryBuilder<?> builder = datasetClause.from("name3"); + String[] s = byLine(builder); + assertContains("FROM NAMED <name>", s); + assertContains("FROM NAMED <name2>", s); + assertContains("FROM <name3>", s); + } + + @ContractTest + public void setVarsFromNamed() { + DatasetClause<?> datasetClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = datasetClause.fromNamed("?foo"); + datasetClause.from("?bar"); + builder.setVar(Var.alloc("foo"), + NodeFactory.createURI("http://example.com/foo";)); + + String s = builder.buildString(); + assertTrue(s.contains("FROM NAMED <http://example.com/foo>")); + assertTrue(s.contains("FROM <?bar>")); + } + + @ContractTest + public void setVarsFrom() { + DatasetClause<?> datasetClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = datasetClause.fromNamed("?foo"); + datasetClause.from("?bar"); + builder.setVar(Var.alloc("bar"), + NodeFactory.createURI("http://example.com/bar";)); + + String s = builder.buildString(); + assertTrue(s.contains("FROM NAMED <?foo>")); + assertTrue(s.contains("FROM <http://example.com/bar>")); + } + + @ContractTest + public void setVarsBoth() { + DatasetClause<?> datasetClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = datasetClause.fromNamed("?foo"); + datasetClause.from("?bar"); + builder.setVar(Var.alloc("bar"), + NodeFactory.createURI("http://example.com/bar";)); + builder.setVar(Var.alloc("foo"), + NodeFactory.createURI("http://example.com/foo";)); + String s = builder.buildString(); + assertTrue(s.contains("FROM NAMED <http://example.com/foo>")); + assertTrue(s.contains("FROM <http://example.com/bar>")); + } + +}
http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/PrologClauseTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/PrologClauseTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/PrologClauseTest.java new file mode 100644 index 0000000..0637958 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/PrologClauseTest.java @@ -0,0 +1,144 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.clauses; + +import static org.junit.Assert.*; + +import java.util.HashMap; +import java.util.Map; +import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; +import org.apache.jena.arq.querybuilder.clauses.PrologClause; +import org.apache.jena.arq.querybuilder.handlers.PrologHandler; +import org.junit.After; +import org.xenei.junit.contract.Contract; +import org.xenei.junit.contract.ContractTest; +import org.xenei.junit.contract.IProducer; + +import com.hp.hpl.jena.graph.NodeFactory; +import com.hp.hpl.jena.rdf.model.ResourceFactory; + +@Contract(PrologClause.class) +public class PrologClauseTest<T extends PrologClause<?>> extends + AbstractClauseTest { + + // the producer we will user + private IProducer<T> producer; + + @Contract.Inject + // define the method to set producer. + public final void setProducer(IProducer<T> producer) { + this.producer = producer; + } + + protected final IProducer<T> getProducer() { + return producer; + } + + @After + public final void cleanupDatasetClauseTest() { + getProducer().cleanUp(); // clean up the producer for the next run + } + + @ContractTest + public void testGetPrologHandler() { + PrologClause<?> prologClause = getProducer().newInstance(); + PrologHandler handler = prologClause.getPrologHandler(); + assertNotNull(handler); + } + + @ContractTest + public void testAddPrefixResource() { + PrologClause<?> prologClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = prologClause.addPrefix("pfx", + ResourceFactory.createResource("uri")); + + String[] s = byLine(builder); + assertContainsRegex("PREFIX\\s+pfx:\\s+\\<uri\\>", s); + } + + @ContractTest + public void testAddPrefixNode() { + PrologClause<?> prologClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = prologClause.addPrefix("pfx", + NodeFactory.createURI("uri")); + + String[] s = byLine(builder); + assertContainsRegex("PREFIX\\s+pfx:\\s+\\<uri\\>", s); + } + + @ContractTest + public void testAddPrefixString() { + PrologClause<?> prologClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = prologClause.addPrefix("pfx", "uri"); + + String[] s = byLine(builder); + assertContainsRegex("PREFIX\\s+pfx:\\s+\\<uri\\>", s); + } + + @ContractTest + public void testAddPrefixes() { + Map<String, String> map = new HashMap<String, String>(); + map.put("pfx", "uri"); + map.put("pfx2", "uri2"); + PrologClause<?> prologClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = prologClause.addPrefixes(map); + String[] s = byLine(builder); + assertContainsRegex("PREFIX\\s+pfx:\\s+\\<uri\\>", s); + assertContainsRegex("PREFIX\\s+pfx2:\\s+\\<uri2\\>", s); + } + + @ContractTest + public void testSetBaseResource() { + PrologClause<?> prologClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = prologClause.setBase(ResourceFactory + .createResource("http://example.com/uri";)); + + String[] s = byLine(builder); + assertContainsRegex("BASE\\s+\\<http://example\\.com/uri\\>", s); + } + + @ContractTest + public void testSetBaseNode() { + PrologClause<?> prologClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = prologClause.setBase(NodeFactory + .createURI("http://example.com/uri";)); + + String[] s = byLine(builder); + assertContainsRegex("BASE\\s+\\<http://example\\.com/uri\\>", s); + } + + @ContractTest + public void testSetBaseString() { + PrologClause<?> prologClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = prologClause.setBase("uri"); + + String[] s = byLine(builder); + assertContainsRegex("BASE\\s+\\<file:\\S+/uri\\>", s); + } + + @ContractTest + public void testSetBaseTwice() { + PrologClause<?> prologClause = getProducer().newInstance(); + prologClause.setBase("uri"); + AbstractQueryBuilder<?> builder = prologClause.setBase("uri2"); + + String[] s = byLine(builder); + assertContainsRegex("BASE\\s+\\<file:\\S+/uri2\\>", s); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/SelectClauseTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/SelectClauseTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/SelectClauseTest.java new file mode 100644 index 0000000..8933bb7 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/SelectClauseTest.java @@ -0,0 +1,170 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.clauses; + +import static org.junit.Assert.*; + +import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; +import org.apache.jena.arq.querybuilder.handlers.SelectHandler; +import org.junit.After; +import org.xenei.junit.contract.Contract; +import org.xenei.junit.contract.ContractTest; +import org.xenei.junit.contract.IProducer; + +import com.hp.hpl.jena.graph.NodeFactory; +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.sparql.core.Var; +import com.hp.hpl.jena.sparql.core.VarExprList; + +@Contract(SelectClause.class) +public class SelectClauseTest<T extends SelectClause<?>> extends + AbstractClauseTest { + + // the producer we will user + private IProducer<T> producer; + + @Contract.Inject + // define the method to set producer. + public final void setProducer(IProducer<T> producer) { + this.producer = producer; + } + + protected final IProducer<T> getProducer() { + return producer; + } + + @After + public final void cleanupSelectClauseTest() { + getProducer().cleanUp(); // clean up the producer for the next run + } + + @ContractTest + public void getSelectHandlerTest() { + SelectClause<?> selectClause = getProducer().newInstance(); + SelectHandler handler = selectClause.getSelectHandler(); + assertNotNull(handler); + } + + @ContractTest + public void setDistinctTest() throws Exception { + SelectClause<?> selectClause = getProducer().newInstance(); + Query query = getQuery((AbstractQueryBuilder<?>) selectClause); + assertFalse(query.isDistinct()); + assertFalse(query.isReduced()); + + query = getQuery(selectClause.setDistinct(true)); + assertTrue(query.isDistinct()); + assertFalse(query.isReduced()); + + query = getQuery(selectClause.setReduced(false)); + assertTrue(query.isDistinct()); + assertFalse(query.isReduced()); + + query = getQuery(selectClause.setReduced(true)); + assertFalse(query.isDistinct()); + assertTrue(query.isReduced()); + + query = getQuery(selectClause.setDistinct(true)); + assertTrue(query.isDistinct()); + assertFalse(query.isReduced()); + + query = getQuery(selectClause.setDistinct(false)); + assertFalse(query.isDistinct()); + assertFalse(query.isReduced()); + } + + @ContractTest + public void setReducedTest() throws Exception { + SelectClause<?> selectClause = getProducer().newInstance(); + Query query = getQuery((AbstractQueryBuilder<?>) selectClause); + assertFalse(query.isDistinct()); + assertFalse(query.isReduced()); + + query = getQuery(selectClause.setReduced(true)); + assertFalse(query.isDistinct()); + assertTrue(query.isReduced()); + + query = getQuery(selectClause.setDistinct(false)); + assertFalse(query.isDistinct()); + assertTrue(query.isReduced()); + + query = getQuery(selectClause.setDistinct(true)); + assertTrue(query.isDistinct()); + assertFalse(query.isReduced()); + + query = getQuery(selectClause.setReduced(true)); + assertFalse(query.isDistinct()); + assertTrue(query.isReduced()); + + query = getQuery(selectClause.setReduced(false)); + assertFalse(query.isDistinct()); + assertFalse(query.isReduced()); + } + + @ContractTest + public void testAddVarString() throws Exception { + Var v = Var.alloc("one"); + SelectClause<?> selectClause = getProducer().newInstance(); + selectClause.addVar("one"); + Query query = getQuery(selectClause.addVar("one")); + VarExprList expr = query.getProject(); + assertEquals(1, expr.size()); + assertTrue(expr.contains(v)); + } + + @ContractTest + public void testAddVarNode() throws Exception { + Var v = Var.alloc("one"); + SelectClause<?> selectClause = getProducer().newInstance(); + selectClause.addVar("one"); + Query query = getQuery(selectClause.addVar(NodeFactory + .createVariable("one"))); + VarExprList expr = query.getProject(); + assertEquals(1, expr.size()); + assertTrue(expr.contains(v)); + } + + @ContractTest + public void testAddVarVar() throws Exception { + Var v = Var.alloc("one"); + SelectClause<?> selectClause = getProducer().newInstance(); + Query query = getQuery(selectClause.addVar(v)); + VarExprList expr = query.getProject(); + assertEquals(1, expr.size()); + assertTrue(expr.contains(v)); + } + + @ContractTest + public void getVarsTest() { + SelectClause<?> selectClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = selectClause.addVar(NodeFactory + .createVariable("foo")); + String[] s = byLine(builder); + } + + @ContractTest + public void testAddVarAsterisk() throws Exception { + SelectClause<?> selectClause = getProducer().newInstance(); + selectClause.addVar("*"); + Query query = getQuery(selectClause.addVar("*")); + VarExprList expr = query.getProject(); + assertEquals(0, expr.size()); + assertTrue(query.isQueryResultStar()); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/SolutionModifierTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/SolutionModifierTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/SolutionModifierTest.java new file mode 100644 index 0000000..8a96f54 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/SolutionModifierTest.java @@ -0,0 +1,175 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.clauses; + +import static org.junit.Assert.assertFalse; + +import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; +import org.apache.jena.arq.querybuilder.clauses.SolutionModifierClause; +import org.junit.After; +import org.xenei.junit.contract.Contract; +import org.xenei.junit.contract.ContractTest; +import org.xenei.junit.contract.IProducer; + +import com.hp.hpl.jena.sparql.core.Var; +import com.hp.hpl.jena.sparql.lang.sparql_11.ParseException; + +@Contract(SolutionModifierClause.class) +public class SolutionModifierTest<T extends SolutionModifierClause<?>> extends + AbstractClauseTest { + + // the producer we will user + private IProducer<T> producer; + + @Contract.Inject + // define the method to set producer. + public final void setProducer(IProducer<T> producer) { + this.producer = producer; + } + + protected final IProducer<T> getProducer() { + return producer; + } + + @After + public final void cleanupDatasetClauseTest() { + getProducer().cleanUp(); // clean up the producer for the next run + } + + @ContractTest + public void testAddOrderBy() { + SolutionModifierClause<?> solutionModifier = getProducer() + .newInstance(); + AbstractQueryBuilder<?> builder = solutionModifier.addOrderBy("foo"); + assertContainsRegex(ORDER_BY + var("foo"), builder.buildString()); + + builder = solutionModifier.addOrderBy("bar"); + assertContainsRegex(ORDER_BY + var("foo") + SPACE + var("bar"), + builder.buildString()); + } + + @ContractTest + public void testAddGroupBy() { + SolutionModifierClause<?> solutionModifier = getProducer() + .newInstance(); + AbstractQueryBuilder<?> builder = solutionModifier.addGroupBy("foo"); + assertContainsRegex(GROUP_BY + var("foo"), builder.buildString()); + + builder = solutionModifier.addGroupBy("bar"); + assertContainsRegex(GROUP_BY + var("foo") + SPACE + var("bar"), + builder.buildString()); + } + + @ContractTest + public void testAddHaving() throws ParseException { + SolutionModifierClause<?> solutionModifier = getProducer() + .newInstance(); + AbstractQueryBuilder<?> builder = solutionModifier.addHaving("?foo<10"); + assertContainsRegex(HAVING + OPEN_PAREN + var("foo") + OPT_SPACE + LT + + OPT_SPACE + "10" + CLOSE_PAREN, builder.buildString()); + + builder = solutionModifier.addHaving("?bar < 10"); + assertContainsRegex(HAVING + OPEN_PAREN + var("foo") + OPT_SPACE + LT + + OPT_SPACE + "10" + CLOSE_PAREN + OPT_SPACE + OPEN_PAREN + + var("bar") + OPT_SPACE + LT + OPT_SPACE + "10" + CLOSE_PAREN, + builder.buildString()); + } + + @ContractTest + public void testSetLimit() { + SolutionModifierClause<?> solutionModifier = getProducer() + .newInstance(); + AbstractQueryBuilder<?> builder = solutionModifier.setLimit(500); + assertContainsRegex("LIMIT\\s+500", builder.buildString()); + + builder = solutionModifier.setLimit(200); + String s = builder.buildString(); + assertContainsRegex("LIMIT\\s+200", s); + assertNotContainsRegex("LIMIT\\s+500", s); + + builder = solutionModifier.setLimit(0); + assertFalse("Should not contain LIMIT", + builder.buildString().contains("LIMIT")); + } + + @ContractTest + public void testSetOffset() { + SolutionModifierClause<?> solutionModifier = getProducer() + .newInstance(); + AbstractQueryBuilder<?> builder = solutionModifier.setOffset(500); + + assertContainsRegex("OFFSET\\s+500", builder.buildString()); + + builder = solutionModifier.setOffset(200); + + String s = builder.buildString(); + assertContainsRegex("OFFSET\\s+200", s); + assertNotContainsRegex("OFFSET\\s+500", s); + + builder = solutionModifier.setOffset(0); + + assertFalse("Should not contain OFFSET", builder.buildString() + .contains("OFFSET")); + } + + @ContractTest + public void testSetVarsGroupBy() { + Var v = Var.alloc("v"); + SolutionModifierClause<?> solutionModifier = getProducer() + .newInstance(); + AbstractQueryBuilder<?> builder = solutionModifier.addGroupBy("?v"); + + String[] s = byLine(builder); + assertContainsRegex(GROUP_BY + var("v"), s); + + builder.setVar(v, Var.alloc("v2")); + s = byLine(builder); + assertContainsRegex(GROUP_BY + var("v2"), s); + } + + @ContractTest + public void testSetVarsHaving() throws ParseException { + Var v = Var.alloc("v"); + SolutionModifierClause<?> solutionModifier = getProducer() + .newInstance(); + AbstractQueryBuilder<?> builder = solutionModifier.addHaving("?v"); + + String[] s = byLine(builder); + assertContainsRegex(HAVING + var("v"), s); + + builder.setVar(v, Var.alloc("v2")); + s = byLine(builder); + assertContainsRegex(HAVING + var("v2"), s); + } + + @ContractTest + public void testSetVarsOrderBy() { + Var v = Var.alloc("v"); + SolutionModifierClause<?> solutionModifier = getProducer() + .newInstance(); + AbstractQueryBuilder<?> builder = solutionModifier.addOrderBy("?v"); + + String[] s = byLine(builder); + assertContainsRegex(ORDER_BY + var("v"), s); + + builder.setVar(v, Var.alloc("v2")); + s = byLine(builder); + assertContainsRegex(ORDER_BY + var("v2"), s); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/WhereClauseTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/WhereClauseTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/WhereClauseTest.java new file mode 100644 index 0000000..f663732 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/clauses/WhereClauseTest.java @@ -0,0 +1,285 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.clauses; + +import static org.junit.Assert.assertNotNull; + +import org.apache.jena.arq.querybuilder.AbstractQueryBuilder; +import org.apache.jena.arq.querybuilder.SelectBuilder; +import org.apache.jena.arq.querybuilder.clauses.WhereClause; +import org.apache.jena.arq.querybuilder.handlers.WhereHandler; +import org.junit.After; +import org.xenei.junit.contract.Contract; +import org.xenei.junit.contract.ContractTest; +import org.xenei.junit.contract.IProducer; + +import com.hp.hpl.jena.graph.NodeFactory; +import com.hp.hpl.jena.graph.Triple; +import com.hp.hpl.jena.graph.impl.LiteralLabelFactory; +import com.hp.hpl.jena.sparql.core.Var; +import com.hp.hpl.jena.sparql.lang.sparql_11.ParseException; + +@Contract(WhereClause.class) +public class WhereClauseTest<T extends WhereClause<?>> extends + AbstractClauseTest { + + // the producer we will user + private IProducer<T> producer; + + @Contract.Inject + // define the method to set producer. + public final void setProducer(IProducer<T> producer) { + this.producer = producer; + } + + protected final IProducer<T> getProducer() { + return producer; + } + + @After + public final void cleanupDatasetClauseTest() { + getProducer().cleanUp(); // clean up the producer for the next run + } + + @ContractTest + public void testGetWhereHandler() { + WhereClause<?> whereClause = getProducer().newInstance(); + WhereHandler handler = whereClause.getWhereHandler(); + assertNotNull(handler); + } + + @ContractTest + public void testAddWhereTriple() { + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addWhere(new Triple( + NodeFactory.createURI("one"), NodeFactory.createURI("two"), + NodeFactory.createURI("three"))); + + String[] s = byLine(builder); + assertContainsRegex("<one>\\s+<two>\\s+<three>\\s*\\.", s); + } + + @ContractTest + public void testAddWhereObjects() { + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addWhere( + NodeFactory.createURI("one"), NodeFactory.createURI("two"), + NodeFactory.createURI("three")); + + String[] s = byLine(builder); + assertContainsRegex("<one>\\s+<two>\\s+<three>\\s*\\.", s); + } + + @ContractTest + public void testAddWhereStrings() { + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addWhere("<one>", + "<two>", "three"); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + quote("three") + "\\^\\^" + + node("http://www.w3.org/2001/XMLSchema#string";) + OPT_SPACE + + DOT + CLOSE_CURLY, builder.buildString()); + } + + @ContractTest + public void testAddOptionalString() { + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addOptional("<one>", + "<two>", "three"); + + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + quote("three") + "\\^\\^" + + node("http://www.w3.org/2001/XMLSchema#string";) + OPT_SPACE + + DOT + CLOSE_CURLY + CLOSE_CURLY, builder.buildString()); + + } + + @ContractTest + public void testAddOptionalObjects() { + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addOptional( + NodeFactory.createURI("one"), NodeFactory.createURI("two"), + NodeFactory.createURI("three")); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + node("three") + OPT_SPACE + DOT + CLOSE_CURLY, + builder.buildString()); + } + + @ContractTest + public void testAddOptionalTriple() { + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addOptional(new Triple( + NodeFactory.createURI("one"), NodeFactory.createURI("two"), + NodeFactory.createURI("three"))); + + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + node("three") + OPT_SPACE + DOT + CLOSE_CURLY, + builder.buildString()); + } + + @ContractTest + public void testAddFilter() throws ParseException { + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addFilter("?one<10"); + + assertContainsRegex(WHERE + OPEN_CURLY + "FILTER" + OPT_SPACE + + OPEN_PAREN + var("one") + OPT_SPACE + LT + OPT_SPACE + "10" + + CLOSE_PAREN + CLOSE_CURLY, builder.buildString()); + } + + @ContractTest + public void addSubQuery() { + SelectBuilder sb = new SelectBuilder(); + sb.addPrefix("pfx", "urn:uri").addVar("?x") + .addWhere("pfx:one", "pfx:two", "pfx:three"); + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addSubQuery(sb); + + assertContainsRegex(PREFIX + "pfx:" + SPACE + node("urn:uri") + SPACE + + ".*" + WHERE + OPEN_CURLY + OPEN_CURLY + SELECT + var("x") + + SPACE + WHERE + OPEN_CURLY + "pfx:one" + SPACE + "pfx:two" + + SPACE + "pfx:three" + OPT_SPACE + DOT + CLOSE_CURLY, + builder.buildString()); + + } + + @ContractTest + public void testAddUnion() { + SelectBuilder sb = new SelectBuilder(); + sb.addPrefix("pfx", "uri").addVar("?x") + .addWhere("<one>", "<two>", "three"); + WhereClause<?> whereClause = getProducer().newInstance(); + whereClause.getWhereHandler().addWhere(Triple.ANY); + AbstractQueryBuilder<?> builder = whereClause.addUnion(sb); + + assertContainsRegex(PREFIX + "pfx:" + SPACE + node("uri") + ".+" + + UNION + OPEN_CURLY + SELECT + var("x") + SPACE + WHERE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + quote("three") + "\\^\\^" + + node("http://www.w3.org/2001/XMLSchema#string";) + OPT_SPACE + + DOT + CLOSE_CURLY + CLOSE_CURLY, builder.buildString()); + + } + + @ContractTest + public void testSetVarsInTriple() { + Var v = Var.alloc("v"); + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addWhere(new Triple( + NodeFactory.createURI("one"), NodeFactory.createURI("two"), v)); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + var("v") + OPT_SPACE + DOT + + CLOSE_CURLY, builder.buildString()); + + builder.setVar(v, NodeFactory.createURI("three")); + + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + node("three") + OPT_SPACE + DOT + + CLOSE_CURLY, builder.buildString()); + + builder.setVar(v, NodeFactory.createURI("four")); + + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + node("four") + OPT_SPACE + DOT + + CLOSE_CURLY, builder.buildString()); + + builder.setVar(v, null); + + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + var("v") + OPT_SPACE + DOT + + CLOSE_CURLY, builder.buildString()); + + } + + @ContractTest + public void testSetVarsInFilter() throws ParseException { + Var v = Var.alloc("v"); + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addFilter("?one < ?v"); + assertContainsRegex(WHERE + OPEN_CURLY + "FILTER" + OPT_SPACE + + OPEN_PAREN + var("one") + OPT_SPACE + LT + OPT_SPACE + + var("v") + CLOSE_PAREN + CLOSE_CURLY, builder.buildString()); + + builder.setVar(Var.alloc("v"), + NodeFactory.createLiteral(LiteralLabelFactory.create(10))); + + assertContainsRegex(WHERE + OPEN_CURLY + "FILTER" + OPT_SPACE + + OPEN_PAREN + var("one") + OPT_SPACE + LT + OPT_SPACE + + quote("10") + "\\^\\^" + + node("http://www.w3.org/2001/XMLSchema#int";) + CLOSE_PAREN + + CLOSE_CURLY, builder.buildString()); + + } + + @ContractTest + public void testSetVarsInOptional() { + Var v = Var.alloc("v"); + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addOptional(new Triple( + NodeFactory.createURI("one"), NodeFactory.createURI("two"), v)); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + var("v") + OPT_SPACE + DOT + CLOSE_CURLY + CLOSE_CURLY, + builder.buildString()); + + builder.setVar(v, NodeFactory.createURI("three")); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + node("three") + OPT_SPACE + DOT + CLOSE_CURLY + CLOSE_CURLY, + builder.buildString()); + } + + @ContractTest + public void testSetVarsInSubQuery() { + Var v = Var.alloc("v"); + SelectBuilder sb = new SelectBuilder(); + sb.addPrefix("pfx", "uri").addWhere("<one>", "<two>", v); + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addSubQuery(sb); + + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + ".+" + + node("two") + ".+" + var("v") + ".+" + CLOSE_CURLY, + builder.buildString()); + + builder.setVar(v, NodeFactory.createURI("three")); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + ".+" + + node("two") + ".+" + node("three") + ".+" + CLOSE_CURLY, + builder.buildString()); + } + + @ContractTest + public void testSetVarsInUnion() { + Var v = Var.alloc("v"); + SelectBuilder sb = new SelectBuilder(); + sb.addPrefix("pfx", "uri").addWhere("<one>", "<two>", v); + WhereClause<?> whereClause = getProducer().newInstance(); + AbstractQueryBuilder<?> builder = whereClause.addUnion(sb); + assertContainsRegex(WHERE + OPEN_CURLY + UNION + OPEN_CURLY + + node("one") + ".+" + node("two") + ".+" + var("v") + ".+" + + CLOSE_CURLY, builder.buildString()); + + builder.setVar(v, NodeFactory.createURI("three")); + assertContainsRegex(WHERE + OPEN_CURLY + UNION + OPEN_CURLY + + node("one") + ".+" + node("two") + ".+" + node("three") + + ".+" + CLOSE_CURLY, builder.buildString()); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/AbstractHandlerTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/AbstractHandlerTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/AbstractHandlerTest.java new file mode 100644 index 0000000..64cd39c --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/AbstractHandlerTest.java @@ -0,0 +1,44 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.handlers; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import java.util.Arrays; +import java.util.List; +import org.apache.jena.arq.AbstractRegexpBasedTest; + +public abstract class AbstractHandlerTest extends AbstractRegexpBasedTest { + + protected final String[] byLine(String s) { + return s.split("\n"); + } + + protected final void assertContains(String expected, String[] lst) { + List<String> s = Arrays.asList(lst); + assertTrue(String.format("%s not found in %s", expected, s), + s.contains(expected)); + } + + protected final void assertNotContains(String expected, String[] lst) { + List<String> s = Arrays.asList(lst); + assertFalse(String.format("%s found in %s", expected, s), + s.contains(expected)); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/ConstructHandlerTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/ConstructHandlerTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/ConstructHandlerTest.java new file mode 100644 index 0000000..6ba2dc1 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/ConstructHandlerTest.java @@ -0,0 +1,96 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.handlers; + +import static org.junit.Assert.*; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.junit.Before; +import org.junit.Test; + +import com.hp.hpl.jena.graph.Node; +import com.hp.hpl.jena.graph.NodeFactory; +import com.hp.hpl.jena.graph.Triple; +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.sparql.core.Var; +import com.hp.hpl.jena.sparql.syntax.Template; + +public class ConstructHandlerTest extends AbstractHandlerTest { + private Query query; + private ConstructHandler handler; + + @Before + public void setup() { + query = new Query(); + handler = new ConstructHandler(query); + } + + @Test + public void testAddAll() { + Triple t = new Triple(NodeFactory.createURI("one"), + NodeFactory.createURI("two"), NodeFactory.createURI("three")); + ConstructHandler handler2 = new ConstructHandler(new Query()); + handler2.addConstruct(t); + handler.addAll(handler2); + Template template = query.getConstructTemplate(); + assertNotNull(template); + List<Triple> lst = template.getTriples(); + assertEquals(1, lst.size()); + assertEquals(t, lst.get(0)); + } + + @Test + public void testAddConstruct() { + Triple t = new Triple(NodeFactory.createURI("one"), + NodeFactory.createURI("two"), NodeFactory.createURI("three")); + handler.addConstruct(t); + Template template = query.getConstructTemplate(); + assertNotNull(template); + List<Triple> lst = template.getTriples(); + assertEquals(1, lst.size()); + assertEquals(t, lst.get(0)); + } + + @Test + public void testSetVars() { + Var v = Var.alloc("v"); + Triple t = new Triple(NodeFactory.createURI("one"), + NodeFactory.createURI("two"), v); + handler.addConstruct(t); + Template template = query.getConstructTemplate(); + assertNotNull(template); + List<Triple> lst = template.getTriples(); + assertEquals(1, lst.size()); + assertEquals(t, lst.get(0)); + + Map<Var, Node> values = new HashMap<Var, Node>(); + values.put(v, NodeFactory.createURI("three")); + handler.setVars(values); + + template = query.getConstructTemplate(); + assertNotNull(template); + lst = template.getTriples(); + assertEquals(1, lst.size()); + t = new Triple(NodeFactory.createURI("one"), + NodeFactory.createURI("two"), NodeFactory.createURI("three")); + assertEquals(t, lst.get(0)); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/DatasetHandlerTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/DatasetHandlerTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/DatasetHandlerTest.java new file mode 100644 index 0000000..f9e2d49 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/DatasetHandlerTest.java @@ -0,0 +1,126 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.handlers; + +import static org.junit.Assert.assertTrue; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; + +import org.apache.jena.arq.querybuilder.handlers.DatasetHandler; +import org.junit.Before; +import org.junit.Test; + +import com.hp.hpl.jena.graph.Node; +import com.hp.hpl.jena.graph.NodeFactory; +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.sparql.core.Var; + +public class DatasetHandlerTest extends AbstractHandlerTest { + private Query query; + private DatasetHandler handler; + + @Before + public void setup() { + query = new Query(); + handler = new DatasetHandler(query); + } + + @Test + public void testAddAll() { + DatasetHandler handler2 = new DatasetHandler(new Query()); + handler2.from("foo"); + handler2.fromNamed("bar"); + handler.addAll(handler2); + String s = query.toString(); + assertTrue(s.contains("FROM <foo>")); + assertTrue(s.contains("FROM NAMED <bar>")); + } + + @Test + public void testFromNamedString() { + handler.fromNamed("foo"); + assertTrue(query.toString().contains("FROM NAMED <foo>")); + } + + @Test + public void fromNamedCollection() { + String[] names = { "foo", "bar" }; + handler.fromNamed(Arrays.asList(names)); + String s = query.toString(); + assertTrue(s.contains("FROM NAMED <foo>")); + assertTrue(s.contains("FROM NAMED <bar>")); + } + + @Test + public void fromString() { + handler.from("foo"); + assertTrue(query.toString().contains("FROM <foo>")); + } + + @Test + public void fromStringCollection() { + String[] names = { "foo", "bar" }; + handler.from(Arrays.asList(names)); + assertTrue(query.toString().contains("FROM <foo>")); + assertTrue(query.toString().contains("FROM <bar>")); + } + + @Test + public void setVarsFromNamed() { + Map<Var, Node> values = new HashMap<Var, Node>(); + handler.fromNamed("?foo"); + handler.from("?bar"); + values.put(Var.alloc("foo"), + NodeFactory.createURI("http://example.com/foo";)); + handler.setVars(values); + String s = query.toString(); + assertTrue(s.contains("FROM NAMED <http://example.com/foo>")); + assertTrue(s.contains("FROM <?bar>")); + } + + @Test + public void setVarsFrom() { + Map<Var, Node> values = new HashMap<Var, Node>(); + handler.fromNamed("?foo"); + handler.from("?bar"); + values.put(Var.alloc("bar"), + NodeFactory.createURI("http://example.com/bar";)); + handler.setVars(values); + String s = query.toString(); + assertTrue(s.contains("FROM NAMED <?foo>")); + assertTrue(s.contains("FROM <http://example.com/bar>")); + } + + @Test + public void setVarsBoth() { + Map<Var, Node> values = new HashMap<Var, Node>(); + handler.fromNamed("?foo"); + handler.from("?bar"); + values.put(Var.alloc("bar"), + NodeFactory.createURI("http://example.com/bar";)); + values.put(Var.alloc("foo"), + NodeFactory.createURI("http://example.com/foo";)); + handler.setVars(values); + String s = query.toString(); + assertTrue(s.contains("FROM NAMED <http://example.com/foo>")); + assertTrue(s.contains("FROM <http://example.com/bar>")); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/PrologHandlerTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/PrologHandlerTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/PrologHandlerTest.java new file mode 100644 index 0000000..b53c611 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/PrologHandlerTest.java @@ -0,0 +1,109 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.handlers; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.jena.arq.querybuilder.handlers.PrologHandler; +import org.junit.Before; +import org.junit.Test; + +import com.hp.hpl.jena.query.Query; + +public class PrologHandlerTest extends AbstractHandlerTest { + + private PrologHandler handler; + private Query query; + + @Before + public void setup() { + query = new Query(); + handler = new PrologHandler(query); + } + + @Test + public void testAddPrefixString() { + handler.addPrefix("pfx", "uri"); + String[] lst = byLine(query.toString()); + assertContainsRegex(PREFIX+"pfx:"+SPACE+node("uri"), lst); + } + + @Test + public void testAddPrefixStringWithColon() { + handler.addPrefix("pfx:", "uri"); + String[] lst = byLine(query.toString()); + assertContainsRegex(PREFIX+"pfx:"+SPACE+node("uri"), lst); + } + + @Test + public void testAddPrefixHandler() { + PrologHandler handler2 = new PrologHandler(new Query()); + handler2.addPrefix("pfx", "uri"); + handler.addAll(handler2); + String[] lst = byLine(query.toString()); + assertContainsRegex("PREFIX\\s+pfx:\\s+\\<uri\\>", lst); + } + + @Test + public void testAddPrefixes() { + Map<String, String> map = new HashMap<String, String>(); + map.put("pfx", "uri"); + map.put("pfx2", "uri2"); + handler.addPrefixes(map); + String[] lst = byLine(query.toString()); + assertContainsRegex(PREFIX+"pfx:"+SPACE+node("uri"), lst); + assertContainsRegex(PREFIX+"pfx2:"+SPACE+node("uri2"), lst); + } + + @Test + public void testAddPrefixesWithColon() { + Map<String, String> map = new HashMap<String, String>(); + map.put("pfx:", "uri"); + map.put("pfx2", "uri2"); + handler.addPrefixes(map); + String[] lst = byLine(query.toString()); + assertContainsRegex(PREFIX+"pfx:"+SPACE+node("uri"), lst); + assertContainsRegex(PREFIX+"pfx2:"+SPACE+node("uri2"), lst); + } + + @Test + public void testAddDuplicatePrefix() { + handler.addPrefix("pfx", "uri"); + handler.addPrefix("pfx", "uri"); + String[] lst = byLine(query.toString()); + assertContainsRegex("PREFIX\\s+pfx:\\s+\\<uri\\>", lst); + } + + @Test + public void testSetBaseString() { + handler.setBase("foo"); + String[] lst = byLine(query.toString()); + assertContainsRegex("BASE\\s+\\<.+/foo\\>", lst); + } + + @Test + public void testBaseAndPrefix() { + handler.setBase("foo"); + handler.addPrefix("pfx", "uri"); + String[] lst = byLine(query.toString()); + assertContainsRegex("PREFIX\\s+pfx:\\s+\\<uri\\>", lst); + assertContainsRegex("BASE\\s+\\<.+/foo\\>", lst); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/SelectHandlerTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/SelectHandlerTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/SelectHandlerTest.java new file mode 100644 index 0000000..0f49c8f --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/SelectHandlerTest.java @@ -0,0 +1,152 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.handlers; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.sparql.core.Var; +import com.hp.hpl.jena.sparql.core.VarExprList; + +public class SelectHandlerTest extends AbstractHandlerTest { + + private SelectHandler handler; + private Query query; + + @Before + public void setup() { + query = new Query(); + handler = new SelectHandler(query); + } + + @Test + public void testAddVar() { + Var v = Var.alloc("one"); + handler.addVar(v); + VarExprList expr = query.getProject(); + assertEquals(1, expr.size()); + assertTrue(expr.contains(v)); + } + + @Test + public void testAddVarAsterisk() { + handler.addVar(null); + VarExprList expr = query.getProject(); + assertEquals(0, expr.size()); + assertTrue(query.isQueryResultStar()); + } + + @Test + public void testAddVarAfterAsterisk() { + handler.addVar(null); + handler.addVar(Var.alloc("x")); + VarExprList expr = query.getProject(); + assertEquals(1, expr.size()); + assertFalse(query.isQueryResultStar()); + assertTrue(expr.contains(Var.alloc("x"))); + } + + @Test + public void testAddVarVar() { + Var v = Var.alloc("one"); + handler.addVar(v); + VarExprList expr = query.getProject(); + assertEquals(1, expr.size()); + assertTrue(expr.contains(v)); + } + + @Test + public void testSetDistinct() { + assertFalse(query.isDistinct()); + assertFalse(query.isReduced()); + + handler.setDistinct(true); + assertTrue(query.isDistinct()); + assertFalse(query.isReduced()); + + handler.setReduced(false); + assertTrue(query.isDistinct()); + assertFalse(query.isReduced()); + + handler.setReduced(true); + assertFalse(query.isDistinct()); + assertTrue(query.isReduced()); + + handler.setDistinct(true); + assertTrue(query.isDistinct()); + assertFalse(query.isReduced()); + + handler.setDistinct(false); + assertFalse(query.isDistinct()); + assertFalse(query.isReduced()); + } + + @Test + public void testSetReduced() { + assertFalse(query.isDistinct()); + assertFalse(query.isReduced()); + + handler.setReduced(true); + assertFalse(query.isDistinct()); + assertTrue(query.isReduced()); + + handler.setDistinct(false); + assertFalse(query.isDistinct()); + assertTrue(query.isReduced()); + + handler.setDistinct(true); + assertTrue(query.isDistinct()); + assertFalse(query.isReduced()); + + handler.setReduced(true); + assertFalse(query.isDistinct()); + assertTrue(query.isReduced()); + + handler.setReduced(false); + assertFalse(query.isDistinct()); + assertFalse(query.isReduced()); + + } + + @Test + public void testAddAllResultStartReduced() { + SelectHandler sh = new SelectHandler(new Query()); + sh.addVar(null); + sh.setReduced(true); + + handler.addAll(sh); + assertTrue(query.isReduced()); + assertTrue(query.isQueryResultStar()); + } + + @Test + public void testAddAllVarsDistinct() { + SelectHandler sh = new SelectHandler(new Query()); + sh.addVar(Var.alloc("foo")); + sh.setDistinct(true); + + handler.addAll(sh); + assertTrue(query.isDistinct()); + assertFalse(query.isQueryResultStar()); + assertEquals(1, query.getResultVars().size()); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/SolutionModifierHandlerTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/SolutionModifierHandlerTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/SolutionModifierHandlerTest.java new file mode 100644 index 0000000..bba1807 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/SolutionModifierHandlerTest.java @@ -0,0 +1,201 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.handlers; + +import static org.junit.Assert.assertEquals; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.jena.arq.querybuilder.handlers.SolutionModifierHandler; +import org.junit.Before; +import org.junit.Test; + +import com.hp.hpl.jena.graph.Node; +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.query.SortCondition; +import com.hp.hpl.jena.sparql.core.Var; +import com.hp.hpl.jena.sparql.lang.sparql_11.ParseException; + +public class SolutionModifierHandlerTest extends AbstractHandlerTest { + + private Query query; + private SolutionModifierHandler solutionModifier; + + @Before + public void setup() { + query = new Query(); + solutionModifier = new SolutionModifierHandler(query); + } + + @Test + public void testAddAll() throws ParseException { + SolutionModifierHandler solutionModifier2 = new SolutionModifierHandler( + new Query()); + solutionModifier2.addOrderBy("orderBy"); + solutionModifier2.addGroupBy("groupBy"); + solutionModifier2.addHaving("?having<10"); + solutionModifier2.setLimit(500); + solutionModifier2.setOffset(200); + + solutionModifier.addAll(solutionModifier2); + + String[] s = byLine(query.toString()); + assertContainsRegex(GROUP_BY + var("groupBy"), s); + assertContainsRegex(HAVING + OPEN_PAREN + var("having") + OPT_SPACE + + LT + OPT_SPACE + "10" + CLOSE_PAREN, s); + assertContainsRegex(ORDER_BY + var("orderBy"), s); + assertContainsRegex(LIMIT + "500", s); + assertContainsRegex(OFFSET + "200", s); + } + + @Test + public void testAll() throws ParseException { + solutionModifier.addOrderBy("orderBy"); + solutionModifier.addGroupBy("groupBy"); + solutionModifier.addHaving("SUM(?lprice) > 10"); + solutionModifier.setLimit(500); + solutionModifier.setOffset(200); + + String[] s = byLine(query.toString()); + assertContainsRegex("GROUP BY\\s+\\?groupBy", s); + assertContainsRegex("HAVING\\s+\\( sum\\(\\?lprice\\) > 10 \\)", s); + assertContainsRegex("ORDER BY\\s+\\?orderBy", s); + assertContainsRegex("LIMIT\\s+500", s); + assertContainsRegex("OFFSET\\s+200", s); + + } + + @Test + public void testAddOrderBy() { + solutionModifier.addOrderBy("orderBy"); + List<SortCondition> sc = query.getOrderBy(); + assertEquals("Wrong number of conditions", 1, sc.size()); + assertEquals("Wrong value", sc.get(0).expression.asVar(), + Var.alloc("orderBy")); + + solutionModifier.addOrderBy("orderBy2"); + sc = query.getOrderBy(); + assertEquals("Wrong number of conditions", 2, sc.size()); + assertEquals("Wrong value", sc.get(0).expression.asVar(), + Var.alloc("orderBy")); + assertEquals("Wrong value", sc.get(1).expression.asVar(), + Var.alloc("orderBy2")); + } + + @Test + public void testAddGroupBy() { + solutionModifier.addGroupBy("groupBy"); + String[] s = byLine(query.toString()); + assertContainsRegex("GROUP BY\\s+\\?groupBy", s); + + solutionModifier.addGroupBy("groupBy2"); + s = byLine(query.toString()); + assertContainsRegex("GROUP BY\\s+\\?groupBy\\s+\\?groupBy2", s); + } + + @Test + public void testAddHaving() throws ParseException { + solutionModifier.addHaving("?having<10"); + assertContainsRegex(HAVING + OPEN_PAREN + var("having") + OPT_SPACE + + LT + OPT_SPACE + 10 + CLOSE_PAREN, query.toString()); + + solutionModifier.addHaving("?having2"); + assertContainsRegex(HAVING + OPEN_PAREN + var("having") + OPT_SPACE + + LT + OPT_SPACE + 10 + CLOSE_PAREN + OPT_SPACE + + var("having2"), query.toString()); + } + + @Test + public void testSetLimit() { + solutionModifier.setLimit(500); + String[] s = byLine(query.toString()); + assertContainsRegex("LIMIT\\s+500", s); + + solutionModifier.setLimit(200); + s = byLine(query.toString()); + assertContainsRegex("LIMIT\\s+200", s); + + solutionModifier.setLimit(-1); + s = byLine(query.toString()); + assertNotContainsRegex("LIMIT.*", s); + + } + + @Test + public void testSetOffset() { + solutionModifier.setOffset(500); + String[] s = byLine(query.toString()); + assertContainsRegex("OFFSET\\s+500", s); + + solutionModifier.setOffset(200); + s = byLine(query.toString()); + assertContainsRegex("OFFSET\\s+200", s); + + solutionModifier.setOffset(-1); + s = byLine(query.toString()); + assertNotContainsRegex("OFFSET.*", s); + } + + @Test + public void testSetVarsGroupBy() { + Var v = Var.alloc("v"); + solutionModifier.addGroupBy(v); + + String[] s = byLine(query.toString()); + assertContainsRegex(GROUP_BY + var("v"), s); + + Map<Var, Node> values = new HashMap<Var, Node>(); + values.put(v, Var.alloc("v2")); + solutionModifier.setVars(values); + s = byLine(query.toString()); + assertContainsRegex(GROUP_BY + var("v2"), s); + } + + @Test + public void testSetVarsHaving() { + Var v = Var.alloc("v"); + solutionModifier.addHaving(v); + + String[] s = byLine(query.toString()); + assertContainsRegex(HAVING + var("v"), s); + + Map<Var, Node> values = new HashMap<Var, Node>(); + values.put(v, Var.alloc("v2")); + solutionModifier.setVars(values); + s = byLine(query.toString()); + assertContainsRegex(HAVING + var("v2"), s); + } + + @Test + public void testSetVarsOrderBy() { + Var v = Var.alloc("v"); + solutionModifier.addOrderBy(v); + + String[] s = byLine(query.toString()); + assertContainsRegex(ORDER_BY + var("v"), s); + + Map<Var, Node> values = new HashMap<Var, Node>(); + values.put(v, Var.alloc("v2")); + solutionModifier.setVars(values); + s = byLine(query.toString()); + assertContainsRegex(ORDER_BY + var("v2"), s); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/WhereHandlerTest.java ---------------------------------------------------------------------- diff --git a/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/WhereHandlerTest.java b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/WhereHandlerTest.java new file mode 100644 index 0000000..ef6ff94 --- /dev/null +++ b/jena-extras/jena-querybuilder/src/test/java/org/apache/jena/arq/querybuilder/handlers/WhereHandlerTest.java @@ -0,0 +1,296 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.jena.arq.querybuilder.handlers; + +import java.util.HashMap; +import java.util.Map; + +import org.apache.jena.arq.querybuilder.SelectBuilder; +import org.apache.jena.arq.querybuilder.handlers.WhereHandler; +import org.junit.Before; +import org.junit.Test; + +import com.hp.hpl.jena.graph.Node; +import com.hp.hpl.jena.graph.NodeFactory; +import com.hp.hpl.jena.graph.Triple; +import com.hp.hpl.jena.graph.impl.LiteralLabelFactory; +import com.hp.hpl.jena.query.Query; +import com.hp.hpl.jena.rdf.model.ResourceFactory; +import com.hp.hpl.jena.sparql.core.Var; +import com.hp.hpl.jena.sparql.lang.sparql_11.ParseException; +import com.hp.hpl.jena.vocabulary.RDF; + +public class WhereHandlerTest extends AbstractHandlerTest { + + private Query query; + private WhereHandler handler; + + @Before + public void setup() { + query = new Query(); + handler = new WhereHandler(query); + } + + @Test + public void testAddAll() { + Query query2 = new Query(); + WhereHandler handler2 = new WhereHandler(query2); + handler2.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory + .createURI("two"), NodeFactory.createLiteral("three"))); + handler.addAll(handler2); + + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + quote("three") + OPT_SPACE + DOT + + CLOSE_CURLY, query.toString()); + } + + @Test + public void addWhereTriple() { + handler.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory + .createURI("two"), NodeFactory.createURI("three"))); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + node("three") + OPT_SPACE + DOT + + CLOSE_CURLY, query.toString()); + } + + @Test + public void testAddWhereObjects() { + handler.addWhere(new Triple(NodeFactory.createURI("one"), + ResourceFactory.createResource("two").asNode(), ResourceFactory + .createLangLiteral("three", "en-US").asNode())); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + quote("three") + "@en-US" + OPT_SPACE + + DOT + CLOSE_CURLY, query.toString()); + } + + @Test + public void testAddWhereAnonymous() { + handler.addWhere(new Triple(Node.ANY, RDF.first.asNode(), Node.ANY)); + assertContainsRegex(WHERE + OPEN_CURLY + "ANY" + SPACE + + node("http://www\\.w3\\.org/1999/02/22-rdf-syntax-ns#first";) + + SPACE + "ANY" + OPT_SPACE + DOT + CLOSE_CURLY, + query.toString()); + } + + @Test + public void testAddOptionalStrings() { + handler.addOptional(new Triple(NodeFactory.createURI("one"), + NodeFactory.createURI("two"), NodeFactory.createURI("three"))); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + node("three") + OPT_SPACE + DOT + CLOSE_CURLY + CLOSE_CURLY, + query.toString()); + } + + @Test + public void testAddOptionalAnonymous() { + handler.addOptional(new Triple(Node.ANY, RDF.first.asNode(), Node.ANY)); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + "ANY" + SPACE + + node("http://www\\.w3\\.org/1999/02/22-rdf-syntax-ns#first";) + + SPACE + "ANY" + OPT_SPACE + DOT + CLOSE_CURLY + CLOSE_CURLY, + query.toString()); + } + + @Test + public void testAddOptionalObjects() { + handler.addOptional(new Triple(NodeFactory.createURI("one"), + ResourceFactory.createResource("two").asNode(), ResourceFactory + .createLangLiteral("three", "en-US").asNode())); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + quote("three") + "@en-US" + OPT_SPACE + DOT + CLOSE_CURLY + + CLOSE_CURLY, query.toString()); + } + + @Test + public void testAddWhereStrings() { + handler.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory + .createURI("two"), NodeFactory.createURI("three"))); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + node("three") + OPT_SPACE + DOT + + CLOSE_CURLY, query.toString()); + } + + @Test + public void testAddFilter() throws ParseException { + handler.addFilter("?one < 10"); + + assertContainsRegex(WHERE + OPEN_CURLY + "FILTER" + OPT_SPACE + + OPEN_PAREN + var("one") + OPT_SPACE + LT + OPT_SPACE + "10" + + CLOSE_PAREN + CLOSE_CURLY, query.toString()); + } + + @Test + public void testAddFilterVarOnly() throws ParseException { + handler.addFilter("?one"); + + assertContainsRegex(WHERE + OPEN_CURLY + "FILTER" + OPT_SPACE + + OPEN_PAREN + var("one") + CLOSE_PAREN + CLOSE_CURLY, + query.toString()); + } + + @Test + public void testAddSubQueryWithVars() { + SelectBuilder sb = new SelectBuilder(); + sb.addPrefix("pfx", "uri").addVar("?x") + .addWhere("<one>", "<two>", "three"); + handler.addSubQuery(sb); + assertContainsRegex("SELECT" + SPACE + var("x") + SPACE + WHERE + + OPEN_CURLY + node("one") + ".+" + node("two") + ".+" + + quote("three") + ".+" + CLOSE_CURLY, query.toString()); + } + + @Test + public void testAddSubQueryWithoutVars() { + SelectBuilder sb = new SelectBuilder(); + sb.addPrefix("pfx", "uri").addWhere("<one>", "<two>", "three"); + handler.addSubQuery(sb); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + ".+" + + node("two") + ".+" + quote("three") + ".+" + CLOSE_CURLY, + query.toString()); + } + + @Test + public void testAddUnion() { + SelectBuilder sb = new SelectBuilder(); + sb.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory + .createURI("two"), NodeFactory.createURI("three"))); + + handler.addUnion(sb); + assertContainsRegex(WHERE + OPEN_CURLY + UNION + OPEN_CURLY + + node("one") + SPACE + node("two") + SPACE + node("three") + + OPT_SPACE + DOT + CLOSE_CURLY, query.toString()); + } + + @Test + public void testAddUnionWithVar() { + SelectBuilder sb = new SelectBuilder().addVar("x").addWhere( + new Triple(NodeFactory.createURI("one"), NodeFactory + .createURI("two"), NodeFactory.createURI("three"))); + + handler.addUnion(sb); + assertContainsRegex(WHERE + OPEN_CURLY + UNION + OPEN_CURLY + SELECT + + var("x") + SPACE + WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + node("three") + OPT_SPACE + DOT + + CLOSE_CURLY, query.toString()); + } + + @Test + public void addGraph() { + + WhereHandler handler2 = new WhereHandler(new Query()); + handler2.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory + .createURI("two"), NodeFactory.createURI("three"))); + + handler.addGraph(NodeFactory.createURI("graph"), handler2); + assertContainsRegex(WHERE + OPEN_CURLY + "GRAPH" + SPACE + + node("graph") + SPACE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + node("three") + OPT_SPACE + DOT + + CLOSE_CURLY + CLOSE_CURLY, query.toString()); + + } + + @Test + public void testSetVarsInTriple() { + Var v = Var.alloc("v"); + handler.addWhere(new Triple(NodeFactory.createURI("one"), NodeFactory + .createURI("two"), v)); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + var("v") + OPT_SPACE + DOT + + CLOSE_CURLY, query.toString()); + Map<Var, Node> values = new HashMap<Var, Node>(); + values.put(v, NodeFactory.createURI("three")); + handler.setVars(values); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + SPACE + + node("two") + SPACE + node("three") + OPT_SPACE + DOT + + CLOSE_CURLY, query.toString()); + } + + @Test + public void testSetVarsInFilter() throws ParseException { + handler.addFilter("?one < ?v"); + assertContainsRegex(WHERE + OPEN_CURLY + "FILTER" + OPT_SPACE + + OPEN_PAREN + var("one") + OPT_SPACE + LT + OPT_SPACE + + var("v") + CLOSE_PAREN + CLOSE_CURLY, query.toString()); + Map<Var, Node> values = new HashMap<Var, Node>(); + + values.put(Var.alloc("v"), + NodeFactory.createLiteral(LiteralLabelFactory.create(10))); + handler.setVars(values); + assertContainsRegex(WHERE + OPEN_CURLY + "FILTER" + OPT_SPACE + + OPEN_PAREN + var("one") + OPT_SPACE + LT + OPT_SPACE + + quote("10") + "\\^\\^" + + node("http://www.w3.org/2001/XMLSchema#int";) + CLOSE_PAREN + + CLOSE_CURLY, query.toString()); + + } + + @Test + public void testSetVarsInOptional() { + Var v = Var.alloc("v"); + handler.addOptional(new Triple(NodeFactory.createURI("one"), + NodeFactory.createURI("two"), v)); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + var("v") + OPT_SPACE + DOT + CLOSE_CURLY + CLOSE_CURLY, + query.toString()); + Map<Var, Node> values = new HashMap<Var, Node>(); + values.put(v, NodeFactory.createURI("three")); + handler.setVars(values); + assertContainsRegex(WHERE + OPEN_CURLY + "OPTIONAL" + SPACE + + OPEN_CURLY + node("one") + SPACE + node("two") + SPACE + + node("three") + OPT_SPACE + DOT + CLOSE_CURLY + CLOSE_CURLY, + query.toString()); + } + + @Test + public void testSetVarsInSubQuery() { + Var v = Var.alloc("v"); + SelectBuilder sb = new SelectBuilder(); + sb.addPrefix("pfx", "uri").addWhere("<one>", "<two>", v); + handler.addSubQuery(sb); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + ".+" + + node("two") + ".+" + var("v") + ".+" + CLOSE_CURLY, + query.toString()); + Map<Var, Node> values = new HashMap<Var, Node>(); + values.put(v, NodeFactory.createURI("three")); + handler.setVars(values); + assertContainsRegex(WHERE + OPEN_CURLY + node("one") + ".+" + + node("two") + ".+" + node("three") + ".+" + CLOSE_CURLY, + query.toString()); + } + + @Test + public void testSetVarsInUnion() { + Var v = Var.alloc("v"); + SelectBuilder sb = new SelectBuilder(); + sb.addPrefix("pfx", "uri").addWhere("<one>", "<two>", v); + handler.addUnion(sb); + assertContainsRegex(WHERE + OPEN_CURLY + UNION + OPEN_CURLY + + node("one") + ".+" + node("two") + ".+" + var("v") + ".+" + + CLOSE_CURLY, query.toString()); + Map<Var, Node> values = new HashMap<Var, Node>(); + values.put(v, NodeFactory.createURI("three")); + handler.setVars(values); + assertContainsRegex(WHERE + OPEN_CURLY + UNION + OPEN_CURLY + + node("one") + ".+" + node("two") + ".+" + node("three") + + ".+" + CLOSE_CURLY, query.toString()); + } + +} http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-extras/pom.xml ---------------------------------------------------------------------- diff --git a/jena-extras/pom.xml b/jena-extras/pom.xml deleted file mode 100644 index 3ad1997..0000000 --- a/jena-extras/pom.xml +++ /dev/null @@ -1,120 +0,0 @@ -<?xml version="1.0" encoding="UTF-8"?> - -<project xmlns="http://maven.apache.org/POM/4.0.0"; xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"; xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd";> - <modelVersion>4.0.0</modelVersion> - <artifactId>jena-extras</artifactId> - <version>2.12.2-SNAPSHOT</version> - <packaging>pom</packaging> - <name>Apache Jena Extras - jena-extras</name> - <description>Extra packages for Jena development. -This is the parent module for the Jena Extra modules. - These modules provide utiliities and larger packages that make Apache Jena development or usage - easier but that do not fall within the standard Jena framework.</description> - - <parent> - <groupId>org.apache.jena</groupId> - <artifactId>jena-parent</artifactId> - <version>12-SNAPSHOT</version> - <relativePath>../jena-parent</relativePath> - </parent> - - <!-- Need if the parent is a snapshot --> - <repositories> - <repository> - <id>apache.snapshots</id> - <name>Apache Snapshot Repository</name> - <url>http://repository.apache.org/snapshots</url> - <releases> - <enabled>false</enabled> - </releases> - </repository> - </repositories> - - <modules> - <module>jena-querybuilder</module> - </modules> - - <properties> - <plugin.license.version>1.9.0</plugin.license.version> - <plugin.license.headerPath>${project.basedir}</plugin.license.headerPath> - <jena-version>${project.version}</jena-version> - </properties> - - <build> - <plugins> - <!-- Compiler Plugin --> - <plugin> - <groupId>org.apache.maven.plugins</groupId> - <artifactId>maven-compiler-plugin</artifactId> - <configuration> - <source>${jdk.version}</source> - <target>${jdk.version}</target> - <encoding>${project.build.sourceEncoding}</encoding> - </configuration> - </plugin> - <!-- License Plugin --> - <!-- - <plugin> - <groupId>com.mycila.maven-license-plugin</groupId> - <artifactId>maven-license-plugin</artifactId> - <version>${plugin.license.version}</version> - <executions> - <execution> - <phase>package</phase> - <goals> - <goal>check</goal> - </goals> - </execution> - </executions> - <configuration> - <header>${plugin.license.headerPath}/license-header.txt</header> - <failIfMissing>true</failIfMissing> - <aggregate>true</aggregate> - <excludes> - <exclude>**/*.git*</exclude> - <exclude>**/*.md</exclude> - <exclude>**/*.xml</exclude> - <exclude>**/*.properties</exclude> - <exclude>**/LICENSE</exclude> - <exclude>**/NOTICE</exclude> - </excludes> - <useDefaultMapping>true</useDefaultMapping> - <strictCheck>true</strictCheck> - </configuration> - </plugin> - --> - <!-- Sources Plugin --> - <plugin> - <artifactId>maven-source-plugin</artifactId> - <version>2.1.1</version> - <executions> - <execution> - <id>bundle-sources</id> - <phase>package</phase> - <goals> - <!-- produce source artifact for main project sources --> - <goal>jar-no-fork</goal> - </goals> - </execution> - </executions> - </plugin> - - </plugins> - </build> - <dependencyManagement> - <dependencies> - <dependency> - <groupId>org.apache.jena</groupId> - <artifactId>apache-jena-libs</artifactId> - <version>${jena-version}</version> - <type>pom</type> - </dependency> - <dependency> - <groupId>org.xenei</groupId> - <artifactId>junit-contracts</artifactId> - <version>0.0.5</version> - <scope>test</scope> - </dependency> - </dependencies> - </dependencyManagement> -</project> \ No newline at end of file http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-fuseki/DEPENDENCIES ---------------------------------------------------------------------- diff --git a/jena-fuseki/DEPENDENCIES b/jena-fuseki/DEPENDENCIES deleted file mode 100644 index 7dece40..0000000 --- a/jena-fuseki/DEPENDENCIES +++ /dev/null @@ -1,21 +0,0 @@ -This file lists the dependences for Apache Jena Fuseki. - Version numbers are given in the POM file for a particular distribution. - -Apache Projects: Apache Software License - Apache Jena, including the Jena IRI library - Apache Xerces-J - Apache log4j - Apache HttpComponents (HTTP Client) - Apache Commons Codec - Apache Common FileUpload - -SLF4J : http://www.slf4j.org/ - Copyright (c) 2004-2008 QOS.ch - MIT License - -JUnit : http://junit.org/ - Common Public License - v 1.0 - -Jetty: http://www.eclipse.org/jetty/ - Apache License 2.0 - (also avilable under Eclipse Public License 1.0) http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-fuseki/Data/books.ttl ---------------------------------------------------------------------- diff --git a/jena-fuseki/Data/books.ttl b/jena-fuseki/Data/books.ttl deleted file mode 100644 index 032c805..0000000 --- a/jena-fuseki/Data/books.ttl +++ /dev/null @@ -1,46 +0,0 @@ -@prefix dc: <http://purl.org/dc/elements/1.1/> . -@prefix vcard: <http://www.w3.org/2001/vcard-rdf/3.0#> . -@prefix ns: <http://example.org/ns#> . - -@prefix : <http://example.org/book/> . - -# A small dataset for usage examples of Joseki -# This data is intentionaly irregular (e.g. different ways to -# record the book creator) as if the information is either an -# aggregation or was created at different times. - -:book1 - dc:title "Harry Potter and the Philosopher's Stone" ; - dc:creator "J.K. Rowling" ; - . - -:book2 - dc:title "Harry Potter and the Chamber of Secrets" ; - dc:creator _:a . - -:book3 - dc:title "Harry Potter and the Prisoner Of Azkaban" ; - dc:creator _:a . - -:book4 - dc:title "Harry Potter and the Goblet of Fire" . - -:book5 - dc:title "Harry Potter and the Order of the Phoenix"; - dc:creator "J.K. Rowling" ; - . - -:book6 - dc:title "Harry Potter and the Half-Blood Prince"; - dc:creator "J.K. Rowling" . - -:book7 - dc:title "Harry Potter and the Deathly Hallows" ; - dc:creator "J.K. Rowling" . -_:a - vcard:FN "J.K. Rowling" ; - vcard:N - [ vcard:Family "Rowling" ; - vcard:Given "Joanna" - ] - . http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-fuseki/Data/test_abox.ttl ---------------------------------------------------------------------- diff --git a/jena-fuseki/Data/test_abox.ttl b/jena-fuseki/Data/test_abox.ttl deleted file mode 100644 index 18b907f..0000000 --- a/jena-fuseki/Data/test_abox.ttl +++ /dev/null @@ -1,5 +0,0 @@ -@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . -@prefix : <http://example/ns#> . - -:x rdf:type :A . - http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-fuseki/Data/test_data_rdfs.ttl ---------------------------------------------------------------------- diff --git a/jena-fuseki/Data/test_data_rdfs.ttl b/jena-fuseki/Data/test_data_rdfs.ttl deleted file mode 100644 index d1dbe43..0000000 --- a/jena-fuseki/Data/test_data_rdfs.ttl +++ /dev/null @@ -1,12 +0,0 @@ -@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . -@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . - -@prefix : <http://example/ns#> . - -:A a rdfs:Class . -:B a rdfs:Class . - -:A rdfs:subClassOf :B . - -:x rdf:type :A . - http://git-wip-us.apache.org/repos/asf/jena/blob/2fb788d3/jena-fuseki/Data/test_tbox.ttl ---------------------------------------------------------------------- diff --git a/jena-fuseki/Data/test_tbox.ttl b/jena-fuseki/Data/test_tbox.ttl deleted file mode 100644 index 7c6e456..0000000 --- a/jena-fuseki/Data/test_tbox.ttl +++ /dev/null @@ -1,9 +0,0 @@ -@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . -@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . - -@prefix : <http://example/ns#> . - -:A a rdfs:Class . -:B a rdfs:Class . - -:A rdfs:subClassOf :B .
