diff --git a/scijava/scijava-discovery-plugin/pom.xml b/scijava/scijava-discovery-plugin/pom.xml index 2beeccbcb..908b37cc0 100644 --- a/scijava/scijava-discovery-plugin/pom.xml +++ b/scijava/scijava-discovery-plugin/pom.xml @@ -104,8 +104,13 @@ - junit - junit + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine test diff --git a/scijava/scijava-discovery-plugin/src/test/java/org/scijava/discovery/plugin/PluginDiscovererTest.java b/scijava/scijava-discovery-plugin/src/test/java/org/scijava/discovery/plugin/PluginDiscovererTest.java index aed089706..8095ca3b3 100644 --- a/scijava/scijava-discovery-plugin/src/test/java/org/scijava/discovery/plugin/PluginDiscovererTest.java +++ b/scijava/scijava-discovery-plugin/src/test/java/org/scijava/discovery/plugin/PluginDiscovererTest.java @@ -3,36 +3,17 @@ import java.util.List; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; -import org.scijava.Context; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.scijava.discovery.Discoverer; -import org.scijava.plugin.PluginService; public class PluginDiscovererTest { - private static Context ctx; - private static PluginService plugins; - - @BeforeClass - public static void setUp() { - ctx = new Context(PluginService.class); - plugins = ctx.getService(PluginService.class); - } - - @AfterClass - public static void tearDown() throws Exception { - ctx.close(); - plugins = null; - } - @Test public void testPluginDiscovery() { Discoverer d = new PluginBasedDiscoverer(); List discoveries = d.discover(TestPlugin.class); - Assert.assertTrue(discoveries.stream().anyMatch(o -> o.getClass() == TestPluginImpl.class)); + Assertions.assertTrue(discoveries.stream().anyMatch(o -> o.getClass() == TestPluginImpl.class)); } } diff --git a/scijava/scijava-discovery-test/pom.xml b/scijava/scijava-discovery-test/pom.xml index 7df08c3ba..b59c6b9b1 100644 --- a/scijava/scijava-discovery-test/pom.xml +++ b/scijava/scijava-discovery-test/pom.xml @@ -119,8 +119,13 @@ - junit - junit + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine test diff --git a/scijava/scijava-discovery-test/src/test/java/org/scijava/discovery/test/ServiceLoaderDiscovererTest.java b/scijava/scijava-discovery-test/src/test/java/org/scijava/discovery/test/ServiceLoaderDiscovererTest.java index b8af1b5eb..9891c3af9 100644 --- a/scijava/scijava-discovery-test/src/test/java/org/scijava/discovery/test/ServiceLoaderDiscovererTest.java +++ b/scijava/scijava-discovery-test/src/test/java/org/scijava/discovery/test/ServiceLoaderDiscovererTest.java @@ -5,8 +5,8 @@ import java.util.ServiceLoader; import java.util.stream.Collectors; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.scijava.discovery.Discoverer; import org.scijava.ops.spi.Op; import org.scijava.ops.spi.OpCollection; @@ -25,8 +25,8 @@ private static void assertDiscoveryRequirements(Discoverer d, Class disco List> implementingClasses = d.discover(discovery).stream().map(o -> (Class) o.getClass()).collect( Collectors.toList()); for(Class cls : impls) - Assert.assertTrue(implementingClasses.contains(cls)); + Assertions.assertTrue(implementingClasses.contains(cls)); - Assert.assertEquals(impls.length, implementingClasses.size()); + Assertions.assertEquals(impls.length, implementingClasses.size()); } } diff --git a/scijava/scijava-discovery-therapi/pom.xml b/scijava/scijava-discovery-therapi/pom.xml index f077b4040..b81dfd639 100644 --- a/scijava/scijava-discovery-therapi/pom.xml +++ b/scijava/scijava-discovery-therapi/pom.xml @@ -114,8 +114,13 @@ - junit - junit + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine test diff --git a/scijava/scijava-discovery-therapi/src/test/java/org/scijava/discovery/therapi/TagOptionsTest.java b/scijava/scijava-discovery-therapi/src/test/java/org/scijava/discovery/therapi/TagOptionsTest.java index 745f24945..9a8320725 100644 --- a/scijava/scijava-discovery-therapi/src/test/java/org/scijava/discovery/therapi/TagOptionsTest.java +++ b/scijava/scijava-discovery-therapi/src/test/java/org/scijava/discovery/therapi/TagOptionsTest.java @@ -1,35 +1,33 @@ package org.scijava.discovery.therapi; +import org.junit.jupiter.api.Test; + import java.util.List; -import org.junit.Assert; -import org.junit.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; public class TagOptionsTest { - private List getTaggedDiscoveries( - String tagType) - { + private List getTaggedDiscoveries(String tagType) { return new TaggedElementDiscoverer(tagType).discover(TaggedElement.class); } @Test public void optionsTest() { - List elements = getTaggedDiscoveries( - "optionsTest"); + List elements = getTaggedDiscoveries("optionsTest"); TaggedElement annotatedElement = elements.get(0); - Assert.assertEquals("e", annotatedElement.option("singleKey")); - Assert.assertEquals("[e1, e2]", annotatedElement.option("listKey")); + assertEquals("e", annotatedElement.option("singleKey")); + assertEquals("[e1, e2]", annotatedElement.option("listKey")); } @Test public void optionsPerLineTest() { - List elements = getTaggedDiscoveries( - "optionsPerLineTest"); + List elements = getTaggedDiscoveries("optionsPerLineTest"); TaggedElement annotatedElement = elements.get(0); - Assert.assertEquals("e", annotatedElement.option("singleKey")); - Assert.assertEquals("[e1, e2]", annotatedElement.option("listKey")); + assertEquals("e", annotatedElement.option("singleKey")); + assertEquals("[e1, e2]", annotatedElement.option("listKey")); } /** @@ -38,11 +36,10 @@ public void optionsPerLineTest() { */ @Test public void forgottenCommaTest() { - List elements = getTaggedDiscoveries( - "forgottenComma"); + List elements = getTaggedDiscoveries("forgottenComma"); TaggedElement annotatedElement = elements.get(0); - Assert.assertThrows(IllegalArgumentException.class, // - () -> annotatedElement.option("singleKey")); + assertThrows(IllegalArgumentException.class, // + () -> annotatedElement.option("singleKey")); } /** @@ -50,22 +47,20 @@ public void forgottenCommaTest() { */ @Test public void forgottenQuoteTest() { - List elements = getTaggedDiscoveries( - "forgottenQuote"); + List elements = getTaggedDiscoveries("forgottenQuote"); TaggedElement annotatedElement = elements.get(0); - Assert.assertEquals("e", annotatedElement.option("singleKey")); + assertEquals("e", annotatedElement.option("singleKey")); } /** - * Tests duplicate definition behaviors. When a tag tries to define a tag - * twice, we expect that the second definition overwrites the first. + * Tests duplicate definition behaviors. When a tag tries to define a tag twice, + * we expect that the second definition overwrites the first. */ @Test public void duplicateOptionTest() { - List elements = getTaggedDiscoveries( - "duplicateOption"); + List elements = getTaggedDiscoveries("duplicateOption"); TaggedElement annotatedElement = elements.get(0); - Assert.assertEquals("[e1, e2]", annotatedElement.option("singleKey")); + assertEquals("[e1, e2]", annotatedElement.option("singleKey")); } /** @@ -73,25 +68,24 @@ public void duplicateOptionTest() { */ @Test public void absentOptionTest() { - List elements = getTaggedDiscoveries( - "absentOption"); + List elements = getTaggedDiscoveries("absentOption"); TaggedElement annotatedElement = elements.get(0); - Assert.assertEquals("", annotatedElement.option("singleKey")); + assertEquals("", annotatedElement.option("singleKey")); } /** * @implNote optionsTest singleKey='e', listKey={'e1', 'e2'} */ @SuppressWarnings("unused") - public void foo() {} + public void foo() { + } /** - * @implNote optionsPerLineTest - * singleKey='e', - * listKey={'e1', 'e2'} + * @implNote optionsPerLineTest singleKey='e', listKey={'e1', 'e2'} */ @SuppressWarnings("unused") - public void boo() {} + public void boo() { + } /** * A tagged element whose tag doesn't have a comma between options @@ -99,7 +93,8 @@ public void boo() {} * @implNote forgottenComma singleKey='e' listKey={'e1', 'e2'} */ @SuppressWarnings("unused") - public void too() {} + public void too() { + } /** * A tagged element whose tag doesn't have a quotes surrounding the value @@ -107,7 +102,8 @@ public void too() {} * @implNote forgottenQuote singleKey=e, listKey={'e1', 'e2'} */ @SuppressWarnings("unused") - public void moo() {} + public void moo() { + } /** * A tagged element whose tag tries to define a key twice @@ -115,7 +111,8 @@ public void moo() {} * @implNote duplicateOption singleKey='e', singleKey={'e1', 'e2'} */ @SuppressWarnings("unused") - public void coo() {} + public void coo() { + } /** * A tagged element who has no options @@ -123,5 +120,6 @@ public void coo() {} * @implNote absentOption */ @SuppressWarnings("unused") - public void woo() {} + public void woo() { + } } diff --git a/scijava/scijava-discovery-therapi/src/test/java/org/scijava/discovery/therapi/TherapiDiscovererTest.java b/scijava/scijava-discovery-therapi/src/test/java/org/scijava/discovery/therapi/TherapiDiscovererTest.java index 27ec7ae65..ec17ad4f1 100644 --- a/scijava/scijava-discovery-therapi/src/test/java/org/scijava/discovery/therapi/TherapiDiscovererTest.java +++ b/scijava/scijava-discovery-therapi/src/test/java/org/scijava/discovery/therapi/TherapiDiscovererTest.java @@ -4,33 +4,32 @@ import java.util.List; import java.util.function.Function; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.scijava.discovery.Discoverer; +import static org.junit.jupiter.api.Assertions.assertTrue; + public class TherapiDiscovererTest { - private Discoverer discoverer() - { + private Discoverer discoverer() { return new TaggedElementDiscoverer("test"); } @Test public void discoverClass() { List elements = discoverer().discover(TaggedElement.class); - Assert.assertTrue(elements.stream().anyMatch(e -> e.discovery() == ClassTest.class)); + assertTrue(elements.stream().anyMatch(e -> e.discovery() == ClassTest.class)); } @Test public void discoverField() throws SecurityException { List elements = discoverer().discover(TaggedElement.class); - Assert.assertTrue(elements.stream().anyMatch(d -> { + assertTrue(elements.stream().anyMatch(d -> { try { AnnotatedElement actual = d.discovery(); AnnotatedElement expected = this.getClass().getDeclaredField("fieldTest"); return expected.equals(actual); - } - catch (NoSuchFieldException ex) { + } catch (NoSuchFieldException ex) { return false; } })); @@ -39,13 +38,12 @@ public void discoverField() throws SecurityException { @Test public void discoverMethod() throws SecurityException { List elements = discoverer().discover(TaggedElement.class); - Assert.assertTrue(elements.stream().anyMatch(d -> { + assertTrue(elements.stream().anyMatch(d -> { try { AnnotatedElement actual = d.discovery(); AnnotatedElement expected = this.getClass().getDeclaredMethod("methodTest"); return expected.equals(actual); - } - catch (NoSuchMethodException ex) { + } catch (NoSuchMethodException ex) { return false; } })); @@ -55,13 +53,13 @@ public void discoverMethod() throws SecurityException { * @implNote test */ public void methodTest() { - + } /** * @implNote test */ - public final Function fieldTest = (in) -> in+ 1; + public final Function fieldTest = (in) -> in + 1; } /** @@ -70,5 +68,5 @@ public void methodTest() { * */ class ClassTest { - + } diff --git a/scijava/scijava-log2/pom.xml b/scijava/scijava-log2/pom.xml index 7084943f1..5148bc7e5 100644 --- a/scijava/scijava-log2/pom.xml +++ b/scijava/scijava-log2/pom.xml @@ -94,8 +94,13 @@ - junit - junit + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine test diff --git a/scijava/scijava-log2/src/test/java/org/scijava/log2/CallingClassUtilsTest.java b/scijava/scijava-log2/src/test/java/org/scijava/log2/CallingClassUtilsTest.java index 5db29cdac..64387d1e6 100644 --- a/scijava/scijava-log2/src/test/java/org/scijava/log2/CallingClassUtilsTest.java +++ b/scijava/scijava-log2/src/test/java/org/scijava/log2/CallingClassUtilsTest.java @@ -29,9 +29,9 @@ package org.scijava.log2; -import static org.junit.Assert.assertEquals; +import org.junit.jupiter.api.Test; -import org.junit.Test; +import static org.junit.jupiter.api.Assertions.assertEquals; /** * Tests {@link CallingClassUtils}. diff --git a/scijava/scijava-log2/src/test/java/org/scijava/log2/DefaultLoggerTest.java b/scijava/scijava-log2/src/test/java/org/scijava/log2/DefaultLoggerTest.java index 5d9f227f3..e3e9b7e51 100644 --- a/scijava/scijava-log2/src/test/java/org/scijava/log2/DefaultLoggerTest.java +++ b/scijava/scijava-log2/src/test/java/org/scijava/log2/DefaultLoggerTest.java @@ -29,14 +29,13 @@ package org.scijava.log2; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.*; import java.util.Arrays; +import java.util.List; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; /** * Tests {@link DefaultLogger} @@ -45,12 +44,13 @@ */ public class DefaultLoggerTest { - private Logger logger; - private TestLogListener listener; + private static Logger logger; + private static TestLogListener listener; - @Before - public void setup() { - logger = new DefaultLogger(message -> {}, LogSource.newRoot(), LogLevel.INFO); + @BeforeAll + public static void setup() { + logger = new DefaultLogger(message -> { + }, LogSource.newRoot(), LogLevel.INFO); listener = new TestLogListener(); logger.addLogListener(listener); } @@ -84,7 +84,7 @@ public void testHierarchicLogger() { subB.error("Hello World!"); assertTrue(listener.hasLogged(m -> m.source().equals(subB.getSource()))); - assertEquals(Arrays.asList("subA"), subA.getSource().path()); + assertEquals(List.of("subA"), subA.getSource().path()); assertEquals(Arrays.asList("subA", "subB"), subB.getSource().path()); } diff --git a/scijava/scijava-log2/src/test/java/org/scijava/log2/LogMessageTest.java b/scijava/scijava-log2/src/test/java/org/scijava/log2/LogMessageTest.java index 525874a52..c6401ae19 100644 --- a/scijava/scijava-log2/src/test/java/org/scijava/log2/LogMessageTest.java +++ b/scijava/scijava-log2/src/test/java/org/scijava/log2/LogMessageTest.java @@ -29,14 +29,14 @@ package org.scijava.log2; -import static junit.framework.TestCase.assertTrue; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.Collections; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; /** * Tests {@link LogMessage}. @@ -53,11 +53,11 @@ public void testToString() { LogMessage message = new LogMessage(LogSource.newRoot(), LogLevel.DEBUG, 42, new NullPointerException()); // process String s = message.toString(); - //test - Assert.assertTrue("Log message contains level", s.contains(LogLevel.prefix(message.level()))); - Assert.assertTrue("Log message contains msg", s.contains(message.text())); - Assert.assertTrue("Log message contains throwable", s.contains(message.throwable().toString())); - Assert.assertTrue("Log message contains stack trace", s.contains(nameOfThisMethod)); + // test + assertTrue(s.contains(LogLevel.prefix(message.level())), "Log message contains level"); + assertTrue(s.contains(message.text()), "Log message contains msg"); + assertTrue(s.contains(message.throwable().toString()), "Log message contains throwable"); + assertTrue(s.contains(nameOfThisMethod), "Log message contains stack trace"); } @Test @@ -70,12 +70,12 @@ public void testToStringOptionalParameters() { String s = message.toString(); // test - Assert.assertTrue("Log message contains level", s.contains(LogLevel.prefix(message.level()))); + Assertions.assertTrue(s.contains(LogLevel.prefix(message.level())), "Log message contains level"); } @Test public void testAttachments() { - LogMessage message = new LogMessage(LogSource.newRoot(), LogLevel.ERROR, "Message") ; + LogMessage message = new LogMessage(LogSource.newRoot(), LogLevel.ERROR, "Message"); assertTrue(message.attachments().isEmpty()); Object object = new Object(); message.attach(object); diff --git a/scijava/scijava-log2/src/test/java/org/scijava/log2/LogSourceTest.java b/scijava/scijava-log2/src/test/java/org/scijava/log2/LogSourceTest.java index 02316168b..4f4282cff 100644 --- a/scijava/scijava-log2/src/test/java/org/scijava/log2/LogSourceTest.java +++ b/scijava/scijava-log2/src/test/java/org/scijava/log2/LogSourceTest.java @@ -29,14 +29,11 @@ package org.scijava.log2; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; +import org.junit.jupiter.api.Test; import java.util.Collections; -import org.junit.Test; +import static org.junit.jupiter.api.Assertions.*; /** * Tests {@link LogSource} diff --git a/scijava/scijava-log2/src/test/java/org/scijava/log2/StderrLogServiceTest.java b/scijava/scijava-log2/src/test/java/org/scijava/log2/StderrLogServiceTest.java index 160b094c3..8cf6a3ca5 100644 --- a/scijava/scijava-log2/src/test/java/org/scijava/log2/StderrLogServiceTest.java +++ b/scijava/scijava-log2/src/test/java/org/scijava/log2/StderrLogServiceTest.java @@ -29,14 +29,14 @@ package org.scijava.log2; -import static org.junit.Assert.assertTrue; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.scijava.log2.LogLevel.WARN; import java.io.ByteArrayOutputStream; import java.io.PrintStream; -import org.junit.Test; - /** * Tests {@link StderrLoggerFactory}. * @@ -49,8 +49,8 @@ public class StderrLogServiceTest { public void testDefaultLevel() { final Logger log = new StderrLoggerFactory().create(); int level = log.getLevel(); - assertTrue("default level (" + level + // - ") is at least INFO(" + WARN + ")", level >= WARN); + assertTrue(level >= WARN, "default level (" + level + // + ") is at least INFO(" + WARN + ")"); } @Test diff --git a/scijava/scijava-ops-api/src/main/java/module-info.java b/scijava/scijava-ops-api/src/main/java/module-info.java index 6aa156357..2aeb0e9bf 100644 --- a/scijava/scijava-ops-api/src/main/java/module-info.java +++ b/scijava/scijava-ops-api/src/main/java/module-info.java @@ -1,5 +1,4 @@ module org.scijava.ops.api { - exports org.scijava.ops.api; exports org.scijava.ops.api.features; @@ -8,4 +7,5 @@ requires transitive org.scijava.struct; requires org.scijava.types; + uses org.scijava.ops.api.OpInfoGenerator; } diff --git a/scijava/scijava-ops-api/src/main/java/org/scijava/ops/api/OpInfoGenerator.java b/scijava/scijava-ops-api/src/main/java/org/scijava/ops/api/OpInfoGenerator.java index 5a6684c81..fbee2b450 100644 --- a/scijava/scijava-ops-api/src/main/java/org/scijava/ops/api/OpInfoGenerator.java +++ b/scijava/scijava-ops-api/src/main/java/org/scijava/ops/api/OpInfoGenerator.java @@ -1,11 +1,20 @@ package org.scijava.ops.api; import java.util.List; +import java.util.ServiceLoader; +import java.util.stream.Collectors; +import java.util.stream.StreamSupport; public interface OpInfoGenerator { boolean canGenerateFrom(Object o); List generateInfosFrom(Object o); + + static List generateAll(Object o) { + return StreamSupport.stream(ServiceLoader.load(OpInfoGenerator.class).spliterator(), true) // + .flatMap(g -> g.generateInfosFrom(o).stream()) // + .collect(Collectors.toList()); + } } diff --git a/scijava/scijava-ops-engine/pom.xml b/scijava/scijava-ops-engine/pom.xml index 095da9051..373483e9c 100644 --- a/scijava/scijava-ops-engine/pom.xml +++ b/scijava/scijava-ops-engine/pom.xml @@ -189,8 +189,13 @@ - junit - junit + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine test diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/AbstractTestEnvironment.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/AbstractTestEnvironment.java index 8ab0e290c..243e099a1 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/AbstractTestEnvironment.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/AbstractTestEnvironment.java @@ -1,15 +1,15 @@ package org.scijava.ops.engine; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.util.Arrays; import java.util.Iterator; import java.util.Optional; import java.util.ServiceLoader; -import org.junit.AfterClass; -import org.junit.BeforeClass; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; import org.scijava.discovery.Discoverer; import org.scijava.discovery.ManualDiscoverer; import org.scijava.log2.Logger; @@ -28,14 +28,14 @@ public abstract class AbstractTestEnvironment { protected static Logger logger; protected static TypeReifier types; - @BeforeClass + @BeforeAll public static void setUp() { logger = new StderrLoggerFactory().create(); types = new DefaultTypeReifier(logger, Discoverer.using(ServiceLoader::load)); ops = barebonesEnvironment(); } - @AfterClass + @AfterAll public static void tearDown() { ops = null; logger = null; @@ -82,10 +82,10 @@ protected static void assertIterationsEqual(final Iterable expected, fina final Iterator e = expected.iterator(); final Iterator a = actual.iterator(); while (e.hasNext()) { - assertTrue("Fewer elements than expected", a.hasNext()); + assertTrue(a.hasNext(), "Fewer elements than expected"); assertEquals(e.next(), a.next()); } - assertFalse("More elements than expected", a.hasNext()); + assertFalse(a.hasNext(), "More elements than expected"); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/InfoChainTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/InfoChainTest.java index c109766f0..aded331a0 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/InfoChainTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/InfoChainTest.java @@ -4,9 +4,9 @@ import java.util.Collections; import java.util.Iterator; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Producer; import org.scijava.ops.api.InfoChain; import org.scijava.ops.api.OpInfo; @@ -24,7 +24,7 @@ */ public class InfoChainTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new InfoChainTest()); ops.register(new ComplexOp()); @@ -41,7 +41,7 @@ public void testInfoChainInstantiation() { InfoChain chain = new InfoChain(info); Nil> nil = new Nil<>() {}; Producer op = ops.opFromInfoChain(chain, nil); - Assert.assertEquals(S, op.create()); + Assertions.assertEquals(S, op.create()); } @Test @@ -57,14 +57,14 @@ public void testInfoChainWithDependenciesInstantiation() { Nil> nil = new Nil<>() {}; Producer op = ops.opFromInfoChain(chain, nil); - Assert.assertEquals(S, op.create()); + Assertions.assertEquals(S, op.create()); } private OpInfo singularInfoOfName(String name) { Iterator infos = ops.infos(name).iterator(); - Assert.assertTrue(infos.hasNext()); + Assertions.assertTrue(infos.hasNext()); OpInfo info = infos.next(); - Assert.assertFalse(infos.hasNext()); + Assertions.assertFalse(infos.hasNext()); return info; } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/JavadocParameterTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/JavadocParameterTest.java index 4fa4b8a83..43104cdd0 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/JavadocParameterTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/JavadocParameterTest.java @@ -10,9 +10,9 @@ import java.util.function.Function; import java.util.stream.Collectors; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Inplaces; import org.scijava.ops.api.OpInfo; @@ -32,7 +32,7 @@ */ public class JavadocParameterTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new JavadocParameterTest()); ops.register(new JavadocOp()); @@ -104,7 +104,7 @@ public void testJavadocMethodPR() { OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.method\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.method\""); } isSuitableScrapedOpMethodInfo(info); } @@ -115,7 +115,7 @@ public void testJavadocMethodIO() { OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.method\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.method\""); } isSuitableGenericOpMethodInfo(info); } @@ -126,7 +126,7 @@ public void testJavadocMethodIR() { OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.method\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.method\""); } isSuitableGenericOpMethodInfo(info); } @@ -137,7 +137,7 @@ public void testJavadocMethodI() { OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.method\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.method\""); } isSuitableGenericOpMethodInfo(info); } @@ -174,27 +174,27 @@ public void testJavadocMethodInplaceI() { OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.method\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.method\""); } // assert input names String[] inputNames = info.inputs().stream().map(m -> m.getKey()).toArray( String[]::new); - Assert.assertArrayEquals(inputNames, new String[] { "foo" }); + Assertions.assertArrayEquals(inputNames, new String[] { "foo" }); // assert input descriptions String[] inputDescriptions = info.inputs().stream().map(m -> m .getDescription()).toArray(String[]::new); - Assert.assertArrayEquals(inputDescriptions, new String[] { + Assertions.assertArrayEquals(inputDescriptions, new String[] { "the i/o argument"}); // assert output name String outputName = info.output().getKey(); - Assert.assertEquals("foo", outputName); + Assertions.assertEquals("foo", outputName); // assert output description String outputDescription = info.output().getDescription(); - Assert.assertEquals("the i/o argument", outputDescription); + Assertions.assertEquals("the i/o argument", outputDescription); } @Test @@ -203,33 +203,33 @@ public void testJavadocMethodInplaceWithDepedency() { OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.methodDependency\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.methodDependency\""); } // assert input names String[] inputNames = info.inputs().stream().map(m -> m.getKey()).toArray( String[]::new); - Assert.assertArrayEquals(inputNames, new String[] { "foo" }); + Assertions.assertArrayEquals(inputNames, new String[] { "foo" }); // assert input descriptions String[] inputDescriptions = info.inputs().stream().map(m -> m .getDescription()).toArray(String[]::new); - Assert.assertArrayEquals(inputDescriptions, new String[] { + Assertions.assertArrayEquals(inputDescriptions, new String[] { "the i/o argument"}); // assert dependency descriptions String[] dependencyDescriptions = info.dependencies().stream().map(m -> m .getDescription()).toArray(String[]::new); - Assert.assertArrayEquals(dependencyDescriptions, new String[] { + Assertions.assertArrayEquals(dependencyDescriptions, new String[] { "the Op being wrapped"}); // assert output name String outputName = info.output().getKey(); - Assert.assertEquals("foo", outputName); + Assertions.assertEquals("foo", outputName); // assert output description String outputDescription = info.output().getDescription(); - Assert.assertEquals("the i/o argument", outputDescription); + Assertions.assertEquals("the i/o argument", outputDescription); } /** @@ -247,20 +247,20 @@ private void isSuitableScrapedOpMethodInfo(OpInfo info) { // assert input names String[] inputNames = info.inputs().stream().map(m -> m.getKey()).toArray( String[]::new); - Assert.assertArrayEquals(inputNames, new String[] { "foo", "bar" }); + Assertions.assertArrayEquals(inputNames, new String[] { "foo", "bar" }); // assert input descriptions String[] inputDescriptions = info.inputs().stream().map(m -> m.getDescription()).toArray( String[]::new); - Assert.assertArrayEquals(inputDescriptions, new String[] { "the first input", "the second input" }); + Assertions.assertArrayEquals(inputDescriptions, new String[] { "the first input", "the second input" }); // assert output name String outputName = info.output().getKey(); - Assert.assertEquals("output", outputName); + Assertions.assertEquals("output", outputName); // assert output description String outputDescription = info.output().getDescription(); - Assert.assertEquals("foo + bar", outputDescription); + Assertions.assertEquals("foo + bar", outputDescription); } /** @@ -278,20 +278,20 @@ private void isSuitableGenericOpMethodInfo(OpInfo info) { // assert input names String[] inputNames = info.inputs().stream().map(m -> m.getKey()).toArray( String[]::new); - Assert.assertArrayEquals(new String[] { "input1", "input2" }, inputNames); + Assertions.assertArrayEquals(new String[] { "input1", "input2" }, inputNames); // assert input descriptions String[] inputDescriptions = info.inputs().stream().map(m -> m.getDescription()).toArray( String[]::new); - Assert.assertArrayEquals(new String[] { "", ""}, inputDescriptions); + Assertions.assertArrayEquals(new String[] { "", ""}, inputDescriptions); // assert output name String outputName = info.output().getKey(); - Assert.assertEquals("output1", outputName); + Assertions.assertEquals("output1", outputName); // assert output description String outputDescription = info.output().getDescription(); - Assert.assertEquals("", outputDescription); + Assertions.assertEquals("", outputDescription); } /** @@ -318,30 +318,30 @@ public void testJavadocFieldF() { Iterator infos = ops.infos("test.javadoc.fieldF").iterator(); if (!infos.hasNext()) { - Assert.fail("No OpInfos with name \"test.javadoc.fieldF\""); + Assertions.fail("No OpInfos with name \"test.javadoc.fieldF\""); } OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.fieldF\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.fieldF\""); } // assert input names String[] inputNames = info.inputs().stream().map(m -> m.getKey()).toArray( String[]::new); - Assert.assertArrayEquals(new String[] { "in" }, inputNames); + Assertions.assertArrayEquals(new String[] { "in" }, inputNames); // assert input descriptions String[] inputDescriptions = info.inputs().stream().map(m -> m.getDescription()).toArray( String[]::new); - Assert.assertArrayEquals(new String[] { "the input" }, inputDescriptions); + Assertions.assertArrayEquals(new String[] { "the input" }, inputDescriptions); // assert output name String outputName = info.output().getKey(); - Assert.assertEquals("output1", outputName); + Assertions.assertEquals("output1", outputName); // assert output description String outputDescription = info.output().getDescription(); - Assert.assertEquals("the output", outputDescription); + Assertions.assertEquals("the output", outputDescription); } @Test @@ -349,30 +349,30 @@ public void testJavadocFieldC() { Iterator infos = ops.infos("test.javadoc.fieldC").iterator(); if (!infos.hasNext()) { - Assert.fail("No OpInfos with name \"test.javadoc.fieldC\""); + Assertions.fail("No OpInfos with name \"test.javadoc.fieldC\""); } OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.fieldC\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.fieldC\""); } // assert input names String[] inputNames = info.inputs().stream().map(m -> m.getKey()).toArray( String[]::new); - Assert.assertArrayEquals(new String[] { "inList", "outList" }, inputNames); + Assertions.assertArrayEquals(new String[] { "inList", "outList" }, inputNames); // assert input descriptions String[] inputDescriptions = info.inputs().stream().map(m -> m.getDescription()).toArray( String[]::new); - Assert.assertArrayEquals(new String[] { "the input", "the preallocated output" }, inputDescriptions); + Assertions.assertArrayEquals(new String[] { "the input", "the preallocated output" }, inputDescriptions); // assert output name String outputName = info.output().getKey(); - Assert.assertEquals("outList", outputName); + Assertions.assertEquals("outList", outputName); // assert output description String outputDescription = info.output().getDescription(); - Assert.assertEquals("the preallocated output", outputDescription); + Assertions.assertEquals("the preallocated output", outputDescription); } @Test @@ -380,37 +380,37 @@ public void testJavadocClass() { Iterator infos = ops.infos("test.javadoc.dependentClass").iterator(); if (!infos.hasNext()) { - Assert.fail("No OpInfos with name \"test.javadoc.dependentClass\""); + Assertions.fail("No OpInfos with name \"test.javadoc.dependentClass\""); } OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.dependentClass\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.dependentClass\""); } // assert input names String[] inputNames = info.inputs().stream().map(m -> m.getKey()).toArray( String[]::new); - Assert.assertArrayEquals(new String[] { "t" }, inputNames); + Assertions.assertArrayEquals(new String[] { "t" }, inputNames); // assert input descriptions String[] inputDescriptions = info.inputs().stream().map(m -> m.getDescription()).toArray( String[]::new); - Assert.assertArrayEquals(new String[] { "the input" }, inputDescriptions); + Assertions.assertArrayEquals(new String[] { "the input" }, inputDescriptions); // assert dependency description String[] dependencyDescriptions = info.dependencies().stream().map(m -> m .getDescription()).toArray(String[]::new); - Assert.assertArrayEquals(new String[] { + Assertions.assertArrayEquals(new String[] { "Used to compute output for each element in the array" }, dependencyDescriptions); // assert output name String outputName = info.output().getKey(); - Assert.assertEquals("output", outputName); + Assertions.assertEquals("output", outputName); // assert output description String outputDescription = info.output().getDescription(); - Assert.assertEquals("the output", outputDescription); + Assertions.assertEquals("the output", outputDescription); } @Test @@ -419,7 +419,7 @@ public void opStringRegressionTest() { OpInfo info = infos.next(); if (infos.hasNext()) { - Assert.fail("Multiple OpInfos with name \"test.javadoc.method\""); + Assertions.fail("Multiple OpInfos with name \"test.javadoc.method\""); } // test standard op string @@ -432,7 +432,7 @@ public void opStringRegressionTest() { " Outputs:\n" + " java.util.List output -> foo + bar\n" + ")\n"; String actual = info.toString(); - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); // test special op string expected = @@ -444,7 +444,7 @@ public void opStringRegressionTest() { " Outputs:\n" + " java.util.List output -> foo + bar\n" + ")\n"; actual = OpUtils.opString(info, info.inputs().get(1)); - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/ModuleTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/ModuleTest.java index a649b0042..5d576831a 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/ModuleTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/ModuleTest.java @@ -1,7 +1,7 @@ package org.scijava.ops.engine; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.io.File; import java.io.IOException; @@ -12,17 +12,16 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class ModuleTest { String moduleBaseDirectory = "src/main/java/org/scijava"; /** - * Recursively finds the name of each package within the module - * org.scijava.ops + * Recursively finds the name of each package within the module org.scijava.ops * - * @param set the set that will be populated with the module names + * @param set the set that will be populated with the module names * @param dirName the starting directory */ private void findPackageNames(Set set, String dirName) { @@ -34,26 +33,24 @@ private void findPackageNames(Set set, String dirName) { String path = file.getPath(); String packName = path.substring(path.indexOf("org"), path.lastIndexOf(File.separator)); set.add(packName.replace(File.separator, ".")); - } - else if (file.isDirectory()) { + } else if (file.isDirectory()) { findPackageNames(set, file.getAbsolutePath()); } } } private Set getPackagesExported(String path) { - try (Stream stream = Files.lines(Paths.get(path))){ + try (Stream stream = Files.lines(Paths.get(path))) { // remove outside whitespace Set exportedPackages = stream.map(str -> str.trim()) - // consider only opens - .filter(str -> str.startsWith("opens")) - // consider only opens to therapi - .filter(str -> str.contains("therapi.runtime.javadoc")) - // get the package from the opens - .map(str -> str.split(" ")[1]).collect(Collectors.toSet()); + // consider only opens + .filter(str -> str.startsWith("opens")) + // consider only opens to therapi + .filter(str -> str.contains("therapi.runtime.javadoc")) + // get the package from the opens + .map(str -> str.split(" ")[1]).collect(Collectors.toSet()); return exportedPackages; - } - catch (IOException e) { + } catch (IOException e) { throw new RuntimeException(e); } } @@ -63,13 +60,11 @@ public void testTherapiExports() { Set packages = new HashSet<>(); findPackageNames(packages, moduleBaseDirectory); - Set exportedPackages = getPackagesExported( - "src/main/java/module-info.java"); + Set exportedPackages = getPackagesExported("src/main/java/module-info.java"); - assertTrue( - "module-info.java does not export all packages to therapi.runtime.javadoc," + - " use bin/generate-groovy.sh to update the list!", packages.equals( - exportedPackages)); + assertTrue(packages.equals(exportedPackages), + "module-info.java does not export all packages to therapi.runtime.javadoc," + + " use bin/generate-groovy.sh to update the list!"); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpBuilderNoOutputTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpBuilderNoOutputTest.java index 69679ad26..158dfac03 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpBuilderNoOutputTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpBuilderNoOutputTest.java @@ -5,9 +5,9 @@ import java.util.ArrayList; import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.spi.OpCollection; import org.scijava.ops.spi.OpField; @@ -24,7 +24,7 @@ public class OpBuilderNoOutputTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new OpBuilderNoOutputTest()); } @@ -50,6 +50,6 @@ private static class WrappedList extends ArrayList {} public void testNoParameterizedTypeOutputGiven() { Object output = ops.op(opName).input(5.).apply(); Type expectedOutputType = new Nil>() {}.getType(); - Assert.assertEquals(ops.genericType(output), expectedOutputType); + Assertions.assertEquals(ops.genericType(output), expectedOutputType); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpBuilderTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpBuilderTest.java index 12c11bd29..9cdc16cb7 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpBuilderTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpBuilderTest.java @@ -29,15 +29,15 @@ package org.scijava.ops.engine; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Functions; import org.scijava.function.Inplaces; @@ -87,7 +87,7 @@ */ public class OpBuilderTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new OpBuilderTestOps()); } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpCollectionTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpCollectionTest.java index 5a96bc143..33de019a4 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpCollectionTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpCollectionTest.java @@ -31,15 +31,15 @@ import java.util.function.BiFunction; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.math.MathOpCollection; import org.scijava.struct.ValidityException; import org.scijava.types.Nil; public class OpCollectionTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new MathOpCollection()); } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpEnvironmentTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpEnvironmentTest.java index 3ba729aa5..1891a78a1 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpEnvironmentTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpEnvironmentTest.java @@ -1,8 +1,8 @@ package org.scijava.ops.engine; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.scijava.Priority; import org.scijava.function.Producer; import org.scijava.ops.api.OpEnvironment; @@ -22,17 +22,17 @@ public class OpEnvironmentTest extends AbstractTestEnvironment { @Test public void testClassOpification() { OpInfo opifyOpInfo = ops.opify(OpifyOp.class); - Assert.assertEquals(OpifyOp.class.getName(), opifyOpInfo.implementationName()); + Assertions.assertEquals(OpifyOp.class.getName(), opifyOpInfo.implementationName()); // assert default priority - Assert.assertEquals(Priority.NORMAL, opifyOpInfo.priority(), 0.); + Assertions.assertEquals(Priority.NORMAL, opifyOpInfo.priority(), 0.); } @Test public void testClassOpificationWithPriority() { OpInfo opifyOpInfo = ops.opify(OpifyOp.class, Priority.HIGH); - Assert.assertEquals(OpifyOp.class.getName(), opifyOpInfo.implementationName()); + Assertions.assertEquals(OpifyOp.class.getName(), opifyOpInfo.implementationName()); // assert default priority - Assert.assertEquals(Priority.HIGH, opifyOpInfo.priority(), 0.); + Assertions.assertEquals(Priority.HIGH, opifyOpInfo.priority(), 0.); } @Test @@ -44,7 +44,7 @@ public void testRegister() { String actual = ops.op(opName).input().outType(String.class).create(); String expected = new OpifyOp().getString(); - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodDependencyPositionTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodDependencyPositionTest.java index 06c081234..7fdd35bb3 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodDependencyPositionTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodDependencyPositionTest.java @@ -6,8 +6,8 @@ import java.util.List; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.spi.OpCollection; import org.scijava.ops.spi.OpDependency; @@ -17,7 +17,7 @@ public class OpMethodDependencyPositionTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new OpMethodDependencyPositionTest()); } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodInParentTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodInParentTest.java index 03066718e..fef9fe031 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodInParentTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodInParentTest.java @@ -3,15 +3,15 @@ import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.spi.Op; import org.scijava.ops.spi.OpClass; public class OpMethodInParentTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new SuperOpMethodHousingClass()); ops.register(new SuperOpMethodHousingInterface()); @@ -23,7 +23,7 @@ public void testFMethodInSuperclass() { String.class).apply(); String expected = "This string came from " + SuperOpMethodHousingClass.class; - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); } @Test @@ -32,7 +32,7 @@ public void testFMethodInInterface() { String.class).apply(); String expected = "This string came from " + SuperOpMethodHousingInterface.class; - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodTest.java index 25131aa96..bd03b76d4 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpMethodTest.java @@ -29,14 +29,14 @@ package org.scijava.ops.engine; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.List; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.spi.OpCollection; import org.scijava.ops.spi.OpMethod; @@ -48,7 +48,7 @@ */ public class OpMethodTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new OpMethodTestOps()); } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpPriorityTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpPriorityTest.java index 78c68ac9a..d593f4dc2 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpPriorityTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpPriorityTest.java @@ -28,10 +28,10 @@ */ package org.scijava.ops.engine; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.Priority; import org.scijava.function.Producer; import org.scijava.ops.spi.Op; @@ -40,7 +40,7 @@ public class OpPriorityTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new TestDouble()); ops.register(new TestFloat()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpsTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpsTest.java index 4932c33c6..e6e348eea 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpsTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/OpsTest.java @@ -32,8 +32,8 @@ import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Inplaces; import org.scijava.ops.engine.math.Add; @@ -44,7 +44,7 @@ public class OpsTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new MathOpCollection()); ops.register(new Zero()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/ServiceLoaderDiscoveryIntegrationTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/ServiceLoaderDiscoveryIntegrationTest.java index d608633ae..0fa20c8c9 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/ServiceLoaderDiscoveryIntegrationTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/ServiceLoaderDiscoveryIntegrationTest.java @@ -4,8 +4,8 @@ import java.util.ServiceLoader; import java.util.stream.Collectors; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.scijava.discovery.Discoverer; import org.scijava.log2.Logger; import org.scijava.log2.StderrLoggerFactory; @@ -22,7 +22,7 @@ public class ServiceLoaderDiscoveryIntegrationTest { public void opDiscoveryRegressionIT() { final Discoverer d = Discoverer.using(ServiceLoader::load); final List discoveries = d.discover(Op.class); - Assert.assertEquals(235, discoveries.size()); + Assertions.assertEquals(235, discoveries.size()); @SuppressWarnings("unused") final Logger l = new StderrLoggerFactory().create(); @@ -30,21 +30,21 @@ public void opDiscoveryRegressionIT() { final List infos = discoveries.stream() // .flatMap(c -> g.generateInfosFrom(c).stream()) // .collect(Collectors.toList()); - Assert.assertEquals(235, infos.size()); + Assertions.assertEquals(235, infos.size()); } @Test public void opCollectionDiscoveryRegressionIT() { final Discoverer d = Discoverer.using(ServiceLoader::load); final List discoveries = d.discover(OpCollection.class); - Assert.assertEquals(16, discoveries.size()); + Assertions.assertEquals(16, discoveries.size()); @SuppressWarnings("unused") final Logger l = new StderrLoggerFactory().create(); final OpInfoGenerator g = new OpCollectionInfoGenerator(); final List infos = discoveries.stream() // .flatMap(c -> g.generateInfosFrom(c).stream()) // .collect(Collectors.toList()); - Assert.assertEquals(264, infos.size()); + Assertions.assertEquals(264, infos.size()); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/TherapiDiscoveryIntegrationTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/TherapiDiscoveryIntegrationTest.java index ac82dbb13..bd54b0467 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/TherapiDiscoveryIntegrationTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/TherapiDiscoveryIntegrationTest.java @@ -3,8 +3,8 @@ import java.util.List; import java.util.ServiceLoader; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.scijava.discovery.Discoverer; import org.scijava.ops.api.OpInfo; import org.scijava.ops.engine.impl.TherapiOpInfoDiscoverer; @@ -17,7 +17,7 @@ public void opDiscoveryRegressionIT() { Parser p = ServiceLoader.load(Parser.class).findFirst().get(); final Discoverer d = new TherapiOpInfoDiscoverer(); final List discoveries = d.discover(OpInfo.class); - Assert.assertEquals(5, discoveries.size()); + Assertions.assertEquals(5, discoveries.size()); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/OpAdaptationPriorityTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/OpAdaptationPriorityTest.java index 9121294af..fe5d2b305 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/OpAdaptationPriorityTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/OpAdaptationPriorityTest.java @@ -29,13 +29,13 @@ package org.scijava.ops.engine.adapt; -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.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Producer; import org.scijava.ops.engine.AbstractTestEnvironment; @@ -53,7 +53,7 @@ */ public class OpAdaptationPriorityTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new OpAdaptationPriorityTest()); Object[] adapters = objsFromNoArgConstructors(ComputersToFunctionsViaFunction.class.getDeclaredClasses()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/complexLift/ComputerToFunctionIterablesTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/complexLift/ComputerToFunctionIterablesTest.java index 2057704d9..5433149c3 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/complexLift/ComputerToFunctionIterablesTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/complexLift/ComputerToFunctionIterablesTest.java @@ -34,13 +34,11 @@ package org.scijava.ops.engine.adapt.complexLift; -import static org.junit.Assert.assertArrayEquals; - import java.util.Arrays; import java.util.List; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.OpBuilderTestOps; @@ -49,6 +47,8 @@ import org.scijava.ops.engine.create.CreateOpCollection; import org.scijava.types.Nil; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + /** * Tests the adaptation of {@link Computers} running on a type into * {@link Computers} running on an {@link Iterable} of that type. @@ -58,7 +58,7 @@ */ public class ComputerToFunctionIterablesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { Object[] lifters = objsFromNoArgConstructors(ComputersToFunctionsAndLift.class.getDeclaredClasses()); ops.register(lifters); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/complexLift/FunctionToComputerIterablesTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/complexLift/FunctionToComputerIterablesTest.java index 833933ded..6ea266739 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/complexLift/FunctionToComputerIterablesTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/complexLift/FunctionToComputerIterablesTest.java @@ -37,9 +37,9 @@ import java.util.Arrays; import java.util.List; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.adapt.functional.FunctionToComputerAdaptTestOps; import org.scijava.ops.engine.adapt.functional.FunctionsToComputers; @@ -48,7 +48,7 @@ public class FunctionToComputerIterablesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { Object[] lifterOps = objsFromNoArgConstructors(FunctionsToComputersAndLift.class.getDeclaredClasses()); ops.register(lifterOps); @@ -64,7 +64,7 @@ public void testFunction1ToComputer1() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in).output(output).compute(); - Assert.assertArrayEquals(new double[] {2, 4}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {2, 4}, output.get(0), 0); } @Test @@ -72,7 +72,7 @@ public void testFunction2ToComputer2() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {4, 8}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {4, 8}, output.get(0), 0); } @Test @@ -80,7 +80,7 @@ public void testFunction3ToComputer3() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {6, 12}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {6, 12}, output.get(0), 0); } @Test @@ -88,7 +88,7 @@ public void testFunction4ToComputer4() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {8, 16}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {8, 16}, output.get(0), 0); } @Test @@ -96,7 +96,7 @@ public void testFunction5ToComputer5() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {10, 20}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {10, 20}, output.get(0), 0); } @Test @@ -104,7 +104,7 @@ public void testFunction6ToComputer6() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {12, 24}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {12, 24}, output.get(0), 0); } @Test @@ -112,7 +112,7 @@ public void testFunction7ToComputer7() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {14, 28}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {14, 28}, output.get(0), 0); } @Test @@ -120,7 +120,7 @@ public void testFunction8ToComputer8() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {16, 32}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {16, 32}, output.get(0), 0); } @Test @@ -128,7 +128,7 @@ public void testFunction9ToComputer9() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {18, 36}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {18, 36}, output.get(0), 0); } @Test @@ -136,7 +136,7 @@ public void testFunction10ToComputer10() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {20, 40}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {20, 40}, output.get(0), 0); } @Test @@ -144,7 +144,7 @@ public void testFunction11ToComputer11() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {22, 44}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {22, 44}, output.get(0), 0); } @Test @@ -152,7 +152,7 @@ public void testFunction12ToComputer12() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {24, 48}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {24, 48}, output.get(0), 0); } @Test @@ -160,7 +160,7 @@ public void testFunction13ToComputer13() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {26, 52}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {26, 52}, output.get(0), 0); } @Test @@ -168,7 +168,7 @@ public void testFunction14ToComputer14() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {28, 56}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {28, 56}, output.get(0), 0); } @Test @@ -176,7 +176,7 @@ public void testFunction15ToComputer15() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {30, 60}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {30, 60}, output.get(0), 0); } @Test @@ -184,7 +184,7 @@ public void testFunction16ToComputer16() { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {32, 64}, output.get(0), 0); + Assertions.assertArrayEquals(new double[] {32, 64}, output.get(0), 0); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/ComputerToFunctionAdaptTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/ComputerToFunctionAdaptTest.java index 3a7c28e3e..7a61081f4 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/ComputerToFunctionAdaptTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/ComputerToFunctionAdaptTest.java @@ -34,15 +34,15 @@ package org.scijava.ops.engine.adapt.functional; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.create.CreateOpCollection; public class ComputerToFunctionAdaptTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new ComputerToFunctionAdaptTestOps()); ops.register(new CreateOpCollection()); @@ -55,7 +55,7 @@ public void testComputer1ToFunction1() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in).outType(double[].class).apply(); double[] expected = {2, 4}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -63,7 +63,7 @@ public void testComputer2ToFunction2() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in).outType(double[].class).apply(); double[] expected = {4, 8}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -71,7 +71,7 @@ public void testComputer3ToFunction3() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in).outType(double[].class).apply(); double[] expected = {6, 12}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -79,7 +79,7 @@ public void testComputer4ToFunction4() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in).outType(double[].class).apply(); double[] expected = {8, 16}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -87,7 +87,7 @@ public void testComputer5ToFunction5() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in).outType(double[].class).apply(); double[] expected = {10, 20}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -95,7 +95,7 @@ public void testComputer6ToFunction6() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {12, 24}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -103,7 +103,7 @@ public void testComputer7ToFunction7() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {14, 28}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -111,7 +111,7 @@ public void testComputer8ToFunction8() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {16, 32}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -119,7 +119,7 @@ public void testComputer9ToFunction9() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {18, 36}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -127,7 +127,7 @@ public void testComputer10ToFunction10() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {20, 40}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -135,7 +135,7 @@ public void testComputer11ToFunction11() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {22, 44}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -143,7 +143,7 @@ public void testComputer12ToFunction12() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {24, 48}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -151,7 +151,7 @@ public void testComputer13ToFunction13() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {26, 52}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -159,7 +159,7 @@ public void testComputer14ToFunction14() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {28, 56}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -167,7 +167,7 @@ public void testComputer15ToFunction15() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {30, 60}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } @Test @@ -175,7 +175,7 @@ public void testComputer16ToFunction16() { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in, in, in).outType(double[].class).apply(); double[] expected = {32, 64}; - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/FunctionToComputerAdaptTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/FunctionToComputerAdaptTest.java index 972eafd53..0d39528c1 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/FunctionToComputerAdaptTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/FunctionToComputerAdaptTest.java @@ -34,15 +34,15 @@ package org.scijava.ops.engine.adapt.functional; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.copy.CopyOpCollection; public class FunctionToComputerAdaptTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new FunctionToComputerAdaptTestOps()); ops.register(new CopyOpCollection()); @@ -54,7 +54,7 @@ public void testFunction1ToComputer1() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in).output(output).compute(); - Assert.assertArrayEquals(new double[] {2, 4}, output, 0); + Assertions.assertArrayEquals(new double[] {2, 4}, output, 0); } @Test @@ -62,7 +62,7 @@ public void testFunction2ToComputer2() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {4, 8}, output, 0); + Assertions.assertArrayEquals(new double[] {4, 8}, output, 0); } @Test @@ -70,7 +70,7 @@ public void testFunction3ToComputer3() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {6, 12}, output, 0); + Assertions.assertArrayEquals(new double[] {6, 12}, output, 0); } @Test @@ -78,7 +78,7 @@ public void testFunction4ToComputer4() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {8, 16}, output, 0); + Assertions.assertArrayEquals(new double[] {8, 16}, output, 0); } @Test @@ -86,7 +86,7 @@ public void testFunction5ToComputer5() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {10, 20}, output, 0); + Assertions.assertArrayEquals(new double[] {10, 20}, output, 0); } @Test @@ -94,7 +94,7 @@ public void testFunction6ToComputer6() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {12, 24}, output, 0); + Assertions.assertArrayEquals(new double[] {12, 24}, output, 0); } @Test @@ -102,7 +102,7 @@ public void testFunction7ToComputer7() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {14, 28}, output, 0); + Assertions.assertArrayEquals(new double[] {14, 28}, output, 0); } @Test @@ -110,7 +110,7 @@ public void testFunction8ToComputer8() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {16, 32}, output, 0); + Assertions.assertArrayEquals(new double[] {16, 32}, output, 0); } @Test @@ -118,7 +118,7 @@ public void testFunction9ToComputer9() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {18, 36}, output, 0); + Assertions.assertArrayEquals(new double[] {18, 36}, output, 0); } @Test @@ -126,7 +126,7 @@ public void testFunction10ToComputer10() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {20, 40}, output, 0); + Assertions.assertArrayEquals(new double[] {20, 40}, output, 0); } @Test @@ -134,7 +134,7 @@ public void testFunction11ToComputer11() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {22, 44}, output, 0); + Assertions.assertArrayEquals(new double[] {22, 44}, output, 0); } @Test @@ -142,7 +142,7 @@ public void testFunction12ToComputer12() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {24, 48}, output, 0); + Assertions.assertArrayEquals(new double[] {24, 48}, output, 0); } @Test @@ -150,7 +150,7 @@ public void testFunction13ToComputer13() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {26, 52}, output, 0); + Assertions.assertArrayEquals(new double[] {26, 52}, output, 0); } @Test @@ -158,7 +158,7 @@ public void testFunction14ToComputer14() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {28, 56}, output, 0); + Assertions.assertArrayEquals(new double[] {28, 56}, output, 0); } @Test @@ -166,7 +166,7 @@ public void testFunction15ToComputer15() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {30, 60}, output, 0); + Assertions.assertArrayEquals(new double[] {30, 60}, output, 0); } @Test @@ -174,7 +174,7 @@ public void testFunction16ToComputer16() { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input(in, in, in, in, in, in, in, in, in, in, in, in, in, in, in, in).output(output).compute(); - Assert.assertArrayEquals(new double[] {32, 64}, output, 0); + Assertions.assertArrayEquals(new double[] {32, 64}, output, 0); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/InplaceToFunctionAdaptTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/InplaceToFunctionAdaptTest.java index 91cf002af..086dd46ed 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/InplaceToFunctionAdaptTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/functional/InplaceToFunctionAdaptTest.java @@ -35,12 +35,12 @@ package org.scijava.ops.engine.adapt.functional; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.OpBuilderTestOps; @@ -50,7 +50,7 @@ public class InplaceToFunctionAdaptTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new OpBuilderTestOps()); ops.register(new CreateOpCollection()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/ComputerToArraysTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/ComputerToArraysTest.java index 608c13ffb..379231586 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/ComputerToArraysTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/ComputerToArraysTest.java @@ -34,9 +34,9 @@ package org.scijava.ops.engine.adapt.lift; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.spi.OpCollection; @@ -50,7 +50,7 @@ */ public class ComputerToArraysTest extends AbstractTestEnvironment implements OpCollection{ - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new ComputerToArraysTest()); ops.register(new ComputerToArrays()); @@ -90,7 +90,7 @@ public void testComputer0ToArrays() { ops.op("test.liftArrayC").input().output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(0 * i, output[i].getNumber()); + Assertions.assertEquals(0 * i, output[i].getNumber()); } } @@ -104,7 +104,7 @@ public void testComputer1ToArrays() { ops.op("test.liftArrayC").input(input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(1 * i, output[i].getNumber()); + Assertions.assertEquals(1 * i, output[i].getNumber()); } } @@ -118,7 +118,7 @@ public void testComputer2ToArrays() { ops.op("test.liftArrayC").input(input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(2 * i, output[i].getNumber()); + Assertions.assertEquals(2 * i, output[i].getNumber()); } } @@ -132,7 +132,7 @@ public void testComputer3ToArrays() { ops.op("test.liftArrayC").input(input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(3 * i, output[i].getNumber()); + Assertions.assertEquals(3 * i, output[i].getNumber()); } } @@ -146,7 +146,7 @@ public void testComputer4ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(4 * i, output[i].getNumber()); + Assertions.assertEquals(4 * i, output[i].getNumber()); } } @@ -160,7 +160,7 @@ public void testComputer5ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(5 * i, output[i].getNumber()); + Assertions.assertEquals(5 * i, output[i].getNumber()); } } @@ -174,7 +174,7 @@ public void testComputer6ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(6 * i, output[i].getNumber()); + Assertions.assertEquals(6 * i, output[i].getNumber()); } } @@ -188,7 +188,7 @@ public void testComputer7ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(7 * i, output[i].getNumber()); + Assertions.assertEquals(7 * i, output[i].getNumber()); } } @@ -202,7 +202,7 @@ public void testComputer8ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(8 * i, output[i].getNumber()); + Assertions.assertEquals(8 * i, output[i].getNumber()); } } @@ -216,7 +216,7 @@ public void testComputer9ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(9 * i, output[i].getNumber()); + Assertions.assertEquals(9 * i, output[i].getNumber()); } } @@ -230,7 +230,7 @@ public void testComputer10ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(10 * i, output[i].getNumber()); + Assertions.assertEquals(10 * i, output[i].getNumber()); } } @@ -244,7 +244,7 @@ public void testComputer11ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(11 * i, output[i].getNumber()); + Assertions.assertEquals(11 * i, output[i].getNumber()); } } @@ -258,7 +258,7 @@ public void testComputer12ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(12 * i, output[i].getNumber()); + Assertions.assertEquals(12 * i, output[i].getNumber()); } } @@ -272,7 +272,7 @@ public void testComputer13ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(13 * i, output[i].getNumber()); + Assertions.assertEquals(13 * i, output[i].getNumber()); } } @@ -286,7 +286,7 @@ public void testComputer14ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(14 * i, output[i].getNumber()); + Assertions.assertEquals(14 * i, output[i].getNumber()); } } @@ -300,7 +300,7 @@ public void testComputer15ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(15 * i, output[i].getNumber()); + Assertions.assertEquals(15 * i, output[i].getNumber()); } } @@ -314,7 +314,7 @@ public void testComputer16ToArrays() { ops.op("test.liftArrayC").input(input, input, input, input, input, input, input, input, input, input, input, input, input, input, input, input).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals(16 * i, output[i].getNumber()); + Assertions.assertEquals(16 * i, output[i].getNumber()); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/ComputerToIterablesTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/ComputerToIterablesTest.java index a2942cbc1..44d3d90c4 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/ComputerToIterablesTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/ComputerToIterablesTest.java @@ -34,13 +34,13 @@ package org.scijava.ops.engine.adapt.lift; -import static org.junit.Assert.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; import java.util.Arrays; import java.util.List; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.OpBuilderTestOps; @@ -53,7 +53,7 @@ */ public class ComputerToIterablesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new ComputerToIterables()); ops.register(new OpBuilderTestOps()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/FunctionToArraysTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/FunctionToArraysTest.java index a914db6d2..4d0fe5b5b 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/FunctionToArraysTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/FunctionToArraysTest.java @@ -37,9 +37,9 @@ import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Functions; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.spi.OpCollection; @@ -54,7 +54,7 @@ */ public class FunctionToArraysTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new FunctionToArraysTest()); ops.register(new FunctionToArrays()); @@ -91,7 +91,7 @@ public void testFunction1ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(1 * i, output[i].getNumber()); + Assertions.assertEquals(1 * i, output[i].getNumber()); } } @@ -110,7 +110,7 @@ public void testFunction2ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(2 * i, output[i].getNumber()); + Assertions.assertEquals(2 * i, output[i].getNumber()); } } @@ -129,7 +129,7 @@ public void testFunction3ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(3 * i, output[i].getNumber()); + Assertions.assertEquals(3 * i, output[i].getNumber()); } } @@ -148,7 +148,7 @@ public void testFunction4ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(4 * i, output[i].getNumber()); + Assertions.assertEquals(4 * i, output[i].getNumber()); } } @@ -167,7 +167,7 @@ public void testFunction5ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(5 * i, output[i].getNumber()); + Assertions.assertEquals(5 * i, output[i].getNumber()); } } @@ -186,7 +186,7 @@ public void testFunction6ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(6 * i, output[i].getNumber()); + Assertions.assertEquals(6 * i, output[i].getNumber()); } } @@ -205,7 +205,7 @@ public void testFunction7ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(7 * i, output[i].getNumber()); + Assertions.assertEquals(7 * i, output[i].getNumber()); } } @@ -224,7 +224,7 @@ public void testFunction8ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(8 * i, output[i].getNumber()); + Assertions.assertEquals(8 * i, output[i].getNumber()); } } @@ -243,7 +243,7 @@ public void testFunction9ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(9 * i, output[i].getNumber()); + Assertions.assertEquals(9 * i, output[i].getNumber()); } } @@ -262,7 +262,7 @@ public void testFunction10ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(10 * i, output[i].getNumber()); + Assertions.assertEquals(10 * i, output[i].getNumber()); } } @@ -281,7 +281,7 @@ public void testFunction11ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(11 * i, output[i].getNumber()); + Assertions.assertEquals(11 * i, output[i].getNumber()); } } @@ -300,7 +300,7 @@ public void testFunction12ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(12 * i, output[i].getNumber()); + Assertions.assertEquals(12 * i, output[i].getNumber()); } } @@ -319,7 +319,7 @@ public void testFunction13ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(13 * i, output[i].getNumber()); + Assertions.assertEquals(13 * i, output[i].getNumber()); } } @@ -338,7 +338,7 @@ public void testFunction14ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(14 * i, output[i].getNumber()); + Assertions.assertEquals(14 * i, output[i].getNumber()); } } @@ -357,7 +357,7 @@ public void testFunction15ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(15 * i, output[i].getNumber()); + Assertions.assertEquals(15 * i, output[i].getNumber()); } } @@ -376,7 +376,7 @@ public void testFunction16ToArrays() { {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals(16 * i, output[i].getNumber()); + Assertions.assertEquals(16 * i, output[i].getNumber()); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/FunctionToIterablesTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/FunctionToIterablesTest.java index 8eca4f4d9..6bc6d41b3 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/FunctionToIterablesTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/FunctionToIterablesTest.java @@ -37,8 +37,8 @@ import java.util.Arrays; import java.util.List; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Functions; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.OpBuilderTestOps; @@ -52,7 +52,7 @@ */ public class FunctionToIterablesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new FunctionToIterables()); ops.register(new OpBuilderTestOps()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/InplaceToArraysTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/InplaceToArraysTest.java index a8f4636f6..2bb122b91 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/InplaceToArraysTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/adapt/lift/InplaceToArraysTest.java @@ -34,9 +34,9 @@ package org.scijava.ops.engine.adapt.lift; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Inplaces; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.spi.OpCollection; @@ -50,7 +50,7 @@ */ public class InplaceToArraysTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new InplaceToArraysTest()); ops.register(new InplaceToArrays()); @@ -93,7 +93,7 @@ public void testInplace1ToArrays() { .mutate(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(1 * i, io[i].getNumber()); + Assertions.assertEquals(1 * i, io[i].getNumber()); } } @@ -114,7 +114,7 @@ public void testInplace2_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(2 * i, io[i].getNumber()); + Assertions.assertEquals(2 * i, io[i].getNumber()); } } @@ -135,7 +135,7 @@ public void testInplace2_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(2 * i, io[i].getNumber()); + Assertions.assertEquals(2 * i, io[i].getNumber()); } } @@ -157,7 +157,7 @@ public void testInplace3_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(3 * i, io[i].getNumber()); + Assertions.assertEquals(3 * i, io[i].getNumber()); } } @@ -179,7 +179,7 @@ public void testInplace3_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(3 * i, io[i].getNumber()); + Assertions.assertEquals(3 * i, io[i].getNumber()); } } @@ -201,7 +201,7 @@ public void testInplace3_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(3 * i, io[i].getNumber()); + Assertions.assertEquals(3 * i, io[i].getNumber()); } } @@ -224,7 +224,7 @@ public void testInplace4_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(4 * i, io[i].getNumber()); + Assertions.assertEquals(4 * i, io[i].getNumber()); } } @@ -247,7 +247,7 @@ public void testInplace4_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(4 * i, io[i].getNumber()); + Assertions.assertEquals(4 * i, io[i].getNumber()); } } @@ -270,7 +270,7 @@ public void testInplace4_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(4 * i, io[i].getNumber()); + Assertions.assertEquals(4 * i, io[i].getNumber()); } } @@ -293,7 +293,7 @@ public void testInplace4_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(4 * i, io[i].getNumber()); + Assertions.assertEquals(4 * i, io[i].getNumber()); } } @@ -317,7 +317,7 @@ public void testInplace5_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(5 * i, io[i].getNumber()); + Assertions.assertEquals(5 * i, io[i].getNumber()); } } @@ -341,7 +341,7 @@ public void testInplace5_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(5 * i, io[i].getNumber()); + Assertions.assertEquals(5 * i, io[i].getNumber()); } } @@ -365,7 +365,7 @@ public void testInplace5_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(5 * i, io[i].getNumber()); + Assertions.assertEquals(5 * i, io[i].getNumber()); } } @@ -389,7 +389,7 @@ public void testInplace5_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(5 * i, io[i].getNumber()); + Assertions.assertEquals(5 * i, io[i].getNumber()); } } @@ -413,7 +413,7 @@ public void testInplace5_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(5 * i, io[i].getNumber()); + Assertions.assertEquals(5 * i, io[i].getNumber()); } } @@ -438,7 +438,7 @@ public void testInplace6_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(6 * i, io[i].getNumber()); + Assertions.assertEquals(6 * i, io[i].getNumber()); } } @@ -463,7 +463,7 @@ public void testInplace6_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(6 * i, io[i].getNumber()); + Assertions.assertEquals(6 * i, io[i].getNumber()); } } @@ -488,7 +488,7 @@ public void testInplace6_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(6 * i, io[i].getNumber()); + Assertions.assertEquals(6 * i, io[i].getNumber()); } } @@ -513,7 +513,7 @@ public void testInplace6_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(6 * i, io[i].getNumber()); + Assertions.assertEquals(6 * i, io[i].getNumber()); } } @@ -538,7 +538,7 @@ public void testInplace6_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(6 * i, io[i].getNumber()); + Assertions.assertEquals(6 * i, io[i].getNumber()); } } @@ -563,7 +563,7 @@ public void testInplace6_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(6 * i, io[i].getNumber()); + Assertions.assertEquals(6 * i, io[i].getNumber()); } } @@ -589,7 +589,7 @@ public void testInplace7_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(7 * i, io[i].getNumber()); + Assertions.assertEquals(7 * i, io[i].getNumber()); } } @@ -615,7 +615,7 @@ public void testInplace7_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(7 * i, io[i].getNumber()); + Assertions.assertEquals(7 * i, io[i].getNumber()); } } @@ -641,7 +641,7 @@ public void testInplace7_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(7 * i, io[i].getNumber()); + Assertions.assertEquals(7 * i, io[i].getNumber()); } } @@ -667,7 +667,7 @@ public void testInplace7_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(7 * i, io[i].getNumber()); + Assertions.assertEquals(7 * i, io[i].getNumber()); } } @@ -693,7 +693,7 @@ public void testInplace7_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(7 * i, io[i].getNumber()); + Assertions.assertEquals(7 * i, io[i].getNumber()); } } @@ -719,7 +719,7 @@ public void testInplace7_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(7 * i, io[i].getNumber()); + Assertions.assertEquals(7 * i, io[i].getNumber()); } } @@ -745,7 +745,7 @@ public void testInplace7_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(7 * i, io[i].getNumber()); + Assertions.assertEquals(7 * i, io[i].getNumber()); } } @@ -772,7 +772,7 @@ public void testInplace8_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(8 * i, io[i].getNumber()); + Assertions.assertEquals(8 * i, io[i].getNumber()); } } @@ -799,7 +799,7 @@ public void testInplace8_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(8 * i, io[i].getNumber()); + Assertions.assertEquals(8 * i, io[i].getNumber()); } } @@ -826,7 +826,7 @@ public void testInplace8_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(8 * i, io[i].getNumber()); + Assertions.assertEquals(8 * i, io[i].getNumber()); } } @@ -853,7 +853,7 @@ public void testInplace8_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(8 * i, io[i].getNumber()); + Assertions.assertEquals(8 * i, io[i].getNumber()); } } @@ -880,7 +880,7 @@ public void testInplace8_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(8 * i, io[i].getNumber()); + Assertions.assertEquals(8 * i, io[i].getNumber()); } } @@ -907,7 +907,7 @@ public void testInplace8_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(8 * i, io[i].getNumber()); + Assertions.assertEquals(8 * i, io[i].getNumber()); } } @@ -934,7 +934,7 @@ public void testInplace8_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(8 * i, io[i].getNumber()); + Assertions.assertEquals(8 * i, io[i].getNumber()); } } @@ -961,7 +961,7 @@ public void testInplace8_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(8 * i, io[i].getNumber()); + Assertions.assertEquals(8 * i, io[i].getNumber()); } } @@ -989,7 +989,7 @@ public void testInplace9_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1017,7 +1017,7 @@ public void testInplace9_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1045,7 +1045,7 @@ public void testInplace9_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1073,7 +1073,7 @@ public void testInplace9_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1101,7 +1101,7 @@ public void testInplace9_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1129,7 +1129,7 @@ public void testInplace9_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1157,7 +1157,7 @@ public void testInplace9_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1185,7 +1185,7 @@ public void testInplace9_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1213,7 +1213,7 @@ public void testInplace9_9ToArrays() { .mutate9(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(9 * i, io[i].getNumber()); + Assertions.assertEquals(9 * i, io[i].getNumber()); } } @@ -1242,7 +1242,7 @@ public void testInplace10_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1271,7 +1271,7 @@ public void testInplace10_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1300,7 +1300,7 @@ public void testInplace10_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1329,7 +1329,7 @@ public void testInplace10_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1358,7 +1358,7 @@ public void testInplace10_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1387,7 +1387,7 @@ public void testInplace10_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1416,7 +1416,7 @@ public void testInplace10_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1445,7 +1445,7 @@ public void testInplace10_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1474,7 +1474,7 @@ public void testInplace10_9ToArrays() { .mutate9(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1503,7 +1503,7 @@ public void testInplace10_10ToArrays() { .mutate10(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(10 * i, io[i].getNumber()); + Assertions.assertEquals(10 * i, io[i].getNumber()); } } @@ -1533,7 +1533,7 @@ public void testInplace11_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1563,7 +1563,7 @@ public void testInplace11_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1593,7 +1593,7 @@ public void testInplace11_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1623,7 +1623,7 @@ public void testInplace11_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1653,7 +1653,7 @@ public void testInplace11_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1683,7 +1683,7 @@ public void testInplace11_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1713,7 +1713,7 @@ public void testInplace11_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1743,7 +1743,7 @@ public void testInplace11_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1773,7 +1773,7 @@ public void testInplace11_9ToArrays() { .mutate9(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1803,7 +1803,7 @@ public void testInplace11_10ToArrays() { .mutate10(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1833,7 +1833,7 @@ public void testInplace11_11ToArrays() { .mutate11(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(11 * i, io[i].getNumber()); + Assertions.assertEquals(11 * i, io[i].getNumber()); } } @@ -1864,7 +1864,7 @@ public void testInplace12_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -1895,7 +1895,7 @@ public void testInplace12_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -1926,7 +1926,7 @@ public void testInplace12_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -1957,7 +1957,7 @@ public void testInplace12_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -1988,7 +1988,7 @@ public void testInplace12_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -2019,7 +2019,7 @@ public void testInplace12_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -2050,7 +2050,7 @@ public void testInplace12_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -2081,7 +2081,7 @@ public void testInplace12_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -2112,7 +2112,7 @@ public void testInplace12_9ToArrays() { .mutate9(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -2143,7 +2143,7 @@ public void testInplace12_10ToArrays() { .mutate10(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -2174,7 +2174,7 @@ public void testInplace12_11ToArrays() { .mutate11(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -2205,7 +2205,7 @@ public void testInplace12_12ToArrays() { .mutate12(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(12 * i, io[i].getNumber()); + Assertions.assertEquals(12 * i, io[i].getNumber()); } } @@ -2237,7 +2237,7 @@ public void testInplace13_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2269,7 +2269,7 @@ public void testInplace13_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2301,7 +2301,7 @@ public void testInplace13_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2333,7 +2333,7 @@ public void testInplace13_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2365,7 +2365,7 @@ public void testInplace13_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2397,7 +2397,7 @@ public void testInplace13_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2429,7 +2429,7 @@ public void testInplace13_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2461,7 +2461,7 @@ public void testInplace13_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2493,7 +2493,7 @@ public void testInplace13_9ToArrays() { .mutate9(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2525,7 +2525,7 @@ public void testInplace13_10ToArrays() { .mutate10(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2557,7 +2557,7 @@ public void testInplace13_11ToArrays() { .mutate11(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2589,7 +2589,7 @@ public void testInplace13_12ToArrays() { .mutate12(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2621,7 +2621,7 @@ public void testInplace13_13ToArrays() { .mutate13(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(13 * i, io[i].getNumber()); + Assertions.assertEquals(13 * i, io[i].getNumber()); } } @@ -2654,7 +2654,7 @@ public void testInplace14_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2687,7 +2687,7 @@ public void testInplace14_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2720,7 +2720,7 @@ public void testInplace14_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2753,7 +2753,7 @@ public void testInplace14_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2786,7 +2786,7 @@ public void testInplace14_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2819,7 +2819,7 @@ public void testInplace14_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2852,7 +2852,7 @@ public void testInplace14_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2885,7 +2885,7 @@ public void testInplace14_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2918,7 +2918,7 @@ public void testInplace14_9ToArrays() { .mutate9(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2951,7 +2951,7 @@ public void testInplace14_10ToArrays() { .mutate10(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -2984,7 +2984,7 @@ public void testInplace14_11ToArrays() { .mutate11(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -3017,7 +3017,7 @@ public void testInplace14_12ToArrays() { .mutate12(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -3050,7 +3050,7 @@ public void testInplace14_13ToArrays() { .mutate13(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -3083,7 +3083,7 @@ public void testInplace14_14ToArrays() { .mutate14(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(14 * i, io[i].getNumber()); + Assertions.assertEquals(14 * i, io[i].getNumber()); } } @@ -3117,7 +3117,7 @@ public void testInplace15_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3151,7 +3151,7 @@ public void testInplace15_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3185,7 +3185,7 @@ public void testInplace15_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3219,7 +3219,7 @@ public void testInplace15_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3253,7 +3253,7 @@ public void testInplace15_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3287,7 +3287,7 @@ public void testInplace15_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3321,7 +3321,7 @@ public void testInplace15_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3355,7 +3355,7 @@ public void testInplace15_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3389,7 +3389,7 @@ public void testInplace15_9ToArrays() { .mutate9(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3423,7 +3423,7 @@ public void testInplace15_10ToArrays() { .mutate10(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3457,7 +3457,7 @@ public void testInplace15_11ToArrays() { .mutate11(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3491,7 +3491,7 @@ public void testInplace15_12ToArrays() { .mutate12(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3525,7 +3525,7 @@ public void testInplace15_13ToArrays() { .mutate13(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3559,7 +3559,7 @@ public void testInplace15_14ToArrays() { .mutate14(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3593,7 +3593,7 @@ public void testInplace15_15ToArrays() { .mutate15(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(15 * i, io[i].getNumber()); + Assertions.assertEquals(15 * i, io[i].getNumber()); } } @@ -3628,7 +3628,7 @@ public void testInplace16_1ToArrays() { .mutate1(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3663,7 +3663,7 @@ public void testInplace16_2ToArrays() { .mutate2(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3698,7 +3698,7 @@ public void testInplace16_3ToArrays() { .mutate3(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3733,7 +3733,7 @@ public void testInplace16_4ToArrays() { .mutate4(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3768,7 +3768,7 @@ public void testInplace16_5ToArrays() { .mutate5(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3803,7 +3803,7 @@ public void testInplace16_6ToArrays() { .mutate6(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3838,7 +3838,7 @@ public void testInplace16_7ToArrays() { .mutate7(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3873,7 +3873,7 @@ public void testInplace16_8ToArrays() { .mutate8(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3908,7 +3908,7 @@ public void testInplace16_9ToArrays() { .mutate9(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3943,7 +3943,7 @@ public void testInplace16_10ToArrays() { .mutate10(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -3978,7 +3978,7 @@ public void testInplace16_11ToArrays() { .mutate11(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -4013,7 +4013,7 @@ public void testInplace16_12ToArrays() { .mutate12(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -4048,7 +4048,7 @@ public void testInplace16_13ToArrays() { .mutate13(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -4083,7 +4083,7 @@ public void testInplace16_14ToArrays() { .mutate14(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -4118,7 +4118,7 @@ public void testInplace16_15ToArrays() { .mutate15(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } @@ -4153,7 +4153,7 @@ public void testInplace16_16ToArrays() { .mutate16(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals(16 * i, io[i].getNumber()); + Assertions.assertEquals(16 * i, io[i].getNumber()); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/copy/CopyOpCollectionTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/copy/CopyOpCollectionTest.java index e696e2c38..93f6e0e38 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/copy/CopyOpCollectionTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/copy/CopyOpCollectionTest.java @@ -29,14 +29,14 @@ package org.scijava.ops.engine.copy; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; public class CopyOpCollectionTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new CopyOpCollection()); } @@ -47,7 +47,7 @@ public void testCopyOp() { double[] output = {4, 5, 6}; ops.op("cp").input(input).output(output).compute(); - Assert.assertArrayEquals(input, output, 0.); + Assertions.assertArrayEquals(input, output, 0.); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/hints/AdaptationHintTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/hints/AdaptationHintTest.java index 0638df466..fe19232ba 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/hints/AdaptationHintTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/hints/AdaptationHintTest.java @@ -2,8 +2,8 @@ import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.api.Hints; import org.scijava.ops.api.OpHints; @@ -18,7 +18,7 @@ public class AdaptationHintTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new AdaptationHintTest()); ops.register(new FunctionsToComputers.Function1ToComputer1()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/hints/SimplificationHintTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/hints/SimplificationHintTest.java index cce216e7d..63790019d 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/hints/SimplificationHintTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/hints/SimplificationHintTest.java @@ -4,8 +4,8 @@ import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.Hints; import org.scijava.ops.api.OpHints; import org.scijava.ops.api.features.BaseOpHints.Simplification; @@ -20,7 +20,7 @@ public class SimplificationHintTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new SimplificationHintTest()); ops.register(new IdentityLossReporter()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/LambdaTypeBakerTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/LambdaTypeBakerTest.java index bbf997cb9..a8f8d787a 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/LambdaTypeBakerTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/LambdaTypeBakerTest.java @@ -2,9 +2,10 @@ import java.lang.reflect.Type; import java.util.function.Function; +import java.util.function.Supplier; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.scijava.types.GenericTyped; import org.scijava.types.Nil; @@ -13,17 +14,16 @@ public class LambdaTypeBakerTest { @Test public void testBakeType() { Function func = (in) -> in * 2; - Type funcType = new Nil>() {}.getType(); + Type funcType = new Nil>() { + }.getType(); - Function wrappedFunction = LambdaTypeBaker.bakeLambdaType(func, - funcType); + Function wrappedFunction = LambdaTypeBaker.bakeLambdaType(func, funcType); - Assert.assertTrue("wrappedFunction should be a GenericTyped but is not!", - wrappedFunction instanceof GenericTyped); + Assertions.assertTrue(wrappedFunction instanceof GenericTyped, + "wrappedFunction should be a GenericTyped but is not!"); Type type = ((GenericTyped) wrappedFunction).getType(); - Assert.assertEquals("wrappedFunction type " + type + - "is not equivalent to the provided type " + funcType + "!", funcType, - type); + Assertions.assertEquals(funcType, type, + "wrappedFunction type " + type + "is not equivalent to the provided type " + funcType + "!"); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/OpCachingTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/OpCachingTest.java index 777af2f8f..e7d6f0be7 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/OpCachingTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/OpCachingTest.java @@ -29,16 +29,16 @@ package org.scijava.ops.engine.impl; -import static org.junit.Assert.fail; +import static org.junit.jupiter.api.Assertions.fail; import java.lang.reflect.Field; import java.util.Map; import java.util.Optional; import java.util.ServiceLoader; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.scijava.discovery.Discoverer; import org.scijava.discovery.ManualDiscoverer; import org.scijava.function.Producer; @@ -47,11 +47,7 @@ import org.scijava.ops.api.*; import org.scijava.ops.api.features.MatchingConditions; import org.scijava.ops.api.features.MatchingRoutine; -import org.scijava.ops.spi.Op; -import org.scijava.ops.spi.OpClass; -import org.scijava.ops.spi.OpCollection; -import org.scijava.ops.spi.OpDependency; -import org.scijava.ops.spi.OpField; +import org.scijava.ops.spi.*; import org.scijava.types.DefaultTypeReifier; import org.scijava.types.Nil; import org.scijava.types.TypeReifier; @@ -60,7 +56,7 @@ public class OpCachingTest implements OpCollection { private OpEnvironment ops; - @Before + @BeforeEach public void setUp() { Logger logger = new StderrLoggerFactory().create(); TypeReifier types = new DefaultTypeReifier(logger, Discoverer.using( @@ -122,10 +118,9 @@ public void cacheOp() throws SecurityException, IllegalArgumentException, // assert there is exactly one Op in the cache OpInstance cachedInstance = opCache.values().iterator().next(); - Assert.assertEquals(opCache.size(), 1, 0); - Assert.assertEquals( - "Object in cache was not the same Object that was returned!", basicOp, - cachedInstance.op()); + Assertions.assertEquals(opCache.size(), 1, 0); + Assertions.assertEquals(basicOp, cachedInstance.op(), + "Object in cache was not the same Object that was returned!"); // assert that the same call to the matcher returns our Object MatchingConditions cachedConditions = opCache.keySet().iterator().next(); @@ -138,9 +133,8 @@ public void cacheOp() throws SecurityException, IllegalArgumentException, Producer invadedOp = defOpEnv.op("test.basicOp").input().outType( String.class).producer(); - Assert.assertEquals( - "Op returned did not match the Op inserted into the cache!", invadedOp - .create(), newProducer.create()); + Assertions.assertEquals(newProducer.create(), invadedOp.create(), + "Op returned did not match the Op inserted into the cache!"); } @Test @@ -155,27 +149,26 @@ public void cacheOpAndDependencies() throws NoSuchFieldException, Map> opCache = getOpCache(defOpEnv); // assert there are exactly two Ops in the cache - Assert.assertEquals(opCache.size(), 2, 0); + Assertions.assertEquals(opCache.size(), 2, 0); // assert that complicatedOp is in the cache ( Optional complicatedOptional = opCache.keySet().stream() .filter(condition -> condition.ref().getName().equals( "test.complicatedOp")).findFirst(); - Assert.assertFalse("test.complicatedOp not in cache!", complicatedOptional - .isEmpty()); - Assert.assertTrue("Object in cache was not an instance of ComplicatedOp!", - opCache.get(complicatedOptional.get()).op() instanceof ComplicatedOp); + Assertions.assertFalse(complicatedOptional + .isEmpty(), "test.complicatedOp not in cache!"); + Assertions.assertTrue( + opCache.get(complicatedOptional.get()).op() instanceof ComplicatedOp, + "Object in cache was not an instance of ComplicatedOp!"); // assert that basic Op is also in the cache Optional basicOptional = opCache.keySet().stream() .filter(condition -> condition.ref().getName().equals("test.basicOp")) .findFirst(); - Assert.assertFalse( - "test.basicOp not in cache despite being an OpDependency of test.complicatedOp", - basicOptional.isEmpty()); - Assert.assertEquals( - "Object in cache was not the same Object that was returned!", opCache.get( - basicOptional.get()).op(), basicOp); + Assertions.assertFalse(basicOptional.isEmpty(), + "test.basicOp not in cache despite being an OpDependency of test.complicatedOp"); + Assertions.assertEquals(opCache.get(basicOptional.get()).op(), basicOp, + "Object in cache was not the same Object that was returned!"); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/ProvenanceTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/ProvenanceTest.java index eb2e2e72d..8d9d47e31 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/ProvenanceTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/ProvenanceTest.java @@ -8,9 +8,9 @@ import java.util.List; import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.Priority; import org.scijava.function.Computers; import org.scijava.function.Producer; @@ -32,7 +32,7 @@ public class ProvenanceTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new ProvenanceTest()); ops.register(new FunctionToArrays()); @@ -52,13 +52,13 @@ public static void AddNeededOps() { public void testProvenance() { String s = ops.op("test.provenance").input().outType(String.class).create(); List> executionsUpon = history.executionsUpon(s); - Assert.assertEquals(1, executionsUpon.size()); + Assertions.assertEquals(1, executionsUpon.size()); // Assert only one info in the execution hierarchy InfoChain executionHierarchy = history.opExecutionChain(executionsUpon .get(0)); - Assert.assertEquals(0, executionHierarchy.dependencies().size()); + Assertions.assertEquals(0, executionHierarchy.dependencies().size()); OpInfo info = executionHierarchy.info(); - Assert.assertTrue(info.implementationName().contains(this.getClass() + Assertions.assertTrue(info.implementationName().contains(this.getClass() .getPackageName())); } @@ -94,21 +94,21 @@ public void testPriorityProvenance() { List> history1 = history.executionsUpon(out1); List> history2 = history.executionsUpon(out2); - Assert.assertEquals(1, history1.size()); + Assertions.assertEquals(1, history1.size()); InfoChain opExecutionChain = history.opExecutionChain(history1.get( 0)); - Assert.assertEquals(0, opExecutionChain.dependencies().size()); + Assertions.assertEquals(0, opExecutionChain.dependencies().size()); String expected = "public final java.util.function.Function org.scijava.ops.engine.impl.ProvenanceTest.baz"; - Assert.assertEquals(expected, opExecutionChain.info().getAnnotationBearer() + Assertions.assertEquals(expected, opExecutionChain.info().getAnnotationBearer() .toString()); - Assert.assertEquals(1, history2.size()); + Assertions.assertEquals(1, history2.size()); opExecutionChain = history.opExecutionChain(history2.get(0)); - Assert.assertEquals(0, opExecutionChain.dependencies().size()); + Assertions.assertEquals(0, opExecutionChain.dependencies().size()); expected = "public final java.util.function.Function org.scijava.ops.engine.impl.ProvenanceTest.bar"; - Assert.assertEquals(expected, opExecutionChain.info().getAnnotationBearer() + Assertions.assertEquals(expected, opExecutionChain.info().getAnnotationBearer() .toString()); } @@ -152,7 +152,7 @@ public void testMappingProvenance() { // Assert two executions upon this Object, once from the mapped function, once from the mapper List> executionsUpon = history.executionsUpon(out); - Assert.assertEquals(2, executionsUpon.size()); + Assertions.assertEquals(2, executionsUpon.size()); } @Test @@ -171,15 +171,14 @@ public void testMappingExecutionChain() { Iterator mapperInfos = ops.infos("test.provenanceMapper") .iterator(); OpInfo mapperInfo = mapperInfos.next(); - Assert.assertTrue(executionChain.info().equals(mapperInfo)); + Assertions.assertTrue(executionChain.info().equals(mapperInfo)); // Assert mapped is in the execution chain Iterator mappedInfos = ops.infos("test.provenanceMapped") .iterator(); OpInfo mappedInfo = mappedInfos.next(); - Assert.assertEquals("Expected only one dependency of the mapper Op!", 1, - executionChain.dependencies().size()); - Assert.assertTrue(executionChain.dependencies().get(0).info().equals( - mappedInfo)); + Assertions.assertEquals(1, executionChain.dependencies().size(), + "Expected only one dependency of the mapper Op!"); + Assertions.assertTrue(executionChain.dependencies().get(0).info().equals(mappedInfo)); } @Test @@ -194,16 +193,16 @@ public void testMappingProvenanceAndCaching() { // Assert that two Ops operated on the return. List> mutators = history.executionsUpon(out); - Assert.assertEquals(2, mutators.size()); + Assertions.assertEquals(2, mutators.size()); // Run the mapped Op, assert still two runs on the mapper Thing out1 = ops.op("test.provenanceMapped").input(2.).outType(Thing.class) .apply(hints); mutators = history.executionsUpon(out); - Assert.assertEquals(2, mutators.size()); + Assertions.assertEquals(2, mutators.size()); // Assert one run on the mapped Op as well mutators = history.executionsUpon(out1); - Assert.assertEquals(1, mutators.size()); + Assertions.assertEquals(1, mutators.size()); } @@ -213,7 +212,7 @@ public void testDependencylessOpRecoveryFromString() { Function mapper = ops.op("test.provenanceMapped").input(5.0) .outType(Thing.class).function(hints); InfoChain chain = history.opExecutionChain(mapper); - Assert.assertEquals(0, chain.dependencies().size()); + Assertions.assertEquals(0, chain.dependencies().size()); String signature = chain.signature(); Nil> special = new Nil<>() {}; @SuppressWarnings("unused") @@ -271,7 +270,7 @@ public void testSimplificationRecovery() { Integer[] actual = { 0, 0, 0 }; fromString.compute(in, actual); Integer[] expected = { 1, 2, 3 }; - Assert.assertArrayEquals(expected, actual); + Assertions.assertArrayEquals(expected, actual); } @Test @@ -285,14 +284,14 @@ public void testSimplificationAdaptationRecovery() { Integer[] in = { 1, 2, 3 }; Integer[] actual = fromString.apply(in); Integer[] expected = { 1, 2, 3 }; - Assert.assertArrayEquals(expected, actual); + Assertions.assertArrayEquals(expected, actual); } private OpInfo singularInfoOfName(String name) { Iterator infos = ops.infos(name).iterator(); - Assert.assertTrue(infos.hasNext()); + Assertions.assertTrue(infos.hasNext()); OpInfo info = infos.next(); - Assert.assertFalse(infos.hasNext()); + Assertions.assertFalse(infos.hasNext()); return info; } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/TherapiBasedOpTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/TherapiBasedOpTest.java index 2c7e0e1e3..a4418fcb3 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/TherapiBasedOpTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/impl/TherapiBasedOpTest.java @@ -2,10 +2,10 @@ import java.util.ServiceLoader; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.discovery.Discoverer; import org.scijava.discovery.therapi.TherapiDiscoverer; import org.scijava.function.Producer; @@ -28,7 +28,7 @@ public class TherapiBasedOpTest { protected static TypeReifier types; protected static Parser parser; - @BeforeClass + @BeforeAll public static void setUp() { logger = new StderrLoggerFactory().create(); types = new DefaultTypeReifier(logger, Discoverer.using( @@ -39,7 +39,7 @@ public static void setUp() { ops.registerInfosFrom(new TherapiOpClass()); } - @AfterClass + @AfterAll public static void tearDown() { ops = null; logger = null; @@ -73,21 +73,21 @@ protected static OpEnvironment barebonesEnvironment() public void therapiOpFieldTest() throws NoSuchFieldException { String actual = ops.op("test.therapiOpField").input().outType(String.class).create(); String expected = FIELD_STRING; - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); } @Test public void therapiOpClassTest() { String actual = ops.op("test.therapiOpClass").input().outType(String.class).create(); String expected = CLASS_STRING; - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); } @Test public void therapiOpMethodTest() { String actual = ops.op("test.therapiOpMethod").input().outType(String.class).create(); String expected = METHOD_STRING; - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); } /** @@ -116,7 +116,7 @@ public static String therapiMethod() { public void therapiOpFieldPriorityTest() { String actual = ops.op("test.therapiPriority").input().outType(String.class).create(); String expected = HIGH_PRIORITY_STRING; - Assert.assertEquals(expected, actual); + Assertions.assertEquals(expected, actual); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/DefaultMatchingErrorTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/DefaultMatchingErrorTest.java index a634b8434..f86a38617 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/DefaultMatchingErrorTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/DefaultMatchingErrorTest.java @@ -4,9 +4,9 @@ import java.util.Arrays; import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.api.features.DependencyMatchingException; import org.scijava.ops.api.features.OpMatchingException; @@ -21,7 +21,7 @@ public class DefaultMatchingErrorTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new DefaultMatchingErrorTest()); ops.register(new DependentOp()); @@ -48,12 +48,12 @@ public void duplicateErrorRegressionTest() { try { ops.op("test.duplicateOp").inType(Double.class).outType(Double.class) .function(); - Assert.fail(); + Assertions.fail(); } catch (OpMatchingException e) { - Assert.assertTrue(e.getMessage().startsWith( + Assertions.assertTrue(e.getMessage().startsWith( "No MatchingRoutine was able to produce a match!")); - Assert.assertTrue(Arrays.stream(e.getSuppressed()).anyMatch(s -> s + Assertions.assertTrue(Arrays.stream(e.getSuppressed()).anyMatch(s -> s .getMessage().startsWith("Multiple 'test.duplicateOp/" + "java.util.function.Function' " + "ops of priority 0.0:"))); @@ -68,11 +68,11 @@ public void missingDependencyRegressionTest() { try { ops.op("test.missingDependencyOp").input(1.).outType(Double.class) .apply(); - Assert.fail("Expected DependencyMatchingException"); + Assertions.fail("Expected DependencyMatchingException"); } catch (DependencyMatchingException e) { String message = e.getMessage(); - Assert.assertTrue(message.contains("Name: \"test.nonexistingOp\"")); + Assertions.assertTrue(message.contains("Name: \"test.nonexistingOp\"")); } } @@ -84,12 +84,12 @@ public void missingDependencyRegressionTest() { public void missingNestedDependencyRegressionTest() { try { ops.op("test.outsideOp").input(1.).outType(Double.class).apply(); - Assert.fail("Expected DependencyMatchingException"); + Assertions.fail("Expected DependencyMatchingException"); } catch (DependencyMatchingException e) { String message = e.getMessage(); - Assert.assertTrue(message.contains("Name: \"test.missingDependencyOp\"")); - Assert.assertTrue(message.contains("Name: \"test.nonexistingOp\"")); + Assertions.assertTrue(message.contains("Name: \"test.missingDependencyOp\"")); + Assertions.assertTrue(message.contains("Name: \"test.nonexistingOp\"")); } } @@ -102,12 +102,12 @@ public void missingDependencyViaAdaptationTest() { Double[] d = new Double[0]; try { ops.op("test.adaptMissingDep").input(d).outType(Double[].class).apply(); - Assert.fail("Expected DependencyMatchingException"); + Assertions.fail("Expected DependencyMatchingException"); } catch (DependencyMatchingException e) { String message = e.getMessage(); - Assert.assertTrue(message.contains("Adaptor:")); - Assert.assertTrue(message.contains("Name: \"test.nonexistingOp\"")); + Assertions.assertTrue(message.contains("Adaptor:")); + Assertions.assertTrue(message.contains("Name: \"test.nonexistingOp\"")); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingUtilsTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingUtilsTest.java index c0ba5dbfe..a9ee08e23 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingUtilsTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingUtilsTest.java @@ -29,7 +29,8 @@ package org.scijava.ops.engine.matcher; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; @@ -41,8 +42,8 @@ import java.util.function.Function; import java.util.function.Supplier; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.matcher.impl.MatchingUtils; import org.scijava.types.Nil; import org.scijava.types.Types; @@ -59,13 +60,14 @@ private void assertAll(Class from, boolean condition, Nil... tos) { private void assertAll(Class from, boolean condition, Type... tos) { for (Type to : tos) { if (to instanceof ParameterizedType) { - assertTrue(GenericAssignability.checkGenericAssignability(from, (ParameterizedType) to, false) == condition); + assertTrue(GenericAssignability.checkGenericAssignability(from, (ParameterizedType) to, + false) == condition); } else { assertTrue(Types.isAssignable(from, to, new HashMap, Type>()) == condition); } } } - + @Test public void genericAssignabilityVarToVar() { abstract class Single implements Supplier { @@ -81,7 +83,7 @@ abstract class SingleBounded implements Supplier { assertAll(Single.class, true, y1, y2); assertAll(Single.class, false, n1); - + assertAll(SingleBounded.class, true, y2); assertAll(SingleBounded.class, false, y1, n1); } @@ -276,9 +278,10 @@ abstract class SingleVarBoundedNestedWildcardMultipleOccurenceUsedNested implements Function> {} - + + abstract class SingleVarMultipleOccurenceUsedNested implements Function> { + } + Nil>> n6 = new Nil<>() { }; assertAll(SingleVarMultipleOccurenceUsedNested.class, false, n6); @@ -342,7 +345,7 @@ abstract class IBoundedByN> implements B }; Nil, Integer>> n5 = new Nil<>() { }; - + assertAll(BExtendsI.class, true, y1, y2, y3); assertAll(BExtendsI.class, false, n1, n2, n3, n4, n5); @@ -371,7 +374,7 @@ abstract class IBoundedByNImplicitely> Nil, Iterable, List>> y1 = new Nil<>() { }; - + assertAll(IBoundedByNImplicitely.class, true, y1); } @@ -401,7 +404,7 @@ abstract class DoubleVarBoundedAndWildcard, List> { @@ -421,22 +424,25 @@ abstract class Wildcards implements Function, List implements - BiConsumer, T> - {} - - Nil, Number>> y1 = new Nil<>() {}; - Nil, Integer>> y2 = new Nil<>() {}; - Nil, ? extends Number>> y3 = new Nil<>() {}; + abstract class StrangeConsumer implements BiConsumer, T> { + } - Nil, Double>> n1 = new Nil<>() {}; + Nil, Number>> y1 = new Nil<>() { + }; + Nil, Integer>> y2 = new Nil<>() { + }; + Nil, ? extends Number>> y3 = new Nil<>() { + }; + + Nil, Double>> n1 = new Nil<>() { + }; assertAll(StrangeConsumer.class, true, y1, y2, y3); assertAll(StrangeConsumer.class, false, n1); - + } /** @@ -485,16 +491,20 @@ public Double apply(O[] t) { return null; } } - Nil> doubleFunction = new Nil<>() {}; + Nil> doubleFunction = new Nil<>() { + }; assertAll(Foo.class, true, doubleFunction); assertAll(Bar.class, false, doubleFunction); } @Test public void testGenericArrayToWildcardWithinParameterizedType() { - abstract class Foo implements List {} - final Nil> upperType = new Nil<>() {}; - final Nil> lowerType = new Nil<>() {}; + abstract class Foo implements List { + } + final Nil> upperType = new Nil<>() { + }; + final Nil> lowerType = new Nil<>() { + }; // Since it is legal to write // List list = new Foo<>() {...}; @@ -504,47 +514,58 @@ abstract class Foo implements List {} @Test public void testSuperWildcardToSuperWildcard() { - final Nil> listT = new Nil<>() {}; - final Nil> listWildcard = new Nil<>() {}; + final Nil> listT = new Nil<>() { + }; + final Nil> listWildcard = new Nil<>() { + }; // unfortunately we cannot use assertAll since it is impossible to create a // Class implementing List boolean success = GenericAssignability.checkGenericAssignability(listT.getType(), - (ParameterizedType) listWildcard.getType(), false); - Assert.assertTrue(success); + (ParameterizedType) listWildcard.getType(), false); + Assertions.assertTrue(success); } @Test public void testNonReifiableFunction() { Function fooFunc = (in) -> in; - final Nil> doubleFunc = new Nil<>() {}; - final Nil> integerFunc = new Nil<>() {}; - - boolean successDouble = GenericAssignability.checkGenericAssignability(fooFunc - .getClass(), (ParameterizedType) doubleFunc.getType(), false); - Assert.assertTrue(successDouble); - boolean successInteger = GenericAssignability.checkGenericAssignability(fooFunc - .getClass(), (ParameterizedType) integerFunc.getType(), false); - Assert.assertTrue(successInteger); + final Nil> doubleFunc = new Nil<>() { + }; + final Nil> integerFunc = new Nil<>() { + }; + + boolean successDouble = GenericAssignability.checkGenericAssignability(fooFunc.getClass(), + (ParameterizedType) doubleFunc.getType(), false); + Assertions.assertTrue(successDouble); + boolean successInteger = GenericAssignability.checkGenericAssignability(fooFunc.getClass(), + (ParameterizedType) integerFunc.getType(), false); + Assertions.assertTrue(successInteger); } - @Test(expected = NullPointerException.class) + @Test public void testIsAssignableNullToNull() { - GenericAssignability.checkGenericAssignability(null, null, false); + assertThrows(NullPointerException.class, + () -> GenericAssignability.checkGenericAssignability(null, null, false)); } - @Test(expected = NullPointerException.class) + @Test public void testIsAssignableClassToNull() { - GenericAssignability.checkGenericAssignability(Object.class, null, false); + assertThrows(NullPointerException.class, + () -> GenericAssignability.checkGenericAssignability(Object.class, null, false)); } @Test public void testIsAssignableT() { - final Nil t = new Nil<>() {}; - final Nil> listT = new Nil<>() {}; - final Nil> listNumber = new Nil<>() {}; - final Nil> listInteger = new Nil<>() {}; - final Nil> listExtendsNumber = new Nil<>() {}; + final Nil t = new Nil<>() { + }; + final Nil> listT = new Nil<>() { + }; + final Nil> listNumber = new Nil<>() { + }; + final Nil> listInteger = new Nil<>() { + }; + final Nil> listExtendsNumber = new Nil<>() { + }; assertAll(List.class, true, listT, listNumber, listInteger, listExtendsNumber); assertAll(List.class, false, t); @@ -552,23 +573,28 @@ public void testIsAssignableT() { @Test public void testIsAssignableOutputToObject() { - final Type fooSource = new Nil>>() {}.getType(); - final Type fooFunc = new Nil>() {}.getType(); + final Type fooSource = new Nil>>() { + }.getType(); + final Type fooFunc = new Nil>() { + }.getType(); - Assert.assertFalse(GenericAssignability.checkGenericAssignability(fooSource, - (ParameterizedType) fooFunc, false)); - Assert.assertTrue(GenericAssignability.checkGenericAssignability(fooSource, - (ParameterizedType) fooFunc, true)); + Assertions.assertFalse( + GenericAssignability.checkGenericAssignability(fooSource, (ParameterizedType) fooFunc, false)); + Assertions.assertTrue( + GenericAssignability.checkGenericAssignability(fooSource, (ParameterizedType) fooFunc, true)); + + } + + class Thing { + } + class StrangeThing extends Thing { } - class Thing {} - - class StrangeThing extends Thing {} - /** - * {@link MatchingUtils#checkGenericOutputsAssignability(Type[], Type[], HashMap)} not yet fully - * implemented. If this is done, all the tests below should not fail. + * {@link MatchingUtils#checkGenericOutputsAssignability(Type[], Type[], HashMap)} + * not yet fully implemented. If this is done, all the tests below should not + * fail. */ @Test public void testOutputAssignability() { diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingWithAnyTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingWithAnyTest.java index 57bec537f..ddbc029ea 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingWithAnyTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingWithAnyTest.java @@ -1,12 +1,13 @@ package org.scijava.ops.engine.matcher; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Producer; import org.scijava.ops.engine.AbstractTestEnvironment; @@ -22,7 +23,7 @@ */ public class MatchingWithAnyTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new MatchingWithAnyTest()); ops.register(new ComputersToFunctionsViaSource.Computer2ToFunction2ViaSource()); @@ -47,11 +48,13 @@ public void testAny() { * easily be avoided by making TypeExtractors for any class for which this kind * of exception can happen. */ - @Test(expected = ClassCastException.class) + @Test public void testExceptionalThing() { ExceptionalThing ething = new ExceptionalThing<>(0.5); - Double d = ops.op("test.exceptionalAny").input(ething).outType(Double.class).apply(); + assertThrows(ClassCastException.class, () -> { + Double d = ops.op("test.exceptionalAny").input(ething).outType(Double.class).apply(); + }); } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingWithGCSTTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingWithGCSTTest.java index f1396ce04..8c4421bcb 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingWithGCSTTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/MatchingWithGCSTTest.java @@ -1,13 +1,13 @@ package org.scijava.ops.engine.matcher; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.ArrayList; import java.util.List; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.spi.OpCollection; import org.scijava.ops.spi.OpField; @@ -21,7 +21,7 @@ */ public class MatchingWithGCSTTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new MatchingWithGCSTTest()); } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/OpWrappersTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/OpWrappersTest.java index b96b21df7..1ab9dcb1b 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/OpWrappersTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/matcher/OpWrappersTest.java @@ -5,13 +5,13 @@ package org.scijava.ops.engine.matcher; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Functions; import org.scijava.function.Inplaces; @@ -30,7 +30,7 @@ */ public class OpWrappersTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new OpBuilderTestOps()); } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/monitor/OpMonitorTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/monitor/OpMonitorTest.java index 4b2c1ace0..265d79a39 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/monitor/OpMonitorTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/monitor/OpMonitorTest.java @@ -8,15 +8,18 @@ import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.spi.Op; import org.scijava.ops.spi.OpClass; import org.scijava.types.Nil; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.fail; + /** * Tests correct functionality of {@link OpMonitor} * @@ -26,7 +29,7 @@ */ public class OpMonitorTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new InfiniteOp()); ops.register(new CountingOp()); @@ -35,7 +38,7 @@ public static void addNeededOps() { /** * Basic test of cancellation on the same thread */ - @Test(expected = CancellationException.class) + @Test public void testCancellation() { Function bigOp = OpBuilder.matchFunction(ops, "test.opMonitor", new Nil() {}, new Nil() {}); @@ -43,7 +46,7 @@ public void testCancellation() { monitor.cancel(); // NOTE: we have to cancel the op before we call it because the execution of // this Op and the test that call it are on the same thread. - bigOp.apply(monitor); + assertThrows(CancellationException.class, () -> bigOp.apply(monitor)); } /** @@ -52,7 +55,7 @@ public void testCancellation() { * @throws InterruptedException * - should not happen */ - @Test(expected = CancellationException.class) + @Test public void testCancellationDifferentThread() throws InterruptedException { Function bigOp = OpBuilder.matchFunction(ops, "test.opMonitor", new Nil() {}, new Nil() {}); @@ -61,10 +64,10 @@ public void testCancellationDifferentThread() throws InterruptedException { Future future = Executors.newSingleThreadExecutor().submit(() -> bigOp.apply(monitor)); monitor.cancel(); future.get(); + fail(); } catch (ExecutionException exc) { Throwable cancellationException = exc.getCause(); - Assert.assertTrue(cancellationException instanceof CancellationException); - throw (CancellationException) cancellationException; + Assertions.assertTrue(cancellationException instanceof CancellationException); } } @@ -83,8 +86,8 @@ public void testProgress() throws InterruptedException, ExecutionException{ progress = monitor.getProgress(); } BigInteger bi = future.get(); - Assert.assertTrue(bi.equals(target)); - Assert.assertEquals(monitor.getProgress(), 1, 0); + Assertions.assertTrue(bi.equals(target)); + Assertions.assertEquals(monitor.getProgress(), 1, 0); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/PrimitiveListSimplifierTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/PrimitiveListSimplifierTest.java index a28b892da..15775c9a9 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/PrimitiveListSimplifierTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/PrimitiveListSimplifierTest.java @@ -1,14 +1,14 @@ package org.scijava.ops.engine.simplify; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -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.assertTrue; import java.util.ArrayList; import java.util.LinkedList; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class PrimitiveListSimplifierTest { diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplificationAdaptationTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplificationAdaptationTest.java index 6e3ec9e97..5110d42c9 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplificationAdaptationTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplificationAdaptationTest.java @@ -1,8 +1,8 @@ package org.scijava.ops.engine.simplify; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.adapt.functional.ComputersToFunctionsViaFunction; @@ -14,7 +14,7 @@ public class SimplificationAdaptationTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new SimplificationAdaptationTest()); ops.register(new PrimitiveSimplifiers()); @@ -40,7 +40,7 @@ public void adaptAndSimplifyTest() { Double[] expected = { 1., 1., 0. }; Double[] actual = ops.op("test.math.modulus").input(inArr, modulus) .outType(Double[].class).apply(); - Assert.assertArrayEquals(expected, actual); + Assertions.assertArrayEquals(expected, actual); } } diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplificationPriorityTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplificationPriorityTest.java index 2aaa1fc1d..e27bbce45 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplificationPriorityTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplificationPriorityTest.java @@ -4,9 +4,9 @@ import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.OpHints; import org.scijava.ops.api.features.BaseOpHints.Simplification; import org.scijava.ops.engine.AbstractTestEnvironment; @@ -19,7 +19,7 @@ public class SimplificationPriorityTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new SimplificationPriorityTest()); ops.register(new IdentityLossReporter()); @@ -52,7 +52,7 @@ public void testSimplificationPriority() { Double output = ops.op("test.thing").input(thing1, thing2).outType( Double.class).apply(); - Assert.assertEquals(1., output, 0.); + Assertions.assertEquals(1., output, 0.); } @Test @@ -61,7 +61,7 @@ public void testMissingLossReporter() { Double output = ops.op("test.thing").input(thing1).outType( Double.class).apply(); - Assert.assertEquals(2., output, 0.); + Assertions.assertEquals(2., output, 0.); } @OpHints(hints = {Simplification.FORBIDDEN}) diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplifyIOTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplifyIOTest.java index 08f8620b7..0febab22b 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplifyIOTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplifyIOTest.java @@ -1,12 +1,12 @@ package org.scijava.ops.engine.simplify; -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Inplaces; import org.scijava.ops.engine.AbstractTestEnvironment; @@ -16,7 +16,7 @@ public class SimplifyIOTest extends AbstractTestEnvironment implements OpCollection{ - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new SimplifyIOTest()); ops.register(new PrimitiveSimplifiers()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplifyTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplifyTest.java index a696a4738..ca6cd60e8 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplifyTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/simplify/SimplifyTest.java @@ -1,12 +1,12 @@ package org.scijava.ops.engine.simplify; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.function.BiFunction; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.conversionLoss.impl.IdentityLossReporter; import org.scijava.ops.engine.conversionLoss.impl.LossReporterWrapper; @@ -24,7 +24,7 @@ */ public class SimplifyTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new SimplifyTest()); ops.register(new PrimitiveSimplifiers()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/stats/MeanTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/stats/MeanTest.java index 2062db895..b4e8bfc0c 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/stats/MeanTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/stats/MeanTest.java @@ -1,13 +1,13 @@ package org.scijava.ops.engine.stats; -import static org.junit.Assert.assertEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; import java.util.Arrays; import java.util.List; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.math.Add; @@ -16,7 +16,7 @@ public class MeanTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new Size.StatsSizeFunction(), new Size.StatsSizeFunctionDouble<>()); ops.register(new Mean.MeanFunction()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/AdaptersTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/AdaptersTest.java index 39f9faea8..7dba2d9b8 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/AdaptersTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/AdaptersTest.java @@ -31,8 +31,8 @@ import java.util.function.BiFunction; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.TestOps; @@ -40,7 +40,7 @@ public class AdaptersTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { Object[] objs = objsFromNoArgConstructors(TestOps.class.getDeclaredClasses()); ops.register(objs); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/ComputersTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/ComputersTest.java index 974d2470a..26b4c69d4 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/ComputersTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/ComputersTest.java @@ -29,8 +29,8 @@ package org.scijava.ops.engine.util; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.engine.AbstractTestEnvironment; @@ -40,7 +40,7 @@ public class ComputersTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new Sqrt()); ops.register(new Add()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/FunctionsTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/FunctionsTest.java index e312ff7ed..7afa4f2fa 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/FunctionsTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/FunctionsTest.java @@ -32,8 +32,8 @@ import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.math.Add; @@ -43,7 +43,7 @@ public class FunctionsTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new Sqrt()); ops.register(new Add()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/InplacesTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/InplacesTest.java index 0011cad07..9e3654d2a 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/InplacesTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/InplacesTest.java @@ -29,8 +29,8 @@ package org.scijava.ops.engine.util; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Inplaces; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.engine.AbstractTestEnvironment; @@ -40,7 +40,7 @@ public class InplacesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new Sqrt()); ops.register(new Add()); diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/LambdaizerTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/LambdaizerTest.java index fa3810582..be1876c4c 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/LambdaizerTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/LambdaizerTest.java @@ -6,7 +6,7 @@ import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Inplaces; diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/LiftTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/LiftTest.java index cebc0c852..b968a12b6 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/LiftTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/LiftTest.java @@ -36,9 +36,9 @@ import java.util.List; import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.engine.AbstractTestEnvironment; @@ -47,7 +47,7 @@ public class LiftTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { Object[] objects = objsFromNoArgConstructors(TestOps.class.getDeclaredClasses()); ops.register(objects); @@ -65,11 +65,11 @@ public void testliftFunction(){ Function, Iterable> liftedToIterable = Maps.FunctionMaps.Iterables.liftBoth(powFunction); Iterable res2 = liftedToIterable.apply(Arrays.asList(1.0, 2.0, 3.0, 4.0)); - Assert.assertTrue(arrayEquals(toArray(res2), 2.0, 3.0, 4.0, 5.0)); + Assertions.assertTrue(arrayEquals(toArray(res2), 2.0, 3.0, 4.0, 5.0)); Function liftedToArray = Maps.FunctionMaps.Arrays.liftBoth(powFunction, Double.class); Double[] res3 = liftedToArray.apply(new Double[] { 1.0, 2.0, 3.0, 4.0 }); - Assert.assertTrue(arrayEquals(Arrays.stream(res3).mapToDouble(d -> d).toArray(), 2.0, 3.0, 4.0, 5.0)); + Assertions.assertTrue(arrayEquals(Arrays.stream(res3).mapToDouble(d -> d).toArray(), 2.0, 3.0, 4.0, 5.0)); } private static double[] toArray(Iterable iter) { @@ -86,7 +86,7 @@ public void testliftComputer() { Iterable res = wrap(new double[4]); liftedToIterable.compute(wrap(new double[] { 1.0, 2.0, 3.0, 4.0 }), res); - Assert.assertTrue(arrayEquals(unwrap(res), 2.0, 3.0, 4.0, 5.0)); + Assertions.assertTrue(arrayEquals(unwrap(res), 2.0, 3.0, 4.0, 5.0)); } private static double[] unwrap(Iterable ds) { diff --git a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/OpsAsParametersTest.java b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/OpsAsParametersTest.java index 2971da047..c0e0566fb 100644 --- a/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/OpsAsParametersTest.java +++ b/scijava/scijava-ops-engine/src/test/java/org/scijava/ops/engine/util/OpsAsParametersTest.java @@ -5,8 +5,9 @@ import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.api.features.OpMatchingException; import org.scijava.ops.engine.AbstractTestEnvironment; @@ -16,9 +17,11 @@ import org.scijava.ops.spi.OpField; import org.scijava.types.Nil; +import static org.junit.jupiter.api.Assertions.assertThrows; + public class OpsAsParametersTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new OpsAsParametersTest()); ops.register(new FuncClass()); @@ -35,7 +38,7 @@ public static void addNeededOps() { return output; }; - @Test(expected=OpMatchingException.class) + @Test public void TestOpWithNonReifiableFunction() { List list = new ArrayList<>(); @@ -43,7 +46,10 @@ public void TestOpWithNonReifiableFunction() { list.add(20.5); list.add(4.0d); - List output = ops.op("test.parameter.op").input(list, func).outType(new Nil>() {}).apply(); + assertThrows(OpMatchingException.class, // + () -> ops.op("test.parameter.op").input(list, func).outType(new Nil>() { + }).apply() // + ); } @Test diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/OpBuilderTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/OpBuilderTest.vm index b5d649a40..259f13c5c 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/OpBuilderTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/OpBuilderTest.vm @@ -29,15 +29,15 @@ package org.scijava.ops.engine; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Functions; import org.scijava.function.Inplaces; @@ -87,7 +87,7 @@ import org.scijava.ops.api.OpBuilder; */ public class OpBuilderTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new OpBuilderTestOps()); } diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/OpMethodTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/OpMethodTest.vm index 5aeaf3eec..ca68dcbad 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/OpMethodTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/OpMethodTest.vm @@ -29,14 +29,14 @@ package org.scijava.ops.engine; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.ArrayList; import java.util.List; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.spi.OpCollection; import org.scijava.ops.spi.OpMethod; @@ -48,7 +48,7 @@ import org.scijava.ops.spi.OpMethod; */ public class OpMethodTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new OpMethodTestOps()); } diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/complexLift/ComputerToFunctionIterablesTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/complexLift/ComputerToFunctionIterablesTest.vm index f5108430c..3e85f3ce6 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/complexLift/ComputerToFunctionIterablesTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/complexLift/ComputerToFunctionIterablesTest.vm @@ -34,13 +34,11 @@ package org.scijava.ops.engine.adapt.complexLift; -import static org.junit.Assert.assertArrayEquals; - import java.util.Arrays; import java.util.List; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.OpBuilderTestOps; @@ -49,6 +47,8 @@ import org.scijava.ops.engine.adapt.lift.FunctionToIterables; import org.scijava.ops.engine.create.CreateOpCollection; import org.scijava.types.Nil; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; + /** * Tests the adaptation of {@link Computers} running on a type into * {@link Computers} running on an {@link Iterable} of that type. @@ -58,7 +58,7 @@ import org.scijava.types.Nil; */ public class ComputerToFunctionIterablesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { Object[] lifters = objsFromNoArgConstructors(ComputersToFunctionsAndLift.class.getDeclaredClasses()); ops.register(lifters); diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/complexLift/FunctionToComputerIterablesTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/complexLift/FunctionToComputerIterablesTest.vm index 1f5ff31a5..c866bfa92 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/complexLift/FunctionToComputerIterablesTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/complexLift/FunctionToComputerIterablesTest.vm @@ -37,9 +37,9 @@ package org.scijava.ops.engine.adapt.complexLift; import java.util.Arrays; import java.util.List; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.adapt.functional.FunctionToComputerAdaptTestOps; import org.scijava.ops.engine.adapt.functional.FunctionsToComputers; @@ -48,7 +48,7 @@ import org.scijava.ops.engine.copy.CopyOpCollection; public class FunctionToComputerIterablesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { Object[] lifterOps = objsFromNoArgConstructors(FunctionsToComputersAndLift.class.getDeclaredClasses()); ops.register(lifterOps); @@ -65,7 +65,7 @@ public class FunctionToComputerIterablesTest extends AbstractTestEnvironment { List in = Arrays.asList(new double[] { 2, 4 }); List output = Arrays.asList(new double[] { 0, 0 }); ops.op("test.FtC").input($inList.call($arity)).output(output).compute(); - Assert.assertArrayEquals(new double[] $expectedValue.call($arity), output.get(0), 0); + Assertions.assertArrayEquals(new double[] $expectedValue.call($arity), output.get(0), 0); } #end } diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/ComputerToFunctionAdaptTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/ComputerToFunctionAdaptTest.vm index e894ba59e..cb0910f6e 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/ComputerToFunctionAdaptTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/ComputerToFunctionAdaptTest.vm @@ -34,15 +34,15 @@ package org.scijava.ops.engine.adapt.functional; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.create.CreateOpCollection; public class ComputerToFunctionAdaptTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new ComputerToFunctionAdaptTestOps()); ops.register(new CreateOpCollection()); @@ -56,7 +56,7 @@ public class ComputerToFunctionAdaptTest extends AbstractTestEnvironment { double[] in = {2, 4}; double[] output = ops.op("test.CtF").input($inList.call($arity)).outType(double[].class).apply(); double[] expected = $expectedValue.call($arity); - Assert.assertArrayEquals(expected, output, 0); + Assertions.assertArrayEquals(expected, output, 0); } #end } diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/FunctionToComputerAdaptTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/FunctionToComputerAdaptTest.vm index 7d508a61c..220e00d82 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/FunctionToComputerAdaptTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/FunctionToComputerAdaptTest.vm @@ -34,15 +34,15 @@ package org.scijava.ops.engine.adapt.functional; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.copy.CopyOpCollection; public class FunctionToComputerAdaptTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new FunctionToComputerAdaptTestOps()); ops.register(new CopyOpCollection()); @@ -55,7 +55,7 @@ public class FunctionToComputerAdaptTest extends AbstractTestEnvironment { double[] in = { 2, 4 }; double[] output = { 0, 0 }; ops.op("test.FtC").input($inList.call($arity)).output(output).compute(); - Assert.assertArrayEquals(new double[] $expectedValue.call($arity), output, 0); + Assertions.assertArrayEquals(new double[] $expectedValue.call($arity), output, 0); } #end } diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/InplaceToFunctionAdaptTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/InplaceToFunctionAdaptTest.vm index bbaff644e..d6ce2277a 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/InplaceToFunctionAdaptTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/functional/InplaceToFunctionAdaptTest.vm @@ -35,12 +35,12 @@ package org.scijava.ops.engine.adapt.functional; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.Arrays; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.ops.api.OpBuilder; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.OpBuilderTestOps; @@ -50,7 +50,7 @@ import org.scijava.types.Nil; public class InplaceToFunctionAdaptTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new OpBuilderTestOps()); ops.register(new CreateOpCollection()); diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/ComputerToArraysTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/ComputerToArraysTest.vm index 11c48401f..37cba8b1e 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/ComputerToArraysTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/ComputerToArraysTest.vm @@ -34,9 +34,9 @@ package org.scijava.ops.engine.adapt.lift; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.spi.OpCollection; @@ -50,7 +50,7 @@ import org.scijava.ops.spi.OpField; */ public class ComputerToArraysTest extends AbstractTestEnvironment implements OpCollection{ - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new ComputerToArraysTest()); ops.register(new ComputerToArrays()); @@ -91,7 +91,7 @@ public class ComputerToArraysTest extends AbstractTestEnvironment implements OpC ops.op("test.liftArrayC").input($inputArgs.call($arity)).output(output).compute(); for(int i = 0; i < output.length; i++) { - Assert.assertEquals($arity * i, output[i].getNumber()); + Assertions.assertEquals($arity * i, output[i].getNumber()); } } diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/ComputerToIterablesTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/ComputerToIterablesTest.vm index d3dd7522a..71c40029e 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/ComputerToIterablesTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/ComputerToIterablesTest.vm @@ -34,13 +34,13 @@ package org.scijava.ops.engine.adapt.lift; -import static org.junit.Assert.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertArrayEquals; import java.util.Arrays; import java.util.List; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.OpBuilderTestOps; @@ -53,7 +53,7 @@ import org.scijava.ops.engine.OpBuilderTestOps; */ public class ComputerToIterablesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new ComputerToIterables()); ops.register(new OpBuilderTestOps()); diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/FunctionToArraysTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/FunctionToArraysTest.vm index 65f51706c..5ec77c1c5 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/FunctionToArraysTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/FunctionToArraysTest.vm @@ -37,9 +37,9 @@ package org.scijava.ops.engine.adapt.lift; import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Functions; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.spi.OpCollection; @@ -54,7 +54,7 @@ import org.scijava.types.Nil; */ public class FunctionToArraysTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new FunctionToArraysTest()); ops.register(new FunctionToArrays()); @@ -92,7 +92,7 @@ public class FunctionToArraysTest extends AbstractTestEnvironment implements OpC {}).apply(); for (int i = 0; i < output.length; i++) { - Assert.assertEquals($arity * i, output[i].getNumber()); + Assertions.assertEquals($arity * i, output[i].getNumber()); } } diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/FunctionToIterablesTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/FunctionToIterablesTest.vm index f165caa71..95878a049 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/FunctionToIterablesTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/FunctionToIterablesTest.vm @@ -37,8 +37,8 @@ package org.scijava.ops.engine.adapt.lift; import java.util.Arrays; import java.util.List; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Functions; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.engine.OpBuilderTestOps; @@ -52,7 +52,7 @@ import org.scijava.types.Nil; */ public class FunctionToIterablesTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new FunctionToIterables()); ops.register(new OpBuilderTestOps()); diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/InplaceToArraysTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/InplaceToArraysTest.vm index d27d979aa..188ef4399 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/InplaceToArraysTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/adapt/lift/InplaceToArraysTest.vm @@ -34,9 +34,9 @@ package org.scijava.ops.engine.adapt.lift; -import org.junit.Assert; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Inplaces; import org.scijava.ops.engine.AbstractTestEnvironment; import org.scijava.ops.spi.OpCollection; @@ -50,7 +50,7 @@ import org.scijava.ops.spi.OpField; */ public class InplaceToArraysTest extends AbstractTestEnvironment implements OpCollection { - @BeforeClass + @BeforeAll public static void addNeededOps() { ops.register(new InplaceToArraysTest()); ops.register(new InplaceToArrays()); @@ -101,7 +101,7 @@ public class InplaceToArraysTest extends AbstractTestEnvironment implements OpCo .${mutateMethod.call($arity, $a)}(); for (int i = 0; i < input.length; i++) { - Assert.assertEquals($arity * i, io[i].getNumber()); + Assertions.assertEquals($arity * i, io[i].getNumber()); } } #end diff --git a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/matcher/OpWrappersTest.vm b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/matcher/OpWrappersTest.vm index 586b5d281..6a6d26afa 100644 --- a/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/matcher/OpWrappersTest.vm +++ b/scijava/scijava-ops-engine/templates/test/java/org/scijava/ops/engine/matcher/OpWrappersTest.vm @@ -5,13 +5,13 @@ package org.scijava.ops.engine.matcher; -import static org.junit.Assert.assertTrue; +import static org.junit.jupiter.api.Assertions.assertTrue; import java.util.function.BiFunction; import java.util.function.Function; -import org.junit.BeforeClass; -import org.junit.Test; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; import org.scijava.function.Computers; import org.scijava.function.Functions; import org.scijava.function.Inplaces; @@ -30,7 +30,7 @@ import org.scijava.types.Nil; */ public class OpWrappersTest extends AbstractTestEnvironment { - @BeforeClass + @BeforeAll public static void AddNeededOps() { ops.register(new OpBuilderTestOps()); } diff --git a/scijava/scijava-parse2/pom.xml b/scijava/scijava-parse2/pom.xml index e43ab5d7c..bb32bb92d 100644 --- a/scijava/scijava-parse2/pom.xml +++ b/scijava/scijava-parse2/pom.xml @@ -103,8 +103,13 @@ - junit - junit + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine test diff --git a/scijava/scijava-parse2/src/test/java/org/scijava/parse2/impl/ParseServiceTest.java b/scijava/scijava-parse2/src/test/java/org/scijava/parse2/impl/ParseServiceTest.java index 84f65d2ee..0206e818d 100644 --- a/scijava/scijava-parse2/src/test/java/org/scijava/parse2/impl/ParseServiceTest.java +++ b/scijava/scijava-parse2/src/test/java/org/scijava/parse2/impl/ParseServiceTest.java @@ -29,21 +29,18 @@ package org.scijava.parse2.impl; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertSame; -import static org.junit.Assert.assertTrue; import java.util.List; import java.util.Map; -import org.junit.Before; -import org.junit.Test; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; import org.scijava.parse2.Item; import org.scijava.parse2.Items; import org.scijava.parse2.Parser; +import static org.junit.jupiter.api.Assertions.*; + /** * Tests {@link Parser}. * @@ -53,7 +50,7 @@ public class ParseServiceTest { private Parser parser; - @Before + @BeforeEach public void setUp() { parser = new DefaultParser(); } @@ -123,7 +120,7 @@ private void assertMapCorrect(final Items items) { // test that map iteration order is the same int index = 0; for (final Object value : map.values()) { - assertSame("" + index + ":", items.get(index++).value(), value); + assertSame(items.get(index++).value(), value, "" + index + ":"); } } diff --git a/scijava/scijava-persist/pom.xml b/scijava/scijava-persist/pom.xml index b8f9f99f0..23dc1756a 100644 --- a/scijava/scijava-persist/pom.xml +++ b/scijava/scijava-persist/pom.xml @@ -113,8 +113,13 @@ - junit - junit + org.junit.jupiter + junit-jupiter-api + test + + + org.junit.jupiter + junit-jupiter-engine test diff --git a/scijava/scijava-persist/src/test/java/org/scijava/persist/SerializationTests.java b/scijava/scijava-persist/src/test/java/org/scijava/persist/SerializationTests.java index 0dc3a94ff..6f5513be4 100644 --- a/scijava/scijava-persist/src/test/java/org/scijava/persist/SerializationTests.java +++ b/scijava/scijava-persist/src/test/java/org/scijava/persist/SerializationTests.java @@ -3,12 +3,13 @@ import com.google.gson.Gson; -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.scijava.Context; +import static org.junit.jupiter.api.Assertions.assertEquals; + public class SerializationTests { static Context context; @@ -22,7 +23,7 @@ public static void main(String... args) { gson = ScijavaGsonHelper.getGson(context); } - @Before + @BeforeEach public void openFiji() { // Initializes static SourceService and Display Service and plugins for // serialization @@ -33,7 +34,7 @@ public void openFiji() { gson = ScijavaGsonHelper.getGson(context, true); } - @After + @AfterEach public void closeFiji() throws Exception { context.dispose(); context = null; @@ -77,6 +78,6 @@ public static void testSerializationDeserialization(Gson gson, Object o, Object oRestored = gson.fromJson(json, c); String json2 = gson.toJson(oRestored, c); System.out.println(json2); - Assert.assertEquals(json, json2); + assertEquals(json, json2); } } diff --git a/scijava/scijava-testutil/pom.xml b/scijava/scijava-testutil/pom.xml index b004cb29d..78155cb04 100644 --- a/scijava/scijava-testutil/pom.xml +++ b/scijava/scijava-testutil/pom.xml @@ -93,11 +93,6 @@ - - junit - junit - compile - org.junit.jupiter junit-jupiter-api diff --git a/scijava/scijava-testutil/src/test/java/org/scijava/testutil/AppTest.java b/scijava/scijava-testutil/src/test/java/org/scijava/testutil/AppTest.java deleted file mode 100644 index 3e4777883..000000000 --- a/scijava/scijava-testutil/src/test/java/org/scijava/testutil/AppTest.java +++ /dev/null @@ -1,20 +0,0 @@ -package org.scijava.testutil; - -import static org.junit.Assert.assertTrue; - -import org.junit.Test; - -/** - * Unit test for simple App. - */ -public class AppTest -{ - /** - * Rigorous Test :-) - */ - @Test - public void shouldAnswerWithTrue() - { - assertTrue( true ); - } -}