добавляем и модернизируем тесты для NetStream (ByteArray*)

proto_1.12.2/src/main/java/mc/core/network/proto_1_12_2/ByteArrayOutputNetStream.java

@@ -27,28 +27,28 @@ public class ByteArrayOutputNetStream extends NetOutputStream_p340 {
 
     @Override
     public void writeShort(int value) {
-        baos.write((byte) value >>> 8);
+        baos.write((byte) (value >>> 8));
         baos.write((byte) value);
     }
 
     @Override
     public void writeInt(int value) {
-        baos.write((byte)((int)(value >>> 24)));
+        baos.write((value >>> 24) & 0xFF);
-        baos.write((byte)((int)(value >>> 16)));
+        baos.write((value >>> 16) & 0xFF);
-        baos.write((byte)((int)(value >>> 8)));
+        baos.write((value >>> 8) & 0xFF);
-        baos.write((byte)((int)(value)));
+        baos.write(value & 0xFF);
     }
 
     @Override
     public void writeLong(long value) {
-        baos.write((byte)((int)(value >>> 56)));
+        baos.write((int) ((value >>> 56) & 0xFF));
-        baos.write((byte)((int)(value >>> 48)));
+        baos.write((int) ((value >>> 48) & 0xFF));
-        baos.write((byte)((int)(value >>> 40)));
+        baos.write((int) ((value >>> 40) & 0xFF));
-        baos.write((byte)((int)(value >>> 32)));
+        baos.write((int) ((value >>> 32) & 0xFF));
-        baos.write((byte)((int)(value >>> 24)));
+        baos.write((int) ((value >>> 24) & 0xFF));
-        baos.write((byte)((int)(value >>> 16)));
+        baos.write((int) ((value >>> 16) & 0xFF));
-        baos.write((byte)((int)(value >>> 8)));
+        baos.write((int) ((value >>> 8) & 0xFF));
-        baos.write((byte)((int)(value)));
+        baos.write((int) (value & 0xFF));
     }
 
     @Override

proto_1.12.2/src/test/java/mc/core/network/proto_1_12_2/ByteArrayInputNetStream.java

@@ -1,7 +1,6 @@
-package mc.core.network.proto_1_12_2.packets;
+package mc.core.network.proto_1_12_2;
 
 import lombok.extern.slf4j.Slf4j;
-import mc.core.network.proto_1_12_2.NetInputStream_p340;
 
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
@@ -16,7 +15,7 @@ public class ByteArrayInputNetStream extends NetInputStream_p340 {
 
     @Override
     public boolean readBoolean() {
-        return false;
+        throw new UnsupportedOperationException();
     }
 
     @Override
@@ -40,17 +39,17 @@ public class ByteArrayInputNetStream extends NetInputStream_p340 {
 
     @Override
     public int readUnsignedByte() {
-        return 0;
+        throw new UnsupportedOperationException();
     }
 
     @Override
     public int readUnsignedShort() {
-        return 0;
+        throw new UnsupportedOperationException();
     }
 
     @Override
     public short readShort() {
-        return 0;
+        throw new UnsupportedOperationException();
     }
 
     @Override
@@ -65,7 +64,7 @@ public class ByteArrayInputNetStream extends NetInputStream_p340 {
 
     @Override
     public long readLong() {
-        return 0;
+        throw new UnsupportedOperationException();
     }
 
     @Override
@@ -75,11 +74,11 @@ public class ByteArrayInputNetStream extends NetInputStream_p340 {
 
     @Override
     public double readDouble() {
-        return 0;
+        throw new UnsupportedOperationException();
     }
 
     @Override
     public void skipBytes(int count) {
-
+        throw new UnsupportedOperationException();
     }
 }

proto_1.12.2/src/test/java/mc/core/network/proto_1_12_2/ByteArrayInputNetStreamTest.java

@@ -0,0 +1,99 @@
+package mc.core.network.proto_1_12_2;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class ByteArrayInputNetStreamTest {
+    private Random random;
+
+    @BeforeEach
+    void before() {
+        random = new Random(System.currentTimeMillis());
+    }
+
+    @Test
+    void testReadByte() throws IOException {
+        final byte[] bytes = new byte[1];
+        random.nextBytes(bytes);
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeByte(bytes[0]);
+
+        ByteArrayInputNetStream byteArrayInputNetStream = new ByteArrayInputNetStream(byteArrayOutputNetStream.toByteArray());
+
+        assertEquals(bytes[0], byteArrayInputNetStream.readByte());
+
+        byteArrayInputNetStream = new ByteArrayInputNetStream(byteArrayOutputNetStream.toByteArray());
+
+        assertEquals(bytes[0], byteArrayInputNetStream.read());
+    }
+
+    @Test
+    void testReadBytes() throws IOException {
+        final byte[] expectedBytes = new byte[10];
+        random.nextBytes(expectedBytes);
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeBytes(expectedBytes);
+
+        ByteArrayInputNetStream byteArrayInputNetStream = new ByteArrayInputNetStream(byteArrayOutputNetStream.toByteArray());
+        byte[] actualBytes = new byte[10];
+        byteArrayInputNetStream.readBytes(actualBytes);
+
+        assertArrayEquals(expectedBytes, actualBytes);
+
+        byteArrayInputNetStream = new ByteArrayInputNetStream(byteArrayOutputNetStream.toByteArray());
+        actualBytes = new byte[10];
+        int r = byteArrayInputNetStream.read(actualBytes);
+
+        assertArrayEquals(expectedBytes, actualBytes);
+        assertEquals(expectedBytes.length, r);
+
+        byteArrayInputNetStream = new ByteArrayInputNetStream(byteArrayOutputNetStream.toByteArray());
+        actualBytes = new byte[10];
+        byteArrayInputNetStream.readBytes(actualBytes, 2, 5);
+        byte[] nibbleExpectedBytes = new byte[10];
+        System.arraycopy(expectedBytes, 0, nibbleExpectedBytes, 2, 5);
+
+        assertArrayEquals(nibbleExpectedBytes, actualBytes);
+
+        byteArrayInputNetStream = new ByteArrayInputNetStream(byteArrayOutputNetStream.toByteArray());
+        actualBytes = new byte[10];
+        r = byteArrayInputNetStream.read(actualBytes, 2, 5);
+        nibbleExpectedBytes = new byte[10];
+        System.arraycopy(expectedBytes, 0, nibbleExpectedBytes, 2, 5);
+
+        assertArrayEquals(nibbleExpectedBytes, actualBytes);
+        assertEquals(5, r);
+    }
+
+    @Test
+    void testReadInt() {
+        final int integerDig = random.nextInt();
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeInt(integerDig);
+
+        ByteArrayInputNetStream byteArrayInputNetStream = new ByteArrayInputNetStream(byteArrayOutputNetStream.toByteArray());
+
+        assertEquals(integerDig, byteArrayInputNetStream.readInt());
+    }
+
+    @Test
+    void readFloat() {
+        final float floatDig = random.nextFloat();
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeFloat(floatDig);
+
+        ByteArrayInputNetStream byteArrayInputNetStream = new ByteArrayInputNetStream(byteArrayOutputNetStream.toByteArray());
+
+        assertEquals(floatDig, byteArrayInputNetStream.readFloat());
+    }
+}

proto_1.12.2/src/test/java/mc/core/network/proto_1_12_2/ByteArrayOutputNetStreamTest.java

@@ -0,0 +1,259 @@
+package mc.core.network.proto_1_12_2;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Random;
+import java.util.UUID;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+class ByteArrayOutputNetStreamTest {
+    private Random random;
+
+    @BeforeEach
+    void before() {
+        random = new Random(System.currentTimeMillis());
+    }
+
+    @Test
+    void testWriteBoolean() {
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeBoolean(true);
+
+        assertArrayEquals(new byte[]{0x01}, byteArrayOutputNetStream.toByteArray());
+
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeBoolean(false);
+
+        assertArrayEquals(new byte[]{0x00}, byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteByte() throws IOException {
+        final byte[] bytes = new byte[1];
+        random.nextBytes(bytes);
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeByte(bytes[0]);
+
+        assertArrayEquals(bytes, byteArrayOutputNetStream.toByteArray());
+
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.write(bytes[0]);
+
+        assertArrayEquals(bytes, byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteUnsignedByte() {
+        final byte[] bytes = new byte[1];
+        random.nextBytes(bytes);
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeUnsignedByte(bytes[0]);
+
+        assertArrayEquals(bytes, byteArrayOutputNetStream.toByteArray());
+
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeUnsignedByte(0xFF);
+
+        assertArrayEquals(new byte[]{(byte) 0xFF}, byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteBytes() throws IOException {
+        final byte[] expectedBytes = new byte[10];
+        random.nextBytes(expectedBytes);
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeBytes(expectedBytes);
+
+        assertArrayEquals(expectedBytes, byteArrayOutputNetStream.toByteArray());
+
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.write(expectedBytes);
+
+        assertArrayEquals(expectedBytes, byteArrayOutputNetStream.toByteArray());
+
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeBytes(expectedBytes, 2, 5);
+        byte[] nibbleExpectedBytes = new byte[5];
+        System.arraycopy(expectedBytes, 2, nibbleExpectedBytes, 0, 5);
+
+        assertArrayEquals(nibbleExpectedBytes, byteArrayOutputNetStream.toByteArray());
+
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.write(expectedBytes, 2, 5);
+        nibbleExpectedBytes = new byte[5];
+        System.arraycopy(expectedBytes, 2, nibbleExpectedBytes, 0, 5);
+
+        assertArrayEquals(nibbleExpectedBytes, byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteShort() {
+        int smallInt;
+        do {
+            smallInt = random.nextInt();
+        } while (smallInt > Short.MAX_VALUE || smallInt < Short.MIN_VALUE);
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeShort(smallInt);
+
+        assertArrayEquals(new byte[]{ (byte) (smallInt >>> 8),
+                                      (byte) smallInt },
+                          byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteInt() {
+        final int integerDig = random.nextInt();
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeInt(integerDig);
+
+        assertArrayEquals(new byte[]{ (byte) ((integerDig >>> 24) & 0xFF),
+                                      (byte) ((integerDig >>> 16) & 0xFF),
+                                      (byte) ((integerDig >>> 8) & 0xFF),
+                                      (byte) (integerDig & 0xFF) },
+                          byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteLong() {
+        final long longDig = random.nextLong();
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeLong(longDig);
+
+        assertArrayEquals(new byte[]{ (byte) ((longDig >>> 56) & 0xFF),
+                                      (byte) ((longDig >>> 48) & 0xFF),
+                                      (byte) ((longDig >>> 40) & 0xFF),
+                                      (byte) ((longDig >>> 32) & 0xFF),
+                                      (byte) ((longDig >>> 24) & 0xFF),
+                                      (byte) ((longDig >>> 16) & 0xFF),
+                                      (byte) ((longDig >>> 8) & 0xFF),
+                                      (byte) (longDig & 0xFF) },
+                          byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteFloat() {
+        final float floatDig = random.nextFloat();
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeFloat(floatDig);
+        final int floatBits = Float.floatToIntBits(floatDig);
+
+        assertArrayEquals(new byte[]{ (byte) ((floatBits >>> 24) & 0xFF),
+                                      (byte) ((floatBits >>> 16) & 0xFF),
+                                      (byte) ((floatBits >>> 8) & 0xFF),
+                                      (byte) (floatBits & 0xFF) },
+                          byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteDouble() {
+        final double doubleDig = random.nextDouble();
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeDouble(doubleDig);
+        final long doubleBits = Double.doubleToLongBits(doubleDig);
+
+        assertArrayEquals(new byte[]{ (byte) ((doubleBits >>> 56) & 0xFF),
+                                      (byte) ((doubleBits >>> 48) & 0xFF),
+                                      (byte) ((doubleBits >>> 40) & 0xFF),
+                                      (byte) ((doubleBits >>> 32) & 0xFF),
+                                      (byte) ((doubleBits >>> 24) & 0xFF),
+                                      (byte) ((doubleBits >>> 16) & 0xFF),
+                                      (byte) ((doubleBits >>> 8) & 0xFF),
+                                      (byte) (doubleBits & 0xFF) },
+                          byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteVarInt() {
+        final int b1Int = 120;
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeVarInt(b1Int);
+
+        assertArrayEquals(new byte[]{ 0x78 },
+                          byteArrayOutputNetStream.toByteArray());
+
+        final int b2Int = 12000;
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeVarInt(b2Int);
+
+        assertArrayEquals(new byte[]{ (byte) 0xE0, 0x5D },
+                          byteArrayOutputNetStream.toByteArray());
+
+        final int b3Int = 120000;
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeVarInt(b3Int);
+
+        assertArrayEquals(new byte[]{ (byte) 0xC0, (byte) 0xA9, 0x07 },
+                          byteArrayOutputNetStream.toByteArray());
+
+        final int b4Int = 120000000;
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeVarInt(b4Int);
+
+        assertArrayEquals(new byte[]{ (byte) 0x80, (byte) 0x9C, (byte) 0x9C, (byte) 0x39 },
+                          byteArrayOutputNetStream.toByteArray());
+
+        final int b5Int = 1200000000;
+        byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeVarInt(b5Int);
+
+        assertArrayEquals(new byte[]{ (byte) 0x80, (byte) 0x98, (byte) 0x9A, (byte) 0xBC, 0x04 },
+                          byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteString() {
+        final String string = "Hello? Есть тут кто?";
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeString(string);
+
+        final byte[] strBytes = string.getBytes(StandardCharsets.UTF_8);
+        final byte[] bytes = new byte[strBytes.length + 1];
+        bytes[0] = (byte) string.length(); // здесь считается, что размер поместится в один байт
+        System.arraycopy(strBytes, 0, bytes, 1, strBytes.length);
+
+        assertArrayEquals(bytes, byteArrayOutputNetStream.toByteArray());
+    }
+
+    @Test
+    void testWriteUUID() {
+        final UUID uuid = UUID.randomUUID();
+
+        ByteArrayOutputNetStream byteArrayOutputNetStream = new ByteArrayOutputNetStream();
+        byteArrayOutputNetStream.writeUUID(uuid);
+
+        final long mostSignificantBits = uuid.getMostSignificantBits();
+        final long leastSignificantBits = uuid.getLeastSignificantBits();
+
+        assertArrayEquals(new byte[]{ (byte) ((mostSignificantBits >>> 56) & 0xFF),
+                                      (byte) ((mostSignificantBits >>> 48) & 0xFF),
+                                      (byte) ((mostSignificantBits >>> 40) & 0xFF),
+                                      (byte) ((mostSignificantBits >>> 32) & 0xFF),
+                                      (byte) ((mostSignificantBits >>> 24) & 0xFF),
+                                      (byte) ((mostSignificantBits >>> 16) & 0xFF),
+                                      (byte) ((mostSignificantBits >>> 8) & 0xFF),
+                                      (byte) (mostSignificantBits & 0xFF),
+
+                                      (byte) ((leastSignificantBits >>> 56) & 0xFF),
+                                      (byte) ((leastSignificantBits >>> 48) & 0xFF),
+                                      (byte) ((leastSignificantBits >>> 40) & 0xFF),
+                                      (byte) ((leastSignificantBits >>> 32) & 0xFF),
+                                      (byte) ((leastSignificantBits >>> 24) & 0xFF),
+                                      (byte) ((leastSignificantBits >>> 16) & 0xFF),
+                                      (byte) ((leastSignificantBits >>> 8) & 0xFF),
+                                      (byte) (leastSignificantBits & 0xFF) },
+                          byteArrayOutputNetStream.toByteArray());
+    }
+}

proto_1.12.2/src/test/java/mc/core/network/proto_1_12_2/packets/ByteArrayInputNetStreamTest.java

@@ -1,48 +0,0 @@
-package mc.core.network.proto_1_12_2.packets;
-
-import mc.core.network.proto_1_12_2.ByteArrayOutputNetStream;
-import org.junit.jupiter.api.Test;
-
-import java.util.Random;
-
-import static org.junit.jupiter.api.Assertions.assertEquals;
-
-class ByteArrayInputNetStreamTest {
-    private Random rnd = new Random();
-
-    @Test
-    void readByte() {
-        final byte b0 = (byte) rnd.nextInt();
-        ByteArrayOutputNetStream netStream = new ByteArrayOutputNetStream();
-        netStream.writeByte(b0);
-        byte[] buffer = netStream.toByteArray();
-
-        ByteArrayInputNetStream netInputStream = new ByteArrayInputNetStream(buffer);
-        byte b1 = netInputStream.readByte();
-        assertEquals(b0, b1);
-    }
-
-    @Test
-    void readInt() {
-        final int i0 = rnd.nextInt();
-        ByteArrayOutputNetStream netStream = new ByteArrayOutputNetStream();
-        netStream.writeInt(i0);
-        byte[] buffer = netStream.toByteArray();
-
-        ByteArrayInputNetStream netInputStream = new ByteArrayInputNetStream(buffer);
-        int i1 = netInputStream.readInt();
-        assertEquals(i0, i1);
-    }
-
-    @Test
-    void readFloat() {
-        final float f0 = rnd.nextFloat();
-        ByteArrayOutputNetStream netStream = new ByteArrayOutputNetStream();
-        netStream.writeFloat(f0);
-        byte[] buffer = netStream.toByteArray();
-
-        ByteArrayInputNetStream netInputStream = new ByteArrayInputNetStream(buffer);
-        float f1 = netInputStream.readFloat();
-        assertEquals(f0, f1, 0.00001f);
-    }
-}

proto_1.12.2/src/test/java/mc/core/network/proto_1_12_2/packets/PlayerAbilitiesPacketTest.java

@@ -1,5 +1,6 @@
 package mc.core.network.proto_1_12_2.packets;
 
+import mc.core.network.proto_1_12_2.ByteArrayInputNetStream;
 import mc.core.network.proto_1_12_2.ByteArrayOutputNetStream;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;