From d77dbe2085ffa89b2a933637c5432d113b7432b8 Mon Sep 17 00:00:00 2001 From: Aaron Coburn Date: Wed, 22 Nov 2017 10:28:25 -0500 Subject: [PATCH] CLEREZZA-1023: Upgrade to JUnit5 This change upgrades the test suite to JUnit 5 --- parent/pom.xml | 16 +- rdf/core.test/pom.xml | 14 +- .../clerezza/rdf/core/test/GraphTest.java | 235 +++++++++--------- .../rdf/core/test/TcProviderTest.java | 19 +- rdf/core/pom.xml | 16 +- .../clerezza/rdf/core/LanguageTest.java | 16 +- .../clerezza/rdf/core/LiteralFactoryTest.java | 39 +-- .../apache/clerezza/rdf/core/UriRefTest.java | 16 +- .../rdf/core/access/SecurityTest.java | 102 +++++--- .../rdf/core/access/TcManagerTest.java | 55 ++-- .../impl/util/SimpleLiteralFactoryTest.java | 21 +- .../rdf/core/impl/util/W3CDateFormatTest.java | 11 +- .../rdf/core/serializedform/ParserTest.java | 24 +- .../core/serializedform/SerializerTest.java | 25 +- .../TestServiceManagedProvider.java | 11 +- .../QueryParserSerializerCombinationTest.java | 39 +-- .../rdf/core/sparql/QueryParserTest.java | 115 +++++---- .../rdf/core/sparql/QuerySerializerTest.java | 32 ++- .../rdf/core/sparql/SparqlPreParserTest.java | 82 +++--- rdf/scala.utils/pom.xml | 16 +- .../rdf/scala/utils/EzMGraphTest.scala | 19 +- .../rdf/scala/utils/RichGraphNodeTest.scala | 64 ++--- .../rdf/scala/utils/TypeConversionTest.scala | 19 +- rdf/schemagen/main/pom.xml | 7 +- rdf/schemagen/maven-plugin/pom.xml | 9 +- rdf/simple.storage/pom.xml | 16 +- .../simple/storage/AccessViaTcManager.java | 15 +- .../simple/storage/GenericTcProviderTest.java | 5 +- rdf/utils/pom.xml | 16 +- .../clerezza/rdf/utils/GraphUtilsTest.java | 22 +- .../clerezza/rdf/utils/IfpSmushTest.java | 17 +- .../clerezza/rdf/utils/RdfListTest.java | 36 +-- .../clerezza/rdf/utils/SameAsSmushTest.java | 30 ++- .../clerezza/rdf/utils/TestGraphNode.java | 75 +++--- .../clerezza/rdf/utils/UnionGraphTest.java | 30 ++- .../rdf/utils/smushing/SameAsSmushTest.java | 32 ++- 36 files changed, 775 insertions(+), 541 deletions(-) diff --git a/parent/pom.xml b/parent/pom.xml index e219aebbe..121b4e367 100644 --- a/parent/pom.xml +++ b/parent/pom.xml @@ -326,9 +326,19 @@ - junit - junit - 4.12 + org.junit.jupiter + junit-jupiter-engine + 5.0.2 + + + org.junit.platform + junit-platform-runner + 1.0.2 + + + org.apiguardian + apiguardian-api + 1.0.0 org.apache.wink diff --git a/rdf/core.test/pom.xml b/rdf/core.test/pom.xml index 125c01d21..d29a5a201 100644 --- a/rdf/core.test/pom.xml +++ b/rdf/core.test/pom.xml @@ -35,8 +35,16 @@ Utilities to test Clerezza rdf.core implementations - junit - junit + org.junit.platform + junit-platform-runner + + + org.junit.jupiter + junit-jupiter-engine + + + org.apiguardian + apiguardian-api org.apache.clerezza @@ -48,4 +56,4 @@ commons-lang - \ No newline at end of file + diff --git a/rdf/core.test/src/main/java/org/apache/clerezza/rdf/core/test/GraphTest.java b/rdf/core.test/src/main/java/org/apache/clerezza/rdf/core/test/GraphTest.java index f110041da..3de63dabb 100644 --- a/rdf/core.test/src/main/java/org/apache/clerezza/rdf/core/test/GraphTest.java +++ b/rdf/core.test/src/main/java/org/apache/clerezza/rdf/core/test/GraphTest.java @@ -18,26 +18,31 @@ */ package org.apache.clerezza.rdf.core.test; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.Iterator; import java.util.Set; + import org.apache.clerezza.commons.rdf.BlankNode; -import org.apache.clerezza.commons.rdf.Literal; -import org.apache.clerezza.commons.rdf.Graph; import org.apache.clerezza.commons.rdf.BlankNodeOrIRI; -import org.apache.clerezza.commons.rdf.RDFTerm; -import org.apache.clerezza.commons.rdf.Triple; +import org.apache.clerezza.commons.rdf.Graph; import org.apache.clerezza.commons.rdf.IRI; -import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; -import org.junit.Test; import org.apache.clerezza.commons.rdf.Language; +import org.apache.clerezza.commons.rdf.Literal; +import org.apache.clerezza.commons.rdf.RDFTerm; +import org.apache.clerezza.commons.rdf.Triple; import org.apache.clerezza.commons.rdf.impl.utils.PlainLiteralImpl; +import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; import org.apache.clerezza.commons.rdf.impl.utils.TypedLiteralImpl; -import org.junit.Assert; - +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * A generic abstract test class, implementations overwrite this class, @@ -45,6 +50,7 @@ * * @author reto, szalay, mir, hhn */ +@RunWith(JUnitPlatform.class) public abstract class GraphTest { private final IRI uriRef1 = @@ -78,15 +84,15 @@ public abstract class GraphTest { @Test public void testAddCountAndGetTriples() { Graph graph = getEmptyGraph(); - Assert.assertEquals(0, graph.size()); + assertEquals(0, graph.size()); final TripleImpl triple1 = new TripleImpl(uriRef1, uriRef2, uriRef1); graph.add(triple1); - Assert.assertEquals(1, graph.size()); + assertEquals(1, graph.size()); Iterator tripleIter = graph.filter(uriRef1, uriRef2, uriRef1); - Assert.assertTrue(tripleIter.hasNext()); + assertTrue(tripleIter.hasNext()); Triple tripleGot = tripleIter.next(); - Assert.assertEquals(triple1, tripleGot); - Assert.assertFalse(tripleIter.hasNext()); + assertEquals(triple1, tripleGot); + assertFalse(tripleIter.hasNext()); BlankNode bnode = new BlankNode() {}; graph.add(new TripleImpl(bnode, uriRef1, uriRef3)); graph.add(new TripleImpl(bnode, uriRef1, uriRef4)); @@ -98,86 +104,86 @@ public void testAddCountAndGetTriples() { subjectInMatchingTriples.add(triple.getSubject()); objectsInMatchingTriples.add(triple.getObject()); } - Assert.assertEquals(1, subjectInMatchingTriples.size()); - Assert.assertEquals(2, objectsInMatchingTriples.size()); + assertEquals(1, subjectInMatchingTriples.size()); + assertEquals(2, objectsInMatchingTriples.size()); Set expectedObjects = new HashSet(); expectedObjects.add(uriRef3); expectedObjects.add(uriRef4); - Assert.assertEquals(expectedObjects, objectsInMatchingTriples); + assertEquals(expectedObjects, objectsInMatchingTriples); graph.add(new TripleImpl(bnode, uriRef4, bnode)); tripleIter = graph.filter(null, uriRef4, null); - Assert.assertTrue(tripleIter.hasNext()); + assertTrue(tripleIter.hasNext()); Triple retrievedTriple = tripleIter.next(); - Assert.assertFalse(tripleIter.hasNext()); - Assert.assertEquals(retrievedTriple.getSubject(), retrievedTriple.getObject()); + assertFalse(tripleIter.hasNext()); + assertEquals(retrievedTriple.getSubject(), retrievedTriple.getObject()); tripleIter = graph.filter(uriRef1, uriRef2, null); - Assert.assertTrue(tripleIter.hasNext()); + assertTrue(tripleIter.hasNext()); retrievedTriple = tripleIter.next(); - Assert.assertFalse(tripleIter.hasNext()); - Assert.assertEquals(retrievedTriple.getSubject(), retrievedTriple.getObject()); + assertFalse(tripleIter.hasNext()); + assertEquals(retrievedTriple.getSubject(), retrievedTriple.getObject()); } @Test public void testRemoveAllTriples() { Graph graph = getEmptyGraph(); - Assert.assertEquals(0, graph.size()); + assertEquals(0, graph.size()); graph.add(new TripleImpl(uriRef1, uriRef2, uriRef3)); graph.add(new TripleImpl(uriRef2, uriRef3, uriRef4)); - Assert.assertEquals(2, graph.size()); + assertEquals(2, graph.size()); graph.clear(); - Assert.assertEquals(0, graph.size()); + assertEquals(0, graph.size()); } @Test public void testUseTypedLiterals() { Graph graph = getEmptyGraph(); - Assert.assertEquals(0, graph.size()); + assertEquals(0, graph.size()); Literal value = new TypedLiteralImpl("value",xmlLiteralType); final TripleImpl triple1 = new TripleImpl(uriRef1, uriRef2, value); graph.add(triple1); Iterator tripleIter = graph.filter(uriRef1, uriRef2, null); - Assert.assertTrue(tripleIter.hasNext()); + assertTrue(tripleIter.hasNext()); RDFTerm gotValue = tripleIter.next().getObject(); - Assert.assertEquals(value, gotValue); + assertEquals(value, gotValue); } @Test public void testUseLanguageLiterals() { Graph graph = getEmptyGraph(); - Assert.assertEquals(0, graph.size()); + assertEquals(0, graph.size()); Language language = new Language("it"); Literal value = new PlainLiteralImpl("value",language); final TripleImpl triple1 = new TripleImpl(uriRef1, uriRef2, value); graph.add(triple1); Iterator tripleIter = graph.filter(uriRef1, uriRef2, null); - Assert.assertTrue(tripleIter.hasNext()); + assertTrue(tripleIter.hasNext()); RDFTerm gotValue = tripleIter.next().getObject(); - Assert.assertEquals(value, gotValue); - Assert.assertEquals(language, ((Literal)gotValue).getLanguage()); + assertEquals(value, gotValue); + assertEquals(language, ((Literal)gotValue).getLanguage()); } @Test public void testRemoveViaIterator() { Graph graph = getEmptyGraph(); - Assert.assertEquals(0, graph.size()); + assertEquals(0, graph.size()); final TripleImpl triple1 = new TripleImpl(uriRef1, uriRef2, uriRef1); graph.add(triple1); final TripleImpl triple2 = new TripleImpl(uriRef1, uriRef2, uriRef4); graph.add(triple2); - Assert.assertEquals(2, graph.size()); + assertEquals(2, graph.size()); Iterator iterator = graph.iterator(); while (iterator.hasNext()) { iterator.next(); iterator.remove(); } - Assert.assertEquals(0, graph.size()); + assertEquals(0, graph.size()); } @Test public void testGetSize() throws Exception { Graph graph = getEmptyGraph(); // The test graph must always be empty after test fixture setup - Assert.assertEquals(0, graph.size()); + assertEquals(0, graph.size()); } @@ -188,9 +194,9 @@ public void testAddSingleTriple() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/alice"); - Assert.assertEquals(0, graph.size()); - Assert.assertTrue(graph.add(triple)); - Assert.assertEquals(1, graph.size()); + assertEquals(0, graph.size()); + assertTrue(graph.add(triple)); + assertEquals(1, graph.size()); } @@ -201,10 +207,10 @@ public void testAddSameTripleTwice() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/alice"); - Assert.assertEquals(0, graph.size()); - Assert.assertTrue(graph.add(triple)); - Assert.assertFalse(graph.add(triple)); // ImmutableGraph does not change - Assert.assertEquals(1, graph.size()); + assertEquals(0, graph.size()); + assertTrue(graph.add(triple)); + assertFalse(graph.add(triple)); // ImmutableGraph does not change + assertEquals(1, graph.size()); } @@ -215,9 +221,9 @@ public void testRemoveSingleTriple() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/alice"); - Assert.assertTrue(graph.add(triple)); - Assert.assertTrue(graph.remove(triple)); - Assert.assertEquals(0, graph.size()); + assertTrue(graph.add(triple)); + assertTrue(graph.remove(triple)); + assertEquals(0, graph.size()); } @Test @@ -231,11 +237,11 @@ public void testRemoveSameTripleTwice() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/bob"); - Assert.assertTrue(graph.add(tripleAlice)); - Assert.assertTrue(graph.add(tripleBob)); - Assert.assertTrue(graph.remove(tripleAlice)); - Assert.assertFalse(graph.remove(tripleAlice)); - Assert.assertEquals(1, graph.size()); + assertTrue(graph.add(tripleAlice)); + assertTrue(graph.add(tripleBob)); + assertTrue(graph.remove(tripleAlice)); + assertFalse(graph.remove(tripleAlice)); + assertEquals(1, graph.size()); } @Test @@ -247,10 +253,10 @@ public void testGetSameBlankNode() throws Exception { final PlainLiteralImpl name2 = new PlainLiteralImpl("http://example.org/people/bob"); final Triple tripleAlice = new TripleImpl(bNode, HAS_NAME, name); final Triple tripleBob = new TripleImpl(bNode, HAS_NAME, name2); - Assert.assertTrue(graph.add(tripleAlice)); - Assert.assertTrue(graph.add(tripleBob)); + assertTrue(graph.add(tripleAlice)); + assertTrue(graph.add(tripleBob)); Iterator result = graph.filter(null, HAS_NAME, name); - Assert.assertEquals(bNode, result.next().getSubject()); + assertEquals(bNode, result.next().getSubject()); } @Test @@ -260,8 +266,8 @@ public void testContainsIfContained() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/alice"); - Assert.assertTrue(graph.add(triple)); - Assert.assertTrue(graph.contains(triple)); + assertTrue(graph.add(triple)); + assertTrue(graph.contains(triple)); } @@ -272,7 +278,7 @@ public void testContainsIfEmpty() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/alice"); - Assert.assertFalse(graph.contains(triple)); + assertFalse(graph.contains(triple)); } @@ -287,8 +293,8 @@ public void testContainsIfNotContained() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/bob"); - Assert.assertTrue(graph.add(tripleAdd)); - Assert.assertFalse(graph.contains(tripleTest)); + assertTrue(graph.add(tripleAdd)); + assertFalse(graph.contains(tripleTest)); } @@ -296,7 +302,7 @@ public void testContainsIfNotContained() throws Exception { public void testFilterEmptyGraph() throws Exception { Graph graph = getEmptyGraph(); Iterator i = graph.filter(null, null, null); - Assert.assertFalse(i.hasNext()); + assertFalse(i.hasNext()); } @@ -307,12 +313,12 @@ public void testFilterSingleEntry() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/alice"); - Assert.assertTrue(graph.add(triple)); + assertTrue(graph.add(triple)); Iterator i = graph.filter(null, null, null); Collection resultSet= toCollection(i); - Assert.assertEquals(1, resultSet.size()); - Assert.assertTrue(resultSet.contains(triple)); + assertEquals(1, resultSet.size()); + assertTrue(resultSet.contains(triple)); } @@ -327,8 +333,8 @@ public void testFilterByObject() throws Exception { "http://example.org/ontology/Person", "http://example.org/ontology/hasName", "http://example.org/people/bob"); - Assert.assertTrue(graph.add(tripleAlice)); - Assert.assertTrue(graph.add(tripleBob)); + assertTrue(graph.add(tripleAlice)); + assertTrue(graph.add(tripleBob)); Iterator iterator; Collection resultSet; @@ -337,23 +343,24 @@ public void testFilterByObject() throws Exception { iterator = graph.filter(null, null, new IRI("http://example.org/people/bob")); resultSet= toCollection(iterator); - Assert.assertEquals(1, resultSet.size()); - Assert.assertTrue(resultSet.contains(tripleBob)); + assertEquals(1, resultSet.size()); + assertTrue(resultSet.contains(tripleBob)); // Find alice iterator = graph.filter(null, null, new IRI("http://example.org/people/alice")); resultSet= toCollection(iterator); - Assert.assertEquals(1, resultSet.size()); - Assert.assertTrue(resultSet.contains(tripleAlice)); + assertEquals(1, resultSet.size()); + assertTrue(resultSet.contains(tripleAlice)); // Find both iterator = graph.filter(null, null, null); resultSet= toCollection(iterator); - Assert.assertEquals(2, resultSet.size()); - Assert.assertTrue(resultSet.contains(tripleAlice)); - Assert.assertTrue(resultSet.contains(tripleBob)); + assertEquals(2, resultSet.size()); + assertTrue(resultSet.contains(tripleAlice)); + assertTrue(resultSet.contains(tripleBob)); } + /* @Test public void graphEventTestAddRemove() { @@ -363,26 +370,26 @@ public void graphEventTestAddRemove() { mGraph.addGraphListener(listener, new FilterTriple(bnode2, null, literal2)); mGraph.addGraphListener(listener, new FilterTriple(null, uriRef4, literal2)); mGraph.add(trpl1); - Assert.assertNull(listener.getEvents()); + assertNull(listener.getEvents()); mGraph.add(trpl2); - Assert.assertEquals(1, listener.getEvents().size()); - Assert.assertEquals(trpl2, listener.getEvents().get(0).getTriple()); - Assert.assertTrue(listener.getEvents().get(0) instanceof AddEvent); + assertEquals(1, listener.getEvents().size()); + assertEquals(trpl2, listener.getEvents().get(0).getTriple()); + assertTrue(listener.getEvents().get(0) instanceof AddEvent); listener.resetEvents(); mGraph.remove(trpl2); - Assert.assertEquals(1, listener.getEvents().size()); - Assert.assertEquals(trpl2, listener.getEvents().get(0).getTriple()); - Assert.assertTrue(listener.getEvents().get(0) instanceof RemoveEvent); + assertEquals(1, listener.getEvents().size()); + assertEquals(trpl2, listener.getEvents().get(0).getTriple()); + assertTrue(listener.getEvents().get(0) instanceof RemoveEvent); listener.resetEvents(); mGraph.add(trpl3); - Assert.assertEquals(1, listener.getEvents().size()); - Assert.assertEquals(trpl3, listener.getEvents().get(0).getTriple()); - Assert.assertTrue(listener.getEvents().get(0) instanceof AddEvent); + assertEquals(1, listener.getEvents().size()); + assertEquals(trpl3, listener.getEvents().get(0).getTriple()); + assertTrue(listener.getEvents().get(0) instanceof AddEvent); listener.resetEvents(); mGraph.remove(trpl4); - Assert.assertNull(listener.getEvents()); + assertNull(listener.getEvents()); } - + @Test public void graphEventTestAddAllRemoveAll() { Graph mGraph = getEmptyGraph(); @@ -398,20 +405,20 @@ public void graphEventTestAddAllRemoveAll() { mGraph.addAll(triples); List cumulatedEvents = listener.getCumulatedEvents(); Set cumulatedTriples = getCumulatedTriples(cumulatedEvents); - Assert.assertEquals(3, cumulatedEvents.size()); - Assert.assertTrue(cumulatedEvents.get(0) instanceof AddEvent); - Assert.assertTrue(cumulatedTriples.contains(trpl2)); - Assert.assertTrue(cumulatedTriples.contains(trpl3)); - Assert.assertTrue(cumulatedTriples.contains(trpl4)); + assertEquals(3, cumulatedEvents.size()); + assertTrue(cumulatedEvents.get(0) instanceof AddEvent); + assertTrue(cumulatedTriples.contains(trpl2)); + assertTrue(cumulatedTriples.contains(trpl3)); + assertTrue(cumulatedTriples.contains(trpl4)); listener.resetCumulatedEvents(); mGraph.removeAll(triples); cumulatedEvents = listener.getCumulatedEvents(); cumulatedTriples = getCumulatedTriples(cumulatedEvents); - Assert.assertEquals(3, cumulatedEvents.size()); - Assert.assertTrue(cumulatedEvents.get(0) instanceof RemoveEvent); - Assert.assertTrue(cumulatedTriples.contains(trpl2)); - Assert.assertTrue(cumulatedTriples.contains(trpl3)); - Assert.assertTrue(cumulatedTriples.contains(trpl4)); + assertEquals(3, cumulatedEvents.size()); + assertTrue(cumulatedEvents.get(0) instanceof RemoveEvent); + assertTrue(cumulatedTriples.contains(trpl2)); + assertTrue(cumulatedTriples.contains(trpl3)); + assertTrue(cumulatedTriples.contains(trpl4)); } @Test @@ -432,9 +439,9 @@ public void graphEventTestFilterRemove() { result.remove(); } List cumulatedEvents = listener.getCumulatedEvents(); - Assert.assertEquals(1, cumulatedEvents.size()); - Assert.assertTrue(cumulatedEvents.get(0) instanceof RemoveEvent); - Assert.assertEquals(trpl2, listener.getEvents().get(0).getTriple()); + assertEquals(1, cumulatedEvents.size()); + assertTrue(cumulatedEvents.get(0) instanceof RemoveEvent); + assertEquals(trpl2, listener.getEvents().get(0).getTriple()); } @Test @@ -456,11 +463,11 @@ public void graphEventTestIteratorRemove() { } List cumulatedEvents = listener.getCumulatedEvents(); Set cumulatedTriples = getCumulatedTriples(cumulatedEvents); - Assert.assertEquals(3, cumulatedEvents.size()); - Assert.assertTrue(cumulatedEvents.get(0) instanceof RemoveEvent); - Assert.assertTrue(cumulatedTriples.contains(trpl2)); - Assert.assertTrue(cumulatedTriples.contains(trpl3)); - Assert.assertTrue(cumulatedTriples.contains(trpl4)); + assertEquals(3, cumulatedEvents.size()); + assertTrue(cumulatedEvents.get(0) instanceof RemoveEvent); + assertTrue(cumulatedTriples.contains(trpl2)); + assertTrue(cumulatedTriples.contains(trpl3)); + assertTrue(cumulatedTriples.contains(trpl4)); } @Test @@ -478,11 +485,11 @@ public void graphEventTestClear() { mGraph.clear(); List cumulatedEvents = listener.getCumulatedEvents(); Set cumulatedTriples = getCumulatedTriples(cumulatedEvents); - Assert.assertEquals(3, cumulatedEvents.size()); - Assert.assertTrue(cumulatedEvents.get(0) instanceof RemoveEvent); - Assert.assertTrue(cumulatedTriples.contains(trpl2)); - Assert.assertTrue(cumulatedTriples.contains(trpl3)); - Assert.assertTrue(cumulatedTriples.contains(trpl4)); + assertEquals(3, cumulatedEvents.size()); + assertTrue(cumulatedEvents.get(0) instanceof RemoveEvent); + assertTrue(cumulatedTriples.contains(trpl2)); + assertTrue(cumulatedTriples.contains(trpl3)); + assertTrue(cumulatedTriples.contains(trpl4)); } private Set getCumulatedTriples(List cumulatedEvents) { @@ -509,13 +516,13 @@ public void graphEventTestWithDelay() throws Exception{ mGraph.add(triple2); mGraph.add(triple3); Thread.sleep(1500); - Assert.assertEquals(3, listener.getEvents().size()); - Assert.assertEquals(triple1, listener.getEvents().get(0).getTriple()); - Assert.assertTrue(listener.getEvents().get(0) instanceof AddEvent); - Assert.assertEquals(triple2, listener.getEvents().get(1).getTriple()); - Assert.assertTrue(listener.getEvents().get(0) instanceof AddEvent); - Assert.assertEquals(triple3, listener.getEvents().get(2).getTriple()); - Assert.assertTrue(listener.getEvents().get(0) instanceof AddEvent); + assertEquals(3, listener.getEvents().size()); + assertEquals(triple1, listener.getEvents().get(0).getTriple()); + assertTrue(listener.getEvents().get(0) instanceof AddEvent); + assertEquals(triple2, listener.getEvents().get(1).getTriple()); + assertTrue(listener.getEvents().get(0) instanceof AddEvent); + assertEquals(triple3, listener.getEvents().get(2).getTriple()); + assertTrue(listener.getEvents().get(0) instanceof AddEvent); } private static class TestGraphListener implements GraphListener { diff --git a/rdf/core.test/src/main/java/org/apache/clerezza/rdf/core/test/TcProviderTest.java b/rdf/core.test/src/main/java/org/apache/clerezza/rdf/core/test/TcProviderTest.java index bea479db0..631a52877 100644 --- a/rdf/core.test/src/main/java/org/apache/clerezza/rdf/core/test/TcProviderTest.java +++ b/rdf/core.test/src/main/java/org/apache/clerezza/rdf/core/test/TcProviderTest.java @@ -18,29 +18,36 @@ */ package org.apache.clerezza.rdf.core.test; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.HashSet; import java.util.Iterator; - import java.util.Set; -import org.junit.Test; + import org.apache.clerezza.commons.rdf.BlankNode; import org.apache.clerezza.commons.rdf.ImmutableGraph; import org.apache.clerezza.commons.rdf.Graph; import org.apache.clerezza.commons.rdf.BlankNodeOrIRI; import org.apache.clerezza.commons.rdf.Triple; import org.apache.clerezza.commons.rdf.IRI; +import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph; +import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; import org.apache.clerezza.rdf.core.access.EntityAlreadyExistsException; import org.apache.clerezza.rdf.core.access.NoSuchEntityException; - import org.apache.clerezza.rdf.core.access.TcProvider; -import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph; -import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; -import static org.junit.Assert.*; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author mir,rbn */ +@RunWith(JUnitPlatform.class) public abstract class TcProviderTest { protected final IRI uriRefA = generateUri("a"); diff --git a/rdf/core/pom.xml b/rdf/core/pom.xml index 144215ed0..039507dd8 100644 --- a/rdf/core/pom.xml +++ b/rdf/core/pom.xml @@ -22,7 +22,7 @@ clerezza org.apache.clerezza - 7 + 8-SNAPSHOT ../../parent org.apache.clerezza @@ -65,8 +65,18 @@ 0.2 - junit - junit + org.junit.platform + junit-platform-runner + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + org.apiguardian + apiguardian-api test diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/LanguageTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/LanguageTest.java index 21d53c367..04474a208 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/LanguageTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/LanguageTest.java @@ -18,33 +18,37 @@ */ package org.apache.clerezza.rdf.core; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import org.apache.clerezza.commons.rdf.Language; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class LanguageTest { @Test public void languageEqualityTest() { Language lang1 = new Language("DE"); Language lang2 = new Language("DE"); - Assert.assertEquals(lang1, lang2); - Assert.assertEquals(lang1.hashCode(), lang2.hashCode()); + assertEquals(lang1, lang2); + assertEquals(lang1.hashCode(), lang2.hashCode()); Language lang3 = new Language("EN"); - Assert.assertFalse(lang1.equals(lang3)); + assertFalse(lang1.equals(lang3)); } @Test public void toStringTest() { final String id = "de"; Language lang1 = new Language(id); - Assert.assertEquals(lang1.toString(), id); + assertEquals(lang1.toString(), id); } } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/LiteralFactoryTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/LiteralFactoryTest.java index f0dbd799d..12adb8ea5 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/LiteralFactoryTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/LiteralFactoryTest.java @@ -18,28 +18,35 @@ */ package org.apache.clerezza.rdf.core; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.apache.clerezza.commons.rdf.Literal; -import org.apache.clerezza.commons.rdf.IRI; import java.util.Arrays; import java.util.Date; -import org.junit.Test; -import junit.framework.Assert; +import org.apache.clerezza.commons.rdf.Literal; +import org.apache.clerezza.commons.rdf.IRI; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class LiteralFactoryTest { /** * Test that a NoConvertorException thrown for an unsupported convertor */ - @Test(expected=NoConvertorException.class) + @Test public void unavailableConvertor() { Object value = new Object() {}; - LiteralFactory.getInstance().createTypedLiteral(value); + assertThrows(NoConvertorException.class, () -> + LiteralFactory.getInstance().createTypedLiteral(value)); } /** @@ -52,13 +59,13 @@ public void byteArrayConversion() { bytes[i] = i; } Literal literal = LiteralFactory.getInstance().createTypedLiteral(bytes); - Assert.assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#base64Binary"), + assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#base64Binary"), literal.getDataType()); //we are using bytes.getClass() but there should be a way to get //that instance of Class without getting it from an instance //but this is java-bug 4071439 (would like byte[].class or byte.class.getArrayType()) byte[] bytesBack = LiteralFactory.getInstance().createObject(bytes.getClass(), literal); - Assert.assertTrue(Arrays.equals(bytes, bytesBack)); + assertTrue(Arrays.equals(bytes, bytesBack)); } @@ -69,10 +76,10 @@ public void byteArrayConversion() { public void dateConversion() { Date date = new Date(); Literal literal = LiteralFactory.getInstance().createTypedLiteral(date); - Assert.assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#dateTime"), + assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#dateTime"), literal.getDataType()); Date dateBack = LiteralFactory.getInstance().createObject(Date.class, literal); - Assert.assertEquals(date.getTime(), dateBack.getTime()); + assertEquals(date.getTime(), dateBack.getTime()); } @@ -83,10 +90,10 @@ public void dateConversion() { public void stringConversion() { String value = "Hello world"; Literal literal = LiteralFactory.getInstance().createTypedLiteral(value); - Assert.assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#string"), + assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#string"), literal.getDataType()); String valueBack = LiteralFactory.getInstance().createObject(String.class, literal); - Assert.assertEquals(value, valueBack); + assertEquals(value, valueBack); } @@ -97,10 +104,10 @@ public void stringConversion() { public void intConversion() { int value = 3; Literal literal = LiteralFactory.getInstance().createTypedLiteral(value); - Assert.assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#int"), + assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#int"), literal.getDataType()); Integer valueBack = LiteralFactory.getInstance().createObject(Integer.class, literal); - Assert.assertEquals(value, valueBack.intValue()); + assertEquals(value, valueBack.intValue()); } @@ -111,10 +118,10 @@ public void intConversion() { public void longConversion() { long value = 332314646; Literal literal = LiteralFactory.getInstance().createTypedLiteral(value); - Assert.assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#long"), + assertEquals(new IRI("http://www.w3.org/2001/XMLSchema#long"), literal.getDataType()); Long valueBack = LiteralFactory.getInstance().createObject(Long.class, literal); - Assert.assertEquals(value, valueBack.longValue()); + assertEquals(value, valueBack.longValue()); } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/UriRefTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/UriRefTest.java index 71d68467f..cd8501c1d 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/UriRefTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/UriRefTest.java @@ -18,12 +18,16 @@ */ package org.apache.clerezza.rdf.core; -import org.apache.clerezza.commons.rdf.IRI; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; + import java.io.UnsupportedEncodingException; import java.net.URLEncoder; -import org.junit.Test; -import junit.framework.Assert; +import org.apache.clerezza.commons.rdf.IRI; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -41,10 +45,10 @@ public void uriRefEqualityTest() { String uriRefString = "http://example.org/üöä"; IRI uriRef1 = new IRI(uriRefString); IRI uriRef2 = new IRI(uriRefString); - Assert.assertEquals(uriRef1, uriRef2); + assertEquals(uriRef1, uriRef2); IRI uriRef3 = new IRI(URLEncoder.encode(uriRefString, "utf-8")); - Assert.assertFalse(uriRef1.equals(uriRef3)); + assertFalse(uriRef1.equals(uriRef3)); } catch (UnsupportedEncodingException ex) { logger.error("Exception {} ", ex); } @@ -54,7 +58,7 @@ public void uriRefEqualityTest() { public void toStringTest() { String uriRefString = "http://example.org/üöä"; IRI uriRef = new IRI(uriRefString); - Assert.assertEquals("<"+uriRefString+">", uriRef.toString()); + assertEquals("<"+uriRefString+">", uriRef.toString()); } } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/access/SecurityTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/access/SecurityTest.java index 36d869263..b0ca93639 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/access/SecurityTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/access/SecurityTest.java @@ -18,6 +18,9 @@ */ package org.apache.clerezza.rdf.core.access; +import static org.slf4j.LoggerFactory.getLogger; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.io.FilePermission; import java.lang.reflect.ReflectPermission; import java.security.AccessControlException; @@ -28,11 +31,7 @@ import java.security.Policy; import java.util.Collections; import java.util.PropertyPermission; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; + import org.apache.clerezza.commons.rdf.Graph; import org.apache.clerezza.commons.rdf.Triple; import org.apache.clerezza.commons.rdf.Graph; @@ -43,16 +42,28 @@ import org.apache.clerezza.commons.rdf.impl.utils.PlainLiteralImpl; import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; +import org.slf4j.Logger; + /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class SecurityTest { - + + private static final Logger LOGGER = getLogger(SecurityTest.class); + public SecurityTest() { } - @BeforeClass + @BeforeAll public static void setUpClass() throws Exception { ////needed to unbind because this is injected with META-INF/services - file TcManager.getInstance().unbindWeightedTcProvider(new WeightedA()); @@ -61,11 +72,11 @@ public static void setUpClass() throws Exception { TcManager.getInstance().createGraph(new IRI("http://example.org/read/ImmutableGraph")); } - @AfterClass + @AfterAll public static void tearDownClass() throws Exception { } - @Before + @BeforeEach public void setUp() { Policy.setPolicy(new Policy() { @@ -91,65 +102,73 @@ public PermissionCollection getPermissions(CodeSource codeSource) { @Override public void checkPermission(Permission perm) { - //System.out.println("Checking "+perm); + LOGGER.debug("Checking {}", perm); super.checkPermission(perm); } @Override public void checkPermission(Permission perm, Object context) { - //System.out.println("Checking "+perm); + LOGGER.debug("Checking {}", perm); super.checkPermission(perm, context); } }); } - @After + @AfterEach public void tearDown() { System.setSecurityManager(null); } - @Test(expected=NoSuchEntityException.class) - public void testAcessGraph() { - TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/permitted")); + @Test + public void testAcessGraph() { + assertThrows(NoSuchEntityException.class, () -> + TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/permitted"))); } - - @Test(expected=AccessControlException.class) + + @Test public void testNoWildCard() { - TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/permitted/subthing")); + assertThrows(AccessControlException.class, () -> + TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/permitted/subthing"))); } - - @Test(expected=NoSuchEntityException.class) + + @Test public void testAllowedArea() { - TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/area/allowed/something")); + assertThrows(NoSuchEntityException.class, () -> + TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/area/allowed/something"))); } - - @Test(expected=AccessControlException.class) + + @Test public void testAcessForbiddenGraph() { - TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/forbidden")); + assertThrows(AccessControlException.class, () -> + TcManager.getInstance().getImmutableGraph(new IRI("http://example.org/forbidden"))); } - @Test(expected=NoSuchEntityException.class) + @Test public void testCustomPermissions() { IRI graphUri = new IRI("http://example.org/custom"); TcManager.getInstance().getTcAccessController().setRequiredReadPermissionStrings(graphUri, Collections.singletonList("(java.io.FilePermission \"/etc\" \"write\")")); //new FilePermission("/etc", "write").toString())); Graph ag = TcManager.getInstance().getGraph(new IRI("urn:x-localinstance:/graph-access.graph")); - System.out.print(ag.toString()); - TcManager.getInstance().getMGraph(graphUri); + + LOGGER.info("Custom permissions graph: {}", ag); + assertThrows(NoSuchEntityException.class, () -> + TcManager.getInstance().getMGraph(graphUri)); } - @Test(expected=AccessControlException.class) + @Test public void testCustomPermissionsIncorrect() { IRI graphUri = new IRI("http://example.org/custom"); TcManager.getInstance().getTcAccessController().setRequiredReadPermissionStrings(graphUri, Collections.singletonList("(java.io.FilePermission \"/etc\" \"write\")")); //new FilePermission("/etc", "write").toString())); Graph ag = TcManager.getInstance().getGraph(new IRI("urn:x-localinstance:/graph-access.graph")); - System.out.print(ag.toString()); - TcManager.getInstance().createGraph(graphUri); + + LOGGER.info("Incorrect custom permissions graph: {}", ag); + assertThrows(AccessControlException.class, () -> + TcManager.getInstance().createGraph(graphUri)); } @Test @@ -159,22 +178,27 @@ public void testCustomReadWritePermissions() { Collections.singletonList("(java.io.FilePermission \"/etc\" \"write\")")); //new FilePermission("/etc", "write").toString())); Graph ag = TcManager.getInstance().getGraph(new IRI("urn:x-localinstance:/graph-access.graph")); - System.out.print(ag.toString()); + + LOGGER.info("Custom read/write permissions graph: {}", ag); TcManager.getInstance().createGraph(graphUri); } - - @Test(expected=EntityAlreadyExistsException.class) + + @Test public void testCreateMGraph() { - TcManager.getInstance().createGraph(new IRI("http://example.org/ImmutableGraph/alreadyexists")); + assertThrows(EntityAlreadyExistsException.class, () -> + TcManager.getInstance().createGraph(new IRI("http://example.org/ImmutableGraph/alreadyexists"))); } - @Test(expected=AccessControlException.class) + + @Test public void testCreateMGraphWithoutWritePermission() { - TcManager.getInstance().createGraph(new IRI("http://example.org/read/ImmutableGraph")); + assertThrows(AccessControlException.class, () -> + TcManager.getInstance().createGraph(new IRI("http://example.org/read/ImmutableGraph"))); } - @Test(expected=ReadOnlyException.class) + + @Test public void testAddTripleToMGraph() { Graph graph = TcManager.getInstance().getMGraph(new IRI("http://example.org/read/ImmutableGraph")); Triple triple = new TripleImpl(new IRI("http://example.org/definition/isNonLiteral"), new IRI("http://example.org/definition/isTest"), new PlainLiteralImpl("test")); - graph.add(triple); + assertThrows(ReadOnlyException.class, () -> graph.add(triple)); } -} \ No newline at end of file +} diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/access/TcManagerTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/access/TcManagerTest.java index 181e36fa3..a542b4060 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/access/TcManagerTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/access/TcManagerTest.java @@ -18,12 +18,13 @@ */ package org.apache.clerezza.rdf.core.access; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; + import java.lang.reflect.Field; import java.util.Iterator; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mockito; + import org.apache.clerezza.commons.rdf.ImmutableGraph; import org.apache.clerezza.commons.rdf.Triple; import org.apache.clerezza.commons.rdf.Graph; @@ -42,12 +43,18 @@ import org.apache.clerezza.rdf.core.sparql.query.Query; import org.apache.clerezza.rdf.core.sparql.query.SelectQuery; -import static org.junit.Assert.*; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; +import org.mockito.Mockito; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class TcManagerTest { public static IRI uriRefAHeavy = new IRI("http://example.org/aHeavy"); @@ -60,7 +67,7 @@ public class TcManagerTest { private final WeightedA1 weightedA1 = new WeightedA1(); private WeightedTcProvider weightedBlight = new WeightedBlight(); - @Before + @BeforeEach public void setUp() { graphAccess = TcManager.getInstance(); graphAccess.bindWeightedTcProvider(weightedA); @@ -70,7 +77,7 @@ public void setUp() { queryEngine = Mockito.mock(QueryEngine.class); } - @After + @AfterEach public void tearDown() { graphAccess = TcManager.getInstance(); graphAccess.unbindWeightedTcProvider(weightedA); @@ -136,60 +143,64 @@ public void getGraphFromAWithHeavy() { graphAccess.unbindWeightedTcProvider(weightedAHeavy); } - @Test(expected = NoQueryEngineException.class) + @Test public void executeSparqlQueryNoEngineWithString() throws Exception { // Prepare injectQueryEngine(null); // Execute - graphAccess.executeSparqlQuery("", new SimpleMGraph()); + assertThrows(NoQueryEngineException.class, () -> + graphAccess.executeSparqlQuery("", new SimpleMGraph())); } - @Test(expected = NoQueryEngineException.class) + @Test public void executeSparqlQueryNoEngineWithQuery() throws Exception { // Prepare injectQueryEngine(null); // Execute - graphAccess.executeSparqlQuery((Query) null, new SimpleMGraph()); + assertThrows(NoQueryEngineException.class, () -> + graphAccess.executeSparqlQuery((Query) null, new SimpleMGraph())); } - @Test(expected = NoQueryEngineException.class) + @Test public void executeSparqlQueryNoEngineWithSelectQuery() throws Exception { // Prepare injectQueryEngine(null); // Execute - graphAccess.executeSparqlQuery((SelectQuery) null, new SimpleMGraph()); + assertThrows(NoQueryEngineException.class, () -> + graphAccess.executeSparqlQuery((SelectQuery) null, new SimpleMGraph())); } - @Test(expected = NoQueryEngineException.class) + @Test public void executeSparqlQueryNoEngineWithAskQuery() throws Exception { // Prepare injectQueryEngine(null); // Execute - graphAccess.executeSparqlQuery((AskQuery) null, new SimpleMGraph()); + assertThrows(NoQueryEngineException.class, () -> + graphAccess.executeSparqlQuery((AskQuery) null, new SimpleMGraph())); } - @Test(expected = NoQueryEngineException.class) + @Test public void executeSparqlQueryNoEngineWithDescribeQuery() throws Exception { // Prepare injectQueryEngine(null); // Execute - graphAccess - .executeSparqlQuery((DescribeQuery) null, new SimpleMGraph()); + assertThrows(NoQueryEngineException.class, () -> + graphAccess.executeSparqlQuery((DescribeQuery) null, new SimpleMGraph())); } - @Test(expected = NoQueryEngineException.class) + @Test public void executeSparqlQueryNoEngineWithConstructQuery() throws Exception { // Prepare injectQueryEngine(null); // Execute - graphAccess.executeSparqlQuery((ConstructQuery) null, - new SimpleMGraph()); + assertThrows(NoQueryEngineException.class, () -> + graphAccess.executeSparqlQuery((ConstructQuery) null, new SimpleMGraph())); } @Test @@ -299,4 +310,4 @@ private void injectQueryEngine(QueryEngine engine) queryEngineField.setAccessible(true); queryEngineField.set(graphAccess, engine); } -} \ No newline at end of file +} diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/impl/util/SimpleLiteralFactoryTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/impl/util/SimpleLiteralFactoryTest.java index e8b16b8f2..83bb233cf 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/impl/util/SimpleLiteralFactoryTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/impl/util/SimpleLiteralFactoryTest.java @@ -18,16 +18,21 @@ */ package org.apache.clerezza.rdf.core.impl.util; -import junit.framework.Assert; +import static org.junit.jupiter.api.Assertions.assertEquals; + import org.apache.clerezza.rdf.core.impl.util.SimpleLiteralFactory; import org.apache.clerezza.commons.rdf.Literal; import org.apache.clerezza.commons.rdf.IRI; -import org.junit.Test; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class SimpleLiteralFactoryTest { final private static IRI xsdInteger = @@ -43,21 +48,21 @@ public class SimpleLiteralFactoryTest { public void longToXsdIntegerAndBackToMany() { long value = 14l; Literal tl = simpleLiteralFactory.createTypedLiteral(value); - Assert.assertEquals(xsdLong, tl.getDataType()); + assertEquals(xsdLong, tl.getDataType()); long longValue = simpleLiteralFactory.createObject(Long.class, tl); - Assert.assertEquals(value, longValue); + assertEquals(value, longValue); int intValue = simpleLiteralFactory.createObject(Integer.class, tl); - Assert.assertEquals(value, intValue); + assertEquals(value, intValue); } @Test public void intToXsdIntAndBackToMany() { int value = 14; Literal tl = simpleLiteralFactory.createTypedLiteral(value); - Assert.assertEquals(xsdInt, tl.getDataType()); + assertEquals(xsdInt, tl.getDataType()); long longValue = simpleLiteralFactory.createObject(Long.class, tl); - Assert.assertEquals(value, longValue); + assertEquals(value, longValue); int intValue = simpleLiteralFactory.createObject(Integer.class, tl); - Assert.assertEquals(value, intValue); + assertEquals(value, intValue); } } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/impl/util/W3CDateFormatTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/impl/util/W3CDateFormatTest.java index 897dde87e..d20167d23 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/impl/util/W3CDateFormatTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/impl/util/W3CDateFormatTest.java @@ -18,17 +18,22 @@ */ package org.apache.clerezza.rdf.core.impl.util; +import static org.junit.jupiter.api.Assertions.assertEquals; + import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import java.util.TimeZone; -import org.junit.Test; -import static org.junit.Assert.*; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class W3CDateFormatTest { @Test @@ -68,4 +73,4 @@ public void roundTrip() throws Exception { assertEquals(date, parsedDate); } -} \ No newline at end of file +} diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/ParserTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/ParserTest.java index 2745026fb..02197d393 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/ParserTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/ParserTest.java @@ -18,18 +18,24 @@ */ package org.apache.clerezza.rdf.core.serializedform; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + import org.apache.clerezza.commons.rdf.IRI; import org.apache.clerezza.commons.rdf.Graph; import java.io.InputStream; -import junit.framework.Assert; import org.apache.clerezza.rdf.core.*; -import org.junit.Test; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class ParserTest { private static boolean providerAInvoked; @@ -43,7 +49,7 @@ public void registerOneProvider() { parser.bindParsingProvider(parsingProviderA); providerAInvoked = false; parser.parse(null, "application/x-fantasy2+rdf"); - Assert.assertTrue(providerAInvoked); + assertTrue(providerAInvoked); } @Test @@ -54,19 +60,19 @@ public void registerAndUnregisterSecond() { providerAInvoked = false; providerBInvoked = false; parser.parse(null, "application/x-fantasy2+rdf"); - Assert.assertFalse(providerAInvoked); - Assert.assertTrue(providerBInvoked); + assertFalse(providerAInvoked); + assertTrue(providerBInvoked); providerAInvoked = false; providerBInvoked = false; parser.parse(null, "application/x-fantasy1+rdf"); - Assert.assertTrue(providerAInvoked); - Assert.assertFalse(providerBInvoked); + assertTrue(providerAInvoked); + assertFalse(providerBInvoked); parser.unbindParsingProvider(parsingProviderB); providerAInvoked = false; providerBInvoked = false; parser.parse(null, "application/x-fantasy2+rdf"); - Assert.assertTrue(providerAInvoked); - Assert.assertFalse(providerBInvoked); + assertTrue(providerAInvoked); + assertFalse(providerBInvoked); } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/SerializerTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/SerializerTest.java index 0cc59a611..fe6695f07 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/SerializerTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/SerializerTest.java @@ -18,18 +18,23 @@ */ package org.apache.clerezza.rdf.core.serializedform; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + import org.apache.clerezza.commons.rdf.Graph; import java.io.OutputStream; -import junit.framework.Assert; - import org.apache.clerezza.rdf.core.*; -import org.junit.Test; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author mir */ +@RunWith(JUnitPlatform.class) public class SerializerTest { private static boolean providerAInvoked; @@ -43,7 +48,7 @@ public void registerOneProvider() { serializer.bindSerializingProvider(serializingProviderA); providerAInvoked = false; serializer.serialize(null, null, "application/x-fantasy2+rdf"); - Assert.assertTrue(providerAInvoked); + assertTrue(providerAInvoked); } @Test @@ -54,19 +59,19 @@ public void registerAndUnregisterSecond() { providerAInvoked = false; providerBInvoked = false; serializer.serialize(null, null, "application/x-fantasy2+rdf"); - Assert.assertFalse(providerAInvoked); - Assert.assertTrue(providerBInvoked); + assertFalse(providerAInvoked); + assertTrue(providerBInvoked); providerAInvoked = false; providerBInvoked = false; serializer.serialize(null, null, "application/x-fantasy1+rdf"); - Assert.assertTrue(providerAInvoked); - Assert.assertFalse(providerBInvoked); + assertTrue(providerAInvoked); + assertFalse(providerBInvoked); serializer.unbindSerializingProvider(serializingProviderB); providerAInvoked = false; providerBInvoked = false; serializer.serialize(null, null, "application/x-fantasy2+rdf"); - Assert.assertTrue(providerAInvoked); - Assert.assertFalse(providerBInvoked); + assertTrue(providerAInvoked); + assertFalse(providerBInvoked); } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/TestServiceManagedProvider.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/TestServiceManagedProvider.java index 7e7adb7fc..869bdf1cf 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/TestServiceManagedProvider.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/serializedform/TestServiceManagedProvider.java @@ -18,18 +18,23 @@ */ package org.apache.clerezza.rdf.core.serializedform; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.io.InputStream; import org.apache.clerezza.commons.rdf.Graph; -import org.junit.Assert; -import org.junit.Test; import org.apache.clerezza.commons.rdf.IRI; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; + /** * This class is listed in * META-INF/services/org.apache.clerezza.serializedform.ParsingProvider * * @author reto */ +@RunWith(JUnitPlatform.class) @SupportedFormat("application/x-test+rdf") public class TestServiceManagedProvider implements ParsingProvider { @@ -44,6 +49,6 @@ public void parse(Graph target, InputStream serializedGraph, String formatIdenti public void registerOneProvider() { Parser parser = Parser.getInstance(); parser.parse(null, "application/x-test+rdf"); - Assert.assertTrue(parseInvoked); + assertTrue(parseInvoked); } } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QueryParserSerializerCombinationTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QueryParserSerializerCombinationTest.java index 50eeee5a9..3a6e34ee5 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QueryParserSerializerCombinationTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QueryParserSerializerCombinationTest.java @@ -18,36 +18,41 @@ */ package org.apache.clerezza.rdf.core.sparql; +import static org.junit.jupiter.api.Assertions.assertEquals; + import org.apache.clerezza.rdf.core.sparql.query.Query; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.Test; + +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author hasan */ +@RunWith(JUnitPlatform.class) public class QueryParserSerializerCombinationTest { - + public QueryParserSerializerCombinationTest() { } - - @BeforeClass + + @BeforeAll public static void setUpClass() { } - - @AfterClass + + @AfterAll public static void tearDownClass() { } - - @Before + + @BeforeEach public void setUp() { } - - @After + + @AfterEach public void tearDown() { } @@ -80,7 +85,7 @@ public void testPatternOrderPreservation() throws Exception { + "} \n"; Query query = QueryParser.getInstance().parse(queryString); - Assert.assertEquals(queryString.replaceAll("\\s", "").trim(), query.toString().replaceAll("\\s", "").trim()); + assertEquals(queryString.replaceAll("\\s", "").trim(), query.toString().replaceAll("\\s", "").trim()); } @Test @@ -135,6 +140,6 @@ public void testParsingAndSerializationStability() throws Exception { Query query1 = QueryParser.getInstance().parse(queryString); Thread.sleep(5000l); Query query2 = QueryParser.getInstance().parse(queryString); - Assert.assertEquals(query1.toString(), query2.toString()); + assertEquals(query1.toString(), query2.toString()); } } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QueryParserTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QueryParserTest.java index f39e33861..1459b30ec 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QueryParserTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QueryParserTest.java @@ -18,11 +18,15 @@ */ package org.apache.clerezza.rdf.core.sparql; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.HashSet; import java.util.List; import java.util.Set; -import org.junit.Assert; -import org.junit.Test; + import org.apache.clerezza.commons.rdf.Language; import org.apache.clerezza.commons.rdf.IRI; import org.apache.clerezza.commons.rdf.impl.utils.PlainLiteralImpl; @@ -46,10 +50,15 @@ import org.apache.clerezza.rdf.core.sparql.query.Variable; import org.apache.clerezza.rdf.core.sparql.query.impl.SimpleTriplePattern; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; + /** * * @author hasan */ +@RunWith(JUnitPlatform.class) public class QueryParserTest { @Test @@ -70,32 +79,32 @@ public void testSelectQuery() throws ParseException { .append(predicate).append("> ?").append(variable).append(" . }"); Query q = QueryParser.getInstance().parse(queryStrBuf.toString()); - Assert.assertTrue(SelectQuery.class.isAssignableFrom(q.getClass())); + assertTrue(SelectQuery.class.isAssignableFrom(q.getClass())); SelectQuery selectQuery = (SelectQuery) q; - Assert.assertTrue(selectQuery.getSelection().get(0) + assertTrue(selectQuery.getSelection().get(0) .equals(new Variable(variable))); - Assert.assertTrue(selectQuery.getDataSet().getDefaultGraphs().toArray()[0] + assertTrue(selectQuery.getDataSet().getDefaultGraphs().toArray()[0] .equals(new IRI(defaultGraph))); GraphPattern gp = (GraphPattern) selectQuery.getQueryPattern() .getGraphPatterns().toArray()[0]; - Assert.assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); + assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); BasicGraphPattern bgp = (BasicGraphPattern) gp; Set triplePatterns = bgp.getTriplePatterns(); - Assert.assertTrue(triplePatterns.size()==1); + assertTrue(triplePatterns.size()==1); ResourceOrVariable s = new ResourceOrVariable(new IRI(subject)); UriRefOrVariable p = new UriRefOrVariable(new IRI(predicate)); ResourceOrVariable o = new ResourceOrVariable(new Variable(variable)); - Assert.assertTrue(triplePatterns.contains( + assertTrue(triplePatterns.contains( new SimpleTriplePattern(s, p, o))); } - @Test(expected=ParseException.class) + @Test public void testInvalidQuery() throws ParseException { - Query q = QueryParser.getInstance().parse("Hello"); + assertThrows(ParseException.class, () -> QueryParser.getInstance().parse("Hello")); } @Test @@ -107,8 +116,8 @@ public void testSelectQuerySelection() throws ParseException { Set expected = new HashSet(); expected.add(new Variable("a")); expected.add(new Variable("b")); - Assert.assertEquals(expected, selectionSet); - Assert.assertFalse(q.isSelectAll()); + assertEquals(expected, selectionSet); + assertFalse(q.isSelectAll()); } @@ -122,8 +131,8 @@ public void testSelectAll() throws ParseException { expected.add(new Variable("a")); expected.add(new Variable("b")); expected.add(new Variable("x")); - Assert.assertEquals(expected, selectionSet); - Assert.assertTrue(q.isSelectAll()); + assertEquals(expected, selectionSet); + assertTrue(q.isSelectAll()); } @@ -134,17 +143,17 @@ public void testPlainLiteral() throws ParseException { GraphPattern gp = (GraphPattern) q.getQueryPattern() .getGraphPatterns().toArray()[0]; - Assert.assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); + assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); BasicGraphPattern bgp = (BasicGraphPattern) gp; Set triplePatterns = bgp.getTriplePatterns(); - Assert.assertTrue(triplePatterns.size()==2); + assertTrue(triplePatterns.size()==2); - Assert.assertTrue(triplePatterns.contains(new SimpleTriplePattern( + assertTrue(triplePatterns.contains(new SimpleTriplePattern( new Variable("a"), new Variable("x"), new PlainLiteralImpl("tiger")))); - Assert.assertTrue(triplePatterns.contains(new SimpleTriplePattern( + assertTrue(triplePatterns.contains(new SimpleTriplePattern( new Variable("a"), new Variable("x"), new PlainLiteralImpl("lion", new Language("en"))))); } @@ -155,10 +164,10 @@ public void testOrderBy() throws ParseException { "SELECT * WHERE {?a ?x ?b} ORDER BY DESC(?b)"); List oc = ((QueryWithSolutionModifier) q).getOrderConditions(); - Assert.assertTrue(oc.size()==1); - Assert.assertFalse(oc.get(0).isAscending()); + assertTrue(oc.size()==1); + assertFalse(oc.get(0).isAscending()); Variable b = new Variable("b"); - Assert.assertEquals(b, oc.get(0).getExpression()); + assertEquals(b, oc.get(0).getExpression()); } @Test @@ -181,30 +190,30 @@ public void testConstructQuery() throws ParseException { .append(predicate2).append("> ?").append(variable1).append("}"); Query q = QueryParser.getInstance().parse(queryStrBuf.toString()); - Assert.assertTrue(ConstructQuery.class.isAssignableFrom(q.getClass())); + assertTrue(ConstructQuery.class.isAssignableFrom(q.getClass())); ConstructQuery constructQuery = (ConstructQuery) q; Set triplePatterns = constructQuery .getConstructTemplate(); - Assert.assertTrue(triplePatterns.size()==1); + assertTrue(triplePatterns.size()==1); ResourceOrVariable s = new ResourceOrVariable(new IRI(subject1)); UriRefOrVariable p = new UriRefOrVariable(new IRI(predicate1)); ResourceOrVariable o = new ResourceOrVariable(new Variable(variable1)); - Assert.assertTrue(triplePatterns.contains( + assertTrue(triplePatterns.contains( new SimpleTriplePattern(s, p, o))); GraphPattern gp = (GraphPattern) constructQuery.getQueryPattern() .getGraphPatterns().toArray()[0]; - Assert.assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); + assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); BasicGraphPattern bgp = (BasicGraphPattern) gp; triplePatterns = bgp.getTriplePatterns(); - Assert.assertTrue(triplePatterns.size()==1); + assertTrue(triplePatterns.size()==1); s = new ResourceOrVariable(new Variable(variable2)); p = new UriRefOrVariable(new IRI(predicate2)); - Assert.assertTrue(triplePatterns.contains( + assertTrue(triplePatterns.contains( new SimpleTriplePattern(s, p, o))); } @@ -219,9 +228,9 @@ public void testDescribeQuery() throws ParseException { queryStrBuf.append("DESCRIBE <").append(resource).append(">"); Query q = QueryParser.getInstance().parse(queryStrBuf.toString()); - Assert.assertTrue(DescribeQuery.class.isAssignableFrom(q.getClass())); + assertTrue(DescribeQuery.class.isAssignableFrom(q.getClass())); DescribeQuery describeQuery = (DescribeQuery) q; - Assert.assertTrue(describeQuery.getResourcesToDescribe().get(0) + assertTrue(describeQuery.getResourcesToDescribe().get(0) .getResource().equals(new IRI(resource))); } @@ -239,18 +248,18 @@ public void testAskQuery() throws ParseException { .append(predicate).append("> \"").append(object).append("\" }"); Query q = QueryParser.getInstance().parse(queryStrBuf.toString()); - Assert.assertTrue(AskQuery.class.isAssignableFrom(q.getClass())); + assertTrue(AskQuery.class.isAssignableFrom(q.getClass())); AskQuery askQuery = (AskQuery) q; GraphPattern gp = (GraphPattern) askQuery.getQueryPattern() .getGraphPatterns().toArray()[0]; - Assert.assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); + assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); BasicGraphPattern bgp = (BasicGraphPattern) gp; Set triplePatterns = bgp.getTriplePatterns(); - Assert.assertTrue(triplePatterns.size()==1); + assertTrue(triplePatterns.size()==1); - Assert.assertTrue(triplePatterns.contains(new SimpleTriplePattern(new Variable(variable), + assertTrue(triplePatterns.contains(new SimpleTriplePattern(new Variable(variable), new IRI(predicate), new PlainLiteralImpl(object)))); } @@ -279,24 +288,24 @@ public void testBaseAndPrefix() throws ParseException { .append(variable).append(" }"); Query q = QueryParser.getInstance().parse(queryStrBuf.toString()); - Assert.assertTrue(SelectQuery.class.isAssignableFrom(q.getClass())); + assertTrue(SelectQuery.class.isAssignableFrom(q.getClass())); SelectQuery selectQuery = (SelectQuery) q; - Assert.assertTrue(selectQuery.getSelection().get(0) + assertTrue(selectQuery.getSelection().get(0) .equals(new Variable(variable))); GraphPattern gp = (GraphPattern) selectQuery.getQueryPattern() .getGraphPatterns().toArray()[0]; - Assert.assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); + assertTrue(BasicGraphPattern.class.isAssignableFrom(gp.getClass())); BasicGraphPattern bgp = (BasicGraphPattern) gp; Set triplePatterns = bgp.getTriplePatterns(); - Assert.assertTrue(triplePatterns.size()==1); + assertTrue(triplePatterns.size()==1); ResourceOrVariable s = new ResourceOrVariable(new IRI(base+subject)); UriRefOrVariable p = new UriRefOrVariable(new IRI(prefixUri+predicate)); ResourceOrVariable o = new ResourceOrVariable(new Variable(variable)); - Assert.assertTrue(triplePatterns.contains( + assertTrue(triplePatterns.contains( new SimpleTriplePattern(s, p, o))); } @@ -335,49 +344,49 @@ public void testOptionalAndFilter() throws ParseException { .append(" .} FILTER ( ! bound(?").append(variable3).append(") ) }"); Query q = QueryParser.getInstance().parse(queryStrBuf.toString()); - Assert.assertTrue(SelectQuery.class.isAssignableFrom(q.getClass())); + assertTrue(SelectQuery.class.isAssignableFrom(q.getClass())); SelectQuery selectQuery = (SelectQuery) q; - Assert.assertTrue(selectQuery.getSelection().size() == 2); + assertTrue(selectQuery.getSelection().size() == 2); Set vars = new HashSet(2); Variable var1 = new Variable(variable1); Variable var2 = new Variable(variable2); vars.add(var1); vars.add(var2); - Assert.assertTrue(selectQuery.getSelection().containsAll(vars)); + assertTrue(selectQuery.getSelection().containsAll(vars)); GroupGraphPattern ggp = selectQuery.getQueryPattern(); List constraints = ggp.getFilter(); - Assert.assertTrue(UnaryOperation.class.isAssignableFrom(constraints + assertTrue(UnaryOperation.class.isAssignableFrom(constraints .get(0).getClass())); UnaryOperation uop = (UnaryOperation) constraints.get(0); - Assert.assertTrue(uop.getOperatorString().equals("!")); - Assert.assertTrue(BuiltInCall.class.isAssignableFrom(uop.getOperand() + assertTrue(uop.getOperatorString().equals("!")); + assertTrue(BuiltInCall.class.isAssignableFrom(uop.getOperand() .getClass())); BuiltInCall bic = (BuiltInCall) uop.getOperand(); - Assert.assertTrue(bic.getName().equals("BOUND")); + assertTrue(bic.getName().equals("BOUND")); Variable var3 = new Variable(variable3); - Assert.assertTrue(bic.getArguements().get(0).equals(var3)); + assertTrue(bic.getArguements().get(0).equals(var3)); GraphPattern gp = (GraphPattern) ggp.getGraphPatterns().toArray()[0]; - Assert.assertTrue(OptionalGraphPattern.class.isAssignableFrom(gp.getClass())); + assertTrue(OptionalGraphPattern.class.isAssignableFrom(gp.getClass())); OptionalGraphPattern ogp = (OptionalGraphPattern) gp; - Assert.assertTrue(BasicGraphPattern.class.isAssignableFrom( + assertTrue(BasicGraphPattern.class.isAssignableFrom( ogp.getMainGraphPattern().getClass())); BasicGraphPattern bgp = (BasicGraphPattern) ogp.getMainGraphPattern(); Set triplePatterns = bgp.getTriplePatterns(); - Assert.assertTrue(triplePatterns.size() == 1); - Assert.assertTrue(triplePatterns.contains(new SimpleTriplePattern(var1, new IRI(prefix1Uri + predicate1), + assertTrue(triplePatterns.size() == 1); + assertTrue(triplePatterns.contains(new SimpleTriplePattern(var1, new IRI(prefix1Uri + predicate1), var2))); GraphPattern gp2 = (GraphPattern) ogp.getOptionalGraphPattern() .getGraphPatterns().toArray()[0]; - Assert.assertTrue(BasicGraphPattern.class.isAssignableFrom(gp2.getClass())); + assertTrue(BasicGraphPattern.class.isAssignableFrom(gp2.getClass())); bgp = (BasicGraphPattern) gp2; triplePatterns = bgp.getTriplePatterns(); - Assert.assertTrue(triplePatterns.size() == 1); - Assert.assertTrue(triplePatterns.contains(new SimpleTriplePattern(var1, new IRI(prefix2Uri + predicate2), + assertTrue(triplePatterns.size() == 1); + assertTrue(triplePatterns.contains(new SimpleTriplePattern(var1, new IRI(prefix2Uri + predicate2), var3))); } } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QuerySerializerTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QuerySerializerTest.java index eccf13f27..0175a1ab6 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QuerySerializerTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/QuerySerializerTest.java @@ -18,10 +18,13 @@ */ package org.apache.clerezza.rdf.core.sparql; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Set; + import org.apache.clerezza.rdf.core.LiteralFactory; import org.apache.clerezza.commons.rdf.IRI; import org.apache.clerezza.rdf.core.sparql.query.BinaryOperation; @@ -42,14 +45,17 @@ import org.apache.clerezza.rdf.core.sparql.query.impl.SimpleOrderCondition; import org.apache.clerezza.rdf.core.sparql.query.impl.SimpleSelectQuery; import org.apache.clerezza.rdf.core.sparql.query.impl.SimpleTriplePattern; -import org.junit.Assert; -import org.junit.Ignore; -import org.junit.Test; + +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author hasan */ +@RunWith(JUnitPlatform.class) public class QuerySerializerTest { @Test @@ -78,7 +84,7 @@ public void testSelectQuery() { queryPattern.addGraphPattern(bgp); selectQuery.setQueryPattern(queryPattern); - Assert.assertTrue(selectQuery.toString() + assertTrue(selectQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } @@ -108,7 +114,7 @@ public void testConstructQuery() { queryPattern.addGraphPattern(bgp); constructQuery.setQueryPattern(queryPattern); - Assert.assertTrue(constructQuery.toString() + assertTrue(constructQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } @@ -121,7 +127,7 @@ public void testDescribeQuery() { describeQuery.addResourceToDescribe(new ResourceOrVariable( new IRI("http://example.org/book/book1"))); - Assert.assertTrue(describeQuery.toString() + assertTrue(describeQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } @@ -146,7 +152,7 @@ public void testAskQuery() { queryPattern.addGraphPattern(bgp); askQuery.setQueryPattern(queryPattern); - Assert.assertTrue(askQuery.toString() + assertTrue(askQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } @@ -154,7 +160,7 @@ public void testAskQuery() { * Ignoring: given that triplePatterns is a Set I don't see what is supposed * to guarantee the expected ordering. */ - @Ignore + @Disabled @Test public void testFilter() { @@ -185,7 +191,7 @@ public void testFilter() { queryPattern.addConstraint(constraint); selectQuery.setQueryPattern(queryPattern); - Assert.assertTrue(selectQuery.toString() + assertTrue(selectQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } @@ -214,7 +220,7 @@ public void testUriRefExpression() { queryPattern.addConstraint(constraint); selectQuery.setQueryPattern(queryPattern); - Assert.assertTrue(selectQuery.toString() + assertTrue(selectQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } @@ -240,7 +246,7 @@ public void testOrderBy() { selectQuery.setQueryPattern(queryPattern); selectQuery.addOrderCondition(new SimpleOrderCondition(c, false)); - Assert.assertTrue(selectQuery.toString() + assertTrue(selectQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } @@ -281,7 +287,7 @@ public void testOptional() { queryPattern.addGraphPattern(ogp); selectQuery.setQueryPattern(queryPattern); - Assert.assertTrue(selectQuery.toString() + assertTrue(selectQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } @@ -312,7 +318,7 @@ public void testRegex() { BuiltInCall constraint = new BuiltInCall("REGEX", arguments); queryPattern.addConstraint(constraint); selectQuery.setQueryPattern(queryPattern); - Assert.assertTrue(selectQuery.toString() + assertTrue(selectQuery.toString() .replaceAll("( |\n)+", " ").trim().equals(queryString)); } } diff --git a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/SparqlPreParserTest.java b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/SparqlPreParserTest.java index c56170c1f..3a0cee9f1 100644 --- a/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/SparqlPreParserTest.java +++ b/rdf/core/src/test/java/org/apache/clerezza/rdf/core/sparql/SparqlPreParserTest.java @@ -18,21 +18,27 @@ */ package org.apache.clerezza.rdf.core.sparql; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.HashSet; import java.util.Set; + import org.apache.clerezza.commons.rdf.IRI; import org.apache.clerezza.rdf.core.access.TcManager; import org.apache.clerezza.rdf.core.access.TcManagerTest; import org.apache.clerezza.rdf.core.access.providers.WeightedA; -import org.junit.After; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; + +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author hasan */ +@RunWith(JUnitPlatform.class) public class SparqlPreParserTest { private TcManager graphAccess; @@ -40,13 +46,13 @@ public class SparqlPreParserTest { private final static IRI DEFAULT_GRAPH = new IRI("http://example.org/default.graph"); private final static IRI TEST_GRAPH = new IRI("http://example.org/test.graph"); - @Before + @BeforeEach public void setUp() { graphAccess = TcManager.getInstance(); graphAccess.addWeightedTcProvider(weightedA); } - @After + @AfterEach public void tearDown() { graphAccess = TcManager.getInstance(); graphAccess.removeWeightedTcProvider(weightedA); @@ -66,7 +72,7 @@ public void testDefaultGraphInSelectQuery() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStrBuilder.toString(), DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -78,7 +84,7 @@ public void testAllGraphReferenceInSelectQuery() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStrBuilder.toString(), DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs == null); + assertTrue(referredGraphs == null); } @Test @@ -96,7 +102,7 @@ public void testSelectQuery() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStrBuilder.toString(), DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); } @Test @@ -107,7 +113,7 @@ public void testSimpleDescribe() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -121,7 +127,7 @@ public void testLoadingToDefaultGraph() throws ParseException { Set expected = new HashSet<>(); expected.add(DEFAULT_GRAPH); expected.add(new IRI("http://example.org/mydata")); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -135,7 +141,7 @@ public void testLoadingToGraph() throws ParseException { Set expected = new HashSet<>(); expected.add(TEST_GRAPH); expected.add(new IRI("http://example.org/mydata")); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -146,7 +152,7 @@ public void testClearingDefaultGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -157,7 +163,7 @@ public void testClearingNamedGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.contains(TcManagerTest.uriRefA)); + assertTrue(referredGraphs.contains(TcManagerTest.uriRefA)); } @Test @@ -168,7 +174,7 @@ public void testClearingGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); } @Test @@ -179,7 +185,7 @@ public void testDroppingDefaultGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -190,7 +196,7 @@ public void testDroppingNamedGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.contains(TcManagerTest.uriRefA)); + assertTrue(referredGraphs.contains(TcManagerTest.uriRefA)); } @Test @@ -201,7 +207,7 @@ public void testDroppingGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); } @Test @@ -212,7 +218,7 @@ public void testCreatingGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); } @Test @@ -226,7 +232,7 @@ public void testAddingTriplesFromDefaultGraphToNamedGraph() throws ParseExceptio Set expected = new HashSet<>(); expected.add(DEFAULT_GRAPH); expected.add(TEST_GRAPH); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -240,7 +246,7 @@ public void testAddingTriplesFromNamedGraphToDefaultGraph() throws ParseExceptio Set expected = new HashSet<>(); expected.add(DEFAULT_GRAPH); expected.add(TEST_GRAPH); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -254,7 +260,7 @@ public void testMovingTriplesFromDefaultGraphToNamedGraph() throws ParseExceptio Set expected = new HashSet<>(); expected.add(DEFAULT_GRAPH); expected.add(TEST_GRAPH); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -268,7 +274,7 @@ public void testMovingTriplesFromNamedGraphToDefaultGraph() throws ParseExceptio Set expected = new HashSet<>(); expected.add(DEFAULT_GRAPH); expected.add(TEST_GRAPH); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -282,7 +288,7 @@ public void testCopyingTriplesFromDefaultGraphToNamedGraph() throws ParseExcepti Set expected = new HashSet<>(); expected.add(DEFAULT_GRAPH); expected.add(TEST_GRAPH); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -296,7 +302,7 @@ public void testCopyingTriplesFromNamedGraphToDefaultGraph() throws ParseExcepti Set expected = new HashSet<>(); expected.add(DEFAULT_GRAPH); expected.add(TEST_GRAPH); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -308,7 +314,7 @@ public void testInsertDataToDefaultGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -319,7 +325,7 @@ public void testInsertDataToNamedGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); } @Test @@ -331,7 +337,7 @@ public void testDeleteDataInDefaultGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -342,7 +348,7 @@ public void testDeleteDataInNamedGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(TEST_GRAPH)); } @Test @@ -358,7 +364,7 @@ public void testInsertAndDeleteData() throws ParseException { Set expected = new HashSet<>(); expected.add(DEFAULT_GRAPH); expected.add(TEST_GRAPH); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -371,7 +377,7 @@ public void testDeleteWhereInDefaultGraph() throws ParseException { parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -388,7 +394,7 @@ public void testDeleteWhereInNamedGraphs() throws ParseException { Set expected = new HashSet<>(); expected.add(new IRI("http://example.com/names")); expected.add(new IRI("http://example.com/addresses")); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -403,7 +409,7 @@ public void testModifyOperationWithFallbackGraph() throws ParseException { Set expected = new HashSet<>(); expected.add(TEST_GRAPH); expected.add(DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -415,7 +421,7 @@ public void testDeleteOperationInDefaultGraph() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -432,7 +438,7 @@ public void testInsertOperationToNamedGraph() throws ParseException { Set expected = new HashSet<>(); expected.add(new IRI("http://example/bookStore2")); expected.add(new IRI("http://example/bookStore")); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -466,7 +472,7 @@ public void testInsertAndDeleteWithCommonPrefix() throws ParseException { Set expected = new HashSet<>(); expected.add(new IRI("http://example/bookStore2")); expected.add(new IRI("http://example/bookStore")); - Assert.assertTrue(referredGraphs.containsAll(expected)); + assertTrue(referredGraphs.containsAll(expected)); } @Test @@ -483,7 +489,7 @@ public void testExistsFunction() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } @Test @@ -500,6 +506,6 @@ public void testNotExistsFunction() throws ParseException { SparqlPreParser parser; parser = new SparqlPreParser(TcManager.getInstance()); Set referredGraphs = parser.getReferredGraphs(queryStr, DEFAULT_GRAPH); - Assert.assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); + assertTrue(referredGraphs.toArray()[0].equals(DEFAULT_GRAPH)); } } diff --git a/rdf/scala.utils/pom.xml b/rdf/scala.utils/pom.xml index 7bbda5c35..d3164224c 100644 --- a/rdf/scala.utils/pom.xml +++ b/rdf/scala.utils/pom.xml @@ -55,8 +55,18 @@ org.osgi.compendium - junit - junit + org.junit.platform + junit-platform-runner + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + org.apiguardian + apiguardian-api test @@ -128,4 +138,4 @@ - \ No newline at end of file + diff --git a/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/EzMGraphTest.scala b/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/EzMGraphTest.scala index bc9bd55de..9a515a3c5 100644 --- a/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/EzMGraphTest.scala +++ b/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/EzMGraphTest.scala @@ -26,15 +26,20 @@ import org.apache.clerezza.commons.rdf.impl.utils.PlainLiteralImpl import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl import org.apache.clerezza.commons.rdf.impl.utils.TypedLiteralImpl import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph -import org.junit._ import org.apache.clerezza.rdf.core._ import impl._ import Preamble._ import org.apache.clerezza.rdf.ontologies._ +import org.junit.jupiter.api.Assertions._; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; + /** * @author bblfish, reto */ +@RunWith(classOf[JUnitPlatform]) class EzGraphTest { val bblfishModulus = """ @@ -103,7 +108,7 @@ class EzGraphTest { val ez = new EzGraph() { henryUri.iri -- FOAF.knows --> retoUri.iri } - Assert.assertEquals("The two graphs should be equals", expected, ez.getImmutableGraph) + assertEquals(expected, ez.getImmutableGraph, "The two graphs should be equals") } @Test @@ -116,7 +121,7 @@ class EzGraphTest { val ez = new EzGraph() { henryUri.iri <-- FOAF.knows -- retoUri.iri } - Assert.assertEquals("The two graphs should be equals", expected, ez.getImmutableGraph) + assertEquals(expected, ez.getImmutableGraph, "The two graphs should be equals") } @Test @@ -144,18 +149,18 @@ class EzGraphTest { -- FOAF.knows --> b_("reto") ) )} - Assert.assertEquals("the two graphs should be of same size",tinyGraph.size,ez.size) - Assert.assertEquals("Both graphs should contain exactly the same triples",tinyGraph,ez.getImmutableGraph) + assertEquals(tinyGraph.size, ez.size, "the two graphs should be of same size") + assertEquals(tinyGraph, ez.getImmutableGraph, "Both graphs should contain exactly the same triples") //We can add triples by creating a new anonymous instance new EzGraph(ez) {( "http://bblfish.net/#hjs".iri -- FOAF.name --> "William" -- FOAF.name --> "Bill" )} - Assert.assertEquals("the triple colletion has grown by one",tinyGraph.size()+2,ez.size) + assertEquals(tinyGraph.size() + 2, ez.size, "the triple colletion has grown by one") //or by just importing it import ez._ ez.b_("danny") -- FOAF.name --> "George" - Assert.assertEquals("the triple colletion has grown by one",tinyGraph.size()+3,ez.size) + assertEquals(tinyGraph.size() + 3, ez.size, "the triple colletion has grown by one") } } diff --git a/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/RichGraphNodeTest.scala b/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/RichGraphNodeTest.scala index fa0a8b07f..aa79650b4 100644 --- a/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/RichGraphNodeTest.scala +++ b/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/RichGraphNodeTest.scala @@ -31,9 +31,15 @@ import org.apache.clerezza.commons.rdf.impl.utils.PlainLiteralImpl import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl import org.apache.clerezza.commons.rdf.impl.utils.TypedLiteralImpl import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph -import org.junit._ import Preamble._ +import org.junit.jupiter.api.Assertions._; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; + +@RunWith(classOf[JUnitPlatform]) class RichGraphNodeTest { private val johnUri = new IRI("http://example.org/john") @@ -44,7 +50,7 @@ class RichGraphNodeTest { private var node : RichGraphNode = null; private var mGraph = new SimpleGraph() - @Before + @BeforeEach def prepare() = { mGraph.add(new TripleImpl(johnUri, FOAF.name, new PlainLiteralImpl("John"))); mGraph.add(new TripleImpl(johnUri, FOAF.nick, new PlainLiteralImpl("johny"))); @@ -77,19 +83,19 @@ class RichGraphNodeTest { import preamble._ def asGn(gn: GraphNode) = gn val johnUriNode = asGn(johnUri) - Assert.assertEquals(johnUriNode, node) + assertEquals(johnUriNode, node) } @Test def testSlash = { val rNode = new RichGraphNode(node) - Assert.assertEquals(new PlainLiteralImpl("johny"), (rNode/FOAF.nick)(0).getNode) - Assert.assertEquals(2, (rNode/FOAF.name).length(20)) + assertEquals(new PlainLiteralImpl("johny"), (rNode/FOAF.nick)(0).getNode) + assertEquals(2, (rNode/FOAF.name).length(20)) val stringNames = (for(name <- (rNode/FOAF.name).iterator) yield { name.toString }).toList - Assert.assertTrue(stringNames.contains("\"Johnathan Guller\"")) - Assert.assertTrue(stringNames.contains("\"John\"")) + assertTrue(stringNames.contains("\"Johnathan Guller\"")) + assertTrue(stringNames.contains("\"John\"")) } @Test @@ -102,57 +108,57 @@ class RichGraphNodeTest { node.addProperty(RDF.`type`, PLATFORM.HeadedPage); node.addProperty(RDF.`type`, RDFS.Class); val test: CollectedIter[RichGraphNode] = node/DCTERMS.language/RDF.`type`; - Assert.assertEquals(1, test.length) + assertEquals(1, test.length) var counter = 0; for(k <- test) { counter = counter + 1 } - Assert.assertEquals(1, counter) + assertEquals(1, counter) } @Test def testInverse = { val rNode = new RichGraphNode(node) - Assert.assertEquals(1, (rNode/-FOAF.knows).length) + assertEquals(1, (rNode/-FOAF.knows).length) } @Test def testMissingProperty = { val rNode = new RichGraphNode(node) - Assert.assertEquals(0, (rNode/FOAF.thumbnail).length) - Assert.assertEquals("", rNode/FOAF.thumbnail*) + assertEquals(0, (rNode/FOAF.thumbnail).length) + assertEquals("", rNode/FOAF.thumbnail*) } @Test def testInverseImplicit = { - Assert.assertEquals(1, (node/-FOAF.knows).length) + assertEquals(1, (node/-FOAF.knows).length) } @Test def testPath = { - Assert.assertEquals(1, (node/-FOAF.knows).length) - Assert.assertEquals(new PlainLiteralImpl("Susanne"), node/-FOAF.knows%0/FOAF.name%0!) - Assert.assertEquals(new PlainLiteralImpl("Susanne"), ((node/-FOAF.knows)(0)/FOAF.name)(0)!) - Assert.assertEquals(new PlainLiteralImpl("Susanne"), node/-FOAF.knows/FOAF.name!) - Assert.assertEquals(new PlainLiteralImpl("Bill"), node/FOAF.knows/FOAF.nick!) - Assert.assertEquals("Bill", (node/FOAF.knows/FOAF.nick)(0)*) - Assert.assertEquals("Bill", node/FOAF.knows/FOAF.nick*) + assertEquals(1, (node/-FOAF.knows).length) + assertEquals(new PlainLiteralImpl("Susanne"), node/-FOAF.knows%0/FOAF.name%0!) + assertEquals(new PlainLiteralImpl("Susanne"), ((node/-FOAF.knows)(0)/FOAF.name)(0)!) + assertEquals(new PlainLiteralImpl("Susanne"), node/-FOAF.knows/FOAF.name!) + assertEquals(new PlainLiteralImpl("Bill"), node/FOAF.knows/FOAF.nick!) + assertEquals("Bill", (node/FOAF.knows/FOAF.nick)(0)*) + assertEquals("Bill", node/FOAF.knows/FOAF.nick*) } @Test def testLists = { - Assert.assertEquals(new PlainLiteralImpl("foo"),(node/SKOS04.related).asList().get(1)) - Assert.assertEquals(new PlainLiteralImpl("foo"), (node/SKOS04.related%0!!)(1)!) - Assert.assertEquals(new PlainLiteralImpl("foo"), + assertEquals(new PlainLiteralImpl("foo"),(node/SKOS04.related).asList().get(1)) + assertEquals(new PlainLiteralImpl("foo"), (node/SKOS04.related%0!!)(1)!) + assertEquals(new PlainLiteralImpl("foo"), (for (value <- node/SKOS04.related%0!!) yield value!).toList(1)) - Assert.assertEquals(new PlainLiteralImpl("bar"), + assertEquals(new PlainLiteralImpl("bar"), (for (value <- node/SKOS04.related%0!!) yield value!).toList(2)) - Assert.assertEquals(new PlainLiteralImpl("foo"), node/SKOS04.related%0%!!1!) + assertEquals(new PlainLiteralImpl("foo"), node/SKOS04.related%0%!!1!) } @Test def sortProperties = { - Assert.assertEquals(new PlainLiteralImpl("bar"), (node/SKOS04.related%0!!).sortWith((a,b) => ((a*) < (b*)))(0)!) - Assert.assertEquals(johnUri, (node/SKOS04.related%0!!).sortWith((a,b) => ((a*) > (b*)))(0)!) + assertEquals(new PlainLiteralImpl("bar"), (node/SKOS04.related%0!!).sortWith((a,b) => ((a*) < (b*)))(0)!) + assertEquals(johnUri, (node/SKOS04.related%0!!).sortWith((a,b) => ((a*) > (b*)))(0)!) } @Test @@ -160,7 +166,7 @@ class RichGraphNodeTest { val dateLiteral = new TypedLiteralImpl("2009-01-01T01:33:58Z", new IRI("http://www.w3.org/2001/XMLSchema#dateTime")) val node = new GraphNode(dateLiteral, new SimpleGraph()) - Assert.assertNotNull(node.as[java.util.Date]) + assertNotNull(node.as[java.util.Date]) } @Test @@ -168,7 +174,7 @@ class RichGraphNodeTest { node = new GraphNode(greetingsUri, mGraph) val lang = new Language("en") val enValue = (node/RDF.value).find(l=>(l!).asInstanceOf[Literal].getLanguage == lang).get - Assert.assertEquals("hello", enValue*) + assertEquals("hello", enValue*) } } diff --git a/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/TypeConversionTest.scala b/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/TypeConversionTest.scala index f60b1eb32..8c39c61c5 100644 --- a/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/TypeConversionTest.scala +++ b/rdf/scala.utils/src/test/scala/org/apache/clerezza/rdf/scala/utils/TypeConversionTest.scala @@ -23,9 +23,14 @@ import org.apache.clerezza.commons.rdf.Language import org.apache.clerezza.commons.rdf.impl.utils.PlainLiteralImpl import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl import org.apache.clerezza.commons.rdf.impl.utils.TypedLiteralImpl -import org.junit._ import org.apache.clerezza.rdf.core._ +import org.junit.jupiter.api.Assertions._; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; + +@RunWith(classOf[JUnitPlatform]) class TypeConversionTest { private val literalFactory = LiteralFactory.getInstance() @@ -35,40 +40,40 @@ class TypeConversionTest { @Test def useStringAsObject { val t = new TripleImpl(new IRI(("http://example.org/subject")), new IRI(("http://example.org/predicate")), "a value") - Assert.assertEquals(literalFactory.createTypedLiteral("a value"), t.getObject) + assertEquals(literalFactory.createTypedLiteral("a value"), t.getObject) } /*@Test def useStringWithLanguageTag { val t = new TripleImpl(new IRI(("http://example.org/subject")), new IRI(("http://example.org/predicate")), "a value"("en")) - Assert.assertEquals(new PlainLiteralImpl("a value", new Language("en")), t.getObject) + assertEquals(new PlainLiteralImpl("a value", new Language("en")), t.getObject) }*/ @Test def useStringWithLanguageTag { val lit = new PlainLiteralImpl("a value", new Language("en")) val t = new TripleImpl(new IRI(("http://example.org/subject")), new IRI(("http://example.org/predicate")), "a value" lang "en") - Assert.assertEquals(lit, t.getObject) + assertEquals(lit, t.getObject) } @Test def useStringWithType { val typeUri = new IRI("http://example.org/dt") val t = new TripleImpl(new IRI(("http://example.org/subject")), new IRI(("http://example.org/predicate")), "a value"^^typeUri) - Assert.assertEquals(new TypedLiteralImpl("a value", typeUri), t.getObject) + assertEquals(new TypedLiteralImpl("a value", typeUri), t.getObject) } @Test def literaToString { val lit = literalFactory.createTypedLiteral("a value") val s: String = lit - Assert.assertEquals("a value", s) + assertEquals("a value", s) } @Test def dotUri { val t = new TripleImpl(new IRI(("http://example.org/subject")), new IRI(("http://example.org/predicate")), "http://example.org".iri) - Assert.assertEquals(new IRI("http://example.org"), t.getObject) + assertEquals(new IRI("http://example.org"), t.getObject) } } diff --git a/rdf/schemagen/main/pom.xml b/rdf/schemagen/main/pom.xml index 7e710e3c5..26d2dffe4 100644 --- a/rdf/schemagen/main/pom.xml +++ b/rdf/schemagen/main/pom.xml @@ -33,11 +33,6 @@ jar Clerezza - RDF - SchemaGen: Class Generator for Ontologies - - junit - junit - test - org.wymiwyg wymiwyg-commons-core @@ -96,4 +91,4 @@ - \ No newline at end of file + diff --git a/rdf/schemagen/maven-plugin/pom.xml b/rdf/schemagen/maven-plugin/pom.xml index b4a3b0f53..ac9b1c07a 100644 --- a/rdf/schemagen/maven-plugin/pom.xml +++ b/rdf/schemagen/maven-plugin/pom.xml @@ -33,16 +33,11 @@ 1.0.1-SNAPSHOT Clerezza - RDF - SchemaGen: Maven Ontologies Plugin - + org.apache.maven maven-plugin-api - junit - junit - test - - org.slf4j slf4j-simple @@ -57,4 +52,4 @@ 2.0.9 - \ No newline at end of file + diff --git a/rdf/simple.storage/pom.xml b/rdf/simple.storage/pom.xml index 45d507e48..364dfd2a7 100644 --- a/rdf/simple.storage/pom.xml +++ b/rdf/simple.storage/pom.xml @@ -34,8 +34,18 @@ Clerezza - RDF - Simple Storage Provider - junit - junit + org.junit.platform + junit-platform-runner + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + org.apiguardian + apiguardian-api test @@ -72,4 +82,4 @@ - \ No newline at end of file + diff --git a/rdf/simple.storage/src/test/java/org/apache/clerezza/rdf/simple/storage/AccessViaTcManager.java b/rdf/simple.storage/src/test/java/org/apache/clerezza/rdf/simple/storage/AccessViaTcManager.java index 8714b9795..291b513b8 100644 --- a/rdf/simple.storage/src/test/java/org/apache/clerezza/rdf/simple/storage/AccessViaTcManager.java +++ b/rdf/simple.storage/src/test/java/org/apache/clerezza/rdf/simple/storage/AccessViaTcManager.java @@ -15,23 +15,28 @@ */ package org.apache.clerezza.rdf.simple.storage; +import static org.junit.jupiter.api.Assertions.assertTrue; + import org.apache.clerezza.rdf.core.access.TcManager; import org.apache.clerezza.commons.rdf.Graph; import org.apache.clerezza.commons.rdf.IRI; import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph; -import org.junit.Assert; -import org.junit.Test; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author developer */ +@RunWith(JUnitPlatform.class) public class AccessViaTcManager { - + @Test public void simple() { Graph g = TcManager.getInstance().createGraph(new IRI("http://example.org/foo")); - Assert.assertTrue(g instanceof SimpleGraph); + assertTrue(g instanceof SimpleGraph); } - + } diff --git a/rdf/simple.storage/src/test/java/org/apache/clerezza/rdf/simple/storage/GenericTcProviderTest.java b/rdf/simple.storage/src/test/java/org/apache/clerezza/rdf/simple/storage/GenericTcProviderTest.java index a7a325037..04052bae1 100644 --- a/rdf/simple.storage/src/test/java/org/apache/clerezza/rdf/simple/storage/GenericTcProviderTest.java +++ b/rdf/simple.storage/src/test/java/org/apache/clerezza/rdf/simple/storage/GenericTcProviderTest.java @@ -18,10 +18,11 @@ */ package org.apache.clerezza.rdf.simple.storage; -import org.junit.After; import org.apache.clerezza.rdf.core.access.TcProvider; import org.apache.clerezza.rdf.core.test.TcProviderTest; +import org.junit.jupiter.api.AfterEach; + /** * * @author mir @@ -30,7 +31,7 @@ public class GenericTcProviderTest extends TcProviderTest { SimpleTcProvider provider = new SimpleTcProvider(); - @After + @AfterEach public void cleanUp() { provider = new SimpleTcProvider(); } diff --git a/rdf/utils/pom.xml b/rdf/utils/pom.xml index 58043dd7c..0ac0cf593 100644 --- a/rdf/utils/pom.xml +++ b/rdf/utils/pom.xml @@ -35,8 +35,18 @@ Utility classed to deal with Clerezza Models - junit - junit + org.junit.platform + junit-platform-runner + test + + + org.junit.jupiter + junit-jupiter-engine + test + + + org.apiguardian + apiguardian-api test @@ -66,4 +76,4 @@ test - \ No newline at end of file + diff --git a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/GraphUtilsTest.java b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/GraphUtilsTest.java index 2ec8af8fb..557f46fa5 100644 --- a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/GraphUtilsTest.java +++ b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/GraphUtilsTest.java @@ -19,19 +19,25 @@ package org.apache.clerezza.rdf.utils; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; + import org.apache.clerezza.commons.rdf.BlankNode; import org.apache.clerezza.commons.rdf.Graph; import org.apache.clerezza.commons.rdf.IRI; import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph; import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; import org.apache.clerezza.rdf.utils.GraphUtils.NoSuchSubGraphException; -import org.junit.Assert; -import org.junit.Test; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class GraphUtilsTest { final IRI u1 = new IRI("http://ex.org/1"); @@ -51,7 +57,7 @@ public void removeSubGraph() throws NoSuchSubGraphException { subGraph.add(new TripleImpl(bNode2, u2, bNode1)); } GraphUtils.removeSubGraph(baseGraph, subGraph); - Assert.assertEquals(1, baseGraph.size()); + assertEquals(1, baseGraph.size()); } private Graph createBaseGraph() { @@ -71,7 +77,7 @@ private Graph createBaseGraph() { * * @throws org.apache.clerezza.rdf.utils.GraphUtils.NoSuchSubGraphException */ - @Test(expected=NoSuchSubGraphException.class) + @Test public void removeIncompleteSubGraph() throws NoSuchSubGraphException { Graph baseGraph = createBaseGraph(); @@ -82,10 +88,11 @@ public void removeIncompleteSubGraph() throws NoSuchSubGraphException { subGraph.add(new TripleImpl(u1, u2, bNode2)); subGraph.add(new TripleImpl(bNode2, u2, bNode2)); } - GraphUtils.removeSubGraph(baseGraph, subGraph); + assertThrows(NoSuchSubGraphException.class, () -> + GraphUtils.removeSubGraph(baseGraph, subGraph)); } - @Test(expected=NoSuchSubGraphException.class) + @Test public void removeInvalidSubGraph() throws NoSuchSubGraphException { Graph baseGraph = createBaseGraph(); @@ -98,7 +105,8 @@ public void removeInvalidSubGraph() throws NoSuchSubGraphException { baseGraph.add(new TripleImpl(bNode2, u2, bNode1)); baseGraph.add(new TripleImpl(bNode2, u2, new BlankNode())); } - GraphUtils.removeSubGraph(baseGraph, subGraph); + assertThrows(NoSuchSubGraphException.class, () -> + GraphUtils.removeSubGraph(baseGraph, subGraph)); } } diff --git a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/IfpSmushTest.java b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/IfpSmushTest.java index 2d9e4c668..2071eef19 100644 --- a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/IfpSmushTest.java +++ b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/IfpSmushTest.java @@ -18,6 +18,8 @@ */ package org.apache.clerezza.rdf.utils; +import static org.junit.jupiter.api.Assertions.assertEquals; + import org.apache.clerezza.commons.rdf.BlankNode; import org.apache.clerezza.commons.rdf.Graph; import org.apache.clerezza.commons.rdf.IRI; @@ -28,13 +30,16 @@ import org.apache.clerezza.rdf.ontologies.OWL; import org.apache.clerezza.rdf.ontologies.RDF; import org.apache.clerezza.rdf.ontologies.RDFS; -import org.junit.Assert; -import org.junit.Test; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class IfpSmushTest { private Graph ontology = new SimpleGraph(); @@ -55,7 +60,7 @@ public void simpleBlankNode() { mGraph.add(new TripleImpl(bNode2, RDFS.comment, new PlainLiteralImpl("another comment"))); Smusher.smush(mGraph, ontology); - Assert.assertEquals(3, mGraph.size()); + assertEquals(3, mGraph.size()); } @Test @@ -77,7 +82,7 @@ public void overlappingEquivalenceClasses() { mGraph.add(new TripleImpl(bNode3, RDFS.comment, new PlainLiteralImpl("yet another comment"))); Smusher.smush(mGraph, ontology); - Assert.assertEquals(5, mGraph.size()); + assertEquals(5, mGraph.size()); } @Test @@ -93,7 +98,7 @@ public void oneIRI() { mGraph.add(new TripleImpl(bNode2, RDFS.comment, new PlainLiteralImpl("another comment"))); Smusher.smush(mGraph, ontology); - Assert.assertEquals(3, mGraph.size()); + assertEquals(3, mGraph.size()); } @Test @@ -109,7 +114,7 @@ public void twoIRIs() { mGraph.add(new TripleImpl(resource2, RDFS.comment, new PlainLiteralImpl("another comment"))); Smusher.smush(mGraph, ontology); - Assert.assertEquals(4, mGraph.size()); + assertEquals(4, mGraph.size()); } } diff --git a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/RdfListTest.java b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/RdfListTest.java index c81547dc1..fe7ce1a07 100644 --- a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/RdfListTest.java +++ b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/RdfListTest.java @@ -18,12 +18,12 @@ */ package org.apache.clerezza.rdf.utils; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.List; import java.util.Set; -import junit.framework.Assert; - -import org.junit.Test; import org.apache.clerezza.commons.rdf.BlankNode; import org.apache.clerezza.commons.rdf.RDFTerm; import org.apache.clerezza.commons.rdf.Triple; @@ -31,12 +31,16 @@ import org.apache.clerezza.commons.rdf.IRI; import org.apache.clerezza.commons.rdf.impl.utils.PlainLiteralImpl; import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph; -import static org.junit.Assert.*; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author rbn */ +@RunWith(JUnitPlatform.class) public class RdfListTest { @Test @@ -132,7 +136,7 @@ public void cleanGraphAfterRemoval() { list.add(new PlainLiteralImpl("hello")); list.add(new PlainLiteralImpl("world")); list.remove(1); - Assert.assertEquals(2, tc.size()); + assertEquals(2, tc.size()); } @@ -160,24 +164,24 @@ public void findContainingListNodesAndfindContainingListsTest() { Set containingListNodes = RdfList.findContainingListNodes( new GraphNode(element3, tc)); - Assert.assertEquals(1, containingListNodes.size()); - Assert.assertTrue(containingListNodes.contains(listA)); + assertEquals(1, containingListNodes.size()); + assertTrue(containingListNodes.contains(listA)); Set containingLists = RdfList.findContainingLists( new GraphNode(element3, tc)); - Assert.assertEquals(1, containingLists.size()); - Assert.assertTrue(containingLists.contains(rdfListA)); + assertEquals(1, containingLists.size()); + assertTrue(containingLists.contains(rdfListA)); containingListNodes = RdfList.findContainingListNodes( new GraphNode(element4, tc)); - Assert.assertEquals(2, containingListNodes.size()); - Assert.assertTrue(containingListNodes.contains(listA)); - Assert.assertTrue(containingListNodes.contains(listB)); + assertEquals(2, containingListNodes.size()); + assertTrue(containingListNodes.contains(listA)); + assertTrue(containingListNodes.contains(listB)); containingLists = RdfList.findContainingLists( new GraphNode(element4, tc)); - Assert.assertEquals(2, containingLists.size()); - Assert.assertTrue(containingLists.contains(rdfListA)); - Assert.assertTrue(containingLists.contains(rdfListB)); + assertEquals(2, containingLists.size()); + assertTrue(containingLists.contains(rdfListA)); + assertTrue(containingLists.contains(rdfListB)); } -} \ No newline at end of file +} diff --git a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/SameAsSmushTest.java b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/SameAsSmushTest.java index fc44ec225..25fdbcd22 100644 --- a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/SameAsSmushTest.java +++ b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/SameAsSmushTest.java @@ -18,7 +18,12 @@ */ package org.apache.clerezza.rdf.utils; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.Iterator; + import org.apache.clerezza.commons.rdf.BlankNode; import org.apache.clerezza.commons.rdf.Literal; import org.apache.clerezza.commons.rdf.Graph; @@ -31,13 +36,16 @@ import org.apache.clerezza.rdf.ontologies.OWL; import org.apache.clerezza.rdf.ontologies.RDF; import org.apache.clerezza.rdf.ontologies.RDFS; -import org.junit.Assert; -import org.junit.Test; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class SameAsSmushTest { private final IRI uriA = new IRI("http://example.org/A"); @@ -58,21 +66,21 @@ public class SameAsSmushTest { @Test public void simple() { - Assert.assertEquals(3, dataGraph.size()); + assertEquals(3, dataGraph.size()); Smusher.sameAsSmush(dataGraph, sameAsStatements); - Assert.assertEquals(3, dataGraph.size()); - Assert.assertTrue(dataGraph.filter(null, OWL.sameAs, null).hasNext()); + assertEquals(3, dataGraph.size()); + assertTrue(dataGraph.filter(null, OWL.sameAs, null).hasNext()); //exactly one statement with literal Iterator litStmts = dataGraph.filter(null, null, lit); - Assert.assertTrue(litStmts.hasNext()); + assertTrue(litStmts.hasNext()); Triple litStmt = litStmts.next(); - Assert.assertFalse(litStmts.hasNext()); + assertFalse(litStmts.hasNext()); Iterator knowsStmts = dataGraph.filter(null, FOAF.knows, null); - Assert.assertTrue(knowsStmts.hasNext()); + assertTrue(knowsStmts.hasNext()); Triple knowStmt = knowsStmts.next(); - Assert.assertEquals(knowStmt.getSubject(), knowStmt.getObject()); - Assert.assertEquals(litStmt.getSubject(), knowStmt.getObject()); - Assert.assertEquals(litStmt.getSubject(), dataGraph.filter(null, OWL.sameAs, null).next().getObject()); + assertEquals(knowStmt.getSubject(), knowStmt.getObject()); + assertEquals(litStmt.getSubject(), knowStmt.getObject()); + assertEquals(litStmt.getSubject(), dataGraph.filter(null, OWL.sameAs, null).next().getObject()); } } diff --git a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/TestGraphNode.java b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/TestGraphNode.java index 2fdd2f4c8..7387eae1a 100644 --- a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/TestGraphNode.java +++ b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/TestGraphNode.java @@ -18,13 +18,15 @@ */ package org.apache.clerezza.rdf.utils; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.Set; -import junit.framework.Assert; -import org.junit.Test; import org.apache.clerezza.commons.rdf.BlankNode; import org.apache.clerezza.commons.rdf.Literal; import org.apache.clerezza.commons.rdf.Graph; @@ -36,10 +38,15 @@ import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; import org.apache.clerezza.rdf.core.test.RandomGraph; +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; + /** * * @author reto, mir */ +@RunWith(JUnitPlatform.class) public class TestGraphNode { @Test @@ -55,10 +62,10 @@ public void nodeContext() { g.add(new TripleImpl(property1, property1, bNode2)); g.add(new TripleImpl(property1, property1, new PlainLiteralImpl("bla bla"))); GraphNode n = new GraphNode(bNode1, g); - Assert.assertEquals(4, n.getNodeContext().size()); + assertEquals(4, n.getNodeContext().size()); n.deleteNodeContext(); - Assert.assertEquals(1, g.size()); - Assert.assertFalse(n.getObjects(property2).hasNext()); + assertEquals(1, g.size()); + assertFalse(n.getObjects(property2).hasNext()); } @Test @@ -69,7 +76,7 @@ public void addNode() { IRI property1 = new IRI("http://example.org/property1"); GraphNode n = new GraphNode(bNode1, g); n.addProperty(property1, bNode2); - Assert.assertEquals(1, g.size()); + assertEquals(1, g.size()); } @Test @@ -85,7 +92,7 @@ public void testGetSubjectAndObjectNodes() { Iterator objectNodes = node.getObjectNodes(property); while (objectNodes.hasNext()) { GraphNode graphNode = objectNodes.next(); - Assert.assertTrue(objects.contains(graphNode.getNode())); + assertTrue(objects.contains(graphNode.getNode())); } } } @@ -100,7 +107,7 @@ public void testGetSubjectAndObjectNodes() { Iterator subjectNodes = node.getSubjectNodes(property); while (subjectNodes.hasNext()) { GraphNode graphNode = subjectNodes.next(); - Assert.assertTrue(subjects.contains(graphNode.getNode())); + assertTrue(subjects.contains(graphNode.getNode())); } } } @@ -130,11 +137,11 @@ public void getAvailableProperties(){ while(properties.hasNext()){ i++; IRI prop = properties.next(); - Assert.assertTrue(props.contains(prop)); + assertTrue(props.contains(prop)); props.remove(prop); } - Assert.assertEquals(i, 4); - Assert.assertEquals(props.size(), 0); + assertEquals(i, 4); + assertEquals(props.size(), 0); } @@ -154,7 +161,7 @@ public void deleteAll() { g.add(new TripleImpl(bNode2, property1, new PlainLiteralImpl("bla bla"))); GraphNode n = new GraphNode(bNode1, g); n.deleteProperties(property1); - Assert.assertEquals(3, g.size()); + assertEquals(3, g.size()); } @Test @@ -173,7 +180,7 @@ public void deleteSingleProperty() { g.add(new TripleImpl(bNode2, property1, new PlainLiteralImpl("bla bla"))); GraphNode n = new GraphNode(bNode1, g); n.deleteProperty(property1, new PlainLiteralImpl("literal")); - Assert.assertEquals(4, g.size()); + assertEquals(4, g.size()); } @Test @@ -202,21 +209,21 @@ public void replaceWith() { new SimpleGraph(initialGraph.iterator())); node.replaceWith(newIRI, true); - Assert.assertEquals(5, node.getGraph().size()); + assertEquals(5, node.getGraph().size()); Triple expectedTriple1 = new TripleImpl(bNode1, newIRI, literal1); Triple expectedTriple2 = new TripleImpl(bNode1, property2, newIRI); Triple expectedTriple3 = new TripleImpl(newIRI, newIRI, bNode2); Triple expectedTriple4 = new TripleImpl(newIRI, newIRI, literal2); - Assert.assertTrue(node.getGraph().contains(expectedTriple1)); - Assert.assertTrue(node.getGraph().contains(expectedTriple2)); - Assert.assertTrue(node.getGraph().contains(expectedTriple3)); - Assert.assertTrue(node.getGraph().contains(expectedTriple4)); + assertTrue(node.getGraph().contains(expectedTriple1)); + assertTrue(node.getGraph().contains(expectedTriple2)); + assertTrue(node.getGraph().contains(expectedTriple3)); + assertTrue(node.getGraph().contains(expectedTriple4)); - Assert.assertFalse(node.getGraph().contains(triple1)); - Assert.assertFalse(node.getGraph().contains(triple2)); - Assert.assertFalse(node.getGraph().contains(triple4)); - Assert.assertFalse(node.getGraph().contains(triple5)); + assertFalse(node.getGraph().contains(triple1)); + assertFalse(node.getGraph().contains(triple2)); + assertFalse(node.getGraph().contains(triple4)); + assertFalse(node.getGraph().contains(triple5)); node = new GraphNode(property1, new SimpleGraph(initialGraph.iterator())); node.replaceWith(newBnode); @@ -224,25 +231,25 @@ public void replaceWith() { Triple expectedTriple6 = new TripleImpl(newBnode, property1, bNode2); Triple expectedTriple7 = new TripleImpl(newBnode, property1, literal2); - Assert.assertTrue(node.getGraph().contains(triple1)); - Assert.assertTrue(node.getGraph().contains(expectedTriple5)); - Assert.assertTrue(node.getGraph().contains(expectedTriple6)); - Assert.assertTrue(node.getGraph().contains(expectedTriple7)); + assertTrue(node.getGraph().contains(triple1)); + assertTrue(node.getGraph().contains(expectedTriple5)); + assertTrue(node.getGraph().contains(expectedTriple6)); + assertTrue(node.getGraph().contains(expectedTriple7)); node = new GraphNode(literal1, new SimpleGraph(initialGraph.iterator())); node.replaceWith(newBnode); Triple expectedTriple8 = new TripleImpl(bNode1, property1, newBnode); - Assert.assertTrue(node.getGraph().contains(expectedTriple8)); + assertTrue(node.getGraph().contains(expectedTriple8)); node = new GraphNode(property1, new SimpleGraph(initialGraph.iterator())); node.replaceWith(newIRI); Triple expectedTriple9 = new TripleImpl(bNode1, property2, newIRI); Triple expectedTriple10 = new TripleImpl(newIRI, property1, bNode2); Triple expectedTriple11 = new TripleImpl(newIRI, property1, literal2); - Assert.assertTrue(node.getGraph().contains(triple1)); - Assert.assertTrue(node.getGraph().contains(expectedTriple9)); - Assert.assertTrue(node.getGraph().contains(expectedTriple10)); - Assert.assertTrue(node.getGraph().contains(expectedTriple11)); + assertTrue(node.getGraph().contains(triple1)); + assertTrue(node.getGraph().contains(expectedTriple9)); + assertTrue(node.getGraph().contains(expectedTriple10)); + assertTrue(node.getGraph().contains(expectedTriple11)); } @Test @@ -253,10 +260,10 @@ public void equality() { IRI property1 = new IRI("http://example.org/property1"); GraphNode n = new GraphNode(bNode1, g); n.addProperty(property1, bNode2); - Assert.assertTrue(n.equals(new GraphNode(bNode1, g))); - Assert.assertFalse(n.equals(new GraphNode(bNode2, g))); + assertTrue(n.equals(new GraphNode(bNode1, g))); + assertFalse(n.equals(new GraphNode(bNode2, g))); GraphNode n2 = null; - Assert.assertFalse(n.equals(n2)); + assertFalse(n.equals(n2)); } private Set createSet(Iterator resources) { diff --git a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/UnionGraphTest.java b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/UnionGraphTest.java index 53173f4e3..17b0eb0fd 100644 --- a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/UnionGraphTest.java +++ b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/UnionGraphTest.java @@ -18,20 +18,28 @@ */ package org.apache.clerezza.rdf.utils; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.Iterator; -import org.junit.Test; + import org.apache.clerezza.commons.rdf.BlankNode; import org.apache.clerezza.commons.rdf.Graph; import org.apache.clerezza.commons.rdf.Triple; import org.apache.clerezza.commons.rdf.IRI; import org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph; import org.apache.clerezza.commons.rdf.impl.utils.TripleImpl; -import org.junit.Assert; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author hasan */ +@RunWith(JUnitPlatform.class) public class UnionGraphTest { private final IRI uriRef1 = @@ -53,12 +61,12 @@ public void readAccess() { graph2.add(new TripleImpl(bnode, uriRef1, uriRef3)); Graph unionGraph = new UnionGraph(graph, graph2); Iterator unionTriples = unionGraph.iterator(); - Assert.assertTrue(unionTriples.hasNext()); + assertTrue(unionTriples.hasNext()); unionTriples.next(); - Assert.assertTrue(unionTriples.hasNext()); + assertTrue(unionTriples.hasNext()); unionTriples.next(); - Assert.assertFalse(unionTriples.hasNext()); - Assert.assertEquals(2, unionGraph.size()); + assertFalse(unionTriples.hasNext()); + assertEquals(2, unionGraph.size()); } @Test @@ -69,10 +77,10 @@ public void writeAccess() { }; graph2.add(new TripleImpl(bnode, uriRef1, uriRef3)); Graph unionGraph = new UnionGraph(graph, graph2); - Assert.assertEquals(1, unionGraph.size()); + assertEquals(1, unionGraph.size()); unionGraph.add(new TripleImpl(uriRef4, uriRef1, uriRef3)); - Assert.assertEquals(1, graph.size()); - Assert.assertEquals(2, unionGraph.size()); - Assert.assertEquals(1, graph2.size()); + assertEquals(1, graph.size()); + assertEquals(2, unionGraph.size()); + assertEquals(1, graph2.size()); } -} \ No newline at end of file +} diff --git a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/smushing/SameAsSmushTest.java b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/smushing/SameAsSmushTest.java index 6e67ed40e..ad5898704 100644 --- a/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/smushing/SameAsSmushTest.java +++ b/rdf/utils/src/test/java/org/apache/clerezza/rdf/utils/smushing/SameAsSmushTest.java @@ -18,8 +18,13 @@ */ package org.apache.clerezza.rdf.utils.smushing; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + import java.util.Iterator; import java.util.Set; + import org.apache.clerezza.commons.rdf.BlankNode; import org.apache.clerezza.commons.rdf.Literal; import org.apache.clerezza.commons.rdf.Graph; @@ -32,13 +37,16 @@ import org.apache.clerezza.rdf.ontologies.OWL; import org.apache.clerezza.rdf.ontologies.RDF; import org.apache.clerezza.rdf.ontologies.RDFS; -import org.junit.Assert; -import org.junit.Test; + +import org.junit.jupiter.api.Test; +import org.junit.platform.runner.JUnitPlatform; +import org.junit.runner.RunWith; /** * * @author reto */ +@RunWith(JUnitPlatform.class) public class SameAsSmushTest { private final IRI uriA = new IRI("http://example.org/A"); @@ -71,22 +79,22 @@ protected IRI getPreferedIRI(Set uriRefs) { } }; - Assert.assertEquals(3, dataGraph.size()); + assertEquals(3, dataGraph.size()); smusher.smush(dataGraph, sameAsStatements, true); - Assert.assertEquals(4, dataGraph.size()); - Assert.assertTrue(dataGraph.filter(null, OWL.sameAs, null).hasNext()); + assertEquals(4, dataGraph.size()); + assertTrue(dataGraph.filter(null, OWL.sameAs, null).hasNext()); //exactly one statement with literal Iterator litStmts = dataGraph.filter(null, null, lit); - Assert.assertTrue(litStmts.hasNext()); + assertTrue(litStmts.hasNext()); Triple litStmt = litStmts.next(); - Assert.assertFalse(litStmts.hasNext()); + assertFalse(litStmts.hasNext()); Iterator knowsStmts = dataGraph.filter(null, FOAF.knows, null); - Assert.assertTrue(knowsStmts.hasNext()); + assertTrue(knowsStmts.hasNext()); Triple knowStmt = knowsStmts.next(); - Assert.assertEquals(knowStmt.getSubject(), knowStmt.getObject()); - Assert.assertEquals(litStmt.getSubject(), knowStmt.getObject()); - Assert.assertEquals(litStmt.getSubject(), dataGraph.filter(null, OWL.sameAs, null).next().getObject()); - Assert.assertEquals(knowStmt.getSubject(), uriC); + assertEquals(knowStmt.getSubject(), knowStmt.getObject()); + assertEquals(litStmt.getSubject(), knowStmt.getObject()); + assertEquals(litStmt.getSubject(), dataGraph.filter(null, OWL.sameAs, null).next().getObject()); + assertEquals(knowStmt.getSubject(), uriC); } }