Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

GH-4544 Openrewrite changes to the test classes. #4545

Draft
wants to merge 3 commits into
base: develop
Choose a base branch
from
Draft

GH-4544 Openrewrite changes to the test classes. #4545

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
d95f112
GH-4544 core/model java test cases changed
JervenBolleman May 22, 2023
bb6a438
GH-4544 core/sail/elasticsearch java test cases changed
JervenBolleman May 22, 2023
2f1b8d2
GH-4544 change repository testsuites mvn verify passses
JervenBolleman May 22, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
12 changes: 6 additions & 6 deletions core/model/src/test/java/org/eclipse/rdf4j/model/datatypes/XMLDatatypeUtilTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.rdf4j.model.datatypes;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.base.CoreDatatype;
Expand Down Expand Up @@ -260,15 +260,15 @@ public void testParseFloat() {
public void testCompareDateTimeStamp() {
int sameOffset = XMLDatatypeUtil.compare("2019-12-06T00:00:00Z", "2019-12-06T00:00:00+00:00",
XSD.DATETIMESTAMP);
assertTrue("Not the same", sameOffset == 0);
assertTrue(sameOffset == 0, "Not the same");

int offset1 = XMLDatatypeUtil.compare("2019-12-06T14:00:00+02:00", "2019-12-06T13:00:00+02:00",
XSD.DATETIMESTAMP);
assertTrue("Wrong order", offset1 > 0);
assertTrue(offset1 > 0, "Wrong order");

int offset2 = XMLDatatypeUtil.compare("2019-12-06T12:00:00+02:00", "2019-12-06T13:00:00-04:00",
XSD.DATETIMESTAMP);
assertTrue("Wrong order", offset2 < 0);
assertTrue(offset2 < 0, "Wrong order");
}

@Test
Expand Down
4 changes: 2 additions & 2 deletions core/model/src/test/java/org/eclipse/rdf4j/model/impl/ContextStatementTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,8 +10,8 @@
*******************************************************************************/
package org.eclipse.rdf4j.model.impl;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotEquals;

import java.util.HashSet;
import java.util.Set;
Expand Down
6 changes: 3 additions & 3 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelBuilderTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,9 +10,9 @@
*******************************************************************************/
package org.eclipse.rdf4j.model.util;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.Assertions.fail;

import org.eclipse.rdf4j.model.Model;
import org.eclipse.rdf4j.model.impl.LinkedHashModel;
Expand Down
6 changes: 3 additions & 3 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelCollectorTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,7 +10,7 @@
*******************************************************************************/
package org.eclipse.rdf4j.model.util;

import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;

import java.util.HashSet;
import java.util.Set;
Expand Down Expand Up @@ -41,12 +41,12 @@ public void setUp() throws Exception {
@Test
public void testCollector() {
Model m = stmts.stream().collect(ModelCollector.toModel());
assertEquals("Number of statements does not match", m.size(), nrStmts);
assertEquals(m.size(), nrStmts, "Number of statements does not match");
}

@Test
public void testCollectorParallel() {
Model m = stmts.parallelStream().collect(ModelCollector.toModel());
assertEquals("Number of statements does not match", m.size(), nrStmts);
assertEquals(m.size(), nrStmts, "Number of statements does not match");
}
}
58 changes: 29 additions & 29 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/ModelsTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,10 +11,10 @@
package org.eclipse.rdf4j.model.util;

import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
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 static org.junit.jupiter.api.Assertions.fail;

import java.util.Optional;
Expand Down Expand Up @@ -81,7 +81,7 @@ public void testModelsIsomorphic() {
// add same statement again
model2.add(foo, RDF.TYPE, bar);

assertTrue("Duplicate statement should not be considered", Models.isomorphic(model1, model2));
assertTrue(Models.isomorphic(model1, model2), "Duplicate statement should not be considered");

// two identical statements with bnodes added.
model1.add(foo, RDF.TYPE, VF.createBNode());
Expand Down Expand Up @@ -461,22 +461,22 @@ public void testConvertReificationToRDFStar() {
Model referenceRDFStarModel = RDFStarTestHelper.createRDFStarModel();

Model rdfStarModel1 = Models.convertReificationToRDFStar(VF, reificationModel);
assertTrue("RDF reification conversion to RDF-star with explicit VF, model-to-model",
Models.isomorphic(rdfStarModel1, referenceRDFStarModel));
assertTrue(Models.isomorphic(rdfStarModel1, referenceRDFStarModel),
"RDF reification conversion to RDF-star with explicit VF, model-to-model");

Model rdfStarModel2 = Models.convertReificationToRDFStar(reificationModel);
assertTrue("RDF reification conversion to RDF-star with implicit VF, model-to-model",
Models.isomorphic(rdfStarModel2, referenceRDFStarModel));
assertTrue(Models.isomorphic(rdfStarModel2, referenceRDFStarModel),
"RDF reification conversion to RDF-star with implicit VF, model-to-model");

Model rdfStarModel3 = new TreeModel();
Models.convertReificationToRDFStar(VF, reificationModel, (Consumer<Statement>) rdfStarModel3::add);
assertTrue("RDF reification conversion to RDF-star with explicit VF, model-to-consumer",
Models.isomorphic(rdfStarModel3, referenceRDFStarModel));
assertTrue(Models.isomorphic(rdfStarModel3, referenceRDFStarModel),
"RDF reification conversion to RDF-star with explicit VF, model-to-consumer");

Model rdfStarModel4 = new TreeModel();
Models.convertReificationToRDFStar(reificationModel, rdfStarModel4::add);
assertTrue("RDF reification conversion to RDF-star with implicit VF, model-to-consumer",
Models.isomorphic(rdfStarModel4, referenceRDFStarModel));
assertTrue(Models.isomorphic(rdfStarModel4, referenceRDFStarModel),
"RDF reification conversion to RDF-star with implicit VF, model-to-consumer");
}

@Test
Expand All @@ -486,22 +486,22 @@ public void testConvertIncompleteReificationToRDFStar() {
Model incompleteReificationModel = RDFStarTestHelper.createIncompleteRDFReificationModel();

Model rdfStarModel1 = Models.convertReificationToRDFStar(VF, incompleteReificationModel);
assertTrue("Incomplete RDF reification conversion to RDF-star with explicit VF, model-to-model",
Models.isomorphic(rdfStarModel1, incompleteReificationModel));
assertTrue(Models.isomorphic(rdfStarModel1, incompleteReificationModel),
"Incomplete RDF reification conversion to RDF-star with explicit VF, model-to-model");

Model rdfStarModel2 = Models.convertReificationToRDFStar(incompleteReificationModel);
assertTrue("Incomplete RDF reification conversion to RDF-star with implicit VF, model-to-model",
Models.isomorphic(rdfStarModel2, incompleteReificationModel));
assertTrue(Models.isomorphic(rdfStarModel2, incompleteReificationModel),
"Incomplete RDF reification conversion to RDF-star with implicit VF, model-to-model");

Model rdfStarModel3 = new TreeModel();
Models.convertReificationToRDFStar(VF, incompleteReificationModel, (Consumer<Statement>) rdfStarModel3::add);
assertTrue("Incomplete RDF reification conversion to RDF-star with explicit VF, model-to-consumer",
Models.isomorphic(rdfStarModel3, incompleteReificationModel));
assertTrue(Models.isomorphic(rdfStarModel3, incompleteReificationModel),
"Incomplete RDF reification conversion to RDF-star with explicit VF, model-to-consumer");

Model rdfStarModel4 = new TreeModel();
Models.convertReificationToRDFStar(incompleteReificationModel, rdfStarModel4::add);
assertTrue("Incomplete RDF reification conversion to RDF-star with implicit VF, model-to-consumer",
Models.isomorphic(rdfStarModel4, incompleteReificationModel));
assertTrue(Models.isomorphic(rdfStarModel4, incompleteReificationModel),
"Incomplete RDF reification conversion to RDF-star with implicit VF, model-to-consumer");
}

@Test
Expand All @@ -510,22 +510,22 @@ public void testConvertRDFStarToReification() {
Model referenceModel = RDFStarTestHelper.createRDFReificationModel();

Model reificationModel1 = Models.convertRDFStarToReification(VF, rdfStarModel);
assertTrue("RDF-star conversion to reification with explicit VF, model-to-model",
Models.isomorphic(reificationModel1, referenceModel));
assertTrue(Models.isomorphic(reificationModel1, referenceModel),
"RDF-star conversion to reification with explicit VF, model-to-model");

Model reificationModel2 = Models.convertRDFStarToReification(rdfStarModel);
assertTrue("RDF-star conversion to reification with implicit VF, model-to-model",
Models.isomorphic(reificationModel2, referenceModel));
assertTrue(Models.isomorphic(reificationModel2, referenceModel),
"RDF-star conversion to reification with implicit VF, model-to-model");

Model reificationModel3 = new TreeModel();
Models.convertRDFStarToReification(VF, rdfStarModel, (Consumer<Statement>) reificationModel3::add);
assertTrue("RDF-star conversion to reification with explicit VF, model-to-consumer",
Models.isomorphic(reificationModel3, referenceModel));
assertTrue(Models.isomorphic(reificationModel3, referenceModel),
"RDF-star conversion to reification with explicit VF, model-to-consumer");

Model reificationModel4 = new TreeModel();
Models.convertRDFStarToReification(rdfStarModel, reificationModel4::add);
assertTrue("RDF-star conversion to reification with explicit VF, model-to-consumer",
Models.isomorphic(reificationModel4, referenceModel));
assertTrue(Models.isomorphic(reificationModel4, referenceModel),
"RDF-star conversion to reification with explicit VF, model-to-consumer");
}

}
14 changes: 7 additions & 7 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/NamespacesTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,11 +10,11 @@
*******************************************************************************/
package org.eclipse.rdf4j.model.util;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.util.Collection;
import java.util.Collections;
Expand Down Expand Up @@ -269,7 +269,7 @@ public final void testWrapPut() throws Exception {
Map<String, String> testMap = Namespaces.wrap(testSet);

String put1 = testMap.put(testPrefix1, testName1);
assertNull("Should have returned null from put on an empty backing set", put1);
assertNull(put1, "Should have returned null from put on an empty backing set");
assertEquals(1, testSet.size());
assertTrue(testSet.contains(new SimpleNamespace(testPrefix1, testName1)));
assertTrue(testMap.containsKey(testPrefix1));
Expand All @@ -293,7 +293,7 @@ public final void testWrapPut() throws Exception {
assertFalse(testMap.containsValue(testName2));

String put3 = testMap.put(testPrefix1, testName1);
assertNull("Should have returned null from put on an empty backing set", put3);
assertNull(put3, "Should have returned null from put on an empty backing set");
assertEquals(1, testSet.size());
assertTrue(testSet.contains(new SimpleNamespace(testPrefix1, testName1)));
assertTrue(testMap.containsKey(testPrefix1));
Expand Down
8 changes: 4 additions & 4 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/RDFCollectionsTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,10 +10,10 @@
*******************************************************************************/
package org.eclipse.rdf4j.model.util;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.CALLS_REAL_METHODS;
import static org.mockito.Mockito.atLeastOnce;
Expand Down
6 changes: 3 additions & 3 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/RDFContainersTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -11,9 +11,9 @@

package org.eclipse.rdf4j.model.util;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
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 static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.CALLS_REAL_METHODS;
import static org.mockito.Mockito.atLeastOnce;
Expand Down
24 changes: 12 additions & 12 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/StatementsTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -12,10 +12,10 @@

import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatThrownBy;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
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 static org.junit.jupiter.api.Assertions.fail;

import org.eclipse.rdf4j.model.Model;
import org.eclipse.rdf4j.model.Resource;
Expand Down Expand Up @@ -92,19 +92,19 @@ public void testRDFStarReification() {

Model convertedModel1 = new LinkedHashModel();
rdfStarModel.forEach((s) -> Statements.convertRDFStarToReification(s, convertedModel1::add));
assertTrue("RDF-star conversion to reification with implicit VF",
Models.isomorphic(reifiedModel, convertedModel1));
assertTrue(Models.isomorphic(reifiedModel, convertedModel1),
"RDF-star conversion to reification with implicit VF");

Model convertedModel2 = new LinkedHashModel();
rdfStarModel.forEach((s) -> Statements.convertRDFStarToReification(vf, s, convertedModel2::add));
assertTrue("RDF-star conversion to reification with explicit VF",
Models.isomorphic(reifiedModel, convertedModel2));
assertTrue(Models.isomorphic(reifiedModel, convertedModel2),
"RDF-star conversion to reification with explicit VF");

Model convertedModel3 = new LinkedHashModel();
rdfStarModel.forEach((s) -> Statements.convertRDFStarToReification(vf, (t) -> vf.createBNode(t.stringValue()),
s, convertedModel3::add));
assertTrue("RDF-star conversion to reification with explicit VF and custom BNode mapping",
Models.isomorphic(reifiedModel, convertedModel3));
assertTrue(Models.isomorphic(reifiedModel, convertedModel3),
"RDF-star conversion to reification with explicit VF and custom BNode mapping");
}

@Test
Expand All @@ -113,8 +113,8 @@ public void testTripleToResourceMapper() {
vf.createLiteral("data"));
Triple t2 = vf.createTriple(vf.createIRI("http://example.com/1"), vf.createIRI("http://example.com/2"),
vf.createLiteral("data"));
assertEquals("Identical triples must produce the same blank node",
Statements.TRIPLE_BNODE_MAPPER.apply(t1), Statements.TRIPLE_BNODE_MAPPER.apply(t2));
assertEquals(Statements.TRIPLE_BNODE_MAPPER.apply(t1), Statements.TRIPLE_BNODE_MAPPER.apply(t2),
"Identical triples must produce the same blank node");
}

@Test
Expand Down
54 changes: 27 additions & 27 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/URIUtilTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,8 +10,8 @@
*******************************************************************************/
package org.eclipse.rdf4j.model.util;

import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

import org.junit.jupiter.api.Test;

Expand Down Expand Up @@ -48,35 +48,35 @@ public void testIsCorrectURISplit() throws Exception {
@Test
public void testIsValidURIReference() throws Exception {
assertTrue(URIUtil.isValidURIReference("http://example.org/foo/bar/"));
assertTrue("whitespace should be allowed",
URIUtil.isValidURIReference("http://example.org/foo/bar with a lot of space/"));
assertTrue("unwise chars should be allowed",
URIUtil.isValidURIReference("http://example.org/foo/bar/unwise{<characters>}"));
assertTrue("query params in single quotes should be allowed",
URIUtil.isValidURIReference("http://example.org/foo/bar?query='blah'"));
assertTrue("query params in double quotes should be allowed",
URIUtil.isValidURIReference("http://example.org/foo/bar?query=\"blah\"&foo=bar"));
assertTrue("short simple urns should be allowed", URIUtil.isValidURIReference("urn:p1"));
assertTrue("Escaped special char should be allowed",
URIUtil.isValidURIReference("http://example.org/foo\\u00ea/bar/"));
assertTrue("fragment identifier should be allowed",
URIUtil.isValidURIReference("http://example.org/foo/bar#fragment1"));
assertTrue("Unescaped special char should be allowed",
URIUtil.isValidURIReference("http://example.org/foo®/bar/"));
assertFalse("control char should not be allowed",
URIUtil.isValidURIReference("http://example.org/foo\u0001/bar/"));
assertFalse("relative uri should fail", URIUtil.isValidURIReference("foo/bar/"));
assertFalse("single column is not a valid uri", URIUtil.isValidURIReference(":"));
assertTrue("reserved char is allowed in non-conflicting spot",
URIUtil.isValidURIReference("http://foo.com/b!ar/"));
assertFalse("reserved char should not be allowed in conflicting spot",
URIUtil.isValidURIReference("http;://foo.com/bar/"));
assertTrue(URIUtil.isValidURIReference("http://example.org/foo/bar with a lot of space/"),
"whitespace should be allowed");
assertTrue(URIUtil.isValidURIReference("http://example.org/foo/bar/unwise{<characters>}"),
"unwise chars should be allowed");
assertTrue(URIUtil.isValidURIReference("http://example.org/foo/bar?query='blah'"),
"query params in single quotes should be allowed");
assertTrue(URIUtil.isValidURIReference("http://example.org/foo/bar?query=\"blah\"&foo=bar"),
"query params in double quotes should be allowed");
assertTrue(URIUtil.isValidURIReference("urn:p1"), "short simple urns should be allowed");
assertTrue(URIUtil.isValidURIReference("http://example.org/foo\\u00ea/bar/"),
"Escaped special char should be allowed");
assertTrue(URIUtil.isValidURIReference("http://example.org/foo/bar#fragment1"),
"fragment identifier should be allowed");
assertTrue(URIUtil.isValidURIReference("http://example.org/foo®/bar/"),
"Unescaped special char should be allowed");
assertFalse(URIUtil.isValidURIReference("http://example.org/foo\u0001/bar/"),
"control char should not be allowed");
assertFalse(URIUtil.isValidURIReference("foo/bar/"), "relative uri should fail");
assertFalse(URIUtil.isValidURIReference(":"), "single column is not a valid uri");
assertTrue(URIUtil.isValidURIReference("http://foo.com/b!ar/"),
"reserved char is allowed in non-conflicting spot");
assertFalse(URIUtil.isValidURIReference("http;://foo.com/bar/"),
"reserved char should not be allowed in conflicting spot");
}

@Test
public void controlCharacterInURI() {
assertFalse("URI containing Unicode control char should be invalid",
URIUtil.isValidURIReference("http://example.org/foo\u001F/bar/"));
assertFalse(URIUtil.isValidURIReference("http://example.org/foo\u001F/bar/"),
"URI containing Unicode control char should be invalid");
}

@Test
Expand Down
4 changes: 2 additions & 2 deletions core/model/src/test/java/org/eclipse/rdf4j/model/util/ValuesTest.java
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,8 +17,8 @@
import static org.eclipse.rdf4j.model.util.Values.literal;
import static org.eclipse.rdf4j.model.util.Values.namespace;
import static org.eclipse.rdf4j.model.util.Values.triple;
import static org.junit.Assert.assertThrows;
import static org.junit.Assert.fail;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;

Expand Down
Loading