From 2a6d2d27d7afe32ab9dadda01c032d8e2be1cc60 Mon Sep 17 00:00:00 2001 From: Bukkit/Spigot Date: Sun, 24 Sep 2023 06:09:10 +1000 Subject: [PATCH] #909: Update tests to JUnit 5 By: DerFrZocker --- paper-api/README.md | 2 +- paper-api/pom.xml | 10 +- .../test/java/org/bukkit/AnnotationTest.java | 8 +- .../src/test/java/org/bukkit/ArtTest.java | 9 +- .../java/org/bukkit/BukkitMirrorTest.java | 79 ++--- .../test/java/org/bukkit/ChatColorTest.java | 13 +- .../java/org/bukkit/ChatPaginatorTest.java | 4 +- .../test/java/org/bukkit/CoalTypeTest.java | 4 +- .../src/test/java/org/bukkit/ColorTest.java | 299 ++++++++-------- .../test/java/org/bukkit/CropStateTest.java | 4 +- .../test/java/org/bukkit/DifficultyTest.java | 4 +- .../test/java/org/bukkit/DyeColorTest.java | 58 ++-- .../src/test/java/org/bukkit/EffectTest.java | 4 +- .../test/java/org/bukkit/GameModeTest.java | 4 +- .../java/org/bukkit/GrassSpeciesTest.java | 4 +- .../test/java/org/bukkit/InstrumentTest.java | 4 +- .../java/org/bukkit/LastChatColorTest.java | 50 ++- .../test/java/org/bukkit/LocationTest.java | 113 +++--- .../test/java/org/bukkit/MaterialTest.java | 9 +- .../java/org/bukkit/NamespacedKeyTest.java | 70 ++-- .../src/test/java/org/bukkit/NoteTest.java | 25 +- .../test/java/org/bukkit/TreeSpeciesTest.java | 4 +- .../test/java/org/bukkit/WorldTypeTest.java | 4 +- .../ConfigurationSectionTest.java | 4 +- .../configuration/ConfigurationTest.java | 4 +- .../file/FileConfigurationTest.java | 23 +- .../file/YamlConfigurationTest.java | 4 +- .../ConversationContextTest.java | 6 +- .../conversations/ConversationTest.java | 4 +- .../conversations/ValidatingPromptTest.java | 4 +- .../bukkit/entity/memory/MemoryKeyTest.java | 16 +- .../event/PlayerChatTabCompleteEventTest.java | 6 +- .../org/bukkit/event/SyntheticEventTest.java | 6 +- .../bukkit/materials/MaterialDataTest.java | 322 +++++++++--------- .../metadata/FixedMetadataValueTest.java | 6 +- .../metadata/LazyMetadataValueTest.java | 8 +- .../metadata/MetadataConversionTest.java | 14 +- .../bukkit/metadata/MetadataStoreTest.java | 4 +- .../metadata/MetadataValueAdapterTest.java | 26 +- .../org/bukkit/plugin/PluginManagerTest.java | 16 +- .../plugin/TimedRegisteredListenerTest.java | 4 +- .../messaging/StandardMessengerTest.java | 76 ++--- .../plugin/messaging/TestMessageListener.java | 2 +- .../org/bukkit/scoreboard/CriteriaTest.java | 16 +- .../org/bukkit/support/MatcherAssert.java | 36 ++ .../java/org/bukkit/util/BoundingBoxTest.java | 4 +- .../bukkit/util/StringUtilStartsWithTest.java | 133 ++++---- .../java/org/bukkit/util/StringUtilTest.java | 33 +- .../test/java/org/bukkit/util/VectorTest.java | 8 +- .../util/io/BukkitObjectStreamTest.java | 130 ++++--- 50 files changed, 837 insertions(+), 863 deletions(-) create mode 100644 paper-api/src/test/java/org/bukkit/support/MatcherAssert.java diff --git a/paper-api/README.md b/paper-api/README.md index 2f8abbb9db..c97e2e5d7a 100644 --- a/paper-api/README.md +++ b/paper-api/README.md @@ -88,7 +88,7 @@ Code Requirements * [`@ApiStatus.Experimental`](https://javadoc.io/doc/org.jetbrains/annotations-java5/23.0.0/org/jetbrains/annotations/ApiStatus.Experimental.html) for API that is subject to change * [`@ApiStatus.Internal`](https://javadoc.io/doc/org.jetbrains/annotations-java5/23.0.0/org/jetbrains/annotations/ApiStatus.Internal.html) for API that is intended only for internal use in the Bukkit project and will not adhere to Bukkit's API contract -Bukkit/CraftBukkit employs [JUnit 4](https://www.vogella.com/tutorials/JUnit4/article.html) for testing. Pull Requests(PR) should attempt to integrate within that framework as appropriate. +Bukkit/CraftBukkit employs [JUnit 5](https://www.vogella.com/tutorials/JUnit/article.html) for testing. Pull Requests(PR) should attempt to integrate within that framework as appropriate. Bukkit is a large project and what seems simple to a PR author at the time of writing may easily be overlooked by other authors and updates. Including unit tests with your PR will help to ensure the PR can be easily maintained over time and encourage the Spigot team to pull the PR. diff --git a/paper-api/pom.xml b/paper-api/pom.xml index 1c911797a7..7717324018 100644 --- a/paper-api/pom.xml +++ b/paper-api/pom.xml @@ -86,15 +86,15 @@ - junit - junit - 4.13.2 + org.junit.jupiter + junit-jupiter + 5.10.0 test org.hamcrest - hamcrest-library - 1.3 + hamcrest + 2.2 test diff --git a/paper-api/src/test/java/org/bukkit/AnnotationTest.java b/paper-api/src/test/java/org/bukkit/AnnotationTest.java index 4ac3dd977e..64e7aef622 100644 --- a/paper-api/src/test/java/org/bukkit/AnnotationTest.java +++ b/paper-api/src/test/java/org/bukkit/AnnotationTest.java @@ -1,5 +1,6 @@ package org.bukkit; +import static org.junit.jupiter.api.Assertions.*; import java.io.File; import java.io.FileInputStream; import java.io.IOException; @@ -13,8 +14,7 @@ import java.util.List; import java.util.Map; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; import org.objectweb.asm.ClassReader; import org.objectweb.asm.Opcodes; import org.objectweb.asm.Type; @@ -49,7 +49,7 @@ public class AnnotationTest { File file = new File(loc.toURI()); // Running from jar is not supported yet - Assert.assertTrue("code must be in a directory", file.isDirectory()); + assertTrue(file.isDirectory(), "code must be in a directory"); final HashMap foundClasses = new HashMap<>(); collectClasses(file, foundClasses); @@ -97,7 +97,7 @@ public class AnnotationTest { System.out.println(message); } - Assert.fail("There " + errors.size() + " are missing annotation(s)"); + fail("There " + errors.size() + " are missing annotation(s)"); } private static void collectClasses(@NotNull File from, @NotNull Map to) throws IOException { diff --git a/paper-api/src/test/java/org/bukkit/ArtTest.java b/paper-api/src/test/java/org/bukkit/ArtTest.java index 2e9249a6d4..102f4705f1 100644 --- a/paper-api/src/test/java/org/bukkit/ArtTest.java +++ b/paper-api/src/test/java/org/bukkit/ArtTest.java @@ -1,14 +1,15 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class ArtTest { - @Test(expected = IllegalArgumentException.class) + @Test public void getByNullName() { - Art.getByName(null); + assertThrows(IllegalArgumentException.class, () -> Art.getByName(null)); } @Test diff --git a/paper-api/src/test/java/org/bukkit/BukkitMirrorTest.java b/paper-api/src/test/java/org/bukkit/BukkitMirrorTest.java index 2dfada6606..89ca06ebec 100644 --- a/paper-api/src/test/java/org/bukkit/BukkitMirrorTest.java +++ b/paper-api/src/test/java/org/bukkit/BukkitMirrorTest.java @@ -1,72 +1,59 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; -import com.google.common.base.Function; -import com.google.common.collect.Lists; import java.lang.reflect.Method; import java.lang.reflect.Modifier; -import java.util.Arrays; -import java.util.List; -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameter; -import org.junit.runners.Parameterized.Parameters; +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; -@RunWith(Parameterized.class) public class BukkitMirrorTest { - @Parameters(name = "{index}: {1}") - public static List data() { - return Lists.transform(Arrays.asList(Server.class.getDeclaredMethods()), new Function() { - @Override - public Object[] apply(Method input) { - return new Object[] { - input, - input.toGenericString().substring("public abstract ".length()).replace("(", "{").replace(")", "}") - }; - } - }); + public static Stream data() { + return Stream.of(Server.class.getDeclaredMethods()) + .map(method -> { + try { + return Arguments.of( + method, + method.toGenericString().substring("public abstract ".length()).replace("(", "{").replace(")", "}"), + Bukkit.class.getDeclaredMethod(method.getName(), method.getParameterTypes()) + ); + } catch (NoSuchMethodException e) { + throw new RuntimeException(e); + } + }); } - @Parameter(0) - public Method server; - - @Parameter(1) - public String name; - - private Method bukkit; - - @Before - public void makeBukkit() throws Throwable { - bukkit = Bukkit.class.getDeclaredMethod(server.getName(), server.getParameterTypes()); - } - - @Test - public void isStatic() throws Throwable { + @ParameterizedTest + @MethodSource("data") + public void isStatic(Method server, String name, Method bukkit) throws Throwable { assertThat(Modifier.isStatic(bukkit.getModifiers()), is(true)); } - @Test - public void isDeprecated() throws Throwable { + @ParameterizedTest + @MethodSource("data") + public void isDeprecated(Method server, String name, Method bukkit) throws Throwable { assertThat(bukkit.isAnnotationPresent(Deprecated.class), is(server.isAnnotationPresent(Deprecated.class))); } - @Test - public void returnType() throws Throwable { + @ParameterizedTest + @MethodSource("data") + public void returnType(Method server, String name, Method bukkit) throws Throwable { assertThat(bukkit.getReturnType(), is((Object) server.getReturnType())); // assertThat(bukkit.getGenericReturnType(), is(server.getGenericReturnType())); // too strict on type generics } - @Test - public void parameterTypes() throws Throwable { + @ParameterizedTest + @MethodSource("data") + public void parameterTypes(Method server, String name, Method bukkit) throws Throwable { // assertThat(bukkit.getGenericParameterTypes(), is(server.getGenericParameterTypes())); // too strict on type generics } - @Test - public void declaredException() throws Throwable { + @ParameterizedTest + @MethodSource("data") + public void declaredException(Method server, String name, Method bukkit) throws Throwable { assertThat(bukkit.getGenericExceptionTypes(), is(server.getGenericExceptionTypes())); } } diff --git a/paper-api/src/test/java/org/bukkit/ChatColorTest.java b/paper-api/src/test/java/org/bukkit/ChatColorTest.java index fc4e808537..11c0f86891 100644 --- a/paper-api/src/test/java/org/bukkit/ChatColorTest.java +++ b/paper-api/src/test/java/org/bukkit/ChatColorTest.java @@ -1,8 +1,9 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class ChatColorTest { @@ -13,14 +14,14 @@ public class ChatColorTest { } } - @Test(expected = IllegalArgumentException.class) + @Test public void getByStringWithNull() { - ChatColor.getByChar((String) null); + assertThrows(IllegalArgumentException.class, () -> ChatColor.getByChar((String) null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void getByStringWithEmpty() { - ChatColor.getByChar(""); + assertThrows(IllegalArgumentException.class, () -> ChatColor.getByChar("")); } @Test diff --git a/paper-api/src/test/java/org/bukkit/ChatPaginatorTest.java b/paper-api/src/test/java/org/bukkit/ChatPaginatorTest.java index b0384b12e5..2d7c545930 100644 --- a/paper-api/src/test/java/org/bukkit/ChatPaginatorTest.java +++ b/paper-api/src/test/java/org/bukkit/ChatPaginatorTest.java @@ -1,9 +1,9 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; import org.bukkit.util.ChatPaginator; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class ChatPaginatorTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/CoalTypeTest.java b/paper-api/src/test/java/org/bukkit/CoalTypeTest.java index b90f10c4ef..9373bfd2b7 100644 --- a/paper-api/src/test/java/org/bukkit/CoalTypeTest.java +++ b/paper-api/src/test/java/org/bukkit/CoalTypeTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class CoalTypeTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/ColorTest.java b/paper-api/src/test/java/org/bukkit/ColorTest.java index 1f722fb249..f29fd7bc65 100644 --- a/paper-api/src/test/java/org/bukkit/ColorTest.java +++ b/paper-api/src/test/java/org/bukkit/ColorTest.java @@ -1,9 +1,10 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.configuration.file.YamlConfiguration; -import org.junit.Test; +import org.junit.jupiter.api.Test; @SuppressWarnings("javadoc") public class ColorTest { @@ -58,7 +59,7 @@ public class ColorTest { YamlConfiguration deserialized = new YamlConfiguration(); deserialized.loadFromString(serialized); - assertThat(testColor.name + " on " + serialized, base, is(deserialized.getColor("color"))); + assertThat(base, is(deserialized.getColor("color")), testColor.name + " on " + serialized); } } @@ -73,14 +74,14 @@ public class ColorTest { Color fromRGBs = Color.fromRGB(testColor.r, testColor.g, testColor.b); Color fromBGRs = Color.fromBGR(testColor.b, testColor.g, testColor.r); - assertThat(testColor.name, fromARGB, is(fromARGB)); - assertThat(testColor.name, fromARGBs, is(fromARGBs)); - assertThat(testColor.name, fromRGB, is(fromRGBs)); - assertThat(testColor.name, fromRGB, is(fromBGR)); - assertThat(testColor.name, fromRGB, is(fromBGRs)); - assertThat(testColor.name, fromRGBs, is(fromBGR)); - assertThat(testColor.name, fromRGBs, is(fromBGRs)); - assertThat(testColor.name, fromBGR, is(fromBGRs)); + assertThat(fromARGB, is(fromARGB), testColor.name); + assertThat(fromARGBs, is(fromARGBs), testColor.name); + assertThat(fromRGB, is(fromRGBs), testColor.name); + assertThat(fromRGB, is(fromBGR), testColor.name); + assertThat(fromRGB, is(fromBGRs), testColor.name); + assertThat(fromRGBs, is(fromBGR), testColor.name); + assertThat(fromRGBs, is(fromBGRs), testColor.name); + assertThat(fromBGR, is(fromBGRs), testColor.name); } } @@ -93,11 +94,11 @@ public class ColorTest { TestColor testTo = examples[j]; Color to = Color.fromARGB(testTo.argb); String name = testFrom.name + " to " + testTo.name; - assertThat(name, from, is(not(to))); + assertThat(from, is(not(to)), name); Color transform = from.setAlpha(testTo.a).setRed(testTo.r).setBlue(testTo.b).setGreen(testTo.g); - assertThat(name, transform, is(not(sameInstance(from)))); - assertThat(name, transform, is(to)); + assertThat(transform, is(not(sameInstance(from))), name); + assertThat(transform, is(to), name); } } } @@ -106,8 +107,8 @@ public class ColorTest { @Test public void testARGB() { for (TestColor testColor : examples) { - assertThat(testColor.name, Color.fromARGB(testColor.argb).asARGB(), is(testColor.argb)); - assertThat(testColor.name, Color.fromARGB(testColor.a, testColor.r, testColor.g, testColor.b).asARGB(), is(testColor.argb)); + assertThat(Color.fromARGB(testColor.argb).asARGB(), is(testColor.argb), testColor.name); + assertThat(Color.fromARGB(testColor.a, testColor.r, testColor.g, testColor.b).asARGB(), is(testColor.argb), testColor.name); } } @@ -115,342 +116,342 @@ public class ColorTest { @Test public void testRGB() { for (TestColor testColor : examples) { - assertThat(testColor.name, Color.fromRGB(testColor.rgb).asRGB(), is(testColor.rgb)); - assertThat(testColor.name, Color.fromBGR(testColor.bgr).asRGB(), is(testColor.rgb)); - assertThat(testColor.name, Color.fromRGB(testColor.r, testColor.g, testColor.b).asRGB(), is(testColor.rgb)); - assertThat(testColor.name, Color.fromBGR(testColor.b, testColor.g, testColor.r).asRGB(), is(testColor.rgb)); + assertThat(Color.fromRGB(testColor.rgb).asRGB(), is(testColor.rgb), testColor.name); + assertThat(Color.fromBGR(testColor.bgr).asRGB(), is(testColor.rgb), testColor.name); + assertThat(Color.fromRGB(testColor.r, testColor.g, testColor.b).asRGB(), is(testColor.rgb), testColor.name); + assertThat(Color.fromBGR(testColor.b, testColor.g, testColor.r).asRGB(), is(testColor.rgb), testColor.name); } } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidRGB1() { - Color.fromRGB(0x01000000); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x01000000)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidRGB2() { - Color.fromRGB(Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidRGB3() { - Color.fromRGB(Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidRGB4() { - Color.fromRGB(-1); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(-1)); } // BGR tests @Test public void testBGR() { for (TestColor testColor : examples) { - assertThat(testColor.name, Color.fromRGB(testColor.rgb).asBGR(), is(testColor.bgr)); - assertThat(testColor.name, Color.fromBGR(testColor.bgr).asBGR(), is(testColor.bgr)); - assertThat(testColor.name, Color.fromRGB(testColor.r, testColor.g, testColor.b).asBGR(), is(testColor.bgr)); - assertThat(testColor.name, Color.fromBGR(testColor.b, testColor.g, testColor.r).asBGR(), is(testColor.bgr)); + assertThat(Color.fromRGB(testColor.rgb).asBGR(), is(testColor.bgr), testColor.name); + assertThat(Color.fromBGR(testColor.bgr).asBGR(), is(testColor.bgr), testColor.name); + assertThat(Color.fromRGB(testColor.r, testColor.g, testColor.b).asBGR(), is(testColor.bgr), testColor.name); + assertThat(Color.fromBGR(testColor.b, testColor.g, testColor.r).asBGR(), is(testColor.bgr), testColor.name); } } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidBGR1() { - Color.fromBGR(0x01000000); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x01000000)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidBGR2() { - Color.fromBGR(Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidBGR3() { - Color.fromBGR(Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidBGR4() { - Color.fromBGR(-1); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(-1)); } // Alpha tests @Test public void testAlpha() { for (TestColor testColor : examples) { - assertThat(testColor.name, Color.fromARGB(testColor.argb).getAlpha(), is(testColor.a)); + assertThat(Color.fromARGB(testColor.argb).getAlpha(), is(testColor.a), testColor.name); } } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA01() { - Color.fromARGB(-1, 0x00, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromARGB(-1, 0x00, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA02() { - Color.fromARGB(Integer.MAX_VALUE, 0x00, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromARGB(Integer.MAX_VALUE, 0x00, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA03() { - Color.fromARGB(Integer.MIN_VALUE, 0x00, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromARGB(Integer.MIN_VALUE, 0x00, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA04() { - Color.fromARGB(0x100, 0x00, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromARGB(0x100, 0x00, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA05() { - Color.fromBGR(0x00, 0x00, 0x00).setAlpha(-1); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x00, 0x00).setAlpha(-1)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA06() { - Color.fromBGR(0x00, 0x00, 0x00).setAlpha(Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x00, 0x00).setAlpha(Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA07() { - Color.fromBGR(0x00, 0x00, 0x00).setAlpha(Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x00, 0x00).setAlpha(Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA08() { - Color.fromBGR(0x00, 0x00, 0x00).setAlpha(0x100); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x00, 0x00).setAlpha(0x100)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA09() { - Color.WHITE.setAlpha(-1); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setAlpha(-1)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA10() { - Color.WHITE.setAlpha(Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setAlpha(Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA11() { - Color.WHITE.setAlpha(Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setAlpha(Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidA12() { - Color.WHITE.setAlpha(0x100); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setAlpha(0x100)); } // Red tests @Test public void testRed() { for (TestColor testColor : examples) { - assertThat(testColor.name, Color.fromRGB(testColor.rgb).getRed(), is(testColor.r)); - assertThat(testColor.name, Color.fromBGR(testColor.bgr).getRed(), is(testColor.r)); - assertThat(testColor.name, Color.fromRGB(testColor.r, testColor.g, testColor.b).getRed(), is(testColor.r)); - assertThat(testColor.name, Color.fromBGR(testColor.b, testColor.g, testColor.r).getRed(), is(testColor.r)); + assertThat(Color.fromRGB(testColor.rgb).getRed(), is(testColor.r), testColor.name); + assertThat(Color.fromBGR(testColor.bgr).getRed(), is(testColor.r), testColor.name); + assertThat(Color.fromRGB(testColor.r, testColor.g, testColor.b).getRed(), is(testColor.r), testColor.name); + assertThat(Color.fromBGR(testColor.b, testColor.g, testColor.r).getRed(), is(testColor.r), testColor.name); } } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR01() { - Color.fromRGB(-1, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(-1, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR02() { - Color.fromRGB(Integer.MAX_VALUE, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(Integer.MAX_VALUE, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR03() { - Color.fromRGB(Integer.MIN_VALUE, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(Integer.MIN_VALUE, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR04() { - Color.fromRGB(0x100, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x100, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR05() { - Color.fromBGR(0x00, 0x00, -1); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x00, -1)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR06() { - Color.fromBGR(0x00, 0x00, Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x00, Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR07() { - Color.fromBGR(0x00, 0x00, Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x00, Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR08() { - Color.fromBGR(0x00, 0x00, 0x100); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x00, 0x100)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR09() { - Color.WHITE.setRed(-1); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setRed(-1)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR10() { - Color.WHITE.setRed(Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setRed(Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR11() { - Color.WHITE.setRed(Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setRed(Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidR12() { - Color.WHITE.setRed(0x100); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setRed(0x100)); } // Blue tests @Test public void testBlue() { for (TestColor testColor : examples) { - assertThat(testColor.name, Color.fromRGB(testColor.rgb).getBlue(), is(testColor.b)); - assertThat(testColor.name, Color.fromBGR(testColor.bgr).getBlue(), is(testColor.b)); - assertThat(testColor.name, Color.fromRGB(testColor.r, testColor.g, testColor.b).getBlue(), is(testColor.b)); - assertThat(testColor.name, Color.fromBGR(testColor.b, testColor.g, testColor.r).getBlue(), is(testColor.b)); + assertThat(Color.fromRGB(testColor.rgb).getBlue(), is(testColor.b), testColor.name); + assertThat(Color.fromBGR(testColor.bgr).getBlue(), is(testColor.b), testColor.name); + assertThat(Color.fromRGB(testColor.r, testColor.g, testColor.b).getBlue(), is(testColor.b), testColor.name); + assertThat(Color.fromBGR(testColor.b, testColor.g, testColor.r).getBlue(), is(testColor.b), testColor.name); } } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB01() { - Color.fromRGB(0x00, 0x00, -1); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x00, 0x00, -1)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB02() { - Color.fromRGB(0x00, 0x00, Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x00, 0x00, Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB03() { - Color.fromRGB(0x00, 0x00, Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x00, 0x00, Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB04() { - Color.fromRGB(0x00, 0x00, 0x100); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x00, 0x00, 0x100)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB05() { - Color.fromBGR(-1, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(-1, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB06() { - Color.fromBGR(Integer.MAX_VALUE, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(Integer.MAX_VALUE, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB07() { - Color.fromBGR(Integer.MIN_VALUE, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(Integer.MIN_VALUE, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB08() { - Color.fromBGR(0x100, 0x00, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x100, 0x00, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB09() { - Color.WHITE.setBlue(-1); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setBlue(-1)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB10() { - Color.WHITE.setBlue(Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setBlue(Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB11() { - Color.WHITE.setBlue(Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setBlue(Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidB12() { - Color.WHITE.setBlue(0x100); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setBlue(0x100)); } // Green tests @Test public void testGreen() { for (TestColor testColor : examples) { - assertThat(testColor.name, Color.fromRGB(testColor.rgb).getGreen(), is(testColor.g)); - assertThat(testColor.name, Color.fromBGR(testColor.bgr).getGreen(), is(testColor.g)); - assertThat(testColor.name, Color.fromRGB(testColor.r, testColor.g, testColor.b).getGreen(), is(testColor.g)); - assertThat(testColor.name, Color.fromBGR(testColor.b, testColor.g, testColor.r).getGreen(), is(testColor.g)); + assertThat(Color.fromRGB(testColor.rgb).getGreen(), is(testColor.g), testColor.name); + assertThat(Color.fromBGR(testColor.bgr).getGreen(), is(testColor.g), testColor.name); + assertThat(Color.fromRGB(testColor.r, testColor.g, testColor.b).getGreen(), is(testColor.g), testColor.name); + assertThat(Color.fromBGR(testColor.b, testColor.g, testColor.r).getGreen(), is(testColor.g), testColor.name); } } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG01() { - Color.fromRGB(0x00, -1, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x00, -1, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG02() { - Color.fromRGB(0x00, Integer.MAX_VALUE, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x00, Integer.MAX_VALUE, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG03() { - Color.fromRGB(0x00, Integer.MIN_VALUE, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x00, Integer.MIN_VALUE, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG04() { - Color.fromRGB(0x00, 0x100, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromRGB(0x00, 0x100, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG05() { - Color.fromBGR(0x00, -1, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, -1, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG06() { - Color.fromBGR(0x00, Integer.MAX_VALUE, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, Integer.MAX_VALUE, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG07() { - Color.fromBGR(0x00, Integer.MIN_VALUE, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, Integer.MIN_VALUE, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG08() { - Color.fromBGR(0x00, 0x100, 0x00); + assertThrows(IllegalArgumentException.class, () -> Color.fromBGR(0x00, 0x100, 0x00)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG09() { - Color.WHITE.setGreen(-1); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setGreen(-1)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG10() { - Color.WHITE.setGreen(Integer.MAX_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setGreen(Integer.MAX_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG11() { - Color.WHITE.setGreen(Integer.MIN_VALUE); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setGreen(Integer.MIN_VALUE)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidG12() { - Color.WHITE.setGreen(0x100); + assertThrows(IllegalArgumentException.class, () -> Color.WHITE.setGreen(0x100)); } } diff --git a/paper-api/src/test/java/org/bukkit/CropStateTest.java b/paper-api/src/test/java/org/bukkit/CropStateTest.java index 5cd9d6d2d7..6efe3f1c33 100644 --- a/paper-api/src/test/java/org/bukkit/CropStateTest.java +++ b/paper-api/src/test/java/org/bukkit/CropStateTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class CropStateTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/DifficultyTest.java b/paper-api/src/test/java/org/bukkit/DifficultyTest.java index d7fe8d39a4..37623027c0 100644 --- a/paper-api/src/test/java/org/bukkit/DifficultyTest.java +++ b/paper-api/src/test/java/org/bukkit/DifficultyTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class DifficultyTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/DyeColorTest.java b/paper-api/src/test/java/org/bukkit/DyeColorTest.java index e56d9439a2..4e9ff14fcd 100644 --- a/paper-api/src/test/java/org/bukkit/DyeColorTest.java +++ b/paper-api/src/test/java/org/bukkit/DyeColorTest.java @@ -1,69 +1,57 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; -import java.util.ArrayList; -import java.util.List; import org.bukkit.material.Colorable; import org.bukkit.material.Dye; import org.bukkit.material.Wool; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameter; -import org.junit.runners.Parameterized.Parameters; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; -@RunWith(Parameterized.class) public class DyeColorTest { - @Parameters(name = "{index}: {0}") - public static List data() { - List list = new ArrayList(); - for (DyeColor dye : DyeColor.values()) { - list.add(new Object[] {dye}); - } - return list; - } - - @Parameter public DyeColor dye; - - @Test + @ParameterizedTest + @EnumSource(DyeColor.class) @SuppressWarnings("deprecation") - public void getByData() { + public void getByData(DyeColor dye) { byte data = dye.getWoolData(); DyeColor byData = DyeColor.getByWoolData(data); assertThat(byData, is(dye)); } - @Test - public void getByWoolData() { + @ParameterizedTest + @EnumSource(DyeColor.class) + public void getByWoolData(DyeColor dye) { byte data = dye.getWoolData(); DyeColor byData = DyeColor.getByWoolData(data); assertThat(byData, is(dye)); } - @Test - public void getByDyeData() { + @ParameterizedTest + @EnumSource(DyeColor.class) + public void getByDyeData(DyeColor dye) { byte data = dye.getDyeData(); DyeColor byData = DyeColor.getByDyeData(data); assertThat(byData, is(dye)); } - @Test - public void getDyeDyeColor() { - testColorable(new Dye(Material.LEGACY_INK_SACK, dye.getDyeData())); - testColorable(new Dye(dye)); + @ParameterizedTest + @EnumSource(DyeColor.class) + public void getDyeDyeColor(DyeColor dye) { + testColorable(new Dye(Material.LEGACY_INK_SACK, dye.getDyeData()), dye); + testColorable(new Dye(dye), dye); } - @Test - public void getWoolDyeColor() { - testColorable(new Wool(Material.LEGACY_WOOL, dye.getWoolData())); + @ParameterizedTest + @EnumSource(DyeColor.class) + public void getWoolDyeColor(DyeColor dye) { + testColorable(new Wool(Material.LEGACY_WOOL, dye.getWoolData()), dye); } - private void testColorable(final Colorable colorable) { - assertThat(colorable.getColor(), is(this.dye)); + private void testColorable(final Colorable colorable, DyeColor dye) { + assertThat(colorable.getColor(), is(dye)); } } diff --git a/paper-api/src/test/java/org/bukkit/EffectTest.java b/paper-api/src/test/java/org/bukkit/EffectTest.java index 54e621e86e..4344512fa8 100644 --- a/paper-api/src/test/java/org/bukkit/EffectTest.java +++ b/paper-api/src/test/java/org/bukkit/EffectTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class EffectTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/GameModeTest.java b/paper-api/src/test/java/org/bukkit/GameModeTest.java index 1c53e8ed8b..c5d3a15132 100644 --- a/paper-api/src/test/java/org/bukkit/GameModeTest.java +++ b/paper-api/src/test/java/org/bukkit/GameModeTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class GameModeTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/GrassSpeciesTest.java b/paper-api/src/test/java/org/bukkit/GrassSpeciesTest.java index 39f1b899ea..6739dc240c 100644 --- a/paper-api/src/test/java/org/bukkit/GrassSpeciesTest.java +++ b/paper-api/src/test/java/org/bukkit/GrassSpeciesTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class GrassSpeciesTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/InstrumentTest.java b/paper-api/src/test/java/org/bukkit/InstrumentTest.java index 14ad060eba..8c1d88885d 100644 --- a/paper-api/src/test/java/org/bukkit/InstrumentTest.java +++ b/paper-api/src/test/java/org/bukkit/InstrumentTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class InstrumentTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/LastChatColorTest.java b/paper-api/src/test/java/org/bukkit/LastChatColorTest.java index 64e164ea79..3d1c839cc7 100644 --- a/paper-api/src/test/java/org/bukkit/LastChatColorTest.java +++ b/paper-api/src/test/java/org/bukkit/LastChatColorTest.java @@ -1,40 +1,30 @@ package org.bukkit; -import static org.junit.Assert.*; -import java.util.Arrays; -import java.util.Collection; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; +import static org.junit.jupiter.api.Assertions.*; +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; -@RunWith(Parameterized.class) public class LastChatColorTest { - @Parameterized.Parameters - public static Collection data() { - return Arrays.asList(new Object[][]{ - {String.format("%c%ctest%c%ctest%c", ChatColor.COLOR_CHAR, ChatColor.RED.getChar(), ChatColor.COLOR_CHAR, ChatColor.ITALIC.getChar(), ChatColor.COLOR_CHAR), ChatColor.RED.toString() + ChatColor.ITALIC}, - {String.format("%c%ctest%c%ctest", ChatColor.COLOR_CHAR, ChatColor.RED.getChar(), ChatColor.COLOR_CHAR, ChatColor.BLUE.getChar()), ChatColor.BLUE.toString()}, - {"§x§1§2§3§4§5§6", "§x§1§2§3§4§5§6"}, - {"§y§1§2§3§4§5§6", "§6"}, - {"§3§4§5§6", "§6"}, - {"Test2§x§1§f§3§4§F§6test§l", "§x§1§f§3§4§F§6§l"}, - {"Test2§x§P§f§3§4§F§6test§l", "§6§l"}, - {"Test2§x§fxf§3§4§F§6test§l", "§6§l"}, - {"Test2§x§1§4§F§6test§l", "§6§l"} - }); + public static Stream data() { + return Stream.of( + Arguments.of(String.format("%c%ctest%c%ctest%c", ChatColor.COLOR_CHAR, ChatColor.RED.getChar(), ChatColor.COLOR_CHAR, ChatColor.ITALIC.getChar(), ChatColor.COLOR_CHAR), ChatColor.RED.toString() + ChatColor.ITALIC), + Arguments.of(String.format("%c%ctest%c%ctest", ChatColor.COLOR_CHAR, ChatColor.RED.getChar(), ChatColor.COLOR_CHAR, ChatColor.BLUE.getChar()), ChatColor.BLUE.toString()), + Arguments.of("§x§1§2§3§4§5§6", "§x§1§2§3§4§5§6"), + Arguments.of("§y§1§2§3§4§5§6", "§6"), + Arguments.of("§3§4§5§6", "§6"), + Arguments.of("Test2§x§1§f§3§4§F§6test§l", "§x§1§f§3§4§F§6§l"), + Arguments.of("Test2§x§P§f§3§4§F§6test§l", "§6§l"), + Arguments.of("Test2§x§fxf§3§4§F§6test§l", "§6§l"), + Arguments.of("Test2§x§1§4§F§6test§l", "§6§l") + ); } - private final String input; - private final String expected; - - public LastChatColorTest(String input, String expected) { - this.input = input; - this.expected = expected; - } - - @Test - public void testGetLastColors() { + @ParameterizedTest + @MethodSource("data") + public void testGetLastColors(String input, String expected) { assertEquals(expected, ChatColor.getLastColors(input)); } } diff --git a/paper-api/src/test/java/org/bukkit/LocationTest.java b/paper-api/src/test/java/org/bukkit/LocationTest.java index 02b97fa743..35a98c1457 100644 --- a/paper-api/src/test/java/org/bukkit/LocationTest.java +++ b/paper-api/src/test/java/org/bukkit/LocationTest.java @@ -1,19 +1,15 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; import static org.mockito.Mockito.*; -import com.google.common.collect.ImmutableList; -import java.util.List; import java.util.Random; +import java.util.stream.Stream; import org.bukkit.util.Vector; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameter; -import org.junit.runners.Parameterized.Parameters; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; -@RunWith(Parameterized.class) public class LocationTest { private static final double delta = 1.0 / 1000000; /** @@ -37,59 +33,58 @@ public class LocationTest { */ private static final double HALF_HALF_UNIT = Math.sqrt(1 / 4f); - @Parameters(name = "{index}: {0}") - public static List data() { + public static Stream data() { Random RANDOM = new Random(1L); // Test is deterministic int r = 0; - return ImmutableList.of( - new Object[]{"X", + return Stream.of( + Arguments.of("X", 1, 0, 0, 270, 0 - }, - new Object[]{"-X", + ), + Arguments.of("-X", -1, 0, 0, 90, 0 - }, - new Object[]{"Z", + ), + Arguments.of("Z", 0, 0, 1, 0, 0 - }, - new Object[]{"-Z", + ), + Arguments.of("-Z", 0, 0, -1, 180, 0 - }, - new Object[]{"Y", + ), + Arguments.of("Y", 0, 1, 0, 0, -90 // Zero is here as a "default" value - }, - new Object[]{"-Y", + ), + Arguments.of("-Y", 0, -1, 0, 0, 90 // Zero is here as a "default" value - }, - new Object[]{"X Z", + ), + Arguments.of("X Z", HALF_UNIT, 0, HALF_UNIT, (270 + 360) / 2, 0 - }, - new Object[]{"X -Z", + ), + Arguments.of("X -Z", HALF_UNIT, 0, -HALF_UNIT, (270 + 180) / 2, 0 - }, - new Object[]{"-X -Z", + ), + Arguments.of("-X -Z", -HALF_UNIT, 0, -HALF_UNIT, (90 + 180) / 2, 0 - }, - new Object[]{"-X Z", + ), + Arguments.of("-X Z", -HALF_UNIT, 0, HALF_UNIT, (90 + 0) / 2, 0 - }, - new Object[]{"X Y Z", + ), + Arguments.of("X Y Z", HALF_HALF_UNIT, HALF_UNIT, HALF_HALF_UNIT, (270 + 360) / 2, -45 - }, - new Object[]{"-X -Y -Z", + ), + Arguments.of("-X -Y -Z", -HALF_HALF_UNIT, -HALF_UNIT, -HALF_HALF_UNIT, (90 + 180) / 2, 45 - }, + ), getRandom(RANDOM, r++), getRandom(RANDOM, r++), getRandom(RANDOM, r++), @@ -111,7 +106,7 @@ public class LocationTest { ); } - private static Object[] getRandom(Random random, int index) { + private static Arguments getRandom(Random random, int index) { final double YAW_FACTOR = 360; final double YAW_OFFSET = 0; final double PITCH_FACTOR = 180; @@ -141,52 +136,42 @@ public class LocationTest { location.setDirection(vector); } - return new Object[]{"R" + index, + return Arguments.of("R" + index, vector.getX(), vector.getY(), vector.getZ(), location.getYaw(), location.getPitch() - }; + ); } - @Parameter(0) - public String nane; - @Parameter(1) - public double x; - @Parameter(2) - public double y; - @Parameter(3) - public double z; - @Parameter(4) - public float yaw; - @Parameter(5) - public float pitch; - - @Test - public void testExpectedPitchYaw() { - Location location = getEmptyLocation().setDirection(getVector()); + @ParameterizedTest + @MethodSource("data") + public void testExpectedPitchYaw(String name, double x, double y, double z, float yaw, float pitch) { + Location location = getEmptyLocation().setDirection(getVector(x, y, z)); assertThat((double) location.getYaw(), is(closeTo(yaw, delta))); assertThat((double) location.getPitch(), is(closeTo(pitch, delta))); } - @Test - public void testExpectedXYZ() { - Vector vector = getLocation().getDirection(); + @ParameterizedTest + @MethodSource("data") + public void testExpectedXYZ(String name, double x, double y, double z, float yaw, float pitch) { + Vector vector = getLocation(yaw, pitch).getDirection(); assertThat(vector.getX(), is(closeTo(x, delta))); assertThat(vector.getY(), is(closeTo(y, delta))); assertThat(vector.getZ(), is(closeTo(z, delta))); } - @Test - public void testEquals() { - Location first = getLocation().add(getVector()); - Location second = getLocation().add(getVector()); + @ParameterizedTest + @MethodSource("data") + public void testEquals(String name, double x, double y, double z, float yaw, float pitch) { + Location first = getLocation(yaw, pitch).add(getVector(x, y, z)); + Location second = getLocation(yaw, pitch).add(getVector(x, y, z)); assertThat(first.hashCode(), is(second.hashCode())); assertThat(first, is(second)); } - private Vector getVector() { + private Vector getVector(double x, double y, double z) { return new Vector(x, y, z); } @@ -196,7 +181,7 @@ public class LocationTest { return new Location(TEST_WORLD, 0, 0, 0); } - private Location getLocation() { + private Location getLocation(float yaw, float pitch) { Location location = getEmptyLocation(); location.setYaw(yaw); location.setPitch(pitch); diff --git a/paper-api/src/test/java/org/bukkit/MaterialTest.java b/paper-api/src/test/java/org/bukkit/MaterialTest.java index 6b0eaaadf9..818aa21d3b 100644 --- a/paper-api/src/test/java/org/bukkit/MaterialTest.java +++ b/paper-api/src/test/java/org/bukkit/MaterialTest.java @@ -1,9 +1,10 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.material.MaterialData; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class MaterialTest { @Test @@ -30,9 +31,9 @@ public class MaterialTest { } } - @Test(expected = IllegalArgumentException.class) + @Test public void matchMaterialByNull() { - Material.matchMaterial(null); + assertThrows(IllegalArgumentException.class, () -> Material.matchMaterial(null)); } @Test diff --git a/paper-api/src/test/java/org/bukkit/NamespacedKeyTest.java b/paper-api/src/test/java/org/bukkit/NamespacedKeyTest.java index 9f57889cbb..6317798e43 100644 --- a/paper-api/src/test/java/org/bukkit/NamespacedKeyTest.java +++ b/paper-api/src/test/java/org/bukkit/NamespacedKeyTest.java @@ -1,72 +1,72 @@ package org.bukkit; -import org.junit.Assert; -import org.junit.Test; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; public class NamespacedKeyTest { @Test public void testValid() { - Assert.assertEquals("minecraft:foo", new NamespacedKey("minecraft", "foo").toString()); - Assert.assertEquals("minecraft:foo/bar", new NamespacedKey("minecraft", "foo/bar").toString()); - Assert.assertEquals("minecraft:foo/bar_baz", new NamespacedKey("minecraft", "foo/bar_baz").toString()); - Assert.assertEquals("minecraft:foo/bar_baz-qux", new NamespacedKey("minecraft", "foo/bar_baz-qux").toString()); - Assert.assertEquals("minecraft:foo/bar_baz-qux.quux", new NamespacedKey("minecraft", "foo/bar_baz-qux.quux").toString()); + assertEquals("minecraft:foo", new NamespacedKey("minecraft", "foo").toString()); + assertEquals("minecraft:foo/bar", new NamespacedKey("minecraft", "foo/bar").toString()); + assertEquals("minecraft:foo/bar_baz", new NamespacedKey("minecraft", "foo/bar_baz").toString()); + assertEquals("minecraft:foo/bar_baz-qux", new NamespacedKey("minecraft", "foo/bar_baz-qux").toString()); + assertEquals("minecraft:foo/bar_baz-qux.quux", new NamespacedKey("minecraft", "foo/bar_baz-qux.quux").toString()); } @Test public void testValidFromString() { NamespacedKey expected = NamespacedKey.minecraft("foo"); - Assert.assertEquals(expected, NamespacedKey.fromString("foo")); - Assert.assertEquals(expected, NamespacedKey.fromString(":foo")); - Assert.assertEquals(expected, NamespacedKey.fromString("minecraft:foo")); - Assert.assertEquals(new NamespacedKey("foo", "bar"), NamespacedKey.fromString("foo:bar")); + assertEquals(expected, NamespacedKey.fromString("foo")); + assertEquals(expected, NamespacedKey.fromString(":foo")); + assertEquals(expected, NamespacedKey.fromString("minecraft:foo")); + assertEquals(new NamespacedKey("foo", "bar"), NamespacedKey.fromString("foo:bar")); - Assert.assertNull(NamespacedKey.fromString("fOO")); - Assert.assertNull(NamespacedKey.fromString(":Foo")); - Assert.assertNull(NamespacedKey.fromString("fOO:bar")); - Assert.assertNull(NamespacedKey.fromString("minecraft:fOO")); - Assert.assertNull(NamespacedKey.fromString("foo:bar:bazz")); + assertNull(NamespacedKey.fromString("fOO")); + assertNull(NamespacedKey.fromString(":Foo")); + assertNull(NamespacedKey.fromString("fOO:bar")); + assertNull(NamespacedKey.fromString("minecraft:fOO")); + assertNull(NamespacedKey.fromString("foo:bar:bazz")); } - @Test(expected = IllegalArgumentException.class) + @Test public void testFromStringEmptyInput() { - NamespacedKey.fromString(""); + assertThrows(IllegalArgumentException.class, () -> NamespacedKey.fromString("")); } - @Test(expected = IllegalArgumentException.class) + @Test public void testFromStringNullInput() { - NamespacedKey.fromString(null); + assertThrows(IllegalArgumentException.class, () -> NamespacedKey.fromString(null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void testEmptyNamespace() { - new NamespacedKey("", "foo").toString(); + assertThrows(IllegalArgumentException.class, () -> new NamespacedKey("", "foo").toString()); } - @Test(expected = IllegalArgumentException.class) + @Test public void testEmptyKey() { - new NamespacedKey("minecraft", "").toString(); + assertThrows(IllegalArgumentException.class, () -> new NamespacedKey("minecraft", "").toString()); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidNamespace() { - new NamespacedKey("minecraft/test", "foo").toString(); + assertThrows(IllegalArgumentException.class, () -> new NamespacedKey("minecraft/test", "foo").toString()); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidNamespaceCasing() { - new NamespacedKey("Minecraft", "foo").toString(); + assertThrows(IllegalArgumentException.class, () -> new NamespacedKey("Minecraft", "foo").toString()); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidKeyCasing() { - new NamespacedKey("minecraft", "Foo").toString(); + assertThrows(IllegalArgumentException.class, () -> new NamespacedKey("minecraft", "Foo").toString()); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidKey() { - new NamespacedKey("minecraft", "foo!").toString(); + assertThrows(IllegalArgumentException.class, () -> new NamespacedKey("minecraft", "foo!").toString()); } @Test @@ -75,10 +75,10 @@ public class NamespacedKeyTest { "loremipsumdolorsitametconsecteturadipiscingelitduisvolutpatvelitsitametmaximusscelerisquemorbiullamcorperexacconsequategestas").toString(); } - @Test(expected = IllegalArgumentException.class) + @Test public void testAboveLength() { - new NamespacedKey("loremipsumdolorsitametconsecteturadipiscingelitduisvolutpatvelitsitametmaximusscelerisquemorbiullamcorperexacconsequategestas", + assertThrows(IllegalArgumentException.class, () -> new NamespacedKey("loremipsumdolorsitametconsecteturadipiscingelitduisvolutpatvelitsitametmaximusscelerisquemorbiullamcorperexacconsequategestas", "loremipsumdolorsitametconsecteturadipiscingelitduisvolutpatvelitsitametmaximusscelerisquemorbiullamcorperexacconsequategestas/" - + "loremipsumdolorsitametconsecteturadipiscingelitduisvolutpatvelitsitametmaximusscelerisquemorbiullamcorperexacconsequategestas").toString(); + + "loremipsumdolorsitametconsecteturadipiscingelitduisvolutpatvelitsitametmaximusscelerisquemorbiullamcorperexacconsequategestas").toString()); } } diff --git a/paper-api/src/test/java/org/bukkit/NoteTest.java b/paper-api/src/test/java/org/bukkit/NoteTest.java index 0db4bfa43a..616f4ce9bf 100644 --- a/paper-api/src/test/java/org/bukkit/NoteTest.java +++ b/paper-api/src/test/java/org/bukkit/NoteTest.java @@ -1,10 +1,11 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import com.google.common.collect.Lists; import java.util.Collection; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class NoteTest { @Test @@ -51,24 +52,24 @@ public class NoteTest { } } - @Test(expected = IllegalArgumentException.class) + @Test public void createNoteBelowMin() { - new Note((byte) -1); + assertThrows(IllegalArgumentException.class, () -> new Note((byte) -1)); } - @Test(expected = IllegalArgumentException.class) + @Test public void createNoteAboveMax() { - new Note((byte) 25); + assertThrows(IllegalArgumentException.class, () -> new Note((byte) 25)); } - @Test(expected = IllegalArgumentException.class) + @Test public void createNoteOctaveBelowMax() { - new Note((byte) -1, Note.Tone.A, true); + assertThrows(IllegalArgumentException.class, () -> new Note((byte) -1, Note.Tone.A, true)); } - @Test(expected = IllegalArgumentException.class) + @Test public void createNoteOctaveAboveMax() { - new Note((byte) 3, Note.Tone.A, true); + assertThrows(IllegalArgumentException.class, () -> new Note((byte) 3, Note.Tone.A, true)); } @Test @@ -114,9 +115,9 @@ public class NoteTest { assertEquals(note.getOctave(), 2); } - @Test(expected = IllegalArgumentException.class) + @Test public void testSharpWrapping2() { - new Note(2, Note.Tone.F, true).sharped(); + assertThrows(IllegalArgumentException.class, () -> new Note(2, Note.Tone.F, true).sharped()); } @Test diff --git a/paper-api/src/test/java/org/bukkit/TreeSpeciesTest.java b/paper-api/src/test/java/org/bukkit/TreeSpeciesTest.java index 51e956cc5e..66401d83bd 100644 --- a/paper-api/src/test/java/org/bukkit/TreeSpeciesTest.java +++ b/paper-api/src/test/java/org/bukkit/TreeSpeciesTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class TreeSpeciesTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/WorldTypeTest.java b/paper-api/src/test/java/org/bukkit/WorldTypeTest.java index 3c5f7b8a70..651499066c 100644 --- a/paper-api/src/test/java/org/bukkit/WorldTypeTest.java +++ b/paper-api/src/test/java/org/bukkit/WorldTypeTest.java @@ -1,8 +1,8 @@ package org.bukkit; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class WorldTypeTest { @Test diff --git a/paper-api/src/test/java/org/bukkit/configuration/ConfigurationSectionTest.java b/paper-api/src/test/java/org/bukkit/configuration/ConfigurationSectionTest.java index bfaacbaa33..ee5bc86f47 100644 --- a/paper-api/src/test/java/org/bukkit/configuration/ConfigurationSectionTest.java +++ b/paper-api/src/test/java/org/bukkit/configuration/ConfigurationSectionTest.java @@ -1,6 +1,6 @@ package org.bukkit.configuration; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.util.Arrays; import java.util.Collections; import java.util.HashMap; @@ -11,7 +11,7 @@ import org.bukkit.Material; import org.bukkit.configuration.serialization.ConfigurationSerializable; import org.bukkit.inventory.ItemStack; import org.bukkit.util.Vector; -import org.junit.Test; +import org.junit.jupiter.api.Test; public abstract class ConfigurationSectionTest { public abstract ConfigurationSection getConfigurationSection(); diff --git a/paper-api/src/test/java/org/bukkit/configuration/ConfigurationTest.java b/paper-api/src/test/java/org/bukkit/configuration/ConfigurationTest.java index 65f6ba389d..e5d9269176 100644 --- a/paper-api/src/test/java/org/bukkit/configuration/ConfigurationTest.java +++ b/paper-api/src/test/java/org/bukkit/configuration/ConfigurationTest.java @@ -1,6 +1,6 @@ package org.bukkit.configuration; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.util.Arrays; import java.util.HashMap; import java.util.HashSet; @@ -9,7 +9,7 @@ import java.util.Map; import java.util.Set; import org.bukkit.configuration.serialization.ConfigurationSerialization; import org.bukkit.util.Vector; -import org.junit.Test; +import org.junit.jupiter.api.Test; public abstract class ConfigurationTest { diff --git a/paper-api/src/test/java/org/bukkit/configuration/file/FileConfigurationTest.java b/paper-api/src/test/java/org/bukkit/configuration/file/FileConfigurationTest.java index d6a1410364..c25303e819 100644 --- a/paper-api/src/test/java/org/bukkit/configuration/file/FileConfigurationTest.java +++ b/paper-api/src/test/java/org/bukkit/configuration/file/FileConfigurationTest.java @@ -1,6 +1,6 @@ package org.bukkit.configuration.file; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.io.BufferedWriter; import java.io.File; import java.io.FileWriter; @@ -8,13 +8,12 @@ import java.util.Arrays; import java.util.List; import java.util.Map; import org.bukkit.configuration.MemoryConfigurationTest; -import org.junit.Rule; -import org.junit.Test; -import org.junit.rules.TemporaryFolder; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.io.TempDir; public abstract class FileConfigurationTest extends MemoryConfigurationTest { - @Rule - public TemporaryFolder testFolder = new TemporaryFolder(); + @TempDir + public File testFolder; @Override public abstract FileConfiguration getConfig(); @@ -36,7 +35,8 @@ public abstract class FileConfigurationTest extends MemoryConfigurationTest { @Test public void testSave_File() throws Exception { FileConfiguration config = getConfig(); - File file = testFolder.newFile("test.config"); + File file = new File(testFolder, "test.config"); + file.createNewFile(); for (Map.Entry entry : getTestValues().entrySet()) { config.set(entry.getKey(), entry.getValue()); @@ -50,7 +50,8 @@ public abstract class FileConfigurationTest extends MemoryConfigurationTest { @Test public void testSave_String() throws Exception { FileConfiguration config = getConfig(); - File file = testFolder.newFile("test.config"); + File file = new File(testFolder, "test.config"); + file.createNewFile(); for (Map.Entry entry : getTestValues().entrySet()) { config.set(entry.getKey(), entry.getValue()); @@ -78,7 +79,8 @@ public abstract class FileConfigurationTest extends MemoryConfigurationTest { @Test public void testLoad_File() throws Exception { FileConfiguration config = getConfig(); - File file = testFolder.newFile("test.config"); + File file = new File(testFolder, "test.config"); + file.createNewFile(); BufferedWriter writer = new BufferedWriter(new FileWriter(file)); String saved = getTestValuesString(); Map values = getTestValues(); @@ -101,7 +103,8 @@ public abstract class FileConfigurationTest extends MemoryConfigurationTest { @Test public void testLoad_String() throws Exception { FileConfiguration config = getConfig(); - File file = testFolder.newFile("test.config"); + File file = new File(testFolder, "test.config"); + file.createNewFile(); BufferedWriter writer = new BufferedWriter(new FileWriter(file)); String saved = getTestValuesString(); Map values = getTestValues(); diff --git a/paper-api/src/test/java/org/bukkit/configuration/file/YamlConfigurationTest.java b/paper-api/src/test/java/org/bukkit/configuration/file/YamlConfigurationTest.java index 003f45d8cd..82c7f6ba9c 100644 --- a/paper-api/src/test/java/org/bukkit/configuration/file/YamlConfigurationTest.java +++ b/paper-api/src/test/java/org/bukkit/configuration/file/YamlConfigurationTest.java @@ -1,6 +1,6 @@ package org.bukkit.configuration.file; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; @@ -12,7 +12,7 @@ import org.bukkit.configuration.ConfigurationSection; import org.bukkit.configuration.InvalidConfigurationException; import org.bukkit.configuration.MemoryConfiguration; import org.jetbrains.annotations.NotNull; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class YamlConfigurationTest extends FileConfigurationTest { diff --git a/paper-api/src/test/java/org/bukkit/conversations/ConversationContextTest.java b/paper-api/src/test/java/org/bukkit/conversations/ConversationContextTest.java index 3780a47c1f..48349dfb29 100644 --- a/paper-api/src/test/java/org/bukkit/conversations/ConversationContextTest.java +++ b/paper-api/src/test/java/org/bukkit/conversations/ConversationContextTest.java @@ -1,9 +1,9 @@ package org.bukkit.conversations; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.util.HashMap; import java.util.Map; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** */ @@ -19,7 +19,7 @@ public class ConversationContextTest { public void TestPlugin() { Conversable conversable = new FakeConversable(); ConversationContext context = new ConversationContext(null, conversable, new HashMap()); - assertEquals(null, context.getPlugin()); + assertNull(context.getPlugin()); } @Test diff --git a/paper-api/src/test/java/org/bukkit/conversations/ConversationTest.java b/paper-api/src/test/java/org/bukkit/conversations/ConversationTest.java index c448dc724d..8a515b0fed 100644 --- a/paper-api/src/test/java/org/bukkit/conversations/ConversationTest.java +++ b/paper-api/src/test/java/org/bukkit/conversations/ConversationTest.java @@ -1,8 +1,8 @@ package org.bukkit.conversations; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.plugin.TestPlugin; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** */ diff --git a/paper-api/src/test/java/org/bukkit/conversations/ValidatingPromptTest.java b/paper-api/src/test/java/org/bukkit/conversations/ValidatingPromptTest.java index 6093e9865b..b0c6eb9344 100644 --- a/paper-api/src/test/java/org/bukkit/conversations/ValidatingPromptTest.java +++ b/paper-api/src/test/java/org/bukkit/conversations/ValidatingPromptTest.java @@ -1,7 +1,7 @@ package org.bukkit.conversations; -import static org.junit.Assert.*; -import org.junit.Test; +import static org.junit.jupiter.api.Assertions.*; +import org.junit.jupiter.api.Test; /** */ diff --git a/paper-api/src/test/java/org/bukkit/entity/memory/MemoryKeyTest.java b/paper-api/src/test/java/org/bukkit/entity/memory/MemoryKeyTest.java index b955f6a7ad..2e426a9089 100644 --- a/paper-api/src/test/java/org/bukkit/entity/memory/MemoryKeyTest.java +++ b/paper-api/src/test/java/org/bukkit/entity/memory/MemoryKeyTest.java @@ -1,41 +1,41 @@ package org.bukkit.entity.memory; +import static org.junit.jupiter.api.Assertions.*; import java.util.Arrays; import java.util.List; import org.bukkit.NamespacedKey; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class MemoryKeyTest { @Test public void shouldContainAllMemories() { List memories = Arrays.asList(MemoryKey.HOME, MemoryKey.JOB_SITE, MemoryKey.MEETING_POINT); - Assert.assertTrue(MemoryKey.values().containsAll(memories)); + assertTrue(MemoryKey.values().containsAll(memories)); } @Test public void shouldGetMemoryKeyHomeByNamespacedKey() { - Assert.assertEquals(MemoryKey.HOME, MemoryKey.getByKey(NamespacedKey.minecraft("home"))); + assertEquals(MemoryKey.HOME, MemoryKey.getByKey(NamespacedKey.minecraft("home"))); } @Test public void shouldGetMemoryKeyJobSiteByNamespacedKey() { - Assert.assertEquals(MemoryKey.JOB_SITE, MemoryKey.getByKey(NamespacedKey.minecraft("job_site"))); + assertEquals(MemoryKey.JOB_SITE, MemoryKey.getByKey(NamespacedKey.minecraft("job_site"))); } @Test public void shouldGetMemoryKeyMeetingPointByNamespacedKey() { - Assert.assertEquals(MemoryKey.MEETING_POINT, MemoryKey.getByKey(NamespacedKey.minecraft("meeting_point"))); + assertEquals(MemoryKey.MEETING_POINT, MemoryKey.getByKey(NamespacedKey.minecraft("meeting_point"))); } @Test public void shouldReturnNullWhenNamespacedKeyisNotPresentAsMemoryKey() { - Assert.assertEquals(null, MemoryKey.getByKey(NamespacedKey.minecraft("not_present"))); + assertNull(MemoryKey.getByKey(NamespacedKey.minecraft("not_present"))); } @Test public void shouldReturnNullWhenNamespacedKeyisNull() { - Assert.assertNull(MemoryKey.getByKey(null)); + assertNull(MemoryKey.getByKey(null)); } } diff --git a/paper-api/src/test/java/org/bukkit/event/PlayerChatTabCompleteEventTest.java b/paper-api/src/test/java/org/bukkit/event/PlayerChatTabCompleteEventTest.java index 80c0bfbd2a..346214f24a 100644 --- a/paper-api/src/test/java/org/bukkit/event/PlayerChatTabCompleteEventTest.java +++ b/paper-api/src/test/java/org/bukkit/event/PlayerChatTabCompleteEventTest.java @@ -1,11 +1,11 @@ package org.bukkit.event; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.bukkit.support.MatcherAssert.*; +import static org.hamcrest.Matchers.*; import static org.mockito.Mockito.*; import com.google.common.collect.ImmutableList; import org.bukkit.event.player.PlayerChatTabCompleteEvent; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class PlayerChatTabCompleteEventTest { diff --git a/paper-api/src/test/java/org/bukkit/event/SyntheticEventTest.java b/paper-api/src/test/java/org/bukkit/event/SyntheticEventTest.java index ab53cf1438..40a086f288 100644 --- a/paper-api/src/test/java/org/bukkit/event/SyntheticEventTest.java +++ b/paper-api/src/test/java/org/bukkit/event/SyntheticEventTest.java @@ -1,13 +1,13 @@ package org.bukkit.event; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.Bukkit; import org.bukkit.plugin.PluginLoader; import org.bukkit.plugin.SimplePluginManager; import org.bukkit.plugin.TestPlugin; import org.bukkit.plugin.java.JavaPluginLoader; import org.bukkit.support.AbstractTestingBase; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class SyntheticEventTest extends AbstractTestingBase { @SuppressWarnings("deprecation") @@ -28,7 +28,7 @@ public class SyntheticEventTest extends AbstractTestingBase { pluginManager.registerEvents(impl, plugin); pluginManager.callEvent(event); - Assert.assertEquals(1, impl.callCount); + assertEquals(1, impl.callCount); } public abstract static class Base implements Listener { diff --git a/paper-api/src/test/java/org/bukkit/materials/MaterialDataTest.java b/paper-api/src/test/java/org/bukkit/materials/MaterialDataTest.java index a935ae4a25..8d78435cc4 100644 --- a/paper-api/src/test/java/org/bukkit/materials/MaterialDataTest.java +++ b/paper-api/src/test/java/org/bukkit/materials/MaterialDataTest.java @@ -1,7 +1,7 @@ package org.bukkit.materials; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; import org.bukkit.CropState; import org.bukkit.Material; import org.bukkit.NetherWartsState; @@ -20,7 +20,7 @@ import org.bukkit.material.Tree; import org.bukkit.material.Wood; import org.bukkit.material.WoodenStep; import org.bukkit.material.types.MushroomBlockTexture; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class MaterialDataTest { @@ -28,10 +28,10 @@ public class MaterialDataTest { public void testDoor() { @SuppressWarnings("deprecation") Door door = new Door(); - assertThat("Constructed with default door type", door.getItemType(), equalTo(Material.LEGACY_WOODEN_DOOR)); - assertThat("Constructed with default top or bottom", door.isTopHalf(), equalTo(false)); - assertThat("Constructed with default direction", door.getFacing(), equalTo(BlockFace.WEST)); - assertThat("Constructed with default open state", door.isOpen(), equalTo(false)); + assertThat(door.getItemType(), equalTo(Material.LEGACY_WOODEN_DOOR), "Constructed with default door type"); + assertThat(door.isTopHalf(), equalTo(false), "Constructed with default top or bottom"); + assertThat(door.getFacing(), equalTo(BlockFace.WEST), "Constructed with default direction"); + assertThat(door.isOpen(), equalTo(false), "Constructed with default open state"); Material[] types = new Material[]{Material.LEGACY_WOODEN_DOOR, Material.LEGACY_IRON_DOOR_BLOCK, Material.LEGACY_SPRUCE_DOOR, @@ -44,26 +44,26 @@ public class MaterialDataTest { // Test bottom half for (BlockFace facing : directions) { door = new Door(type, facing); - assertThat("Constructed with correct door type", door.getItemType(), equalTo(type)); - assertThat("Constructed with default top or bottom", door.isTopHalf(), equalTo(false)); - assertThat("Constructed with correct direction", door.getFacing(), equalTo(facing)); - assertThat("Constructed with default open state", door.isOpen(), equalTo(false)); + assertThat(door.getItemType(), equalTo(type), "Constructed with correct door type"); + assertThat(door.isTopHalf(), equalTo(false), "Constructed with default top or bottom"); + assertThat(door.getFacing(), equalTo(facing), "Constructed with correct direction"); + assertThat(door.isOpen(), equalTo(false), "Constructed with default open state"); for (boolean openState : openStates) { door = new Door(type, facing, openState); - assertThat("Constructed with correct door type", door.getItemType(), equalTo(type)); - assertThat("Constructed with default top or bottom", door.isTopHalf(), equalTo(false)); - assertThat("Constructed with correct direction", door.getFacing(), equalTo(facing)); - assertThat("Constructed with correct open state", door.isOpen(), equalTo(openState)); + assertThat(door.getItemType(), equalTo(type), "Constructed with correct door type"); + assertThat(door.isTopHalf(), equalTo(false), "Constructed with default top or bottom"); + assertThat(door.getFacing(), equalTo(facing), "Constructed with correct direction"); + assertThat(door.isOpen(), equalTo(openState), "Constructed with correct open state"); } } // Test top half for (boolean hingeState : hingeStates) { door = new Door(type, hingeState); - assertThat("Constructed with correct door type", door.getItemType(), equalTo(type)); - assertThat("Constructed with default top or bottom", door.isTopHalf(), equalTo(true)); - assertThat("Constructed with correct direction", door.getHinge(), equalTo(hingeState)); + assertThat(door.getItemType(), equalTo(type), "Constructed with correct door type"); + assertThat(door.isTopHalf(), equalTo(true), "Constructed with default top or bottom"); + assertThat(door.getHinge(), equalTo(hingeState), "Constructed with correct direction"); } } } @@ -71,26 +71,26 @@ public class MaterialDataTest { @Test public void testWood() { Wood wood = new Wood(); - assertThat("Constructed with default wood type", wood.getItemType(), equalTo(Material.LEGACY_WOOD)); - assertThat("Constructed with default tree species", wood.getSpecies(), equalTo(TreeSpecies.GENERIC)); + assertThat(wood.getItemType(), equalTo(Material.LEGACY_WOOD), "Constructed with default wood type"); + assertThat(wood.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species"); TreeSpecies[] allSpecies = TreeSpecies.values(); for (TreeSpecies species : allSpecies) { wood = new Wood(species); - assertThat("Constructed with default wood type", wood.getItemType(), equalTo(Material.LEGACY_WOOD)); - assertThat("Constructed with correct tree species", wood.getSpecies(), equalTo(species)); + assertThat(wood.getItemType(), equalTo(Material.LEGACY_WOOD), "Constructed with default wood type"); + assertThat(wood.getSpecies(), equalTo(species), "Constructed with correct tree species"); } Material[] types = new Material[]{Material.LEGACY_WOOD, Material.LEGACY_WOOD_DOUBLE_STEP}; for (Material type : types) { wood = new Wood(type); - assertThat("Constructed with correct wood type", wood.getItemType(), equalTo(type)); - assertThat("Constructed with default tree species", wood.getSpecies(), equalTo(TreeSpecies.GENERIC)); + assertThat(wood.getItemType(), equalTo(type), "Constructed with correct wood type"); + assertThat(wood.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species"); for (TreeSpecies species : allSpecies) { wood = new Wood(type, species); - assertThat("Constructed with correct wood type", wood.getItemType(), equalTo(type)); - assertThat("Constructed with correct tree species", wood.getSpecies(), equalTo(species)); + assertThat(wood.getItemType(), equalTo(type), "Constructed with correct wood type"); + assertThat(wood.getSpecies(), equalTo(species), "Constructed with correct tree species"); } } } @@ -98,14 +98,14 @@ public class MaterialDataTest { @Test public void testTree() { Tree tree = new Tree(); - assertThat("Constructed with default tree type", tree.getItemType(), equalTo(Material.LEGACY_LOG)); - assertThat("Constructed with default tree species", tree.getSpecies(), equalTo(TreeSpecies.GENERIC)); - assertThat("Constructed with default direction", tree.getDirection(), equalTo(BlockFace.UP)); + assertThat(tree.getItemType(), equalTo(Material.LEGACY_LOG), "Constructed with default tree type"); + assertThat(tree.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species"); + assertThat(tree.getDirection(), equalTo(BlockFace.UP), "Constructed with default direction"); tree = new Tree(Material.LEGACY_LOG); - assertThat("Constructed with correct tree type", tree.getItemType(), equalTo(Material.LEGACY_LOG)); - assertThat("Constructed with default tree species", tree.getSpecies(), equalTo(TreeSpecies.GENERIC)); - assertThat("Constructed with default direction", tree.getDirection(), equalTo(BlockFace.UP)); + assertThat(tree.getItemType(), equalTo(Material.LEGACY_LOG), "Constructed with correct tree type"); + assertThat(tree.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species"); + assertThat(tree.getDirection(), equalTo(BlockFace.UP), "Constructed with default direction"); Material[] types = new Material[]{Material.LEGACY_LOG, Material.LEGACY_LOG_2}; TreeSpecies[][] allSpecies = new TreeSpecies[][]{ @@ -116,20 +116,20 @@ public class MaterialDataTest { for (int t = 0; t < types.length; t++) { for (TreeSpecies species : allSpecies[t]) { tree = new Tree(types[t], species); - assertThat("Constructed with correct tree type", tree.getItemType(), equalTo(types[t])); - assertThat("Constructed with correct tree species", tree.getSpecies(), equalTo(species)); - assertThat("Constructed with default direction", tree.getDirection(), equalTo(BlockFace.UP)); + assertThat(tree.getItemType(), equalTo(types[t]), "Constructed with correct tree type"); + assertThat(tree.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(tree.getDirection(), equalTo(BlockFace.UP), "Constructed with default direction"); // check item type is fixed automatically for invalid type-species combo tree = new Tree(types[types.length - 1 - t], species); - assertThat("Constructed with fixed tree type", tree.getItemType(), equalTo(types[t])); - assertThat("Constructed with correct tree species", tree.getSpecies(), equalTo(species)); - assertThat("Constructed with default direction", tree.getDirection(), equalTo(BlockFace.UP)); + assertThat(tree.getItemType(), equalTo(types[t]), "Constructed with fixed tree type"); + assertThat(tree.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(tree.getDirection(), equalTo(BlockFace.UP), "Constructed with default direction"); for (BlockFace dir : allDirections) { tree = new Tree(types[t], species, dir); - assertThat("Constructed with correct tree type", tree.getItemType(), equalTo(types[t])); - assertThat("Constructed with correct tree species", tree.getSpecies(), equalTo(species)); - assertThat("Constructed with correct direction", tree.getDirection(), equalTo(dir)); + assertThat(tree.getItemType(), equalTo(types[t]), "Constructed with correct tree type"); + assertThat(tree.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(tree.getDirection(), equalTo(dir), "Constructed with correct direction"); } } } @@ -138,16 +138,16 @@ public class MaterialDataTest { @Test public void testLeaves() { Leaves leaves = new Leaves(); - assertThat("Constructed with default leaf type", leaves.getItemType(), equalTo(Material.LEGACY_LEAVES)); - assertThat("Constructed with default tree species", leaves.getSpecies(), equalTo(TreeSpecies.GENERIC)); - assertThat("Constructed with default decayable", leaves.isDecayable(), equalTo(true)); - assertThat("Constructed with default decaying", leaves.isDecaying(), equalTo(false)); + assertThat(leaves.getItemType(), equalTo(Material.LEGACY_LEAVES), "Constructed with default leaf type"); + assertThat(leaves.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species"); + assertThat(leaves.isDecayable(), equalTo(true), "Constructed with default decayable"); + assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying"); leaves = new Leaves(Material.LEGACY_LEAVES); - assertThat("Constructed with correct leaf type", leaves.getItemType(), equalTo(Material.LEGACY_LEAVES)); - assertThat("Constructed with default tree species", leaves.getSpecies(), equalTo(TreeSpecies.GENERIC)); - assertThat("Constructed with default decayable", leaves.isDecayable(), equalTo(true)); - assertThat("Constructed with default decaying", leaves.isDecaying(), equalTo(false)); + assertThat(leaves.getItemType(), equalTo(Material.LEGACY_LEAVES), "Constructed with correct leaf type"); + assertThat(leaves.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species"); + assertThat(leaves.isDecayable(), equalTo(true), "Constructed with default decayable"); + assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying"); Material[] types = new Material[]{Material.LEGACY_LEAVES, Material.LEGACY_LEAVES_2}; TreeSpecies[][] allSpecies = new TreeSpecies[][]{ @@ -159,30 +159,30 @@ public class MaterialDataTest { for (int t = 0; t < types.length; t++) { for (TreeSpecies species : allSpecies[t]) { leaves = new Leaves(types[t], species); - assertThat("Constructed with correct leaf type", leaves.getItemType(), equalTo(types[t])); - assertThat("Constructed with correct tree species", leaves.getSpecies(), equalTo(species)); - assertThat("Constructed with default decayable", leaves.isDecayable(), equalTo(true)); - assertThat("Constructed with default decaying", leaves.isDecaying(), equalTo(false)); + assertThat(leaves.getItemType(), equalTo(types[t]), "Constructed with correct leaf type"); + assertThat(leaves.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(leaves.isDecayable(), equalTo(true), "Constructed with default decayable"); + assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying"); // check item type is fixed automatically for invalid type-species combo leaves = new Leaves(types[types.length - 1 - t], species); - assertThat("Constructed with fixed leaf type", leaves.getItemType(), equalTo(types[t])); - assertThat("Constructed with correct tree species", leaves.getSpecies(), equalTo(species)); - assertThat("Constructed with default decayable", leaves.isDecayable(), equalTo(true)); - assertThat("Constructed with default decaying", leaves.isDecaying(), equalTo(false)); + assertThat(leaves.getItemType(), equalTo(types[t]), "Constructed with fixed leaf type"); + assertThat(leaves.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(leaves.isDecayable(), equalTo(true), "Constructed with default decayable"); + assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying"); for (boolean isDecayable : decayable) { leaves = new Leaves(types[t], species, isDecayable); - assertThat("Constructed with correct wood type", leaves.getItemType(), equalTo(types[t])); - assertThat("Constructed with correct tree species", leaves.getSpecies(), equalTo(species)); - assertThat("Constructed with correct decayable", leaves.isDecayable(), equalTo(isDecayable)); - assertThat("Constructed with default decaying", leaves.isDecaying(), equalTo(false)); + assertThat(leaves.getItemType(), equalTo(types[t]), "Constructed with correct wood type"); + assertThat(leaves.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(leaves.isDecayable(), equalTo(isDecayable), "Constructed with correct decayable"); + assertThat(leaves.isDecaying(), equalTo(false), "Constructed with default decaying"); for (boolean isDecaying : decaying) { leaves = new Leaves(types[t], species, isDecayable); leaves.setDecaying(isDecaying); - assertThat("Constructed with correct wood type", leaves.getItemType(), equalTo(types[t])); - assertThat("Constructed with correct tree species", leaves.getSpecies(), equalTo(species)); - assertThat("Constructed with correct decayable", leaves.isDecayable(), equalTo(isDecaying || isDecayable)); - assertThat("Constructed with correct decaying", leaves.isDecaying(), equalTo(isDecaying)); + assertThat(leaves.getItemType(), equalTo(types[t]), "Constructed with correct wood type"); + assertThat(leaves.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(leaves.isDecayable(), equalTo(isDecaying || isDecayable), "Constructed with correct decayable"); + assertThat(leaves.isDecaying(), equalTo(isDecaying), "Constructed with correct decaying"); } } } @@ -192,22 +192,22 @@ public class MaterialDataTest { @Test public void testWoodenStep() { WoodenStep woodenStep = new WoodenStep(); - assertThat("Constructed with default step type", woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP)); - assertThat("Constructed with default tree species", woodenStep.getSpecies(), equalTo(TreeSpecies.GENERIC)); - assertThat("Constructed with default inversion", woodenStep.isInverted(), equalTo(false)); + assertThat(woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP), "Constructed with default step type"); + assertThat(woodenStep.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species"); + assertThat(woodenStep.isInverted(), equalTo(false), "Constructed with default inversion"); TreeSpecies[] allSpecies = TreeSpecies.values(); boolean[] inversion = new boolean[]{true, false}; for (TreeSpecies species : allSpecies) { woodenStep = new WoodenStep(species); - assertThat("Constructed with default step type", woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP)); - assertThat("Constructed with correct tree species", woodenStep.getSpecies(), equalTo(species)); - assertThat("Constructed with default inversion", woodenStep.isInverted(), equalTo(false)); + assertThat(woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP), "Constructed with default step type"); + assertThat(woodenStep.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(woodenStep.isInverted(), equalTo(false), "Constructed with default inversion"); for (boolean isInverted : inversion) { woodenStep = new WoodenStep(species, isInverted); - assertThat("Constructed with default step type", woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP)); - assertThat("Constructed with correct tree species", woodenStep.getSpecies(), equalTo(species)); - assertThat("Constructed with correct inversion", woodenStep.isInverted(), equalTo(isInverted)); + assertThat(woodenStep.getItemType(), equalTo(Material.LEGACY_WOOD_STEP), "Constructed with default step type"); + assertThat(woodenStep.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(woodenStep.isInverted(), equalTo(isInverted), "Constructed with correct inversion"); } } } @@ -215,22 +215,22 @@ public class MaterialDataTest { @Test public void testSapling() { Sapling sapling = new Sapling(); - assertThat("Constructed with default sapling type", sapling.getItemType(), equalTo(Material.LEGACY_SAPLING)); - assertThat("Constructed with default tree species", sapling.getSpecies(), equalTo(TreeSpecies.GENERIC)); - assertThat("Constructed with default growable", sapling.isInstantGrowable(), equalTo(false)); + assertThat(sapling.getItemType(), equalTo(Material.LEGACY_SAPLING), "Constructed with default sapling type"); + assertThat(sapling.getSpecies(), equalTo(TreeSpecies.GENERIC), "Constructed with default tree species"); + assertThat(sapling.isInstantGrowable(), equalTo(false), "Constructed with default growable"); TreeSpecies[] allSpecies = TreeSpecies.values(); boolean[] growable = new boolean[]{true, false}; for (TreeSpecies species : allSpecies) { sapling = new Sapling(species); - assertThat("Constructed with default sapling type", sapling.getItemType(), equalTo(Material.LEGACY_SAPLING)); - assertThat("Constructed with correct tree species", sapling.getSpecies(), equalTo(species)); - assertThat("Constructed with default growable", sapling.isInstantGrowable(), equalTo(false)); + assertThat(sapling.getItemType(), equalTo(Material.LEGACY_SAPLING), "Constructed with default sapling type"); + assertThat(sapling.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(sapling.isInstantGrowable(), equalTo(false), "Constructed with default growable"); for (boolean isInstantGrowable : growable) { sapling = new Sapling(species, isInstantGrowable); - assertThat("Constructed with default sapling type", sapling.getItemType(), equalTo(Material.LEGACY_SAPLING)); - assertThat("Constructed with correct tree species", sapling.getSpecies(), equalTo(species)); - assertThat("Constructed with correct growable", sapling.isInstantGrowable(), equalTo(isInstantGrowable)); + assertThat(sapling.getItemType(), equalTo(Material.LEGACY_SAPLING), "Constructed with default sapling type"); + assertThat(sapling.getSpecies(), equalTo(species), "Constructed with correct tree species"); + assertThat(sapling.isInstantGrowable(), equalTo(isInstantGrowable), "Constructed with correct growable"); } } } @@ -244,19 +244,19 @@ public class MaterialDataTest { MushroomBlockTexture[] textures = MushroomBlockTexture.values(); for (Material type : mushroomTypes) { Mushroom mushroom = new Mushroom(type); - assertThat("Constructed with correct mushroom type", mushroom.getItemType(), equalTo(type)); - assertThat("Constructed with default pores face", mushroom.getBlockTexture(), equalTo(MushroomBlockTexture.ALL_PORES)); + assertThat(mushroom.getItemType(), equalTo(type), "Constructed with correct mushroom type"); + assertThat(mushroom.getBlockTexture(), equalTo(MushroomBlockTexture.ALL_PORES), "Constructed with default pores face"); for (int f = 0; f < setFaces.length; f++) { mushroom = new Mushroom(type, setFaces[f]); - assertThat("Constructed with correct mushroom type", mushroom.getItemType(), equalTo(type)); - assertThat("Constructed with correct texture", mushroom.getBlockTexture(), equalTo(MushroomBlockTexture.getCapByFace(setFaces[f]))); + assertThat(mushroom.getItemType(), equalTo(type), "Constructed with correct mushroom type"); + assertThat(mushroom.getBlockTexture(), equalTo(MushroomBlockTexture.getCapByFace(setFaces[f])), "Constructed with correct texture"); } for (MushroomBlockTexture texture : textures) { mushroom = new Mushroom(type, texture); - assertThat("Constructed with correct mushroom type", mushroom.getItemType(), equalTo(type)); - assertThat("Constructed with correct texture", mushroom.getBlockTexture(), equalTo(texture)); + assertThat(mushroom.getItemType(), equalTo(type), "Constructed with correct mushroom type"); + assertThat(mushroom.getBlockTexture(), equalTo(texture), "Constructed with correct texture"); } } } @@ -264,90 +264,90 @@ public class MaterialDataTest { @Test public void testCrops() { Crops crops = new Crops(); - assertThat("Constructed with default crops type", crops.getItemType(), equalTo(Material.LEGACY_CROPS)); - assertThat("Constructed with default crop state", crops.getState(), equalTo(CropState.SEEDED)); + assertThat(crops.getItemType(), equalTo(Material.LEGACY_CROPS), "Constructed with default crops type"); + assertThat(crops.getState(), equalTo(CropState.SEEDED), "Constructed with default crop state"); CropState[] allStates = CropState.values(); for (CropState state : allStates) { crops = new Crops(state); - assertThat("Constructed with default crops type", crops.getItemType(), equalTo(Material.LEGACY_CROPS)); - assertThat("Constructed with correct crop state", crops.getState(), equalTo(state)); + assertThat(crops.getItemType(), equalTo(Material.LEGACY_CROPS), "Constructed with default crops type"); + assertThat(crops.getState(), equalTo(state), "Constructed with correct crop state"); } // The crops which fully implement all crop states Material[] allCrops = new Material[]{Material.LEGACY_CROPS, Material.LEGACY_CARROT, Material.LEGACY_POTATO}; for (Material crop : allCrops) { crops = new Crops(crop); - assertThat("Constructed with correct crops type", crops.getItemType(), equalTo(crop)); - assertThat("Constructed with default crop state", crops.getState(), equalTo(CropState.SEEDED)); + assertThat(crops.getItemType(), equalTo(crop), "Constructed with correct crops type"); + assertThat(crops.getState(), equalTo(CropState.SEEDED), "Constructed with default crop state"); for (CropState state : allStates) { crops = new Crops(crop, state); - assertThat("Constructed with correct crops type", crops.getItemType(), equalTo(crop)); - assertThat("Constructed with correct crop state", crops.getState(), equalTo(state)); + assertThat(crops.getItemType(), equalTo(crop), "Constructed with correct crops type"); + assertThat(crops.getState(), equalTo(state), "Constructed with correct crop state"); } } // Beetroot are crops too, but they only have four states // Setting different crop states for beetroot will return the following when retrieved back CropState[] beetrootStates = new CropState[]{CropState.SEEDED, CropState.SEEDED, CropState.SMALL, CropState.SMALL, CropState.TALL, CropState.TALL, CropState.RIPE, CropState.RIPE}; - assertThat("Beetroot state translations match size", beetrootStates.length, equalTo(allStates.length)); + assertThat(beetrootStates.length, equalTo(allStates.length), "Beetroot state translations match size"); crops = new Crops(Material.LEGACY_BEETROOT_BLOCK); - assertThat("Constructed with correct crops type", crops.getItemType(), equalTo(Material.LEGACY_BEETROOT_BLOCK)); - assertThat("Constructed with default crop state", crops.getState(), equalTo(CropState.SEEDED)); + assertThat(crops.getItemType(), equalTo(Material.LEGACY_BEETROOT_BLOCK), "Constructed with correct crops type"); + assertThat(crops.getState(), equalTo(CropState.SEEDED), "Constructed with default crop state"); for (int s = 0; s < beetrootStates.length; s++) { crops = new Crops(Material.LEGACY_BEETROOT_BLOCK, allStates[s]); - assertThat("Constructed with correct crops type", crops.getItemType(), equalTo(Material.LEGACY_BEETROOT_BLOCK)); - assertThat("Constructed with correct crop state", crops.getState(), equalTo(beetrootStates[s])); + assertThat(crops.getItemType(), equalTo(Material.LEGACY_BEETROOT_BLOCK), "Constructed with correct crops type"); + assertThat(crops.getState(), equalTo(beetrootStates[s]), "Constructed with correct crop state"); } // In case you want to treat NetherWarts as Crops, although they really aren't crops = new Crops(Material.LEGACY_NETHER_WARTS); NetherWarts warts = new NetherWarts(); - assertThat("Constructed with correct crops type", crops.getItemType(), equalTo(warts.getItemType())); - assertThat("Constructed with default crop state", crops.getState(), equalTo(CropState.SEEDED)); - assertThat("Constructed with default wart state", warts.getState(), equalTo(NetherWartsState.SEEDED)); + assertThat(crops.getItemType(), equalTo(warts.getItemType()), "Constructed with correct crops type"); + assertThat(crops.getState(), equalTo(CropState.SEEDED), "Constructed with default crop state"); + assertThat(warts.getState(), equalTo(NetherWartsState.SEEDED), "Constructed with default wart state"); allStates = new CropState[]{CropState.SEEDED, CropState.SMALL, CropState.TALL, CropState.RIPE}; NetherWartsState[] allWartStates = NetherWartsState.values(); - assertThat("Nether Warts state translations match size", allWartStates.length, equalTo(allStates.length)); + assertThat(allWartStates.length, equalTo(allStates.length), "Nether Warts state translations match size"); for (int s = 0; s < allStates.length; s++) { crops = new Crops(Material.LEGACY_NETHER_WARTS, allStates[s]); warts = new NetherWarts(allWartStates[s]); - assertThat("Constructed with correct crops type", crops.getItemType(), equalTo(warts.getItemType())); - assertThat("Constructed with correct crop state", crops.getState(), equalTo(allStates[s])); - assertThat("Constructed with correct wart state", warts.getState(), equalTo(allWartStates[s])); + assertThat(crops.getItemType(), equalTo(warts.getItemType()), "Constructed with correct crops type"); + assertThat(crops.getState(), equalTo(allStates[s]), "Constructed with correct crop state"); + assertThat(warts.getState(), equalTo(allWartStates[s]), "Constructed with correct wart state"); } } @Test public void testDiode() { Diode diode = new Diode(); - assertThat("Constructed with backward compatible diode state", diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_ON)); - assertThat("Constructed with backward compatible powered", diode.isPowered(), equalTo(true)); - assertThat("Constructed with default delay", diode.getDelay(), equalTo(1)); - assertThat("Constructed with default direction", diode.getFacing(), equalTo(BlockFace.NORTH)); + assertThat(diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_ON), "Constructed with backward compatible diode state"); + assertThat(diode.isPowered(), equalTo(true), "Constructed with backward compatible powered"); + assertThat(diode.getDelay(), equalTo(1), "Constructed with default delay"); + assertThat(diode.getFacing(), equalTo(BlockFace.NORTH), "Constructed with default direction"); BlockFace[] directions = new BlockFace[]{BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST}; int[] delays = new int[]{1, 2, 3, 4}; boolean[] states = new boolean[]{false, true}; for (BlockFace direction : directions) { diode = new Diode(direction); - assertThat("Constructed with default diode state", diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_OFF)); - assertThat("Constructed with default powered", diode.isPowered(), equalTo(false)); - assertThat("Constructed with default delay", diode.getDelay(), equalTo(1)); - assertThat("Constructed with correct direction", diode.getFacing(), equalTo(direction)); + assertThat(diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_OFF), "Constructed with default diode state"); + assertThat(diode.isPowered(), equalTo(false), "Constructed with default powered"); + assertThat(diode.getDelay(), equalTo(1), "Constructed with default delay"); + assertThat(diode.getFacing(), equalTo(direction), "Constructed with correct direction"); for (int delay : delays) { diode = new Diode(direction, delay); - assertThat("Constructed with default diode state", diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_OFF)); - assertThat("Constructed with default powered", diode.isPowered(), equalTo(false)); - assertThat("Constructed with correct delay", diode.getDelay(), equalTo(delay)); - assertThat("Constructed with correct direction", diode.getFacing(), equalTo(direction)); + assertThat(diode.getItemType(), equalTo(Material.LEGACY_DIODE_BLOCK_OFF), "Constructed with default diode state"); + assertThat(diode.isPowered(), equalTo(false), "Constructed with default powered"); + assertThat(diode.getDelay(), equalTo(delay), "Constructed with correct delay"); + assertThat(diode.getFacing(), equalTo(direction), "Constructed with correct direction"); for (boolean state : states) { diode = new Diode(direction, delay, state); - assertThat("Constructed with correct diode state", diode.getItemType(), equalTo(state ? Material.LEGACY_DIODE_BLOCK_ON : Material.LEGACY_DIODE_BLOCK_OFF)); - assertThat("Constructed with default powered", diode.isPowered(), equalTo(state)); - assertThat("Constructed with correct delay", diode.getDelay(), equalTo(delay)); - assertThat("Constructed with correct direction", diode.getFacing(), equalTo(direction)); + assertThat(diode.getItemType(), equalTo(state ? Material.LEGACY_DIODE_BLOCK_ON : Material.LEGACY_DIODE_BLOCK_OFF), "Constructed with correct diode state"); + assertThat(diode.isPowered(), equalTo(state), "Constructed with default powered"); + assertThat(diode.getDelay(), equalTo(delay), "Constructed with correct delay"); + assertThat(diode.getFacing(), equalTo(direction), "Constructed with correct direction"); } } } @@ -356,44 +356,44 @@ public class MaterialDataTest { @Test public void testComparator() { Comparator comparator = new Comparator(); - assertThat("Constructed with default comparator state", comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF)); - assertThat("Constructed with default powered", comparator.isPowered(), equalTo(false)); - assertThat("Constructed with default being powered", comparator.isBeingPowered(), equalTo(false)); - assertThat("Constructed with default mode", comparator.isSubtractionMode(), equalTo(false)); - assertThat("Constructed with default direction", comparator.getFacing(), equalTo(BlockFace.NORTH)); + assertThat(comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with default comparator state"); + assertThat(comparator.isPowered(), equalTo(false), "Constructed with default powered"); + assertThat(comparator.isBeingPowered(), equalTo(false), "Constructed with default being powered"); + assertThat(comparator.isSubtractionMode(), equalTo(false), "Constructed with default mode"); + assertThat(comparator.getFacing(), equalTo(BlockFace.NORTH), "Constructed with default direction"); BlockFace[] directions = new BlockFace[]{BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST}; boolean[] modes = new boolean[]{false, true}; boolean[] states = new boolean[]{false, true}; for (BlockFace direction : directions) { comparator = new Comparator(direction); - assertThat("Constructed with default comparator state", comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF)); - assertThat("Constructed with default powered", comparator.isPowered(), equalTo(false)); - assertThat("Constructed with default being powered", comparator.isBeingPowered(), equalTo(false)); - assertThat("Constructed with default mode", comparator.isSubtractionMode(), equalTo(false)); - assertThat("Constructed with correct direction", comparator.getFacing(), equalTo(direction)); + assertThat(comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with default comparator state"); + assertThat(comparator.isPowered(), equalTo(false), "Constructed with default powered"); + assertThat(comparator.isBeingPowered(), equalTo(false), "Constructed with default being powered"); + assertThat(comparator.isSubtractionMode(), equalTo(false), "Constructed with default mode"); + assertThat(comparator.getFacing(), equalTo(direction), "Constructed with correct direction"); for (boolean mode : modes) { comparator = new Comparator(direction, mode); - assertThat("Constructed with default comparator state", comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF)); - assertThat("Constructed with default powered", comparator.isPowered(), equalTo(false)); - assertThat("Constructed with default being powered", comparator.isBeingPowered(), equalTo(false)); - assertThat("Constructed with correct mode", comparator.isSubtractionMode(), equalTo(mode)); - assertThat("Constructed with correct direction", comparator.getFacing(), equalTo(direction)); + assertThat(comparator.getItemType(), equalTo(Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with default comparator state"); + assertThat(comparator.isPowered(), equalTo(false), "Constructed with default powered"); + assertThat(comparator.isBeingPowered(), equalTo(false), "Constructed with default being powered"); + assertThat(comparator.isSubtractionMode(), equalTo(mode), "Constructed with correct mode"); + assertThat(comparator.getFacing(), equalTo(direction), "Constructed with correct direction"); for (boolean state : states) { comparator = new Comparator(direction, mode, state); - assertThat("Constructed with correct comparator state", comparator.getItemType(), equalTo(state ? Material.LEGACY_REDSTONE_COMPARATOR_ON : Material.LEGACY_REDSTONE_COMPARATOR_OFF)); - assertThat("Constructed with correct powered", comparator.isPowered(), equalTo(state)); - assertThat("Constructed with default being powered", comparator.isBeingPowered(), equalTo(false)); - assertThat("Constructed with correct mode", comparator.isSubtractionMode(), equalTo(mode)); - assertThat("Constructed with correct direction", comparator.getFacing(), equalTo(direction)); + assertThat(comparator.getItemType(), equalTo(state ? Material.LEGACY_REDSTONE_COMPARATOR_ON : Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with correct comparator state"); + assertThat(comparator.isPowered(), equalTo(state), "Constructed with correct powered"); + assertThat(comparator.isBeingPowered(), equalTo(false), "Constructed with default being powered"); + assertThat(comparator.isSubtractionMode(), equalTo(mode), "Constructed with correct mode"); + assertThat(comparator.getFacing(), equalTo(direction), "Constructed with correct direction"); // Check if the game sets the fourth bit, that block data is still interpreted correctly comparator.setData((byte) ((comparator.getData() & 0x7) | 0x8)); - assertThat("Constructed with correct comparator state", comparator.getItemType(), equalTo(state ? Material.LEGACY_REDSTONE_COMPARATOR_ON : Material.LEGACY_REDSTONE_COMPARATOR_OFF)); - assertThat("Constructed with correct powered", comparator.isPowered(), equalTo(state)); - assertThat("Constructed with correct being powered", comparator.isBeingPowered(), equalTo(true)); - assertThat("Constructed with correct mode", comparator.isSubtractionMode(), equalTo(mode)); - assertThat("Constructed with correct direction", comparator.getFacing(), equalTo(direction)); + assertThat(comparator.getItemType(), equalTo(state ? Material.LEGACY_REDSTONE_COMPARATOR_ON : Material.LEGACY_REDSTONE_COMPARATOR_OFF), "Constructed with correct comparator state"); + assertThat(comparator.isPowered(), equalTo(state), "Constructed with correct powered"); + assertThat(comparator.isBeingPowered(), equalTo(true), "Constructed with correct being powered"); + assertThat(comparator.isSubtractionMode(), equalTo(mode), "Constructed with correct mode"); + assertThat(comparator.getFacing(), equalTo(direction), "Constructed with correct direction"); } } } @@ -402,25 +402,25 @@ public class MaterialDataTest { @Test public void testHopper() { Hopper hopper = new Hopper(); - assertThat("Constructed with default hopper type", hopper.getItemType(), equalTo(Material.LEGACY_HOPPER)); - assertThat("Constructed with default active state", hopper.isActive(), equalTo(true)); - assertThat("Constructed with default powered state", hopper.isPowered(), equalTo(false)); - assertThat("Constructed with default direction", hopper.getFacing(), equalTo(BlockFace.DOWN)); + assertThat(hopper.getItemType(), equalTo(Material.LEGACY_HOPPER), "Constructed with default hopper type"); + assertThat(hopper.isActive(), equalTo(true), "Constructed with default active state"); + assertThat(hopper.isPowered(), equalTo(false), "Constructed with default powered state"); + assertThat(hopper.getFacing(), equalTo(BlockFace.DOWN), "Constructed with default direction"); BlockFace[] directions = new BlockFace[]{BlockFace.DOWN, BlockFace.NORTH, BlockFace.SOUTH, BlockFace.WEST, BlockFace.EAST}; boolean[] activeStates = new boolean[]{true, false}; for (BlockFace direction : directions) { hopper = new Hopper(direction); - assertThat("Constructed with default hopper type", hopper.getItemType(), equalTo(Material.LEGACY_HOPPER)); - assertThat("Constructed with default active state", hopper.isActive(), equalTo(true)); - assertThat("Constructed with correct powered state", hopper.isPowered(), equalTo(false)); - assertThat("Constructed with correct direction", hopper.getFacing(), equalTo(direction)); + assertThat(hopper.getItemType(), equalTo(Material.LEGACY_HOPPER), "Constructed with default hopper type"); + assertThat(hopper.isActive(), equalTo(true), "Constructed with default active state"); + assertThat(hopper.isPowered(), equalTo(false), "Constructed with correct powered state"); + assertThat(hopper.getFacing(), equalTo(direction), "Constructed with correct direction"); for (boolean isActive : activeStates) { hopper = new Hopper(direction, isActive); - assertThat("Constructed with default hopper type", hopper.getItemType(), equalTo(Material.LEGACY_HOPPER)); - assertThat("Constructed with correct active state", hopper.isActive(), equalTo(isActive)); - assertThat("Constructed with correct powered state", hopper.isPowered(), equalTo(!isActive)); - assertThat("Constructed with correct direction", hopper.getFacing(), equalTo(direction)); + assertThat(hopper.getItemType(), equalTo(Material.LEGACY_HOPPER), "Constructed with default hopper type"); + assertThat(hopper.isActive(), equalTo(isActive), "Constructed with correct active state"); + assertThat(hopper.isPowered(), equalTo(!isActive), "Constructed with correct powered state"); + assertThat(hopper.getFacing(), equalTo(direction), "Constructed with correct direction"); } } } diff --git a/paper-api/src/test/java/org/bukkit/metadata/FixedMetadataValueTest.java b/paper-api/src/test/java/org/bukkit/metadata/FixedMetadataValueTest.java index e8cea99fd0..91584b94b5 100644 --- a/paper-api/src/test/java/org/bukkit/metadata/FixedMetadataValueTest.java +++ b/paper-api/src/test/java/org/bukkit/metadata/FixedMetadataValueTest.java @@ -1,9 +1,9 @@ package org.bukkit.metadata; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.TestPlugin; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class FixedMetadataValueTest { private Plugin plugin = new TestPlugin("X"); @@ -21,7 +21,7 @@ public class FixedMetadataValueTest { subject = new FixedMetadataValue(plugin, new Integer(5)); assertEquals(new Integer(5), subject.value()); assertEquals(5, subject.asInt()); - assertEquals(true, subject.asBoolean()); + assertTrue(subject.asBoolean()); assertEquals(5, subject.asByte()); assertEquals(5.0, subject.asFloat(), 0.1e-8); assertEquals(5.0D, subject.asDouble(), 0.1e-8D); diff --git a/paper-api/src/test/java/org/bukkit/metadata/LazyMetadataValueTest.java b/paper-api/src/test/java/org/bukkit/metadata/LazyMetadataValueTest.java index bc8a18eea6..dd2acf3f11 100644 --- a/paper-api/src/test/java/org/bukkit/metadata/LazyMetadataValueTest.java +++ b/paper-api/src/test/java/org/bukkit/metadata/LazyMetadataValueTest.java @@ -1,9 +1,9 @@ package org.bukkit.metadata; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.util.concurrent.Callable; import org.bukkit.plugin.TestPlugin; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class LazyMetadataValueTest { private LazyMetadataValue subject; @@ -41,7 +41,7 @@ public class LazyMetadataValueTest { assertEquals(value, subject.value()); } - @Test(expected = MetadataEvaluationException.class) + @Test public void testEvalException() { subject = new LazyMetadataValue(plugin, LazyMetadataValue.CacheStrategy.CACHE_AFTER_FIRST_EVAL, new Callable() { @Override @@ -49,7 +49,7 @@ public class LazyMetadataValueTest { throw new RuntimeException("Gotcha!"); } }); - subject.value(); + assertThrows(MetadataEvaluationException.class, () -> subject.value()); } @Test diff --git a/paper-api/src/test/java/org/bukkit/metadata/MetadataConversionTest.java b/paper-api/src/test/java/org/bukkit/metadata/MetadataConversionTest.java index a9c10a2fd9..29546b6219 100644 --- a/paper-api/src/test/java/org/bukkit/metadata/MetadataConversionTest.java +++ b/paper-api/src/test/java/org/bukkit/metadata/MetadataConversionTest.java @@ -15,10 +15,10 @@ package org.bukkit.metadata; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.TestPlugin; -import org.junit.Test; +import org.junit.jupiter.api.Test; /** */ @@ -40,7 +40,7 @@ public class MetadataConversionTest { assertEquals(10, subject.asLong()); assertEquals(10, subject.asShort()); assertEquals(10, subject.asByte()); - assertEquals(true, subject.asBoolean()); + assertTrue(subject.asBoolean()); assertEquals("10", subject.asString()); } @@ -54,7 +54,7 @@ public class MetadataConversionTest { assertEquals(10, subject.asLong()); assertEquals(10, subject.asShort()); assertEquals(10, subject.asByte()); - assertEquals(true, subject.asBoolean()); + assertTrue(subject.asBoolean()); assertEquals("10.5", subject.asString()); } @@ -68,7 +68,7 @@ public class MetadataConversionTest { assertEquals(10, subject.asLong()); assertEquals(10, subject.asShort()); assertEquals(10, subject.asByte()); - assertEquals(false, subject.asBoolean()); + assertFalse(subject.asBoolean()); assertEquals("10", subject.asString()); } @@ -82,7 +82,7 @@ public class MetadataConversionTest { assertEquals(0, subject.asLong()); assertEquals(0, subject.asShort()); assertEquals(0, subject.asByte()); - assertEquals(true, subject.asBoolean()); + assertTrue(subject.asBoolean()); assertEquals("true", subject.asString()); } @@ -96,7 +96,7 @@ public class MetadataConversionTest { assertEquals(0, subject.asLong()); assertEquals(0, subject.asShort()); assertEquals(0, subject.asByte()); - assertEquals(false, subject.asBoolean()); + assertFalse(subject.asBoolean()); assertEquals("", subject.asString()); } } diff --git a/paper-api/src/test/java/org/bukkit/metadata/MetadataStoreTest.java b/paper-api/src/test/java/org/bukkit/metadata/MetadataStoreTest.java index 12373ff16c..e52659f010 100644 --- a/paper-api/src/test/java/org/bukkit/metadata/MetadataStoreTest.java +++ b/paper-api/src/test/java/org/bukkit/metadata/MetadataStoreTest.java @@ -1,11 +1,11 @@ package org.bukkit.metadata; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import java.util.List; import java.util.concurrent.Callable; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.TestPlugin; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class MetadataStoreTest { private Plugin pluginX = new TestPlugin("x"); diff --git a/paper-api/src/test/java/org/bukkit/metadata/MetadataValueAdapterTest.java b/paper-api/src/test/java/org/bukkit/metadata/MetadataValueAdapterTest.java index c1e78568a8..2b6a53b2de 100644 --- a/paper-api/src/test/java/org/bukkit/metadata/MetadataValueAdapterTest.java +++ b/paper-api/src/test/java/org/bukkit/metadata/MetadataValueAdapterTest.java @@ -1,9 +1,9 @@ package org.bukkit.metadata; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.plugin.Plugin; import org.bukkit.plugin.TestPlugin; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class MetadataValueAdapterTest { private TestPlugin plugin = new TestPlugin("x"); @@ -38,25 +38,25 @@ public class MetadataValueAdapterTest { @Test public void testBooleanConversion() { // null is False. - assertEquals(false, simpleValue(null).asBoolean()); + assertFalse(simpleValue(null).asBoolean()); // String to boolean. - assertEquals(true, simpleValue("True").asBoolean()); - assertEquals(true, simpleValue("TRUE").asBoolean()); - assertEquals(false, simpleValue("false").asBoolean()); + assertTrue(simpleValue("True").asBoolean()); + assertTrue(simpleValue("TRUE").asBoolean()); + assertFalse(simpleValue("false").asBoolean()); // Number to boolean. - assertEquals(true, simpleValue(1).asBoolean()); - assertEquals(true, simpleValue(5.0).asBoolean()); - assertEquals(false, simpleValue(0).asBoolean()); - assertEquals(false, simpleValue(0.1).asBoolean()); + assertTrue(simpleValue(1).asBoolean()); + assertTrue(simpleValue(5.0).asBoolean()); + assertFalse(simpleValue(0).asBoolean()); + assertFalse(simpleValue(0.1).asBoolean()); // Boolean as boolean, of course. - assertEquals(true, simpleValue(Boolean.TRUE).asBoolean()); - assertEquals(false, simpleValue(Boolean.FALSE).asBoolean()); + assertTrue(simpleValue(Boolean.TRUE).asBoolean()); + assertFalse(simpleValue(Boolean.FALSE).asBoolean()); // any object that is not null and not a Boolean, String, or Number is true. - assertEquals(true, simpleValue(new Object()).asBoolean()); + assertTrue(simpleValue(new Object()).asBoolean()); } /** Test String conversions return an empty string when given null. */ diff --git a/paper-api/src/test/java/org/bukkit/plugin/PluginManagerTest.java b/paper-api/src/test/java/org/bukkit/plugin/PluginManagerTest.java index 4c61b180c2..03b08e47e9 100644 --- a/paper-api/src/test/java/org/bukkit/plugin/PluginManagerTest.java +++ b/paper-api/src/test/java/org/bukkit/plugin/PluginManagerTest.java @@ -1,14 +1,14 @@ package org.bukkit.plugin; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; import org.bukkit.Bukkit; import org.bukkit.event.Event; import org.bukkit.event.TestEvent; import org.bukkit.permissions.Permission; import org.bukkit.support.AbstractTestingBase; -import org.junit.After; -import org.junit.Test; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.Test; public class PluginManagerTest extends AbstractTestingBase { private class MutableObject { @@ -164,20 +164,20 @@ public class PluginManagerTest extends AbstractTestingBase { private void testRemovePermissionByName(final String name) { final Permission perm = new Permission(name); pm.addPermission(perm); - assertThat("Permission \"" + name + "\" was not added", pm.getPermission(name), is(perm)); + assertThat(pm.getPermission(name), is(perm), "Permission \"" + name + "\" was not added"); pm.removePermission(name); - assertThat("Permission \"" + name + "\" was not removed", pm.getPermission(name), is(nullValue())); + assertThat(pm.getPermission(name), is(nullValue()), "Permission \"" + name + "\" was not removed"); } private void testRemovePermissionByPermission(final String name) { final Permission perm = new Permission(name); pm.addPermission(perm); - assertThat("Permission \"" + name + "\" was not added", pm.getPermission(name), is(perm)); + assertThat(pm.getPermission(name), is(perm), "Permission \"" + name + "\" was not added"); pm.removePermission(perm); - assertThat("Permission \"" + name + "\" was not removed", pm.getPermission(name), is(nullValue())); + assertThat(pm.getPermission(name), is(nullValue()), "Permission \"" + name + "\" was not removed"); } - @After + @AfterEach public void tearDown() { pm.clearPlugins(); assertThat(pm.getPermissions(), is(empty())); diff --git a/paper-api/src/test/java/org/bukkit/plugin/TimedRegisteredListenerTest.java b/paper-api/src/test/java/org/bukkit/plugin/TimedRegisteredListenerTest.java index 351fc4a9f4..9ed416ed57 100644 --- a/paper-api/src/test/java/org/bukkit/plugin/TimedRegisteredListenerTest.java +++ b/paper-api/src/test/java/org/bukkit/plugin/TimedRegisteredListenerTest.java @@ -1,7 +1,7 @@ package org.bukkit.plugin; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; import org.bukkit.event.Event; import org.bukkit.event.EventException; import org.bukkit.event.EventPriority; @@ -10,7 +10,7 @@ import org.bukkit.event.block.BlockBreakEvent; import org.bukkit.event.player.PlayerEvent; import org.bukkit.event.player.PlayerInteractEvent; import org.bukkit.event.player.PlayerMoveEvent; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class TimedRegisteredListenerTest { diff --git a/paper-api/src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java b/paper-api/src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java index bf00b7a9d8..144ae2f31b 100644 --- a/paper-api/src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java +++ b/paper-api/src/test/java/org/bukkit/plugin/messaging/StandardMessengerTest.java @@ -1,13 +1,13 @@ package org.bukkit.plugin.messaging; -import static org.hamcrest.CoreMatchers.*; -import static org.junit.Assert.*; +import static org.bukkit.support.MatcherAssert.*; +import static org.hamcrest.Matchers.*; +import static org.junit.jupiter.api.Assertions.*; import static org.mockito.Mockito.*; import java.util.Collection; import org.bukkit.entity.Player; import org.bukkit.plugin.TestPlugin; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class StandardMessengerTest { public StandardMessenger getMessenger() { @@ -45,12 +45,12 @@ public class StandardMessengerTest { assertFalse(messenger.isOutgoingChannelRegistered(plugin, "test:foo")); } - @Test(expected = ReservedChannelException.class) + @Test public void testReservedOutgoingRegistration() { Messenger messenger = getMessenger(); TestPlugin plugin = getPlugin(); - messenger.registerOutgoingPluginChannel(plugin, "minecraft:register"); + assertThrows(ReservedChannelException.class, () -> messenger.registerOutgoingPluginChannel(plugin, "minecraft:register")); } @Test @@ -91,22 +91,22 @@ public class StandardMessengerTest { assertFalse(listener.hasReceived()); } - @Test(expected = ReservedChannelException.class) + @Test public void testReservedIncomingRegistration() { Messenger messenger = getMessenger(); TestPlugin plugin = getPlugin(); - messenger.registerIncomingPluginChannel(plugin, "minecraft:register", new TestMessageListener("test:foo", "test:bar".getBytes())); + assertThrows(ReservedChannelException.class, () -> messenger.registerIncomingPluginChannel(plugin, "minecraft:register", new TestMessageListener("test:foo", "test:bar".getBytes()))); } - @Test(expected = IllegalArgumentException.class) + @Test public void testDuplicateIncomingRegistration() { Messenger messenger = getMessenger(); TestPlugin plugin = getPlugin(); TestMessageListener listener = new TestMessageListener("test:foo", "test:bar".getBytes()); messenger.registerIncomingPluginChannel(plugin, "test:baz", listener); - messenger.registerIncomingPluginChannel(plugin, "test:baz", listener); + assertThrows(IllegalArgumentException.class, () -> messenger.registerIncomingPluginChannel(plugin, "test:baz", listener)); } @Test @@ -173,14 +173,14 @@ public class StandardMessengerTest { TestPlugin plugin1 = getPlugin(); TestPlugin plugin2 = getPlugin(); - assertEquals(messenger.getOutgoingChannels()); + assertCollectionEquals(messenger.getOutgoingChannels()); messenger.registerOutgoingPluginChannel(plugin1, "test:foo"); messenger.registerOutgoingPluginChannel(plugin1, "test:bar"); messenger.registerOutgoingPluginChannel(plugin2, "test:baz"); messenger.registerOutgoingPluginChannel(plugin2, "test:baz"); - assertEquals(messenger.getOutgoingChannels(), "test:foo", "test:bar", "test:baz"); + assertCollectionEquals(messenger.getOutgoingChannels(), "test:foo", "test:bar", "test:baz"); } @Test @@ -195,9 +195,9 @@ public class StandardMessengerTest { messenger.registerOutgoingPluginChannel(plugin2, "test:baz"); messenger.registerOutgoingPluginChannel(plugin2, "test:qux"); - assertEquals(messenger.getOutgoingChannels(plugin1), "test:foo", "test:bar"); - assertEquals(messenger.getOutgoingChannels(plugin2), "test:baz", "test:qux"); - assertEquals(messenger.getOutgoingChannels(plugin3)); + assertCollectionEquals(messenger.getOutgoingChannels(plugin1), "test:foo", "test:bar"); + assertCollectionEquals(messenger.getOutgoingChannels(plugin2), "test:baz", "test:qux"); + assertCollectionEquals(messenger.getOutgoingChannels(plugin3)); } @Test @@ -206,14 +206,14 @@ public class StandardMessengerTest { TestPlugin plugin1 = getPlugin(); TestPlugin plugin2 = getPlugin(); - assertEquals(messenger.getIncomingChannels()); + assertCollectionEquals(messenger.getIncomingChannels()); messenger.registerIncomingPluginChannel(plugin1, "test:foo", new TestMessageListener("test:foo", "test:bar".getBytes())); messenger.registerIncomingPluginChannel(plugin1, "test:bar", new TestMessageListener("test:foo", "test:bar".getBytes())); messenger.registerIncomingPluginChannel(plugin2, "test:baz", new TestMessageListener("test:foo", "test:bar".getBytes())); messenger.registerIncomingPluginChannel(plugin2, "test:baz", new TestMessageListener("test:foo", "test:bar".getBytes())); - assertEquals(messenger.getIncomingChannels(), "test:foo", "test:bar", "test:baz"); + assertCollectionEquals(messenger.getIncomingChannels(), "test:foo", "test:bar", "test:baz"); } @Test @@ -228,9 +228,9 @@ public class StandardMessengerTest { messenger.registerIncomingPluginChannel(plugin2, "test:baz", new TestMessageListener("test:foo", "test:bar".getBytes())); messenger.registerIncomingPluginChannel(plugin2, "test:qux", new TestMessageListener("test:foo", "test:bar".getBytes())); - assertEquals(messenger.getIncomingChannels(plugin1), "test:foo", "test:bar"); - assertEquals(messenger.getIncomingChannels(plugin2), "test:baz", "test:qux"); - assertEquals(messenger.getIncomingChannels(plugin3)); + assertCollectionEquals(messenger.getIncomingChannels(plugin1), "test:foo", "test:bar"); + assertCollectionEquals(messenger.getIncomingChannels(plugin2), "test:baz", "test:qux"); + assertCollectionEquals(messenger.getIncomingChannels(plugin3)); } @Test @@ -244,9 +244,9 @@ public class StandardMessengerTest { PluginMessageListenerRegistration registration3 = messenger.registerIncomingPluginChannel(plugin2, "test:baz", new TestMessageListener("test:foo", "test:bar".getBytes())); PluginMessageListenerRegistration registration4 = messenger.registerIncomingPluginChannel(plugin2, "test:qux", new TestMessageListener("test:foo", "test:bar".getBytes())); - assertEquals(messenger.getIncomingChannelRegistrations(plugin1), registration1, registration2); - assertEquals(messenger.getIncomingChannelRegistrations(plugin2), registration3, registration4); - assertEquals(messenger.getIncomingChannels(plugin3)); + assertCollectionEquals(messenger.getIncomingChannelRegistrations(plugin1), registration1, registration2); + assertCollectionEquals(messenger.getIncomingChannelRegistrations(plugin2), registration3, registration4); + assertCollectionEquals(messenger.getIncomingChannels(plugin3)); } @Test @@ -259,9 +259,9 @@ public class StandardMessengerTest { PluginMessageListenerRegistration registration3 = messenger.registerIncomingPluginChannel(plugin2, "test:foo", new TestMessageListener("test:foo", "test:bar".getBytes())); PluginMessageListenerRegistration registration4 = messenger.registerIncomingPluginChannel(plugin2, "test:bar", new TestMessageListener("test:foo", "test:bar".getBytes())); - assertEquals(messenger.getIncomingChannelRegistrations("test:foo"), registration1, registration3); - assertEquals(messenger.getIncomingChannelRegistrations("test:bar"), registration2, registration4); - assertEquals(messenger.getIncomingChannelRegistrations("test:baz")); + assertCollectionEquals(messenger.getIncomingChannelRegistrations("test:foo"), registration1, registration3); + assertCollectionEquals(messenger.getIncomingChannelRegistrations("test:bar"), registration2, registration4); + assertCollectionEquals(messenger.getIncomingChannelRegistrations("test:baz")); } @Test @@ -277,30 +277,30 @@ public class StandardMessengerTest { PluginMessageListenerRegistration registration5 = messenger.registerIncomingPluginChannel(plugin2, "test:baz", new TestMessageListener("test:foo", "test:bar".getBytes())); PluginMessageListenerRegistration registration6 = messenger.registerIncomingPluginChannel(plugin2, "test:baz", new TestMessageListener("test:foo", "test:bar".getBytes())); - assertEquals(messenger.getIncomingChannelRegistrations(plugin1, "test:foo"), registration1, registration2); - assertEquals(messenger.getIncomingChannelRegistrations(plugin1, "test:bar"), registration3); - assertEquals(messenger.getIncomingChannelRegistrations(plugin2, "test:bar"), registration4); - assertEquals(messenger.getIncomingChannelRegistrations(plugin2, "test:baz"), registration5, registration6); - assertEquals(messenger.getIncomingChannelRegistrations(plugin1, "test:baz")); - assertEquals(messenger.getIncomingChannelRegistrations(plugin3, "test:qux")); + assertCollectionEquals(messenger.getIncomingChannelRegistrations(plugin1, "test:foo"), registration1, registration2); + assertCollectionEquals(messenger.getIncomingChannelRegistrations(plugin1, "test:bar"), registration3); + assertCollectionEquals(messenger.getIncomingChannelRegistrations(plugin2, "test:bar"), registration4); + assertCollectionEquals(messenger.getIncomingChannelRegistrations(plugin2, "test:baz"), registration5, registration6); + assertCollectionEquals(messenger.getIncomingChannelRegistrations(plugin1, "test:baz")); + assertCollectionEquals(messenger.getIncomingChannelRegistrations(plugin3, "test:qux")); } - @Test(expected = IllegalArgumentException.class) + @Test public void testInvalidChannel() { Messenger messenger = getMessenger(); TestPlugin plugin = getPlugin(); - messenger.registerOutgoingPluginChannel(plugin, "foo"); + assertThrows(IllegalArgumentException.class, () -> messenger.registerOutgoingPluginChannel(plugin, "foo")); } @Test public void testValidateAndCorrectChannel() { - Assert.assertEquals("bungeecord:main", StandardMessenger.validateAndCorrectChannel("BungeeCord")); - Assert.assertEquals("BungeeCord", StandardMessenger.validateAndCorrectChannel("bungeecord:main")); + assertEquals("bungeecord:main", StandardMessenger.validateAndCorrectChannel("BungeeCord")); + assertEquals("BungeeCord", StandardMessenger.validateAndCorrectChannel("bungeecord:main")); } - private static void assertEquals(Collection actual, T... expected) { - assertThat("Size of the array", actual.size(), is(expected.length)); + private static void assertCollectionEquals(Collection actual, T... expected) { + assertThat(actual.size(), is(expected.length), "Size of the array"); assertThat(actual, hasItems(expected)); } } diff --git a/paper-api/src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java b/paper-api/src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java index 7a5b6108d5..20981f604e 100644 --- a/paper-api/src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java +++ b/paper-api/src/test/java/org/bukkit/plugin/messaging/TestMessageListener.java @@ -1,6 +1,6 @@ package org.bukkit.plugin.messaging; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.entity.Player; public class TestMessageListener implements PluginMessageListener { diff --git a/paper-api/src/test/java/org/bukkit/scoreboard/CriteriaTest.java b/paper-api/src/test/java/org/bukkit/scoreboard/CriteriaTest.java index 025ec8d637..034faf9a44 100644 --- a/paper-api/src/test/java/org/bukkit/scoreboard/CriteriaTest.java +++ b/paper-api/src/test/java/org/bukkit/scoreboard/CriteriaTest.java @@ -1,22 +1,22 @@ package org.bukkit.scoreboard; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.Material; import org.bukkit.Statistic; import org.bukkit.entity.EntityType; import org.bukkit.support.AbstractTestingBase; -import org.junit.Assert; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class CriteriaTest extends AbstractTestingBase { @Test public void testStatistic() { - Assert.assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.AVIATE_ONE_CM, Material.STONE)); // Generic statistic with block - Assert.assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.AVIATE_ONE_CM, EntityType.CREEPER)); // Generic statistic with entity type + assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.AVIATE_ONE_CM, Material.STONE)); // Generic statistic with block + assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.AVIATE_ONE_CM, EntityType.CREEPER)); // Generic statistic with entity type - Assert.assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.ENTITY_KILLED_BY, Material.AMETHYST_SHARD)); // Entity statistic with material - Assert.assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.MINE_BLOCK, Material.DIAMOND_PICKAXE)); // Block statistic with item - Assert.assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.BREAK_ITEM, Material.WATER)); // Item statistic with block - Assert.assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.KILL_ENTITY, Material.STONE)); // Entity statistic with Material + assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.ENTITY_KILLED_BY, Material.AMETHYST_SHARD)); // Entity statistic with material + assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.MINE_BLOCK, Material.DIAMOND_PICKAXE)); // Block statistic with item + assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.BREAK_ITEM, Material.WATER)); // Item statistic with block + assertThrows(IllegalArgumentException.class, () -> Criteria.statistic(Statistic.KILL_ENTITY, Material.STONE)); // Entity statistic with Material } } diff --git a/paper-api/src/test/java/org/bukkit/support/MatcherAssert.java b/paper-api/src/test/java/org/bukkit/support/MatcherAssert.java new file mode 100644 index 0000000000..b100262e88 --- /dev/null +++ b/paper-api/src/test/java/org/bukkit/support/MatcherAssert.java @@ -0,0 +1,36 @@ +package org.bukkit.support; + +import org.hamcrest.Matcher; + +/** + * Custom assertThat methods, where the reason is put at the end of the method call. + * To better match with JUnit 5 argument order and also help with readability for longer reasons. + *
+ * 
+ * assertThat(String.format("""
+ *         The block data created for the material %s is not an instance of the data class from that material.
+ *         """, material), blockData, is(instanceOf(expectedClass)));
+ *
+ * vs. + * 
+ * assertThat(blockData, is(instanceOf(expectedClass)), String.format("""
+ *         The block data created for the material %s is not an instance of the data class from that material.
+ *         """, material));
+ *
+ */ +public final class MatcherAssert { + + private MatcherAssert() {} + + public static void assertThat(T actual, Matcher matcher) { + org.hamcrest.MatcherAssert.assertThat(actual, matcher); + } + + public static void assertThat(T actual, Matcher matcher, String reason) { + org.hamcrest.MatcherAssert.assertThat(reason, actual, matcher); + } + + public static void assertThat(boolean assertion, String reason) { + org.hamcrest.MatcherAssert.assertThat(reason, assertion); + } +} diff --git a/paper-api/src/test/java/org/bukkit/util/BoundingBoxTest.java b/paper-api/src/test/java/org/bukkit/util/BoundingBoxTest.java index 2d50a9ed66..3141c007d1 100644 --- a/paper-api/src/test/java/org/bukkit/util/BoundingBoxTest.java +++ b/paper-api/src/test/java/org/bukkit/util/BoundingBoxTest.java @@ -1,11 +1,11 @@ package org.bukkit.util; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; import java.util.Map; import org.bukkit.Location; import org.bukkit.block.BlockFace; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class BoundingBoxTest { diff --git a/paper-api/src/test/java/org/bukkit/util/StringUtilStartsWithTest.java b/paper-api/src/test/java/org/bukkit/util/StringUtilStartsWithTest.java index 229c67c769..c93bd4d630 100644 --- a/paper-api/src/test/java/org/bukkit/util/StringUtilStartsWithTest.java +++ b/paper-api/src/test/java/org/bukkit/util/StringUtilStartsWithTest.java @@ -1,83 +1,72 @@ package org.bukkit.util; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; -import com.google.common.collect.ImmutableList; -import java.util.List; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameter; -import org.junit.runners.Parameterized.Parameters; +import java.util.stream.Stream; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; -@RunWith(Parameterized.class) public class StringUtilStartsWithTest { - @Parameters(name = "{index}: {0} startsWith {1} == {2}") - public static List data() { - return ImmutableList.of( - new Object[] { - "Apple", - "Apples", - false - }, - new Object[] { - "Apples", - "Apple", - true - }, - new Object[] { - "Apple", - "Apple", - true - }, - new Object[] { - "Apple", - "apples", - false - }, - new Object[] { - "apple", - "Apples", - false - }, - new Object[] { - "apple", - "apples", - false - }, - new Object[] { - "Apples", - "apPL", - true - }, - new Object[] { - "123456789", - "1234567", - true - }, - new Object[] { - "", - "", - true - }, - new Object[] { - "string", - "", - true - } + public static Stream data() { + return Stream.of( + Arguments.of( + "Apple", + "Apples", + false + ), + Arguments.of( + "Apples", + "Apple", + true + ), + Arguments.of( + "Apple", + "Apple", + true + ), + Arguments.of( + "Apple", + "apples", + false + ), + Arguments.of( + "apple", + "Apples", + false + ), + Arguments.of( + "apple", + "apples", + false + ), + Arguments.of( + "Apples", + "apPL", + true + ), + Arguments.of( + "123456789", + "1234567", + true + ), + Arguments.of( + "", + "", + true + ), + Arguments.of( + "string", + "", + true + ) ); } - @Parameter(0) - public String base; - @Parameter(1) - public String prefix; - @Parameter(2) - public boolean result; - - @Test - public void testFor() { - assertThat(base + " starts with " + prefix + ": " + result, StringUtil.startsWithIgnoreCase(base, prefix), is(result)); + @ParameterizedTest + @MethodSource("data") + public void testFor(String base, String prefix, boolean result) { + assertThat(StringUtil.startsWithIgnoreCase(base, prefix), is(result), base + " starts with " + prefix + ": " + result); } } diff --git a/paper-api/src/test/java/org/bukkit/util/StringUtilTest.java b/paper-api/src/test/java/org/bukkit/util/StringUtilTest.java index 6476dd2d1b..87e9146191 100644 --- a/paper-api/src/test/java/org/bukkit/util/StringUtilTest.java +++ b/paper-api/src/test/java/org/bukkit/util/StringUtilTest.java @@ -1,38 +1,39 @@ package org.bukkit.util; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import com.google.common.collect.ImmutableList; import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class StringUtilTest { - @Test(expected = NullPointerException.class) + @Test public void nullPrefixTest() { - StringUtil.startsWithIgnoreCase("String", null); + assertThrows(NullPointerException.class, () -> StringUtil.startsWithIgnoreCase("String", null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void nullStringTest() { - StringUtil.startsWithIgnoreCase(null, "String"); + assertThrows(IllegalArgumentException.class, () -> StringUtil.startsWithIgnoreCase(null, "String")); } - @Test(expected = IllegalArgumentException.class) + @Test public void nullCollectionTest() { - StringUtil.copyPartialMatches("Token", ImmutableList.of(), null); + assertThrows(IllegalArgumentException.class, () -> StringUtil.copyPartialMatches("Token", ImmutableList.of(), null)); } - @Test(expected = IllegalArgumentException.class) + @Test public void nullIterableTest() { - StringUtil.copyPartialMatches("Token", null, new ArrayList()); + assertThrows(IllegalArgumentException.class, () -> StringUtil.copyPartialMatches("Token", null, new ArrayList())); } - @Test(expected = IllegalArgumentException.class) + @Test public void nullTokenTest() { - StringUtil.copyPartialMatches(null, ImmutableList.of(), new ArrayList()); + assertThrows(IllegalArgumentException.class, () -> StringUtil.copyPartialMatches(null, ImmutableList.of(), new ArrayList())); } @Test @@ -46,13 +47,13 @@ public class StringUtilTest { assertThat(list.size(), is(expected.size() * 2)); } - @Test(expected = UnsupportedOperationException.class) + @Test public void copyUnsupportedTest() { - StringUtil.copyPartialMatches("token", ImmutableList.of("token1", "token2"), ImmutableList.of()); + assertThrows(UnsupportedOperationException.class, () -> StringUtil.copyPartialMatches("token", ImmutableList.of("token1", "token2"), ImmutableList.of())); } - @Test(expected = IllegalArgumentException.class) + @Test public void copyNullTest() { - StringUtil.copyPartialMatches("token", Arrays.asList("token1", "token2", null), new ArrayList()); + assertThrows(IllegalArgumentException.class, () -> StringUtil.copyPartialMatches("token", Arrays.asList("token1", "token2", null), new ArrayList())); } } diff --git a/paper-api/src/test/java/org/bukkit/util/VectorTest.java b/paper-api/src/test/java/org/bukkit/util/VectorTest.java index 03442bfff0..f0927a0da5 100644 --- a/paper-api/src/test/java/org/bukkit/util/VectorTest.java +++ b/paper-api/src/test/java/org/bukkit/util/VectorTest.java @@ -1,8 +1,8 @@ package org.bukkit.util; -import static org.junit.Assert.*; +import static org.junit.jupiter.api.Assertions.*; import org.bukkit.block.BlockFace; -import org.junit.Test; +import org.junit.jupiter.api.Test; public class VectorTest { @@ -14,9 +14,9 @@ public class VectorTest { assertTrue(new Vector(1, 0, 0).isNormalized()); } - @Test(expected = IllegalArgumentException.class) + @Test public void testNullVectorAxis() { - new Vector(0, 1, 0).rotateAroundAxis(null, Math.PI); + assertThrows(IllegalArgumentException.class, () -> new Vector(0, 1, 0).rotateAroundAxis(null, Math.PI)); } @Test diff --git a/paper-api/src/test/java/org/bukkit/util/io/BukkitObjectStreamTest.java b/paper-api/src/test/java/org/bukkit/util/io/BukkitObjectStreamTest.java index d3edb72ff8..7021a44e49 100644 --- a/paper-api/src/test/java/org/bukkit/util/io/BukkitObjectStreamTest.java +++ b/paper-api/src/test/java/org/bukkit/util/io/BukkitObjectStreamTest.java @@ -1,7 +1,7 @@ package org.bukkit.util.io; +import static org.bukkit.support.MatcherAssert.*; import static org.hamcrest.Matchers.*; -import static org.junit.Assert.*; import com.google.common.collect.ImmutableList; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; @@ -9,80 +9,69 @@ import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.util.List; +import java.util.stream.Stream; import org.bukkit.Color; import org.bukkit.FireworkEffect; import org.bukkit.FireworkEffect.Type; import org.bukkit.configuration.serialization.ConfigurationSerializable; import org.bukkit.util.Vector; -import org.junit.Ignore; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.junit.runners.Parameterized; -import org.junit.runners.Parameterized.Parameter; -import org.junit.runners.Parameterized.Parameters; +import org.junit.jupiter.api.Disabled; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder; -@RunWith(Parameterized.class) public class BukkitObjectStreamTest { - @Parameters(name = "{index}: {0}") - public static List data() { - return ImmutableList.of( - new Object[] { - Color.class.getName(), - "rO0ABXNyADZjb20uZ29vZ2xlLmNvbW1vbi5jb2xsZWN0LkltbXV0YWJsZUxpc3QkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAVsACGVsZW1lbnRzdAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAABXNyABpvcmcuYnVra2l0LnV0aWwuaW8uV3JhcHBlcvJQR+zxEm8FAgABTAADbWFwdAAPTGphdmEvdXRpbC9NYXA7eHBzcgA1Y29tLmdvb2dsZS5jb21tb24uY29sbGVjdC5JbW11dGFibGVNYXAkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAlsABGtleXNxAH4AAVsABnZhbHVlc3EAfgABeHB1cQB+AAMAAAAEdAACPT10AANSRUR0AARCTFVFdAAFR1JFRU51cQB+AAMAAAAEdAAFQ29sb3JzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAA/3NxAH4AEQAAAP9zcQB+ABEAAAD/c3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARAAAAAHNxAH4AEQAAAIBzcQB+ABEAAACAc3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARAAAAgHNxAH4AEQAAAIBxAH4AGnNxAH4ABXNxAH4ACHVxAH4AAwAAAARxAH4AC3EAfgAMcQB+AA1xAH4ADnVxAH4AAwAAAARxAH4AEHNxAH4AEQAAAP9xAH4AGnEAfgAac3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARAAAA/3EAfgAac3EAfgARAAAApQ==", - ImmutableList.of( - Color.WHITE, - Color.TEAL, - Color.PURPLE, - Color.RED, - Color.ORANGE - ) - }, - new Object[] { - FireworkEffect.class.getName(), - "rO0ABXNyADZjb20uZ29vZ2xlLmNvbW1vbi5jb2xsZWN0LkltbXV0YWJsZUxpc3QkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAVsACGVsZW1lbnRzdAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAA3NyABpvcmcuYnVra2l0LnV0aWwuaW8uV3JhcHBlcvJQR+zxEm8FAgABTAADbWFwdAAPTGphdmEvdXRpbC9NYXA7eHBzcgA1Y29tLmdvb2dsZS5jb21tb24uY29sbGVjdC5JbW11dGFibGVNYXAkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAlsABGtleXNxAH4AAVsABnZhbHVlc3EAfgABeHB1cQB+AAMAAAAGdAACPT10AAdmbGlja2VydAAFdHJhaWx0AAZjb2xvcnN0AAtmYWRlLWNvbG9yc3QABHR5cGV1cQB+AAMAAAAGdAAIRmlyZXdvcmtzcgARamF2YS5sYW5nLkJvb2xlYW7NIHKA1Zz67gIAAVoABXZhbHVleHABc3EAfgATAHNxAH4AAHVxAH4AAwAAAAJzcQB+AAVzcQB+AAh1cQB+AAMAAAAEcQB+AAt0AANSRUR0AARCTFVFdAAFR1JFRU51cQB+AAMAAAAEdAAFQ29sb3JzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAHEAfgAicQB+ACJzcQB+AAVzcQB+AAh1cQB+AAMAAAAEcQB+AAtxAH4AG3EAfgAccQB+AB11cQB+AAMAAAAEcQB+AB9zcQB+ACAAAADAc3EAfgAgAAAAwHNxAH4AIAAAAMBzcQB+AAB1cQB+AAMAAAABc3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+ABtxAH4AHHEAfgAddXEAfgADAAAABHEAfgAfc3EAfgAgAAAA/3NxAH4AIAAAAP9zcQB+ACAAAAD/dAAKQkFMTF9MQVJHRXNxAH4ABXNxAH4ACHVxAH4AAwAAAAZxAH4AC3EAfgAMcQB+AA1xAH4ADnEAfgAPcQB+ABB1cQB+AAMAAAAGcQB+ABJxAH4AFXEAfgAVc3EAfgAAdXEAfgADAAAAAXNxAH4ABXNxAH4ACHVxAH4AAwAAAARxAH4AC3EAfgAbcQB+ABxxAH4AHXVxAH4AAwAAAARxAH4AH3EAfgAic3EAfgAgAAAAgHEAfgAic3EAfgAAdXEAfgADAAAAAHQABEJBTExzcQB+AAVzcQB+AAh1cQB+AAMAAAAGcQB+AAtxAH4ADHEAfgANcQB+AA5xAH4AD3EAfgAQdXEAfgADAAAABnEAfgAScQB+ABRxAH4AFHNxAH4AAHVxAH4AAwAAAAFzcQB+AAVzcQB+AAh1cQB+AAMAAAAEcQB+AAtxAH4AG3EAfgAccQB+AB11cQB+AAMAAAAEcQB+AB9zcQB+ACAAAACAcQB+ACJxAH4AInEAfgA/dAAHQ1JFRVBFUg==", - ImmutableList.of( - FireworkEffect.builder() - .withColor(Color.BLACK, Color.SILVER) - .with(Type.BALL_LARGE) - .withFade(Color.WHITE) - .withFlicker() - .build(), - FireworkEffect.builder() - .withColor(Color.NAVY) - .build(), - FireworkEffect.builder() - .withColor(Color.MAROON) - .withTrail() - .withFlicker() - .with(Type.CREEPER) - .build() - ), - }, - new Object[] { - Vector.class.getName(), - "rO0ABXNyADZjb20uZ29vZ2xlLmNvbW1vbi5jb2xsZWN0LkltbXV0YWJsZUxpc3QkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAVsACGVsZW1lbnRzdAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAABHNyABpvcmcuYnVra2l0LnV0aWwuaW8uV3JhcHBlcvJQR+zxEm8FAgABTAADbWFwdAAPTGphdmEvdXRpbC9NYXA7eHBzcgA1Y29tLmdvb2dsZS5jb21tb24uY29sbGVjdC5JbW11dGFibGVNYXAkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAlsABGtleXNxAH4AAVsABnZhbHVlc3EAfgABeHB1cQB+AAMAAAAEdAACPT10AAF4dAABeXQAAXp1cQB+AAMAAAAEdAAGVmVjdG9yc3IAEGphdmEubGFuZy5Eb3VibGWAs8JKKWv7BAIAAUQABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAAAAAABzcQB+ABEAAAAAAAAAAHNxAH4AEQAAAAAAAAAAc3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARQIOFwo9cKPZzcQB+ABFAtCKcKPXCj3NxAH4AEUBzrpeNT987c3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARwEQTMzMzMzNzcQB+ABFASYAAAAAAAHNxAH4AEcCjqG3UQTVUc3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARQd/////AAABzcQB+ABHB4AAAAAAAAHNxAH4AEQAAAAAAAAAA", - ImmutableList.of( - new Vector(0, 0, 0), - new Vector(624.72, 5154.61, 314.912), - new Vector(-40.15, 51, -2516.21451), - new Vector(Integer.MAX_VALUE, Integer.MIN_VALUE, 0) - ) - }); + public static Stream data() { + return Stream.of( + Arguments.of( + Color.class.getName(), + "rO0ABXNyADZjb20uZ29vZ2xlLmNvbW1vbi5jb2xsZWN0LkltbXV0YWJsZUxpc3QkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAVsACGVsZW1lbnRzdAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAABXNyABpvcmcuYnVra2l0LnV0aWwuaW8uV3JhcHBlcvJQR+zxEm8FAgABTAADbWFwdAAPTGphdmEvdXRpbC9NYXA7eHBzcgA1Y29tLmdvb2dsZS5jb21tb24uY29sbGVjdC5JbW11dGFibGVNYXAkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAlsABGtleXNxAH4AAVsABnZhbHVlc3EAfgABeHB1cQB+AAMAAAAEdAACPT10AANSRUR0AARCTFVFdAAFR1JFRU51cQB+AAMAAAAEdAAFQ29sb3JzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAA/3NxAH4AEQAAAP9zcQB+ABEAAAD/c3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARAAAAAHNxAH4AEQAAAIBzcQB+ABEAAACAc3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARAAAAgHNxAH4AEQAAAIBxAH4AGnNxAH4ABXNxAH4ACHVxAH4AAwAAAARxAH4AC3EAfgAMcQB+AA1xAH4ADnVxAH4AAwAAAARxAH4AEHNxAH4AEQAAAP9xAH4AGnEAfgAac3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARAAAA/3EAfgAac3EAfgARAAAApQ==", + ImmutableList.of( + Color.WHITE, + Color.TEAL, + Color.PURPLE, + Color.RED, + Color.ORANGE + ) + ), + Arguments.of( + FireworkEffect.class.getName(), + "rO0ABXNyADZjb20uZ29vZ2xlLmNvbW1vbi5jb2xsZWN0LkltbXV0YWJsZUxpc3QkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAVsACGVsZW1lbnRzdAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAAA3NyABpvcmcuYnVra2l0LnV0aWwuaW8uV3JhcHBlcvJQR+zxEm8FAgABTAADbWFwdAAPTGphdmEvdXRpbC9NYXA7eHBzcgA1Y29tLmdvb2dsZS5jb21tb24uY29sbGVjdC5JbW11dGFibGVNYXAkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAlsABGtleXNxAH4AAVsABnZhbHVlc3EAfgABeHB1cQB+AAMAAAAGdAACPT10AAdmbGlja2VydAAFdHJhaWx0AAZjb2xvcnN0AAtmYWRlLWNvbG9yc3QABHR5cGV1cQB+AAMAAAAGdAAIRmlyZXdvcmtzcgARamF2YS5sYW5nLkJvb2xlYW7NIHKA1Zz67gIAAVoABXZhbHVleHABc3EAfgATAHNxAH4AAHVxAH4AAwAAAAJzcQB+AAVzcQB+AAh1cQB+AAMAAAAEcQB+AAt0AANSRUR0AARCTFVFdAAFR1JFRU51cQB+AAMAAAAEdAAFQ29sb3JzcgARamF2YS5sYW5nLkludGVnZXIS4qCk94GHOAIAAUkABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAHEAfgAicQB+ACJzcQB+AAVzcQB+AAh1cQB+AAMAAAAEcQB+AAtxAH4AG3EAfgAccQB+AB11cQB+AAMAAAAEcQB+AB9zcQB+ACAAAADAc3EAfgAgAAAAwHNxAH4AIAAAAMBzcQB+AAB1cQB+AAMAAAABc3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+ABtxAH4AHHEAfgAddXEAfgADAAAABHEAfgAfc3EAfgAgAAAA/3NxAH4AIAAAAP9zcQB+ACAAAAD/dAAKQkFMTF9MQVJHRXNxAH4ABXNxAH4ACHVxAH4AAwAAAAZxAH4AC3EAfgAMcQB+AA1xAH4ADnEAfgAPcQB+ABB1cQB+AAMAAAAGcQB+ABJxAH4AFXEAfgAVc3EAfgAAdXEAfgADAAAAAXNxAH4ABXNxAH4ACHVxAH4AAwAAAARxAH4AC3EAfgAbcQB+ABxxAH4AHXVxAH4AAwAAAARxAH4AH3EAfgAic3EAfgAgAAAAgHEAfgAic3EAfgAAdXEAfgADAAAAAHQABEJBTExzcQB+AAVzcQB+AAh1cQB+AAMAAAAGcQB+AAtxAH4ADHEAfgANcQB+AA5xAH4AD3EAfgAQdXEAfgADAAAABnEAfgAScQB+ABRxAH4AFHNxAH4AAHVxAH4AAwAAAAFzcQB+AAVzcQB+AAh1cQB+AAMAAAAEcQB+AAtxAH4AG3EAfgAccQB+AB11cQB+AAMAAAAEcQB+AB9zcQB+ACAAAACAcQB+ACJxAH4AInEAfgA/dAAHQ1JFRVBFUg==", + ImmutableList.of( + FireworkEffect.builder() + .withColor(Color.BLACK, Color.SILVER) + .with(Type.BALL_LARGE) + .withFade(Color.WHITE) + .withFlicker() + .build(), + FireworkEffect.builder() + .withColor(Color.NAVY) + .build(), + FireworkEffect.builder() + .withColor(Color.MAROON) + .withTrail() + .withFlicker() + .with(Type.CREEPER) + .build() + ) + ), + Arguments.of( + Vector.class.getName(), + "rO0ABXNyADZjb20uZ29vZ2xlLmNvbW1vbi5jb2xsZWN0LkltbXV0YWJsZUxpc3QkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAVsACGVsZW1lbnRzdAATW0xqYXZhL2xhbmcvT2JqZWN0O3hwdXIAE1tMamF2YS5sYW5nLk9iamVjdDuQzlifEHMpbAIAAHhwAAAABHNyABpvcmcuYnVra2l0LnV0aWwuaW8uV3JhcHBlcvJQR+zxEm8FAgABTAADbWFwdAAPTGphdmEvdXRpbC9NYXA7eHBzcgA1Y29tLmdvb2dsZS5jb21tb24uY29sbGVjdC5JbW11dGFibGVNYXAkU2VyaWFsaXplZEZvcm0AAAAAAAAAAAIAAlsABGtleXNxAH4AAVsABnZhbHVlc3EAfgABeHB1cQB+AAMAAAAEdAACPT10AAF4dAABeXQAAXp1cQB+AAMAAAAEdAAGVmVjdG9yc3IAEGphdmEubGFuZy5Eb3VibGWAs8JKKWv7BAIAAUQABXZhbHVleHIAEGphdmEubGFuZy5OdW1iZXKGrJUdC5TgiwIAAHhwAAAAAAAAAABzcQB+ABEAAAAAAAAAAHNxAH4AEQAAAAAAAAAAc3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARQIOFwo9cKPZzcQB+ABFAtCKcKPXCj3NxAH4AEUBzrpeNT987c3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARwEQTMzMzMzNzcQB+ABFASYAAAAAAAHNxAH4AEcCjqG3UQTVUc3EAfgAFc3EAfgAIdXEAfgADAAAABHEAfgALcQB+AAxxAH4ADXEAfgAOdXEAfgADAAAABHEAfgAQc3EAfgARQd/////AAABzcQB+ABHB4AAAAAAAAHNxAH4AEQAAAAAAAAAA", + ImmutableList.of( + new Vector(0, 0, 0), + new Vector(624.72, 5154.61, 314.912), + new Vector(-40.15, 51, -2516.21451), + new Vector(Integer.MAX_VALUE, Integer.MIN_VALUE, 0) + ) + )); } - @Parameter(0) - public String className; - - @Parameter(1) - public String preEncoded; - - @Parameter(2) - public List object; - - @Test - public void checkSerlialization() throws Throwable { + @ParameterizedTest + @MethodSource("data") + public void checkSerlialization(String className, String preEncoded, List object) throws Throwable { // If this test fails, you may start your trek to debug by commenting the '@Ignore' on the next method // (and of course, you would read those comments too) final ByteArrayOutputStream out = new ByteArrayOutputStream(); @@ -102,7 +91,7 @@ public class BukkitObjectStreamTest { final byte[] preEncodedArray = Base64Coder.decode(preEncoded); final Object readBack; - final Object preEncoded; + final Object encoded; ObjectInputStream ois = null; ObjectInputStream preois = null; @@ -113,7 +102,7 @@ public class BukkitObjectStreamTest { preois = new BukkitObjectInputStream(preIn); readBack = ois.readObject(); - preEncoded = preois.readObject(); + encoded = preois.readObject(); } finally { if (ois != null) { try { @@ -130,12 +119,13 @@ public class BukkitObjectStreamTest { } assertThat(object, is(readBack)); - assertThat(object, is(preEncoded)); + assertThat(object, is(encoded)); } - @Ignore - @Test - public void preEncoded() throws Throwable { + @Disabled + @ParameterizedTest + @MethodSource("data") + public void preEncoded(String className, String preEncoded, List object) throws Throwable { // This test is placed in the case that a necessary change is made to change the encoding format // Just remove the ignore (or run manually) and it'll give you the new pre-encoded values