refac: переосмысление
This commit is contained in:
38
src/test/java/mc/nbt/io/NbtInputStreamTest.java
Normal file
38
src/test/java/mc/nbt/io/NbtInputStreamTest.java
Normal file
@@ -0,0 +1,38 @@
|
||||
package mc.nbt.io;
|
||||
|
||||
import mc.nbt.CompoundTag;
|
||||
import mc.nbt.StringTag;
|
||||
import mc.nbt.TagType;
|
||||
import mc.nbt.TagValue;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Objects;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class NbtInputStreamTest {
|
||||
|
||||
@Test
|
||||
void testSimple() throws IOException {
|
||||
try (var stream = Objects.requireNonNull(NbtInputStreamTest.class.getResourceAsStream("/hello_world.nbt"));
|
||||
NbtInputStream nbtInputStream = new NbtInputStream(stream)) {
|
||||
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertNotNull(tag);
|
||||
assertEquals(TagType.COMPOUND, tag.getType());
|
||||
|
||||
CompoundTag compoundTag = tag.asCompound();
|
||||
assertEquals("hello world", compoundTag.getName());
|
||||
assertEquals(1, compoundTag.size());
|
||||
|
||||
assertTrue(compoundTag.containsKey("name"));
|
||||
tag = compoundTag.get("name");
|
||||
assertEquals(TagType.STRING, tag.getType());
|
||||
|
||||
StringTag stringTag = tag.asString();
|
||||
assertEquals("name", stringTag.getName());
|
||||
assertEquals("Bananrama", stringTag.getValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
381
src/test/java/mc/nbt/io/NbtOutputStreamTest.java
Normal file
381
src/test/java/mc/nbt/io/NbtOutputStreamTest.java
Normal file
@@ -0,0 +1,381 @@
|
||||
package mc.nbt.io;
|
||||
|
||||
import mc.nbt.*;
|
||||
import org.apache.commons.lang3.RandomStringUtils;
|
||||
import org.apache.commons.lang3.RandomUtils;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.params.ParameterizedTest;
|
||||
import org.junit.jupiter.params.provider.Arguments;
|
||||
import org.junit.jupiter.params.provider.MethodSource;
|
||||
|
||||
import java.io.ByteArrayInputStream;
|
||||
import java.io.ByteArrayOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.*;
|
||||
|
||||
class NbtOutputStreamTest {
|
||||
|
||||
ByteArrayOutputStream baos;
|
||||
NbtOutputStream nbtOutputStream;
|
||||
|
||||
@BeforeEach
|
||||
void before() throws IOException {
|
||||
baos = new ByteArrayOutputStream();
|
||||
nbtOutputStream = new NbtOutputStream(baos);
|
||||
}
|
||||
|
||||
@Test
|
||||
void writeEndTag() throws IOException {
|
||||
nbtOutputStream.writeTag(EndTag.getInstance());
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.END, tag.getType());
|
||||
assertNull(tag.getName());
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagByte")
|
||||
void writeByteTag(ByteTag byteTag) throws IOException {
|
||||
nbtOutputStream.writeTag(byteTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.BYTE, tag.getType());
|
||||
assertEquals(byteTag.getValue(), tag.asByte().getValue());
|
||||
assertName(byteTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagShort")
|
||||
void writeShortTag(ShortTag shortTag) throws IOException {
|
||||
nbtOutputStream.writeTag(shortTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.SHORT, tag.getType());
|
||||
assertEquals(shortTag.getValue(), tag.asShort().getValue());
|
||||
assertName(shortTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagInt")
|
||||
void writeIntegerTag(IntegerTag integerTag) throws IOException {
|
||||
nbtOutputStream.writeTag(integerTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.INTEGER, tag.getType());
|
||||
assertEquals(integerTag.getValue(), tag.asInteger().getValue());
|
||||
assertName(integerTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagLong")
|
||||
void writeLongTag(LongTag longTag) throws IOException {
|
||||
nbtOutputStream.writeTag(longTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.LONG, tag.getType());
|
||||
assertEquals(longTag.getValue(), tag.asLong().getValue());
|
||||
assertName(longTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagFloat")
|
||||
void writeFloatTag(FloatTag floatTag) throws IOException {
|
||||
nbtOutputStream.writeTag(floatTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.FLOAT, tag.getType());
|
||||
assertEquals(floatTag.getValue(), tag.asFloat().getValue());
|
||||
assertName(floatTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagDouble")
|
||||
void writeDoubleTag(DoubleTag doubleTag) throws IOException {
|
||||
nbtOutputStream.writeTag(doubleTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.DOUBLE, tag.getType());
|
||||
assertEquals(doubleTag.getValue(), tag.asDouble().getValue());
|
||||
assertName(doubleTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagByteArray")
|
||||
void writeByteArrayTag(ByteArrayTag byteArrayTag) throws IOException {
|
||||
nbtOutputStream.writeTag(byteArrayTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.BYTE_ARRAY, tag.getType());
|
||||
assertArrayEquals(byteArrayTag.getValue(), tag.asByteArray().getValue());
|
||||
assertName(byteArrayTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagString")
|
||||
void writeStringTag(StringTag stringTag) throws IOException {
|
||||
nbtOutputStream.writeTag(stringTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.STRING, tag.getType());
|
||||
assertEquals(stringTag.getValue(), tag.asString().getValue());
|
||||
assertName(stringTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagList")
|
||||
void writeListTag(ListTag listTag) throws IOException {
|
||||
nbtOutputStream.writeTag(listTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.LIST, tag.getType());
|
||||
assertEquals(listTag.size(), tag.asList().size());
|
||||
assertEquals(listTag.getListType(), tag.asList().getListType());
|
||||
assertName(listTag, tag);
|
||||
|
||||
for (int i = 0; i < listTag.size(); i++) {
|
||||
LongTag longTag1 = listTag.get(i).asLong();
|
||||
LongTag longTag2 = tag.asList().get(i).asLong();
|
||||
|
||||
assertNull(longTag2.getName());
|
||||
assertEquals(longTag1.getValue(), longTag2.getValue());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagCompound")
|
||||
void writeCompoundTag(CompoundTag compoundTag) throws IOException {
|
||||
nbtOutputStream.writeTag(compoundTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.COMPOUND, tag.getType());
|
||||
assertEquals(compoundTag.size(), tag.asCompound().size());
|
||||
assertName(compoundTag, tag);
|
||||
|
||||
for (int i = 0; i < compoundTag.size(); i++) {
|
||||
compoundTag.forEach((key, tagValue) -> {
|
||||
assertTrue(tag.asCompound().containsKey(key));
|
||||
|
||||
LongTag longTag1 = tagValue.asLong();
|
||||
LongTag longTag2 = tag.asCompound().get(key).asLong();
|
||||
|
||||
assertNotNull(longTag2.getName());
|
||||
assertEquals(longTag1.getValue(), longTag2.getValue());
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagIntArray")
|
||||
void writeIntegerArrayTag(IntegerArrayTag integerArrayTag) throws IOException {
|
||||
nbtOutputStream.writeTag(integerArrayTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.INTEGER_ARRAY, tag.getType());
|
||||
assertArrayEquals(integerArrayTag.getValue(), tag.asIntegerArray().getValue());
|
||||
assertName(integerArrayTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("streamOfTagLongArray")
|
||||
void writeLongArrayTag(LongArrayTag longArrayTag) throws IOException {
|
||||
nbtOutputStream.writeTag(longArrayTag);
|
||||
|
||||
try (var nbtInputStream = createNbtInputStream()) {
|
||||
TagValue tag = nbtInputStream.readTag();
|
||||
assertEquals(TagType.LONG_ARRAY, tag.getType());
|
||||
assertArrayEquals(longArrayTag.getValue(), tag.asLongArray().getValue());
|
||||
assertName(longArrayTag, tag);
|
||||
}
|
||||
}
|
||||
|
||||
// region Methods for ParameterizedTest
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
|
||||
private static Stream<Arguments> streamOfTagByte() {
|
||||
final byte value = RandomUtils.nextBytes(1)[0];
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new ByteTag(value)),
|
||||
Arguments.of(new ByteTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagShort() {
|
||||
final short value = (short) RandomUtils.nextInt(0, Short.MAX_VALUE);
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new ShortTag(value)),
|
||||
Arguments.of(new ShortTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagInt() {
|
||||
final int value = RandomUtils.nextInt();
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new IntegerTag(value)),
|
||||
Arguments.of(new IntegerTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagLong() {
|
||||
final long value = RandomUtils.nextLong();
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new LongTag(value)),
|
||||
Arguments.of(new LongTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagFloat() {
|
||||
final float value = RandomUtils.nextFloat();
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new FloatTag(value)),
|
||||
Arguments.of(new FloatTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagDouble() {
|
||||
final double value = RandomUtils.nextDouble();
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new DoubleTag(value)),
|
||||
Arguments.of(new DoubleTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagByteArray() {
|
||||
final byte[] value = RandomUtils.nextBytes(RandomUtils.nextInt(1, 1000));
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new ByteArrayTag(value)),
|
||||
Arguments.of(new ByteArrayTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagString() {
|
||||
final String value = randomString();
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new StringTag(value)),
|
||||
Arguments.of(new StringTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagList() {
|
||||
return Stream.of(
|
||||
Arguments.of(new ListTag(TagType.LONG).append(new LongTag(1L))),
|
||||
Arguments.of(new ListTag(TagType.LONG) {{
|
||||
this.setName(randomString());
|
||||
}}.append(new LongTag(1L)))
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagCompound() {
|
||||
return Stream.of(
|
||||
Arguments.of(new CompoundTag()
|
||||
.append("TestName1", new LongTag(RandomUtils.nextLong()))
|
||||
.append("TestName2", new LongTag(RandomUtils.nextLong()))
|
||||
.append("TestName3", new LongTag(RandomUtils.nextLong()))),
|
||||
Arguments.of(new CompoundTag() {{
|
||||
this.setName(randomString());
|
||||
}}
|
||||
.append("TestName1", new LongTag(RandomUtils.nextLong()))
|
||||
.append("TestName2", new LongTag(RandomUtils.nextLong()))
|
||||
.append("TestName3", new LongTag(RandomUtils.nextLong())))
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagIntArray() {
|
||||
final int[] value = new int[RandomUtils.nextInt(1, 1000)];
|
||||
|
||||
for (int i = 0; i < value.length; i++) {
|
||||
value[i] = RandomUtils.nextInt();
|
||||
}
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new IntegerArrayTag(value)),
|
||||
Arguments.of(new IntegerArrayTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
private static Stream<Arguments> streamOfTagLongArray() {
|
||||
final long[] value = new long[RandomUtils.nextInt(1, 1000)];
|
||||
|
||||
for (int i = 0; i < value.length; i++) {
|
||||
value[i] = RandomUtils.nextLong();
|
||||
}
|
||||
|
||||
return Stream.of(
|
||||
Arguments.of(new LongArrayTag(value)),
|
||||
Arguments.of(new LongArrayTag(value) {{
|
||||
this.setName(randomString());
|
||||
}})
|
||||
);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------------------------------------------------------------
|
||||
// endregion
|
||||
|
||||
private NbtInputStream createNbtInputStream() throws IOException {
|
||||
return new NbtInputStream(new ByteArrayInputStream(baos.toByteArray()));
|
||||
}
|
||||
|
||||
private static String randomString() {
|
||||
return RandomStringUtils.randomAscii(RandomUtils.nextInt(1, Short.MAX_VALUE));
|
||||
}
|
||||
|
||||
private void assertName(TagValue expectedTag, TagValue actualTag) {
|
||||
if (expectedTag.getName() == null) {
|
||||
assertTrue(actualTag.getName().isEmpty());
|
||||
} else {
|
||||
assertEquals(expectedTag.getName(), actualTag.getName());
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user