From ad30a239bb49bc9fe7063e1b04ec4758aa45e2cc Mon Sep 17 00:00:00 2001 From: Andrew Katz Date: Fri, 12 Feb 2021 23:12:45 -0700 Subject: [PATCH 01/14] Add cool new nbt thingies --- build.gradle | 1 + .../stickyapi/common/nbt/NbtBooleanTag.java | 62 ++++++++++ .../stickyapi/common/nbt/NbtCompoundTag.java | 79 +++++++++++++ .../stickyapi/common/nbt/NbtJsonAdapter.java | 47 ++++++++ .../stickyapi/common/nbt/NbtJsonTag.java | 54 +++++++++ .../stickyapi/common/nbt/NbtListTag.java | 67 +++++++++++ .../stickyapi/common/nbt/NbtNumberTag.java | 85 ++++++++++++++ .../stickyapi/common/nbt/NbtPrimitiveTag.java | 20 ++++ .../stickyapi/common/nbt/NbtStringTag.java | 90 +++++++++++++++ .../stickyapi/common/nbt/NbtTag.java | 24 ++++ .../stickyapi/common/nbt/package-info.java | 9 ++ .../stickyapi/common/util/NumberUtil.java | 1 + .../stickyapi/common/util/StringUtil.java | 19 +++- .../common/nbt/NbtBooleanTagTest.java | 57 ++++++++++ .../common/nbt/NbtNumberTagTest.java | 106 ++++++++++++++++++ .../common/nbt/NbtStringTagTest.java | 37 ++++++ 16 files changed, 756 insertions(+), 2 deletions(-) create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtPrimitiveTag.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java create mode 100644 src/main/java/com/dumbdogdiner/stickyapi/common/nbt/package-info.java create mode 100644 src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java create mode 100644 src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java create mode 100644 src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java diff --git a/build.gradle b/build.gradle index 05b250c1..ebff8ea2 100644 --- a/build.gradle +++ b/build.gradle @@ -56,6 +56,7 @@ dependencies { implementation 'com.github.seancfoley:ipaddress:5.3.3' // Tests - JUnit 5 + testImplementation("org.junit.jupiter:junit-jupiter-params:5.7.0") testImplementation("org.junit.jupiter:junit-jupiter-api:5.7.0") testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:5.7.0") diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java new file mode 100644 index 00000000..ce96ca71 --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.common.base.Preconditions; +import com.google.gson.JsonElement; +import com.google.gson.JsonPrimitive; +import org.jetbrains.annotations.NotNull; + + +/** + * A convenience class for converting booleans from {@link JsonPrimitive}s, and for easily creating + */ +public class NbtBooleanTag extends NbtPrimitiveTag { + private final boolean bool; + + public NbtBooleanTag(boolean bool) { + this.bool = bool; + } + + /** + * Converts a {@link JsonPrimitive} of a boolean to a new {@link NbtBooleanTag} + * It is recommended to make sure the primitive is a boolean first + * + * @param primitive The incoming {@link JsonPrimitive} to be converted, must be a boolean type! + * @return A new tag with tbe boolean value of the primitive + * @throws ClassCastException if the primitive is not a boolean + * @see JsonPrimitive#isBoolean() + */ + public static @NotNull NbtBooleanTag fromPrimitive(@NotNull JsonPrimitive primitive) throws ClassCastException { + return new NbtBooleanTag(primitive.getAsBoolean()); + } + + // As much as I hate the object form... we have to because generics + @Override + public @NotNull Boolean asPrimitive() { + return bool; + } + + @Override + public @NotNull JsonElement toJson() { + return new JsonPrimitive(bool); + } + + @Override + public @NotNull String toSNbt() { + return bool ? NbtNumberTag.TRUE.toSNbt() : NbtNumberTag.FALSE.toSNbt(); + } + + @Override + public boolean equals(Object other) { + if (other instanceof NbtBooleanTag) { + return ((NbtBooleanTag) other).asPrimitive() == bool; + } else if (other instanceof NbtNumberTag) { + return (!((NbtNumberTag) other).asPrimitive().equals(0)) == bool; + } else { + return false; + } + } +} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java new file mode 100644 index 00000000..a40d2d08 --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import org.jetbrains.annotations.NotNull; + +import java.util.HashMap; +import java.util.Map; +import java.util.StringJoiner; + +/** + * A wrapper tag that allows working with Compound NBT tags as maps! + */ +public class NbtCompoundTag extends HashMap implements NbtTag{ + + /** + * Creates a new {@link NbtCompoundTag} from an existing {@link Map} + * {@inheritDoc} + */ + public NbtCompoundTag(Map map) { + super(map); + } + + /** + * Create a new, blank {@link NbtCompoundTag} + * + * {@inheritDoc} + */ + public NbtCompoundTag() { + super(); + } + + /** + * Constructs a new {@link NbtCompoundTag} from a given {@link JsonObject} + */ + public static NbtCompoundTag fromJsonObject(JsonObject object){ + NbtCompoundTag tag = new NbtCompoundTag(); + for(String elementName : object.keySet()){ + tag.put(elementName, NbtJsonAdapter.jsonToNbt(object.get(elementName))); + } + return tag; + } + + @Override + public @NotNull JsonElement toJson() { + JsonObject object = new JsonObject(); + forEach((name, nbtTag) -> { + if(nbtTag instanceof NbtPrimitiveTag){ + Object primitive = ((NbtPrimitiveTag) nbtTag).asPrimitive(); + if(primitive instanceof NbtNumberTag){ + object.addProperty(name, ((NbtNumberTag) primitive).asPrimitive()); + } else if(primitive instanceof NbtBooleanTag){ + object.addProperty(name, ((NbtBooleanTag) primitive).asPrimitive()); + } else if(primitive instanceof NbtStringTag){ + object.addProperty(name, ((NbtStringTag) primitive).asPrimitive()); + } + } else { + object.add(name, nbtTag.toJson()); + } + }); + return object; + } + + @Override + public @NotNull String toSNbt() { + StringJoiner SNBT = new StringJoiner(",", "{", "}"); + forEach((name, nbtTag) -> { + StringJoiner element = new StringJoiner(":"); + element.add(name); + element.add(nbtTag.toSNbt()); + SNBT.add(element.toString()); + }); + return SNBT.toString(); + } +} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java new file mode 100644 index 00000000..63d588d2 --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.gson.JsonElement; +import com.google.gson.JsonPrimitive; +import lombok.experimental.UtilityClass; +import org.jetbrains.annotations.NotNull; + +import java.text.MessageFormat; + +/** + * Utility class for easy creation of the appropriate {@link NbtTag} from an existing {@link JsonElement} + */ +@UtilityClass +public final class NbtJsonAdapter { + /** + * Creates the appropriate tag from a given {@link JsonElement}, but never creates a {@link NbtJsonTag} + * @param jse The incoming {@link JsonElement} to convert + * @return the new {@link NbtTag} + */ + public static NbtTag jsonToNbt(@NotNull JsonElement jse) { + if(jse.isJsonArray()){ + return NbtListTag.fromJsonArray(jse.getAsJsonArray()); + } else if(jse.isJsonObject()){ + return NbtCompoundTag.fromJsonObject(jse.getAsJsonObject()); + } else if(jse.isJsonPrimitive()){ + JsonPrimitive primitive = jse.getAsJsonPrimitive(); + if(primitive.isBoolean()){ + return NbtBooleanTag.fromPrimitive(primitive); + } else if(primitive.isNumber()){ + return NbtNumberTag.fromPrimitive(primitive); + } else if(primitive.isString()){ + return NbtStringTag.fromPrimitive(primitive); + } else { + throw new UnsupportedOperationException("Illegal type of NBT primitive"); + } + } else if(jse.isJsonNull()) { + return null; + } else { + throw new UnsupportedOperationException(MessageFormat.format("This type of JSONElement is unsupported ({0})", jse.getClass().getName())); + } + + } +} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java new file mode 100644 index 00000000..e72170c7 --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.gson.Gson; +import com.google.gson.GsonBuilder; +import com.google.gson.JsonElement; +import org.jetbrains.annotations.NotNull; + +/** + * A special type of {@link NbtTag} that converts an arbitrary {@link JsonElement} into an appropriately escaped string as SNBT + */ +public class NbtJsonTag implements NbtTag{ + private final @NotNull JsonElement element; + private static final Gson G = new GsonBuilder() + // Make sure things aren't weirdly escaped, may need to turn this back on + .disableHtmlEscaping() + .create(); + + public NbtJsonTag(@NotNull JsonElement element) { + this.element = element; + } + + /** + * {@inheritDoc} + */ + @Override + public @NotNull JsonElement toJson() { + return element; + } + + /** + * {@inheritDoc} + */ + @Override + public @NotNull String toSNbt() { + return '\'' + G.toJson(element) + // Because minecraft json is a hack on a hack..... + // And sometimes the NBT is just json that gets quoted + + .replaceAll("(?. All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import org.jetbrains.annotations.NotNull; + +import java.util.ArrayList; +import java.util.StringJoiner; + +/** + * A wrapper class that allows the construction of or conversion (from JSON) of SNBT List Tags + */ + +public class NbtListTag extends ArrayList implements NbtTag { + /** + * Converts a JSON array into an NBT List tag of the native types + * @param arr The Json Array to convert + * @return the new {@link NbtListTag} + */ + public static NbtListTag fromJsonArray(JsonArray arr){ + NbtListTag listTag = new NbtListTag(); + for(JsonElement jse : arr){ + listTag.add(NbtJsonAdapter.jsonToNbt(jse)); + } + return listTag; + } + + /** + * Creates an NBT tag that is a list of stringified JSON elements from source array + * @param arr Source JSON array to convert + * @return The newly converted NBT list tag + */ + public static NbtListTag fromJsonArrayQuoted(JsonArray arr){ + NbtListTag listTag = new NbtListTag(); + for(JsonElement jse : arr){ + listTag.add(new NbtJsonTag(jse)); + } + return listTag; + } + + @Override + public @NotNull JsonElement toJson() { + JsonArray array = new JsonArray(); + for(NbtTag tag : this){ + array.add(tag.toJson()); + } + return array; + } + + @Override + public @NotNull String toSNbt() { + StringJoiner joiner = new StringJoiner(",", "[", "]"); + forEach(nbtTag -> joiner.add(nbtTag.toSNbt())); + return joiner.toString(); + } + + /** + * Creates a {@link NbtStringTag} of escaped NBT as a string + */ + public NbtStringTag toNbtStringTag() { + return new NbtStringTag(toSNbt(), true); + } +} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java new file mode 100644 index 00000000..4d8abe9f --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.common.base.Preconditions; +import com.google.gson.JsonElement; +import com.google.gson.JsonPrimitive; +import lombok.Getter; +import org.jetbrains.annotations.NotNull; + +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; +import java.text.MessageFormat; +import java.text.NumberFormat; +import java.util.Locale; + +/** + * A wrapper class that allows you to deal with numbers in NBT + */ +public class NbtNumberTag extends NbtPrimitiveTag { + private final @NotNull Number number; + + // AFIK, Minecraft numbers are always in US type format, I.E. US style decimal separator + public static final @NotNull NumberFormat NUMBER_FORMAT = new DecimalFormat("#.##########", DecimalFormatSymbols.getInstance(Locale.US)); + public static final @NotNull NbtNumberTag TRUE = new NbtNumberTag(1); + public static final @NotNull NbtNumberTag FALSE = new NbtNumberTag(0); + + /** + * Create a new {@link NbtNumberTag} from an existing {@link Number} + * Warning: this may sometimes produce unintended consequences if the type of number is not supported by minecraft + * @param number the number to wrap + */ + public NbtNumberTag(@NotNull Number number) { + Preconditions.checkNotNull(number); + this.number = number; + } + + /** + * Converts a numerical {@link JsonPrimitive} to the {@link NbtNumberTag} wrapper type + * @param primitive the incoming primative to convert + * @return The newly created {@link NbtNumberTag} + */ + public static NbtNumberTag fromPrimitive(@NotNull JsonPrimitive primitive){ + Preconditions.checkNotNull(primitive); + Preconditions.checkArgument(primitive.isNumber(), "The primative must be a number"); + return new NbtNumberTag(primitive.getAsNumber()); + } + + /** + * {@inheritDoc} + */ + @Override + public @NotNull Number asPrimitive() { + return number; + } + + /** + * {@inheritDoc} + */ + @Override + public @NotNull JsonElement toJson() { + return new JsonPrimitive(number); + } + + /** + * {@inheritDoc} + */ + @Override + public @NotNull String toSNbt() { + return NUMBER_FORMAT.format(number); + } + + @Override + public boolean equals(Object other){ + if(other instanceof NbtNumberTag){ + return number.equals(((NbtNumberTag) other).asPrimitive()); + } else if(other instanceof NbtBooleanTag){ + return other.equals(this); + } else { + return false; + } + } +} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtPrimitiveTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtPrimitiveTag.java new file mode 100644 index 00000000..4be701fe --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtPrimitiveTag.java @@ -0,0 +1,20 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import org.jetbrains.annotations.NotNull; + +/** + * Base class for any NBT tags that wrap simple primitives (and strings) + * + * @param The type of primitive + */ +public abstract class NbtPrimitiveTag implements NbtTag { + /** + * Gets the original primitive back from the tag + */ + @NotNull + public abstract T asPrimitive(); +} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java new file mode 100644 index 00000000..a4a78662 --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.dumbdogdiner.stickyapi.common.util.StringUtil; +import com.google.common.base.Preconditions; +import com.google.gson.JsonElement; +import com.google.gson.JsonPrimitive; +import org.jetbrains.annotations.NotNull; + +/** + * A {@link NbtTag} that wraps and escapes {@link String}s + */ +public class NbtStringTag extends NbtPrimitiveTag { + private final String string; + private final boolean escaped; + + /** + * Creates a new NbtStringTag from a given string + * @param string The string to make a tag from + */ + public NbtStringTag(String string) { + this.string = string; + this.escaped = false; + } + + /** + * For package-local use only, allows preventing additional string escaping + * @see #NbtStringTag(String) + */ + NbtStringTag(String string, boolean escaped){ + this.string = string; + this.escaped = escaped; + } + + + /** + * Converts a {@link JsonPrimitive} into a new {@link NbtStringTag} + * + * @param primitive The incoming primitive + * @return a new {@link NbtStringTag} containing the string + * @throws IllegalArgumentException if the primitive type is wrong + * @see JsonPrimitive#isString() + */ + public static NbtStringTag fromPrimitive(JsonPrimitive primitive) throws IllegalArgumentException { + Preconditions.checkArgument(primitive.isString(), "The primitive must be a string"); + return new NbtStringTag(primitive.getAsString()); + } + + @Override + public String toString() { + return string; + } + + @Override + public @NotNull JsonElement toJson() { + return new JsonPrimitive(string); + } + + @SuppressWarnings("UnnecessaryStringEscape") + @Override + public @NotNull String toSNbt() { + // Make sure there are no other escapes needed + return '\'' + + (escaped ? string : StringUtil.formatChatCodes(string) + .replace("\'", "\\\'") + .replace("\"", "\\\"") + .replace("\n", "\\n")) + + '\''; + + } + + @Override + public @NotNull String asPrimitive() { + return string; + } + + @Override + public boolean equals(Object other){ + if(other instanceof NbtStringTag){ + return escaped == ((NbtStringTag) other).escaped && string.equals(((NbtStringTag) other).asPrimitive()); + } else if(other instanceof NbtJsonTag){ + return other.equals(this); + } else { + return false; + } + } +} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java new file mode 100644 index 00000000..41e28ed3 --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java @@ -0,0 +1,24 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.gson.JsonElement; +import org.jetbrains.annotations.NotNull; + +public interface NbtTag { + /** + * Converts the {@link NbtTag} back to a {@link JsonElement} + * @return a {@link JsonElement} of type equivalent to the source tag + */ + @NotNull + JsonElement toJson(); + + /** + * Converts a tag into Stringified NBT + * @return A representation of the object as Stringified NBT (SNbt) + */ + @NotNull + String toSNbt(); +} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/package-info.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/package-info.java new file mode 100644 index 00000000..1e9b20c9 --- /dev/null +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/package-info.java @@ -0,0 +1,9 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +/** + * This package contains classes designed to help work with SNBT + */ + +package com.dumbdogdiner.stickyapi.common.nbt; diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java b/src/main/java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java index 9f64139f..1515543e 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java @@ -106,6 +106,7 @@ public static String getPercentageString(@NotNull int x, @NotNull int total) { * @return {@link Integer} * @throws IllegalArgumentException when min is greater than max */ + @Deprecated public static int getRandomNumber(@NotNull int min, @NotNull int max) { if (min >= max) throw new IllegalArgumentException("Min may not be greater than max!"); diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/util/StringUtil.java b/src/main/java/com/dumbdogdiner/stickyapi/common/util/StringUtil.java index 516852d0..dcaff3a6 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/util/StringUtil.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/util/StringUtil.java @@ -9,14 +9,18 @@ import java.util.Map; import java.util.UUID; +import com.google.common.base.Preconditions; +import lombok.experimental.UtilityClass; + +import net.md_5.bungee.api.ChatColor; + import org.jetbrains.annotations.NotNull; /** * Operations on {@link java.lang.String} */ +@UtilityClass public final class StringUtil { - private StringUtil() { - } private static HashMap leetReplace = new HashMap<>(); @@ -287,4 +291,15 @@ public static UUID hyphenateUUID(@NotNull String uuid) { return UUID.fromString(uuid); } } + + /** + * Replaces & followed by any valid minecraft format code (matching the regex 
(?=([a-f]|[0-9]|[klmnor]))
with § + * + * @param input The input string + * @return A string where the relevant ampersands are replaced with section symbols + */ + public static String formatChatCodes(String input) { + return input.replaceAll("&(?=([a-f]|[0-9]|[klmnor]))", Character.toString(ChatColor.COLOR_CHAR)); + } + } diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java new file mode 100644 index 00000000..8e55a1d3 --- /dev/null +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.gson.Gson; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import com.google.gson.JsonPrimitive; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + + +import static org.junit.jupiter.api.Assertions.*; + +@RunWith(Parameterized.class) +class NbtBooleanTagTest { + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void fromPrimitive(boolean b) { + assertEquals(new NbtBooleanTag(b), NbtBooleanTag.fromPrimitive(new JsonPrimitive(b))); + } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void asPrimitive(boolean b) { + assertEquals(b, new NbtBooleanTag(b).asPrimitive()); + } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void toJson(boolean b) { + JsonPrimitive primitive = new JsonPrimitive(b); + assertEquals(primitive, new NbtBooleanTag(b).toJson()); + } + + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void toSNbt(boolean b) { + int i = b ? 1 : 0; + assertEquals(Integer.toString(i), new NbtBooleanTag(b).toSNbt()); + } + + @SuppressWarnings("AssertBetweenInconvertibleTypes") + @ParameterizedTest + @ValueSource(booleans = {true, false}) + void equals(boolean b) { + int i = b ? 1 : 0; + assertEquals(new NbtNumberTag(i), new NbtBooleanTag(b)); + } +} \ No newline at end of file diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java new file mode 100644 index 00000000..cffcf033 --- /dev/null +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import com.google.gson.JsonPrimitive; +import org.junit.Before; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.RepeatedTest; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; + +import java.text.MessageFormat; + +import static com.dumbdogdiner.stickyapi.common.util.MathUtil.randomDouble; +import static com.dumbdogdiner.stickyapi.common.util.MathUtil.randomInt; +import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assumptions.*; + +class NbtNumberTagTest { + private static final int REPEAT = 1000; + int i; + float f; + + @BeforeEach + public void setUp(){ + i = randomInt(-256, 4096); + f = (float) randomDouble(-256, 8192); + } + + @RepeatedTest(REPEAT) + void fromPrimitive() { + System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); + JsonPrimitive iPrim = new JsonPrimitive(i); + JsonPrimitive fPrim = new JsonPrimitive(f); + assertEquals(new NbtNumberTag(i), NbtNumberTag.fromPrimitive(iPrim)); + assertEquals(new NbtNumberTag(f), NbtNumberTag.fromPrimitive(fPrim)); + } + + @RepeatedTest(REPEAT) + void asPrimitive() { + System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); + assertEquals(i, new NbtNumberTag(i).asPrimitive()); + assertEquals(i, NbtNumberTag.fromPrimitive(new JsonPrimitive(i)).asPrimitive()); + assertEquals(f, new NbtNumberTag(f).asPrimitive()); + assertEquals(f, NbtNumberTag.fromPrimitive(new JsonPrimitive(f)).asPrimitive()); + } + + @RepeatedTest(REPEAT) + void toJson() { + System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); + JsonPrimitive iPrim = new JsonPrimitive(i); + JsonPrimitive fPrim = new JsonPrimitive(f); + assertEquals(iPrim, new NbtNumberTag(i).toJson()); + assertEquals(iPrim, NbtNumberTag.fromPrimitive(iPrim).toJson()); + assertEquals(fPrim, new NbtNumberTag(f).toJson()); + assertEquals(fPrim, NbtNumberTag.fromPrimitive(fPrim).toJson()); + } + + @RepeatedTest(REPEAT) + void toSNbt() { + System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); + String iString = new NbtNumberTag(i).toSNbt(); + String negativeIString = new NbtNumberTag(-i).toSNbt(); + String fString = new NbtNumberTag(f).toSNbt(); + String negativeFString = new NbtNumberTag(-f).toSNbt(); + assertEquals(NbtNumberTag.NUMBER_FORMAT.format(i), iString); + assertEquals(NbtNumberTag.NUMBER_FORMAT.format(f), fString); + assertEquals(NbtNumberTag.NUMBER_FORMAT.format(-i), negativeIString); + assertEquals(NbtNumberTag.NUMBER_FORMAT.format(-f), negativeFString); + + assumeTrue(i > -i); + assertFalse(iString.contains("-")); + assertFalse(iString.contains(".")); + assertFalse(iString.contains(",")); + assertTrue(negativeIString.contains("-")); + assertFalse(negativeIString.contains(".")); + assertFalse(negativeIString.contains(",")); + + assumeTrue(f != (int) f); + assumeTrue(f > -f); + assertTrue(fString.contains(".")); + assertFalse(fString.contains("-")); + assertFalse(fString.contains(",")); + assertTrue(negativeFString.contains(".")); + assertTrue(negativeFString.contains("-")); + assertFalse(negativeFString.contains(",")); + } + + @RepeatedTest(REPEAT) + void notEquals() { + assertNotEquals(new NbtNumberTag(i), NbtNumberTag.fromPrimitive(new JsonPrimitive(i - 1))); + assertNotEquals(new NbtNumberTag(f), NbtNumberTag.fromPrimitive(new JsonPrimitive(f + 0.1f))); + } + + @Test + @SuppressWarnings("AssertBetweenInconvertibleTypes") + void testEquals() { + assertEquals(new NbtNumberTag(0), NbtNumberTag.FALSE); + assertEquals(new NbtNumberTag(0), new NbtBooleanTag(false)); + assertEquals(new NbtNumberTag(1), NbtNumberTag.TRUE); + assertEquals(new NbtNumberTag(1), new NbtBooleanTag(true)); + } +} diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java new file mode 100644 index 00000000..cd81582f --- /dev/null +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. + * Licensed under the MIT license, see LICENSE for more information... + */ +package com.dumbdogdiner.stickyapi.common.nbt; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class NbtStringTagTest { + + @Test + void fromPrimitive() { + + } + + @Test + void testToString() { + } + + @Test + void toJson() { + } + + @Test + void toSNbt() { + } + + @Test + void asPrimitive() { + } + + @Test + void testEquals() { + } +} \ No newline at end of file From 6e68cc16155454159edf4e17eb2628c2c0ed4332 Mon Sep 17 00:00:00 2001 From: Andrew Katz Date: Fri, 12 Feb 2021 23:42:20 -0700 Subject: [PATCH 02/14] Additional constructor for NbtCompoundTag --- .../stickyapi/common/nbt/NbtCompoundTag.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java index a40d2d08..c3bccf62 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java @@ -34,6 +34,16 @@ public NbtCompoundTag() { super(); } + /** + * Create a new {@link NbtCompoundTag} with an existing key and tag (useful for 1-element compound tags!) + * @param key The key to set + * @param tag The tag to assign + */ + public NbtCompoundTag(String key, NbtTag tag){ + super(); + put(key, tag); + } + /** * Constructs a new {@link NbtCompoundTag} from a given {@link JsonObject} */ From c722a7397267f623fed396f97b99fb99654d5396 Mon Sep 17 00:00:00 2001 From: Andrew Katz Date: Fri, 12 Feb 2021 23:48:09 -0700 Subject: [PATCH 03/14] Allow creating NbtListTag with predefined array --- .../stickyapi/common/nbt/NbtListTag.java | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java index f38c94c6..5bc55a30 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java @@ -9,6 +9,7 @@ import org.jetbrains.annotations.NotNull; import java.util.ArrayList; +import java.util.Arrays; import java.util.StringJoiner; /** @@ -16,6 +17,21 @@ */ public class NbtListTag extends ArrayList implements NbtTag { + /** + * Generates a new, empty {@link NbtListTag} + * {@inheritDoc} + */ + public NbtListTag() { + super(); + } + + /** + * Generate a new {@link NbtListTag} with elements from an existing array or individual objects + */ + public NbtListTag(NbtTag ... tags){ + super(Arrays.asList(tags)); + } + /** * Converts a JSON array into an NBT List tag of the native types * @param arr The Json Array to convert From 587bba958ee66bbe8575ae47a29499789b60c531 Mon Sep 17 00:00:00 2001 From: Andrew Katz Date: Sat, 13 Feb 2021 00:00:08 -0700 Subject: [PATCH 04/14] Add convenience methods to NbtCompoundTag --- .../stickyapi/common/nbt/NbtCompoundTag.java | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java index c3bccf62..94924910 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java @@ -10,6 +10,7 @@ import java.util.HashMap; import java.util.Map; +import java.util.Objects; import java.util.StringJoiner; /** @@ -86,4 +87,32 @@ public static NbtCompoundTag fromJsonObject(JsonObject object){ }); return SNBT.toString(); } + + /** + * Convenience method to add a number directly to the compound tag with a given key + * @return The original number + */ + public @NotNull Number put(@NotNull String key, @NotNull Number n) { + put(key, new NbtNumberTag(n)); + return n; + } + + /** + * Convenience method to add a boolean directly to the compound tag with a given key + * @return The original boolean + */ + public boolean put(@NotNull String key, boolean b) { + put(key, new NbtBooleanTag(b)); + return b; + } + + /** + * Convenience method to add a String directly to the compound tag with a given key + * @return The original String + */ + public String put(@NotNull String key, @NotNull String s){ + put(key, new NbtStringTag(s)); + return s; + } + } From 72fc012147cc984ba8a9225c5cd9bc9d281caf6c Mon Sep 17 00:00:00 2001 From: James Date: Sat, 13 Feb 2021 23:31:38 +0000 Subject: [PATCH 05/14] Hopefully change all occurences of toSNbt to toNbtString --- .../stickyapi/common/nbt/NbtBooleanTag.java | 4 ++-- .../stickyapi/common/nbt/NbtCompoundTag.java | 10 +++++----- .../dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java | 6 +++--- .../dumbdogdiner/stickyapi/common/nbt/NbtListTag.java | 8 ++++---- .../stickyapi/common/nbt/NbtNumberTag.java | 2 +- .../stickyapi/common/nbt/NbtStringTag.java | 2 +- .../com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java | 4 ++-- .../stickyapi/common/nbt/NbtBooleanTagTest.java | 4 ++-- .../stickyapi/common/nbt/NbtNumberTagTest.java | 10 +++++----- .../stickyapi/common/nbt/NbtStringTagTest.java | 2 +- 10 files changed, 26 insertions(+), 26 deletions(-) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java index ce96ca71..0071c136 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java @@ -45,8 +45,8 @@ public NbtBooleanTag(boolean bool) { } @Override - public @NotNull String toSNbt() { - return bool ? NbtNumberTag.TRUE.toSNbt() : NbtNumberTag.FALSE.toSNbt(); + public @NotNull String toNbtString() { + return bool ? NbtNumberTag.TRUE.toNbtString() : NbtNumberTag.FALSE.toNbtString(); } @Override diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java index 94924910..b431e776 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java @@ -77,15 +77,15 @@ public static NbtCompoundTag fromJsonObject(JsonObject object){ } @Override - public @NotNull String toSNbt() { - StringJoiner SNBT = new StringJoiner(",", "{", "}"); + public @NotNull String toNbtString() { + StringJoiner stringNbt = new StringJoiner(",", "{", "}"); forEach((name, nbtTag) -> { StringJoiner element = new StringJoiner(":"); element.add(name); - element.add(nbtTag.toSNbt()); - SNBT.add(element.toString()); + element.add(nbtTag.toNbtString()); + stringNbt.add(element.toString()); }); - return SNBT.toString(); + return stringNbt.toString(); } /** diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java index e72170c7..591b6a00 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java @@ -10,7 +10,7 @@ import org.jetbrains.annotations.NotNull; /** - * A special type of {@link NbtTag} that converts an arbitrary {@link JsonElement} into an appropriately escaped string as SNBT + * A special type of {@link NbtTag} that converts an arbitrary {@link JsonElement} into an appropriately escaped string as NBT */ public class NbtJsonTag implements NbtTag{ private final @NotNull JsonElement element; @@ -35,7 +35,7 @@ public NbtJsonTag(@NotNull JsonElement element) { * {@inheritDoc} */ @Override - public @NotNull String toSNbt() { + public @NotNull String toNbtString() { return '\'' + G.toJson(element) // Because minecraft json is a hack on a hack..... // And sometimes the NBT is just json that gets quoted @@ -49,6 +49,6 @@ public NbtJsonTag(@NotNull JsonElement element) { @Override public boolean equals(Object other){ - return ((other instanceof NbtJsonTag || other instanceof NbtStringTag) && toSNbt().equals(((NbtTag) other).toSNbt())); + return ((other instanceof NbtJsonTag || other instanceof NbtStringTag) && toNbtString().equals(((NbtTag) other).toNbtString())); } } diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java index 5bc55a30..897dc0ce 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java @@ -13,7 +13,7 @@ import java.util.StringJoiner; /** - * A wrapper class that allows the construction of or conversion (from JSON) of SNBT List Tags + * A wrapper class that allows the construction of or conversion (from JSON) of NBT List Tags */ public class NbtListTag extends ArrayList implements NbtTag { @@ -68,9 +68,9 @@ public static NbtListTag fromJsonArrayQuoted(JsonArray arr){ } @Override - public @NotNull String toSNbt() { + public @NotNull String toNbtString() { StringJoiner joiner = new StringJoiner(",", "[", "]"); - forEach(nbtTag -> joiner.add(nbtTag.toSNbt())); + forEach(nbtTag -> joiner.add(nbtTag.toNbtString())); return joiner.toString(); } @@ -78,6 +78,6 @@ public static NbtListTag fromJsonArrayQuoted(JsonArray arr){ * Creates a {@link NbtStringTag} of escaped NBT as a string */ public NbtStringTag toNbtStringTag() { - return new NbtStringTag(toSNbt(), true); + return new NbtStringTag(toNbtString(), true); } } diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java index 4d8abe9f..457a1d07 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java @@ -68,7 +68,7 @@ public static NbtNumberTag fromPrimitive(@NotNull JsonPrimitive primitive){ * {@inheritDoc} */ @Override - public @NotNull String toSNbt() { + public @NotNull String toNbtString() { return NUMBER_FORMAT.format(number); } diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java index a4a78662..797c5109 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java @@ -61,7 +61,7 @@ public String toString() { @SuppressWarnings("UnnecessaryStringEscape") @Override - public @NotNull String toSNbt() { + public @NotNull String toNbtString() { // Make sure there are no other escapes needed return '\'' + (escaped ? string : StringUtil.formatChatCodes(string) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java index 41e28ed3..b7c10d2a 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtTag.java @@ -17,8 +17,8 @@ public interface NbtTag { /** * Converts a tag into Stringified NBT - * @return A representation of the object as Stringified NBT (SNbt) + * @return A representation of the object as Stringified NBT */ @NotNull - String toSNbt(); + String toNbtString(); } diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java index 8e55a1d3..4ccd57a1 100644 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java @@ -42,9 +42,9 @@ void toJson(boolean b) { @ParameterizedTest @ValueSource(booleans = {true, false}) - void toSNbt(boolean b) { + void toNbtString(boolean b) { int i = b ? 1 : 0; - assertEquals(Integer.toString(i), new NbtBooleanTag(b).toSNbt()); + assertEquals(Integer.toString(i), new NbtBooleanTag(b).toNbtString()); } @SuppressWarnings("AssertBetweenInconvertibleTypes") diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java index cffcf033..121c09e6 100644 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java @@ -60,12 +60,12 @@ void toJson() { } @RepeatedTest(REPEAT) - void toSNbt() { + void toNbtString() { System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); - String iString = new NbtNumberTag(i).toSNbt(); - String negativeIString = new NbtNumberTag(-i).toSNbt(); - String fString = new NbtNumberTag(f).toSNbt(); - String negativeFString = new NbtNumberTag(-f).toSNbt(); + String iString = new NbtNumberTag(i).toNbtString(); + String negativeIString = new NbtNumberTag(-i).toNbtString(); + String fString = new NbtNumberTag(f).toNbtString(); + String negativeFString = new NbtNumberTag(-f).toNbtString(); assertEquals(NbtNumberTag.NUMBER_FORMAT.format(i), iString); assertEquals(NbtNumberTag.NUMBER_FORMAT.format(f), fString); assertEquals(NbtNumberTag.NUMBER_FORMAT.format(-i), negativeIString); diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java index cd81582f..be5287c6 100644 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java @@ -24,7 +24,7 @@ void toJson() { } @Test - void toSNbt() { + void toNbtString() { } @Test From 73ac136e4167acee2004f3fab51dbf5640af724a Mon Sep 17 00:00:00 2001 From: James Date: Sat, 13 Feb 2021 23:42:17 +0000 Subject: [PATCH 06/14] Move deprecated annotation to own commit --- .../java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java | 1 - 1 file changed, 1 deletion(-) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java b/src/main/java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java index 1515543e..9f64139f 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/util/NumberUtil.java @@ -106,7 +106,6 @@ public static String getPercentageString(@NotNull int x, @NotNull int total) { * @return {@link Integer} * @throws IllegalArgumentException when min is greater than max */ - @Deprecated public static int getRandomNumber(@NotNull int min, @NotNull int max) { if (min >= max) throw new IllegalArgumentException("Min may not be greater than max!"); From de99c9fb69d7640ad85924fe32ab97939e9efd68 Mon Sep 17 00:00:00 2001 From: James Date: Sat, 13 Feb 2021 23:43:28 +0000 Subject: [PATCH 07/14] StringUtil: remove unused imports, move annotation to own commit --- .../com/dumbdogdiner/stickyapi/common/util/StringUtil.java | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/util/StringUtil.java b/src/main/java/com/dumbdogdiner/stickyapi/common/util/StringUtil.java index dcaff3a6..5a5dddfa 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/util/StringUtil.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/util/StringUtil.java @@ -9,9 +9,6 @@ import java.util.Map; import java.util.UUID; -import com.google.common.base.Preconditions; -import lombok.experimental.UtilityClass; - import net.md_5.bungee.api.ChatColor; import org.jetbrains.annotations.NotNull; @@ -19,8 +16,9 @@ /** * Operations on {@link java.lang.String} */ -@UtilityClass public final class StringUtil { + private StringUtil() { + } private static HashMap leetReplace = new HashMap<>(); From 7af764ae5e2d382a3e023129e33093a1ecd4e810 Mon Sep 17 00:00:00 2001 From: James Date: Sat, 13 Feb 2021 23:44:50 +0000 Subject: [PATCH 08/14] Remove empty test --- .../common/nbt/NbtStringTagTest.java | 37 ------------------- 1 file changed, 37 deletions(-) delete mode 100644 src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java deleted file mode 100644 index be5287c6..00000000 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTagTest.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * Copyright (c) 2020-2021 DumbDogDiner . All rights reserved. - * Licensed under the MIT license, see LICENSE for more information... - */ -package com.dumbdogdiner.stickyapi.common.nbt; - -import org.junit.jupiter.api.Test; - -import static org.junit.jupiter.api.Assertions.*; - -class NbtStringTagTest { - - @Test - void fromPrimitive() { - - } - - @Test - void testToString() { - } - - @Test - void toJson() { - } - - @Test - void toNbtString() { - } - - @Test - void asPrimitive() { - } - - @Test - void testEquals() { - } -} \ No newline at end of file From 810deb4e73dc3c6aa9ff9a0163139bc743eb9ab3 Mon Sep 17 00:00:00 2001 From: James Date: Sat, 13 Feb 2021 23:45:39 +0000 Subject: [PATCH 09/14] Misc fixes: rename nbtjsonadapter stuff; style fixme in nbtjsontag; add spacing to nbtcompoundtag --- .../stickyapi/common/nbt/NbtCompoundTag.java | 2 +- .../stickyapi/common/nbt/NbtJsonAdapter.java | 22 ++++++++++--------- .../stickyapi/common/nbt/NbtJsonTag.java | 2 +- 3 files changed, 14 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java index b431e776..42df6b3d 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java @@ -16,7 +16,7 @@ /** * A wrapper tag that allows working with Compound NBT tags as maps! */ -public class NbtCompoundTag extends HashMap implements NbtTag{ +public class NbtCompoundTag extends HashMap implements NbtTag { /** * Creates a new {@link NbtCompoundTag} from an existing {@link Map} diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java index 63d588d2..eeb7f29a 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonAdapter.java @@ -18,16 +18,18 @@ public final class NbtJsonAdapter { /** * Creates the appropriate tag from a given {@link JsonElement}, but never creates a {@link NbtJsonTag} - * @param jse The incoming {@link JsonElement} to convert + * @param element The incoming {@link JsonElement} to convert * @return the new {@link NbtTag} */ - public static NbtTag jsonToNbt(@NotNull JsonElement jse) { - if(jse.isJsonArray()){ - return NbtListTag.fromJsonArray(jse.getAsJsonArray()); - } else if(jse.isJsonObject()){ - return NbtCompoundTag.fromJsonObject(jse.getAsJsonObject()); - } else if(jse.isJsonPrimitive()){ - JsonPrimitive primitive = jse.getAsJsonPrimitive(); + public static NbtTag fromJson(@NotNull JsonElement element) { + if(element.isJsonArray()){ + return NbtListTag.fromJsonArray(element.getAsJsonArray()); + } else if(element.isJsonObject()){ + return NbtCompoundTag.fromJsonObject(element.getAsJsonObject()); + } else if (element.isJsonPrimitive()) { + // TODO: Rewrite to look cleaner? + // https://github.com/DumbDogDiner/StickyAPI/pull/92/files#r575639999 + JsonPrimitive primitive = element.getAsJsonPrimitive(); if(primitive.isBoolean()){ return NbtBooleanTag.fromPrimitive(primitive); } else if(primitive.isNumber()){ @@ -37,10 +39,10 @@ public static NbtTag jsonToNbt(@NotNull JsonElement jse) { } else { throw new UnsupportedOperationException("Illegal type of NBT primitive"); } - } else if(jse.isJsonNull()) { + } else if(element.isJsonNull()) { return null; } else { - throw new UnsupportedOperationException(MessageFormat.format("This type of JSONElement is unsupported ({0})", jse.getClass().getName())); + throw new UnsupportedOperationException(MessageFormat.format("This type of JSONElement is unsupported ({0})", element.getClass().getName())); } } diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java index 591b6a00..00cd05d6 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java @@ -41,7 +41,7 @@ public NbtJsonTag(@NotNull JsonElement element) { // And sometimes the NBT is just json that gets quoted .replaceAll("(? Date: Sat, 13 Feb 2021 23:49:39 +0000 Subject: [PATCH 10/14] Fix NbtJsonAdapter calls --- .../com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java | 2 +- .../java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java index 42df6b3d..634fc71a 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java @@ -51,7 +51,7 @@ public NbtCompoundTag(String key, NbtTag tag){ public static NbtCompoundTag fromJsonObject(JsonObject object){ NbtCompoundTag tag = new NbtCompoundTag(); for(String elementName : object.keySet()){ - tag.put(elementName, NbtJsonAdapter.jsonToNbt(object.get(elementName))); + tag.put(elementName, NbtJsonAdapter.fromJson(object.get(elementName))); } return tag; } diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java index 897dc0ce..d7b06b92 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtListTag.java @@ -40,7 +40,7 @@ public NbtListTag(NbtTag ... tags){ public static NbtListTag fromJsonArray(JsonArray arr){ NbtListTag listTag = new NbtListTag(); for(JsonElement jse : arr){ - listTag.add(NbtJsonAdapter.jsonToNbt(jse)); + listTag.add(NbtJsonAdapter.fromJson(jse)); } return listTag; } From 4508109fa0595722b6f42a3fe6dce97fc4bc5a07 Mon Sep 17 00:00:00 2001 From: James Date: Sat, 13 Feb 2021 23:51:09 +0000 Subject: [PATCH 11/14] Remove unused imports --- .../com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java | 1 - .../dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java | 1 - .../com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java | 2 -- .../dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java | 5 ----- .../dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java | 3 --- 5 files changed, 12 deletions(-) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java index 0071c136..fe548d2d 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java @@ -4,7 +4,6 @@ */ package com.dumbdogdiner.stickyapi.common.nbt; -import com.google.common.base.Preconditions; import com.google.gson.JsonElement; import com.google.gson.JsonPrimitive; import org.jetbrains.annotations.NotNull; diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java index 634fc71a..15e6e948 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtCompoundTag.java @@ -10,7 +10,6 @@ import java.util.HashMap; import java.util.Map; -import java.util.Objects; import java.util.StringJoiner; /** diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java index 457a1d07..5ebdab80 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java @@ -7,12 +7,10 @@ import com.google.common.base.Preconditions; import com.google.gson.JsonElement; import com.google.gson.JsonPrimitive; -import lombok.Getter; import org.jetbrains.annotations.NotNull; import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; -import java.text.MessageFormat; import java.text.NumberFormat; import java.util.Locale; diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java index 4ccd57a1..ea6aaedb 100644 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java @@ -4,12 +4,7 @@ */ package com.dumbdogdiner.stickyapi.common.nbt; -import com.google.gson.Gson; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; -import com.google.gson.JsonParser; import com.google.gson.JsonPrimitive; -import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.ValueSource; import org.junit.runner.RunWith; diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java index 121c09e6..9eed264b 100644 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java @@ -5,12 +5,9 @@ package com.dumbdogdiner.stickyapi.common.nbt; import com.google.gson.JsonPrimitive; -import org.junit.Before; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.RepeatedTest; import org.junit.jupiter.api.Test; -import org.junit.jupiter.params.ParameterizedTest; -import org.junit.jupiter.params.provider.ValueSource; import java.text.MessageFormat; From fae7169e008093bfec20a8752a6e57cb90a60db6 Mon Sep 17 00:00:00 2001 From: James Date: Sat, 13 Feb 2021 23:56:39 +0000 Subject: [PATCH 12/14] Only repeat 100 times instead of 1000 --- .../com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java index 9eed264b..0b6478d5 100644 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java @@ -17,7 +17,7 @@ import static org.junit.jupiter.api.Assumptions.*; class NbtNumberTagTest { - private static final int REPEAT = 1000; + private static final int REPEAT = 100; // originally 1000, moved to 100 for now int i; float f; From 05ae866559129d7cb6b28e96000f5700838c53da Mon Sep 17 00:00:00 2001 From: James Date: Sun, 14 Feb 2021 00:17:45 +0000 Subject: [PATCH 13/14] Create hashCode() functions for nbt classes --- .../stickyapi/common/nbt/NbtBooleanTag.java | 5 +++++ .../stickyapi/common/nbt/NbtJsonTag.java | 10 ++++++++-- .../stickyapi/common/nbt/NbtNumberTag.java | 12 +++++++++--- .../stickyapi/common/nbt/NbtStringTag.java | 15 ++++++++++++--- 4 files changed, 34 insertions(+), 8 deletions(-) diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java index fe548d2d..c18e36a8 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTag.java @@ -58,4 +58,9 @@ public boolean equals(Object other) { return false; } } + + @Override + public int hashCode() { + return Boolean.hashCode(bool); + } } diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java index 00cd05d6..d913959c 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtJsonTag.java @@ -48,7 +48,13 @@ public NbtJsonTag(@NotNull JsonElement element) { } @Override - public boolean equals(Object other){ - return ((other instanceof NbtJsonTag || other instanceof NbtStringTag) && toNbtString().equals(((NbtTag) other).toNbtString())); + public boolean equals(Object other) { + return ((other instanceof NbtJsonTag || other instanceof NbtStringTag) + && toNbtString().equals(((NbtTag) other).toNbtString())); + } + + @Override + public int hashCode() { + return element.hashCode(); } } diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java index 5ebdab80..38c273e9 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTag.java @@ -71,13 +71,19 @@ public static NbtNumberTag fromPrimitive(@NotNull JsonPrimitive primitive){ } @Override - public boolean equals(Object other){ - if(other instanceof NbtNumberTag){ + public boolean equals(Object other) { + if (other instanceof NbtNumberTag) { return number.equals(((NbtNumberTag) other).asPrimitive()); - } else if(other instanceof NbtBooleanTag){ + } else if (other instanceof NbtBooleanTag) { return other.equals(this); } else { return false; } } + + @Override + public int hashCode() { + // Relatively standard impl based on what IntelliJ IDEA could generate + return (int) (number.intValue() ^ (number.intValue() >>> 32)); + } } diff --git a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java index 797c5109..f9d57f45 100644 --- a/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java +++ b/src/main/java/com/dumbdogdiner/stickyapi/common/nbt/NbtStringTag.java @@ -78,13 +78,22 @@ public String toString() { } @Override - public boolean equals(Object other){ - if(other instanceof NbtStringTag){ + public boolean equals(Object other) { + if (other instanceof NbtStringTag) { return escaped == ((NbtStringTag) other).escaped && string.equals(((NbtStringTag) other).asPrimitive()); - } else if(other instanceof NbtJsonTag){ + } else if (other instanceof NbtJsonTag) { return other.equals(this); } else { return false; } } + + @Override + public int hashCode() { + // Relatively standard impl based on what IntelliJ IDEA could generate + int result = Boolean.hashCode(escaped); + result = 31 * result + string.hashCode(); + return result; + + } } From c6b71aedfedf5e57bc8bdcf22395d29656da95f2 Mon Sep 17 00:00:00 2001 From: James Date: Sun, 14 Feb 2021 00:19:51 +0000 Subject: [PATCH 14/14] add test prefix to nbt test functions --- .../stickyapi/common/nbt/NbtBooleanTagTest.java | 10 +++++----- .../stickyapi/common/nbt/NbtNumberTagTest.java | 10 +++++----- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java index ea6aaedb..ca58e4de 100644 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtBooleanTagTest.java @@ -18,26 +18,26 @@ class NbtBooleanTagTest { @ParameterizedTest @ValueSource(booleans = {true, false}) - void fromPrimitive(boolean b) { + void testFromPrimitive(boolean b) { assertEquals(new NbtBooleanTag(b), NbtBooleanTag.fromPrimitive(new JsonPrimitive(b))); } @ParameterizedTest @ValueSource(booleans = {true, false}) - void asPrimitive(boolean b) { + void testAsPrimitive(boolean b) { assertEquals(b, new NbtBooleanTag(b).asPrimitive()); } @ParameterizedTest @ValueSource(booleans = {true, false}) - void toJson(boolean b) { + void testToJson(boolean b) { JsonPrimitive primitive = new JsonPrimitive(b); assertEquals(primitive, new NbtBooleanTag(b).toJson()); } @ParameterizedTest @ValueSource(booleans = {true, false}) - void toNbtString(boolean b) { + void testToNbtString(boolean b) { int i = b ? 1 : 0; assertEquals(Integer.toString(i), new NbtBooleanTag(b).toNbtString()); } @@ -45,7 +45,7 @@ void toNbtString(boolean b) { @SuppressWarnings("AssertBetweenInconvertibleTypes") @ParameterizedTest @ValueSource(booleans = {true, false}) - void equals(boolean b) { + void testEquals(boolean b) { int i = b ? 1 : 0; assertEquals(new NbtNumberTag(i), new NbtBooleanTag(b)); } diff --git a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java index 0b6478d5..9f84a4f0 100644 --- a/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java +++ b/src/test/java/com/dumbdogdiner/stickyapi/common/nbt/NbtNumberTagTest.java @@ -28,7 +28,7 @@ public void setUp(){ } @RepeatedTest(REPEAT) - void fromPrimitive() { + void testFromPrimitive() { System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); JsonPrimitive iPrim = new JsonPrimitive(i); JsonPrimitive fPrim = new JsonPrimitive(f); @@ -37,7 +37,7 @@ void fromPrimitive() { } @RepeatedTest(REPEAT) - void asPrimitive() { + void testAsPrimitive() { System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); assertEquals(i, new NbtNumberTag(i).asPrimitive()); assertEquals(i, NbtNumberTag.fromPrimitive(new JsonPrimitive(i)).asPrimitive()); @@ -46,7 +46,7 @@ void asPrimitive() { } @RepeatedTest(REPEAT) - void toJson() { + void testToJson() { System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); JsonPrimitive iPrim = new JsonPrimitive(i); JsonPrimitive fPrim = new JsonPrimitive(f); @@ -57,7 +57,7 @@ void toJson() { } @RepeatedTest(REPEAT) - void toNbtString() { + void testToNbtString() { System.out.println(MessageFormat.format("i={0,number,#.##########}; f={1,number,#.##########}", i, f)); String iString = new NbtNumberTag(i).toNbtString(); String negativeIString = new NbtNumberTag(-i).toNbtString(); @@ -87,7 +87,7 @@ void toNbtString() { } @RepeatedTest(REPEAT) - void notEquals() { + void testNotEquals() { assertNotEquals(new NbtNumberTag(i), NbtNumberTag.fromPrimitive(new JsonPrimitive(i - 1))); assertNotEquals(new NbtNumberTag(f), NbtNumberTag.fromPrimitive(new JsonPrimitive(f + 0.1f))); }