diff --git a/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/AbstractMessageBody.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/AbstractMessageBody.java new file mode 100644 index 0000000..c808204 --- /dev/null +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/AbstractMessageBody.java @@ -0,0 +1,28 @@ +package io.github.protocol.mdtp.common.model; + +import io.netty.buffer.ByteBuf; +import lombok.Data; + +import java.util.UUID; + +@Data +public abstract class AbstractMessageBody { + private short messageBodyHeader; + + public void setMessageBodyHeader(MessageType messageType, ServiceGroup serviceGroup, DiscoveryServiceCode serviceCode) { + this.messageBodyHeader = 0; + this.messageBodyHeader |= (short) (messageType.getCode() & 0b111); + this.messageBodyHeader |= (short) ((serviceGroup.getCode() & 0b1111111) << 3); + this.messageBodyHeader |= (short) ((serviceCode.getCode() & 0b111111) << 10); + } + + public short generateRequestId() { + UUID uuid = UUID.randomUUID(); + return (short) (uuid.getLeastSignificantBits() & 0xFFFF); + } + + public ByteBuf toByteBuf(ByteBuf buffer) { + buffer.writeShort(messageBodyHeader); + return buffer; + } +} diff --git a/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/CDATHeader.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/CDATHeader.java new file mode 100644 index 0000000..495c8a6 --- /dev/null +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/CDATHeader.java @@ -0,0 +1,38 @@ +package io.github.protocol.mdtp.common.model; + +import io.netty.buffer.ByteBuf; +import lombok.AllArgsConstructor; +import lombok.Data; +import lombok.NoArgsConstructor; + + +@Data +@AllArgsConstructor +@NoArgsConstructor +public class CDATHeader { + + private byte formatType; + + private byte protocolVersion; + + private short messageLength; + + private long timestamp; + + private byte flags; + + private Integer sequenceNumber; + + private Integer logicalChannelId; + + public ByteBuf toByteBuf(ByteBuf buffer) { + buffer.writeByte(formatType); + buffer.writeByte(protocolVersion); + buffer.writeShort(messageLength); + buffer.writeLong(timestamp); + buffer.writeByte(flags); + buffer.writeInt(sequenceNumber); + buffer.writeInt(logicalChannelId); + return buffer; + } +} diff --git a/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DeviceDiscoveryRequest.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DeviceDiscoveryRequest.java new file mode 100644 index 0000000..c9f5bc6 --- /dev/null +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DeviceDiscoveryRequest.java @@ -0,0 +1,41 @@ +package io.github.protocol.mdtp.common.model; + +import io.netty.buffer.ByteBuf; +import lombok.Data; + + +@Data +public class DeviceDiscoveryRequest extends AbstractMessageBody { + private short requestId; + + private byte mask; + + private byte deviceTypeCount; + + private int[] deviceTypes; + + public ByteBuf toByteBuf(ByteBuf buffer) { + super.toByteBuf(buffer); + buffer.writeShort(requestId); + buffer.writeByte(mask); + buffer.writeByte(deviceTypeCount); + for (int deviceType : deviceTypes) { + buffer.writeInt(deviceType); + } + return buffer; + } + + public static DeviceDiscoveryRequest fromByteBuf(ByteBuf data) { + DeviceDiscoveryRequest request = new DeviceDiscoveryRequest(); + request.requestId = data.readShort(); + request.mask = data.readByte(); + request.deviceTypeCount = data.readByte(); + + int length = request.deviceTypeCount; + request.deviceTypes = new int[length]; + for (int i = 0; i < length; i++) { + request.deviceTypes[i] = data.readInt(); + } + return request; + } +} diff --git a/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DeviceDiscoveryResponse.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DeviceDiscoveryResponse.java new file mode 100644 index 0000000..37eb5cf --- /dev/null +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DeviceDiscoveryResponse.java @@ -0,0 +1,59 @@ +package io.github.protocol.mdtp.common.model; + +import io.netty.buffer.ByteBuf; +import lombok.Data; + +import java.nio.charset.StandardCharsets; + +@Data +public class DeviceDiscoveryResponse { + private short messageHeader; + + private short requestId; + + private short responseId; + + private byte mask; + + private byte deviceStatus; + + private byte addressCount; + + private String[] addresses; + + private short port; + + private int deviceType; + + private byte[] uniqueId; + + private String deviceName; + + public ByteBuf toByteBuf(ByteBuf buffer) { + buffer.writeShort(messageHeader); + buffer.writeShort(requestId); + buffer.writeShort(responseId); + buffer.writeByte(mask); + buffer.writeByte(deviceStatus); + buffer.writeByte(addressCount); + + for (String address : addresses) { + byte[] addressBytes = address.getBytes(StandardCharsets.UTF_8); + buffer.writeBytes(addressBytes); + } + + buffer.writeShort(port); + buffer.writeInt(deviceType); + + if (uniqueId != null) { + buffer.writeBytes(uniqueId); + } + + if (deviceName != null) { + byte[] nameBytes = deviceName.getBytes(StandardCharsets.UTF_8); + buffer.writeBytes(nameBytes); + } + + return buffer; + } +} diff --git a/mdtp-common/src/main/java/iot/github/protocol/mdtp/common/model/DiscoveryServiceCode.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DiscoveryServiceCode.java similarity index 88% rename from mdtp-common/src/main/java/iot/github/protocol/mdtp/common/model/DiscoveryServiceCode.java rename to mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DiscoveryServiceCode.java index c1ac844..0f4b504 100644 --- a/mdtp-common/src/main/java/iot/github/protocol/mdtp/common/model/DiscoveryServiceCode.java +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/DiscoveryServiceCode.java @@ -1,4 +1,4 @@ -package iot.github.protocol.mdtp.common.model; +package io.github.protocol.mdtp.common.model; import lombok.Getter; diff --git a/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/MdtpPacket.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/MdtpPacket.java new file mode 100644 index 0000000..b75b7b3 --- /dev/null +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/MdtpPacket.java @@ -0,0 +1,27 @@ +package io.github.protocol.mdtp.common.model; + +import io.netty.buffer.ByteBuf; +import lombok.Data; + +@Data +public class MdtpPacket { + + private CDATHeader header; + + private SecurityHeader securityHeader; + + private AbstractMessageBody body; + + private Signature signature; + + public ByteBuf toByteBuf(ByteBuf buffer) { + header.toByteBuf(buffer); + if (securityHeader != null) { + securityHeader.toByteBuf(buffer); + } + if (body != null) { + body.toByteBuf(buffer); + } + return buffer; + } +} diff --git a/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/MessageType.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/MessageType.java new file mode 100644 index 0000000..7a05693 --- /dev/null +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/MessageType.java @@ -0,0 +1,19 @@ +package io.github.protocol.mdtp.common.model; + +public enum MessageType { + REQUEST(0), + + RESPONSE(1), + + NOTIFY(2); + + private final int code; + + MessageType(int code) { + this.code = code; + } + + public int getCode() { + return code; + } +} diff --git a/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/SecurityHeader.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/SecurityHeader.java new file mode 100644 index 0000000..000ddb4 --- /dev/null +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/SecurityHeader.java @@ -0,0 +1,17 @@ +package io.github.protocol.mdtp.common.model; + +import io.netty.buffer.ByteBuf; +import lombok.Data; + +@Data +public class SecurityHeader { + private byte[] encryptionData; + + public ByteBuf toByteBuf(ByteBuf buffer) { + for (int data : encryptionData) { + buffer.writeInt(data); + } + return buffer; + } + +} diff --git a/mdtp-common/src/main/java/iot/github/protocol/mdtp/common/model/ServiceGroup.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/ServiceGroup.java similarity index 91% rename from mdtp-common/src/main/java/iot/github/protocol/mdtp/common/model/ServiceGroup.java rename to mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/ServiceGroup.java index dfefdc4..7855c5f 100644 --- a/mdtp-common/src/main/java/iot/github/protocol/mdtp/common/model/ServiceGroup.java +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/ServiceGroup.java @@ -1,4 +1,4 @@ -package iot.github.protocol.mdtp.common.model; +package io.github.protocol.mdtp.common.model; import lombok.Getter; diff --git a/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/Signature.java b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/Signature.java new file mode 100644 index 0000000..a7f48a5 --- /dev/null +++ b/mdtp-common/src/main/java/io/github/protocol/mdtp/common/model/Signature.java @@ -0,0 +1,9 @@ +package io.github.protocol.mdtp.common.model; + +import lombok.Data; + +@Data +public class Signature { + private byte[] signatureData; + +} diff --git a/mdtp-common/src/test/java/io/github/protocol/mdtp/common/AbstractMessageBodyTest.java b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/AbstractMessageBodyTest.java new file mode 100644 index 0000000..9e44892 --- /dev/null +++ b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/AbstractMessageBodyTest.java @@ -0,0 +1,73 @@ +package io.github.protocol.mdtp.common; + +import io.github.protocol.mdtp.common.model.AbstractMessageBody; +import io.github.protocol.mdtp.common.model.DiscoveryServiceCode; +import io.github.protocol.mdtp.common.model.MessageType; +import io.github.protocol.mdtp.common.model.ServiceGroup; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotEquals; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +public class AbstractMessageBodyTest { + + private AbstractMessageBody messageBody; + + @BeforeEach + void setUp() { + messageBody = new AbstractMessageBody(){}; + } + + @Test + void testSetMessageBodyHeader() { + MessageType messageType = mock(MessageType.class); + ServiceGroup serviceGroup = mock(ServiceGroup.class); + DiscoveryServiceCode serviceCode = mock(DiscoveryServiceCode.class); + + when(messageType.getCode()).thenReturn(1); + when(serviceGroup.getCode()).thenReturn(2); + when(serviceCode.getCode()).thenReturn( 3); + + messageBody.setMessageBodyHeader(messageType, serviceGroup, serviceCode); + + short expectedHeader = (short) ((1 & 0b111) | ((2 & 0b1111111) << 3) | ((3 & 0b111111) << 10)); + + assertEquals(expectedHeader, messageBody.getMessageBodyHeader()); + } + + @Test + void testGenerateRequestId() { + short requestId1 = messageBody.generateRequestId(); + short requestId2 = messageBody.generateRequestId(); + + assertEquals(Short.class, ((Object) requestId1).getClass()); + assertEquals(Short.class, ((Object) requestId2).getClass()); + assertNotEquals(requestId1, requestId2); + } + + @Test + void testToByteBuf() { + ByteBuf buffer = Unpooled.buffer(); + + MessageType messageType = mock(MessageType.class); + ServiceGroup serviceGroup = mock(ServiceGroup.class); + DiscoveryServiceCode serviceCode = mock(DiscoveryServiceCode.class); + + when(messageType.getCode()).thenReturn(1); + when(serviceGroup.getCode()).thenReturn(2); + when(serviceCode.getCode()).thenReturn( 3); + + messageBody.setMessageBodyHeader(messageType, serviceGroup, serviceCode); + + messageBody.toByteBuf(buffer); + + assertEquals(messageBody.getMessageBodyHeader(), buffer.readShort()); + + buffer.release(); + } +} diff --git a/mdtp-common/src/test/java/io/github/protocol/mdtp/common/CDATHeaderTest.java b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/CDATHeaderTest.java new file mode 100644 index 0000000..f535cad --- /dev/null +++ b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/CDATHeaderTest.java @@ -0,0 +1,43 @@ +package io.github.protocol.mdtp.common; + +import io.github.protocol.mdtp.common.model.CDATHeader; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class CDATHeaderTest { + private CDATHeader cdatHeader; + + @BeforeEach + void setUp() { + cdatHeader = new CDATHeader( + (byte) 1, + (byte) 2, + (short) 100, + 123456789L, + (byte) 0x1F, + 42, + 7 + ); + } + + @Test + void testToByteBuf() { + ByteBuf buffer = Unpooled.buffer(); + + cdatHeader.toByteBuf(buffer); + + assertEquals(1, buffer.readByte()); + assertEquals(2, buffer.readByte()); + assertEquals(100, buffer.readShort()); + assertEquals(123456789L, buffer.readLong()); + assertEquals(0x1F, buffer.readByte()); + assertEquals(42, buffer.readInt()); + assertEquals(7, buffer.readInt()); + + buffer.release(); + } +} diff --git a/mdtp-common/src/test/java/io/github/protocol/mdtp/common/DeviceDiscoveryRequestTest.java b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/DeviceDiscoveryRequestTest.java new file mode 100644 index 0000000..0b7ff8b --- /dev/null +++ b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/DeviceDiscoveryRequestTest.java @@ -0,0 +1,60 @@ +package io.github.protocol.mdtp.common; + +import io.github.protocol.mdtp.common.model.DeviceDiscoveryRequest; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class DeviceDiscoveryRequestTest { + private DeviceDiscoveryRequest request; + + @BeforeEach + void setUp() { + request = new DeviceDiscoveryRequest(); + request.setMessageBodyHeader((short) 0); + request.setRequestId((short) 123); + request.setMask((byte) 0x1F); + request.setDeviceTypeCount((byte) 3); + request.setDeviceTypes(new int[]{1001, 1002, 1003}); + } + + @Test + void testToByteBuf() { + ByteBuf buffer = Unpooled.buffer(); + + request.toByteBuf(buffer); + assertEquals(0, buffer.readShort()); + assertEquals( 123, buffer.readShort()); + assertEquals(0x1F, buffer.readByte()); + assertEquals(3, buffer.readByte()); + assertEquals(1001, buffer.readInt()); + assertEquals(1002, buffer.readInt()); + assertEquals(1003, buffer.readInt()); + + buffer.release(); + } + + @Test + void testFromByteBuf() { + ByteBuf buffer = Unpooled.buffer(); + buffer.writeShort(123); + buffer.writeByte(0x1F); + buffer.writeByte(3); + buffer.writeInt(1001); + buffer.writeInt(1002); + buffer.writeInt(1003); + + DeviceDiscoveryRequest result = DeviceDiscoveryRequest.fromByteBuf(buffer); + + assertEquals(123, result.getRequestId()); + assertEquals(0x1F, result.getMask()); + assertEquals(3, result.getDeviceTypeCount()); + assertArrayEquals(new int[]{1001, 1002, 1003}, result.getDeviceTypes()); + + buffer.release(); + } +} diff --git a/mdtp-common/src/test/java/io/github/protocol/mdtp/common/DeviceDiscoveryResponseTest.java b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/DeviceDiscoveryResponseTest.java new file mode 100644 index 0000000..868a9d3 --- /dev/null +++ b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/DeviceDiscoveryResponseTest.java @@ -0,0 +1,68 @@ +package io.github.protocol.mdtp.common; + +import io.github.protocol.mdtp.common.model.DeviceDiscoveryResponse; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import java.nio.charset.StandardCharsets; + +import static org.junit.jupiter.api.Assertions.assertArrayEquals; +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class DeviceDiscoveryResponseTest { + + private DeviceDiscoveryResponse response; + + @BeforeEach + void setUp() { + response = new DeviceDiscoveryResponse(); + response.setMessageHeader((short) 100); + response.setRequestId((short) 200); + response.setResponseId((short) 300); + response.setMask((byte) 0x1F); + response.setDeviceStatus((byte) 0x01); + response.setAddressCount((byte) 2); + response.setAddresses(new String[]{"192.168.1.1", "192.168.1.2"}); + response.setPort((short) 8080); + response.setDeviceType(12345); + response.setUniqueId(new byte[]{0x01, 0x02, 0x03, 0x04}); + response.setDeviceName("TestDevice"); + } + + @Test + void testToByteBuf() { + ByteBuf buffer = Unpooled.buffer(); + + response.toByteBuf(buffer); + + assertEquals(100, buffer.readShort()); + assertEquals(200, buffer.readShort()); + assertEquals(300, buffer.readShort()); + assertEquals(0x1F, buffer.readByte()); + assertEquals(0x01, buffer.readByte()); + assertEquals(2, buffer.readByte()); + + byte[] addressBytes1 = new byte[11]; + buffer.readBytes(addressBytes1); + assertEquals("192.168.1.1", new String(addressBytes1, StandardCharsets.UTF_8)); + + byte[] addressBytes2 = new byte[11]; + buffer.readBytes(addressBytes2); + assertEquals("192.168.1.2", new String(addressBytes2, StandardCharsets.UTF_8)); + + assertEquals(8080, buffer.readShort()); + assertEquals(12345, buffer.readInt()); + + byte[] uniqueId = new byte[4]; + buffer.readBytes(uniqueId); + assertArrayEquals(new byte[]{0x01, 0x02, 0x03, 0x04}, uniqueId); + + byte[] nameBytes = new byte[10]; + buffer.readBytes(nameBytes); + assertEquals("TestDevice", new String(nameBytes, StandardCharsets.UTF_8)); + + buffer.release(); + } +} diff --git a/mdtp-common/src/test/java/io/github/protocol/mdtp/common/MdtpPacketTest.java b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/MdtpPacketTest.java new file mode 100644 index 0000000..d2d3b83 --- /dev/null +++ b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/MdtpPacketTest.java @@ -0,0 +1,51 @@ +package io.github.protocol.mdtp.common; + +import io.github.protocol.mdtp.common.model.AbstractMessageBody; +import io.github.protocol.mdtp.common.model.CDATHeader; +import io.github.protocol.mdtp.common.model.MdtpPacket; +import io.github.protocol.mdtp.common.model.SecurityHeader; +import io.github.protocol.mdtp.common.model.Signature; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.verify; + +public class MdtpPacketTest { + private MdtpPacket mdtpPacket; + private CDATHeader mockHeader; + private SecurityHeader mockSecurityHeader; + private AbstractMessageBody mockBody; + private Signature mockSignature; + + @BeforeEach + void setUp() { + mockHeader = mock(CDATHeader.class); + mockSecurityHeader = mock(SecurityHeader.class); + mockBody = mock(AbstractMessageBody.class); + mockSignature = mock(Signature.class); + + mdtpPacket = new MdtpPacket(); + mdtpPacket.setHeader(mockHeader); + mdtpPacket.setSecurityHeader(mockSecurityHeader); + mdtpPacket.setBody(mockBody); + mdtpPacket.setSignature(mockSignature); + } + + @Test + void testToByteBuf() { + ByteBuf buffer = Unpooled.buffer(); + + mdtpPacket.toByteBuf(buffer); + + verify(mockHeader).toByteBuf(buffer); + verify(mockSecurityHeader).toByteBuf(buffer); + verify(mockBody).toByteBuf(buffer); + + buffer.release(); + } + + +} diff --git a/mdtp-common/src/test/java/io/github/protocol/mdtp/common/MessageTypeTest.java b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/MessageTypeTest.java new file mode 100644 index 0000000..680e865 --- /dev/null +++ b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/MessageTypeTest.java @@ -0,0 +1,23 @@ +package io.github.protocol.mdtp.common; + +import io.github.protocol.mdtp.common.model.MessageType; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class MessageTypeTest { + @Test + void testRequestCode() { + assertEquals(0, MessageType.REQUEST.getCode()); + } + + @Test + void testResponseCode() { + assertEquals(1, MessageType.RESPONSE.getCode()); + } + + @Test + void testNotifyCode() { + assertEquals(2, MessageType.NOTIFY.getCode()); + } +} diff --git a/mdtp-common/src/test/java/io/github/protocol/mdtp/common/SecurityHeaderTest.java b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/SecurityHeaderTest.java new file mode 100644 index 0000000..df77a35 --- /dev/null +++ b/mdtp-common/src/test/java/io/github/protocol/mdtp/common/SecurityHeaderTest.java @@ -0,0 +1,33 @@ +package io.github.protocol.mdtp.common; + +import io.github.protocol.mdtp.common.model.SecurityHeader; +import io.netty.buffer.ByteBuf; +import io.netty.buffer.Unpooled; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +public class SecurityHeaderTest { + private SecurityHeader securityHeader; + + @BeforeEach + void setUp() { + securityHeader = new SecurityHeader(); + securityHeader.setEncryptionData(new byte[]{0x01, 0x02, 0x03, 0x04}); + } + + @Test + void testToByteBuf() { + ByteBuf buffer = Unpooled.buffer(); + + securityHeader.toByteBuf(buffer); + + assertEquals(1, buffer.readInt()); + assertEquals(2, buffer.readInt()); + assertEquals(3, buffer.readInt()); + assertEquals(4, buffer.readInt()); + + buffer.release(); + } +} diff --git a/pom.xml b/pom.xml index bb9aa8b..84e07f6 100644 --- a/pom.xml +++ b/pom.xml @@ -26,6 +26,7 @@ 5.11.0 2.20.0 1.18.34 + 5.11.0 4.1.112.Final 2.0.16 @@ -91,6 +92,12 @@ ${junit.version} test + + org.mockito + mockito-core + ${mockito.version} + test +