| /* |
| * |
| * Copyright (c) 2023 Project CHIP Authors |
| * Copyright (c) 2019-2023 Google LLC. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package chip.tlv |
| |
| import com.google.common.truth.Truth.assertThat |
| import kotlin.test.assertFailsWith |
| import org.junit.Test |
| import org.junit.runner.RunWith |
| import org.junit.runners.JUnit4 |
| |
| // TLV Encoded structure taken from the C++ TLV unit test of the Matter SDK |
| private val testTlvSampleData: ByteArray = |
| (""" |
| 0xD5, 0xBB, 0xAA, 0xDD, 0xCC, 0x01, 0x00, 0xC9, 0xBB, 0xAA, 0xDD, 0xCC, 0x02, 0x00, 0x88, 0x02, |
| 0x00, 0x36, 0x00, 0x00, 0x2A, 0x00, 0xEF, 0x02, 0xF0, 0x67, 0xFD, 0xFF, 0x07, 0x00, 0x90, 0x2F, |
| 0x50, 0x09, 0x00, 0x00, 0x00, 0x15, 0x18, 0x17, 0xD4, 0xBB, 0xAA, 0xDD, 0xCC, 0x11, 0x00, 0xB4, |
| 0xA0, 0xBB, 0x0D, 0x00, 0x14, 0xB5, 0x00, 0x28, 0x6B, 0xEE, 0x6D, 0x70, 0x11, 0x01, 0x00, 0x0E, |
| 0x01, 0x53, 0x54, 0x41, 0x52, 0x54, 0x2E, 0x2E, 0x2E, 0x21, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x40, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x23, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x24, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x25, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x5E, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x26, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x2A, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x38, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x28, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x29, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x2D, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x3D, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x5B, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x5D, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x3B, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, |
| 0x37, 0x27, 0x39, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x2E, 0x2E, 0x2E, 0x45, 0x4E, 0x44, 0x18, |
| 0x18, 0x18, 0xCC, 0xBB, 0xAA, 0xDD, 0xCC, 0x05, 0x00, 0x0E, 0x54, 0x68, 0x69, 0x73, 0x20, 0x69, |
| 0x73, 0x20, 0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0x8A, 0xFF, 0xFF, 0x33, 0x33, 0x8F, 0x41, 0xAB, |
| 0x00, 0x00, 0x01, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0xE6, 0x31, 0x40, 0x18 |
| """) |
| .trimIndent() |
| .replace("0x", "") |
| .replace(", ", "") |
| .replace(",", "") |
| .replace("\n", "") |
| .chunked(2) |
| .map { it.toInt(16) and 0xFF } |
| .map { it.toByte() } |
| .toByteArray() |
| |
| private const val TEST_VENDOR_ID: UShort = 0xAABBu |
| private const val TEST_PRODUCT_ID: UShort = 0xCCDDu |
| |
| private val testLargeString: String = |
| """ |
| START... |
| !123456789ABCDEF@123456789ABCDEF#123456789ABCDEF$123456789ABCDEF |
| %123456789ABCDEF^123456789ABCDEF&123456789ABCDEF*123456789ABCDEF |
| 01234567(9ABCDEF01234567)9ABCDEF01234567-9ABCDEF01234567=9ABCDEF |
| 01234567[9ABCDEF01234567]9ABCDEF01234567;9ABCDEF01234567'9ABCDEF |
| ...END |
| """ |
| .trimIndent() |
| .replace("\n", "") |
| |
| @RunWith(JUnit4::class) |
| class TlvReadWriteTest { |
| private fun String.octetsToByteArray(): ByteArray = |
| replace(" ", "").chunked(2).map { it.toInt(16) and 0xFF }.map { it.toByte() }.toByteArray() |
| |
| @Test |
| fun testTlvSampleData_write() { |
| TlvWriter().apply { |
| startStructure(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 1u)) |
| put(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 2u), true) |
| put(ImplicitProfileTag(2, 2u), false) |
| startArray(ContextSpecificTag(0)) |
| put(AnonymousTag, 42) |
| put(AnonymousTag, -17) |
| put(AnonymousTag, -170000) |
| put(AnonymousTag, 40000000000UL) |
| startStructure(AnonymousTag) |
| endStructure() |
| startList(AnonymousTag) |
| putNull(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 17u)) |
| putNull(ImplicitProfileTag(4, 900000u)) |
| putNull(AnonymousTag) |
| startStructure(ImplicitProfileTag(4, 4000000000u)) |
| put(CommonProfileTag(4, 70000u), testLargeString) |
| endStructure() |
| endList() |
| endArray() |
| put(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 5u), "This is a test") |
| put(ImplicitProfileTag(2, 65535u), 17.9f) |
| put(ImplicitProfileTag(4, 65536u), 17.9) |
| endStructure() |
| validateTlv() |
| assertThat(getEncoded()).isEqualTo(testTlvSampleData) |
| } |
| } |
| |
| @Test |
| fun testTlvSampleData_read() { |
| TlvReader(testTlvSampleData).apply { |
| enterStructure(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 1u)) |
| assertThat(getBool(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 2u))).isEqualTo(true) |
| assertThat(getBool(ImplicitProfileTag(2, 2u))).isEqualTo(false) |
| enterArray(ContextSpecificTag(0)) |
| assertThat(getInt(AnonymousTag)).isEqualTo(42) |
| assertThat(getInt(AnonymousTag)).isEqualTo(-17) |
| assertThat(getInt(AnonymousTag)).isEqualTo(-170000) |
| assertThat(getULong(AnonymousTag)).isEqualTo(40000000000UL) |
| enterStructure(AnonymousTag) |
| exitContainer() |
| enterList(AnonymousTag) |
| getNull(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 17u)) |
| getNull(ImplicitProfileTag(4, 900000u)) |
| getNull(AnonymousTag) |
| enterStructure(ImplicitProfileTag(4, 4000000000u)) |
| assertThat(getUtf8String(CommonProfileTag(4, 70000u))).isEqualTo(testLargeString) |
| exitContainer() |
| exitContainer() |
| exitContainer() |
| assertThat(getUtf8String(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 5u))) |
| .isEqualTo("This is a test") |
| assertThat(getFloat(ImplicitProfileTag(2, 65535u))).isEqualTo(17.9f) |
| assertThat(getDouble(ImplicitProfileTag(4, 65536u))).isEqualTo(17.9) |
| exitContainer() |
| assertThat(getLengthRead()).isEqualTo(testTlvSampleData.size) |
| assertThat(isEndOfTlv()).isEqualTo(true) |
| } |
| } |
| |
| @Test |
| fun testTlvSampleData_read_useSkipElementAndExitContinerInTheMiddle() { |
| TlvReader(testTlvSampleData).apply { |
| enterStructure(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 1u)) |
| skipElement() |
| assertThat(getBool(ImplicitProfileTag(2, 2u))).isEqualTo(false) |
| enterArray(ContextSpecificTag(0)) |
| assertThat(getInt(AnonymousTag)).isEqualTo(42) |
| exitContainer() |
| assertThat(getUtf8String(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 5u))) |
| .isEqualTo("This is a test") |
| assertThat(getFloat(ImplicitProfileTag(2, 65535u))).isEqualTo(17.9f) |
| assertThat(getDouble(ImplicitProfileTag(4, 65536u))).isEqualTo(17.9) |
| exitContainer() |
| assertThat(getLengthRead()).isEqualTo(testTlvSampleData.size) |
| assertThat(isEndOfTlv()).isEqualTo(true) |
| } |
| } |
| |
| @Test |
| fun testTlvSampleData_copyElement() { |
| val reader = TlvReader(testTlvSampleData) |
| val encoding = TlvWriter().copyElement(reader).validateTlv().getEncoded() |
| assertThat(encoding).isEqualTo(testTlvSampleData) |
| } |
| |
| @Test |
| fun testTlvSampleData_copyElementWithTag() { |
| val reader = TlvReader(testTlvSampleData) |
| val encoding = |
| TlvWriter() |
| .copyElement(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 1u), reader) |
| .validateTlv() |
| .getEncoded() |
| assertThat(encoding).isEqualTo(testTlvSampleData) |
| } |
| |
| @Test |
| fun testCopyElement_throwsIllegalArgumentException() { |
| val encoding = |
| TlvWriter().startStructure(AnonymousTag).endStructure().validateTlv().getEncoded() |
| val reader = TlvReader(encoding) |
| reader.skipElement() |
| |
| // Throws exception because the reader is positioned at the end of container element |
| assertFailsWith<IllegalArgumentException> { TlvWriter().copyElement(reader) } |
| } |
| |
| @Test |
| fun testCopyElement_replaceTag() { |
| val tag = CommonProfileTag(2, 1000u) |
| val encoding = |
| TlvWriter().startStructure(AnonymousTag).endStructure().validateTlv().getEncoded() |
| val expectedEncoding = TlvWriter().startStructure(tag).endStructure().validateTlv().getEncoded() |
| |
| assertThat(TlvWriter().copyElement(tag, TlvReader(encoding)).validateTlv().getEncoded()) |
| .isEqualTo(expectedEncoding) |
| } |
| |
| @Test |
| fun testCopyElementUInt_replaceTag() { |
| val value = 42U |
| val tag1 = CommonProfileTag(2, 1u) |
| val tag2 = CommonProfileTag(2, 2u) |
| val encoding = TlvWriter().put(tag1, value).validateTlv().getEncoded() |
| val expectedEncoding = TlvWriter().put(tag2, value).validateTlv().getEncoded() |
| |
| assertThat(TlvWriter().copyElement(tag2, TlvReader(encoding)).validateTlv().getEncoded()) |
| .isEqualTo(expectedEncoding) |
| } |
| |
| @Test |
| fun testTlvSampleData_copyElementsOneByOne() { |
| val reader = TlvReader(testTlvSampleData) |
| reader.skipElement() |
| val encoding = |
| TlvWriter() |
| .startStructure(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 1u)) |
| .copyElement(reader) |
| .copyElement(reader) |
| .copyElement(reader) |
| .copyElement(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 5u), reader) |
| .copyElement(reader) |
| .copyElement(reader) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| assertThat(encoding).isEqualTo(testTlvSampleData) |
| } |
| |
| @Test |
| fun testData_IntMinMax() { |
| val encodedTlv = |
| TlvWriter() |
| .apply { |
| put(AnonymousTag, Byte.MIN_VALUE.toByte()) |
| put(AnonymousTag, Byte.MAX_VALUE.toByte()) |
| put(AnonymousTag, Short.MIN_VALUE.toShort()) |
| put(AnonymousTag, Short.MAX_VALUE.toShort()) |
| put(AnonymousTag, Int.MIN_VALUE.toInt()) |
| put(AnonymousTag, Int.MAX_VALUE.toInt()) |
| put(AnonymousTag, Long.MIN_VALUE.toLong()) |
| put(AnonymousTag, Long.MAX_VALUE.toLong()) |
| put(AnonymousTag, UByte.MAX_VALUE.toUByte()) |
| put(AnonymousTag, UShort.MAX_VALUE.toUShort()) |
| put(AnonymousTag, UInt.MAX_VALUE.toUInt()) |
| put(AnonymousTag, ULong.MAX_VALUE.toULong()) |
| } |
| .validateTlv() |
| .getEncoded() |
| |
| TlvReader(encodedTlv).apply { |
| assertThat(getByte(AnonymousTag)).isEqualTo(Byte.MIN_VALUE) |
| assertThat(getByte(AnonymousTag)).isEqualTo(Byte.MAX_VALUE) |
| assertThat(getShort(AnonymousTag)).isEqualTo(Short.MIN_VALUE) |
| assertThat(getShort(AnonymousTag)).isEqualTo(Short.MAX_VALUE) |
| assertThat(getInt(AnonymousTag)).isEqualTo(Int.MIN_VALUE) |
| assertThat(getInt(AnonymousTag)).isEqualTo(Int.MAX_VALUE) |
| assertThat(getLong(AnonymousTag)).isEqualTo(Long.MIN_VALUE) |
| assertThat(getLong(AnonymousTag)).isEqualTo(Long.MAX_VALUE) |
| assertThat(getUByte(AnonymousTag)).isEqualTo(UByte.MAX_VALUE) |
| assertThat(getUShort(AnonymousTag)).isEqualTo(UShort.MAX_VALUE) |
| assertThat(getUInt(AnonymousTag)).isEqualTo(UInt.MAX_VALUE) |
| assertThat(getULong(AnonymousTag)).isEqualTo(ULong.MAX_VALUE) |
| } |
| } |
| |
| @Test |
| fun encodeBoolean_false() { |
| // Boolean false |
| val value = false |
| val encoding = "08".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| validateTlv() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getBool(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeBoolean_true() { |
| // Boolean true |
| val value = true |
| val encoding = "09".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getBool(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeSignedInt_1BytePositive() { |
| // Signed Integer, 1-octet |
| val value = 42 |
| val encoding = "00 2a".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getInt(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeSignedInt_1ByteNegative() { |
| // Signed Integer, 1-octet |
| val value = -17 |
| val encoding = "00 ef".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getInt(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeUnsignedInt_1Byte() { |
| // Unsigned Integer, 1-octet |
| val value = 42u |
| val encoding = "04 2a".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getUInt(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeUnsignedInt_1Byte_usePutUnsigned() { |
| // Unsigned Integer, 1-octet |
| val value = 42 |
| val encoding = "04 2a".octetsToByteArray() |
| |
| TlvWriter().apply { |
| putUnsigned(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| } |
| |
| @Test |
| fun encodeSignedInt_1Byte2octet() { |
| // Signed Integer, 1-byte encoded as 2-octet |
| val value = 42 |
| val encoding = "01 2a 00".octetsToByteArray() |
| |
| // Note: the current implementation follows the minimum encoding policy, which encodes this |
| // value as 1-octet. Testing only decoding. |
| |
| TlvReader(encoding).apply { assertThat(getInt(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeSignedInt_2Bytes() { |
| // Signed Integer, 2-octet |
| val value = 4242 |
| val encoding = "01 92 10".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getInt(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeSignedInt_4Bytes() { |
| // Signed Integer, 4-octet |
| val value = -170000 |
| val encoding = "02 f0 67 fd ff".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getInt(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeSignedInt_8Bytes() { |
| // Signed Integer (Long), 8-octet |
| val value = 40000000000 |
| val encoding = "03 00 90 2f 50 09 00 00 00".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getLong(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeUnsignedInt_8Bytes_usePutUnsigned() { |
| // Unsigned Integer (Long), 8-octet |
| val value = 40000000000 |
| val encoding = "07 00 90 2f 50 09 00 00 00".octetsToByteArray() |
| |
| TlvWriter().apply { |
| putUnsigned(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getULong(AnonymousTag)).isEqualTo(value.toULong()) } |
| } |
| |
| @Test |
| fun encodeSignedInt_8Bytes_useGetULong_throwsIllegalArgumentException() { |
| // Signed Integer (Long), 8-octet |
| val encoding = "03 00 90 2f 50 09 00 00 00".octetsToByteArray() |
| |
| // Throws exception because the encoded value is Long and not ULong as requested by getULong() |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).getULong(AnonymousTag) } |
| } |
| |
| @Test |
| fun encodeSignedInt_8Bytes_useGetInt_throwsTlvParsingException() { |
| // Signed Integer (Long), 8-octet |
| val encoding = "03 00 90 2f 50 09 00 00 00".octetsToByteArray() |
| |
| // Throws exception because the encoded value is out of range of Signed Int |
| assertFailsWith<TlvParsingException> { TlvReader(encoding).getInt(AnonymousTag) } |
| } |
| |
| @Test |
| fun encodeSignedInt_8Bytes_getFullyQualifiedTag_throwsIllegalArgumentException() { |
| // Signed Integer (Long), 8-octet |
| val encoding = "03 00 90 2f 50 09 00 00 00".octetsToByteArray() |
| |
| // Throws exception because the encoded value has AnonymousTag tag |
| assertFailsWith<IllegalArgumentException> { |
| TlvReader(encoding).getLong(FullyQualifiedTag(6, TEST_VENDOR_ID, TEST_PRODUCT_ID, 5u)) |
| } |
| } |
| |
| @Test |
| fun encodeUtf8String_hello() { |
| // UTF-8 String, 1-octet length, "Hello!" |
| val value = "Hello!" |
| val encoding = "0c 06 48 65 6c 6c 6f 21".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getUtf8String(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeUtf8String_tschuh() { |
| // UTF-8 String, 1-octet length, "Tschüs" |
| val value = "Tschüs" |
| val encoding = "0c 07 54 73 63 68 c3 bc 73".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getUtf8String(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeOctetString() { |
| // Octet String, 1-octet length, octets 00 01 02 03 04 |
| val value = "00 01 02 03 04".octetsToByteArray() |
| val encoding = "10 05 00 01 02 03 04".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getByteString(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeNull() { |
| // Null |
| val encoding = "14".octetsToByteArray() |
| |
| TlvWriter().apply { |
| putNull(AnonymousTag) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { getNull(AnonymousTag) } |
| } |
| |
| @Test |
| fun encodeFloat_0() { |
| // Single precision floating point 0.0 |
| val value = 0.0f |
| val encoding = "0a 00 00 00 00".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getFloat(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeFloat_1third() { |
| // Single precision floating point (1.0 / 3.0) |
| val value = 1 / 3.toFloat() |
| val encoding = "0a ab aa aa 3e".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getFloat(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeFloat_17_9() { |
| // Single precision floating point 17.9 |
| val value = 17.9f |
| val encoding = "0a 33 33 8f 41".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getFloat(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeFloat_positiveInfinity() { |
| // Single precision floating point infinity (∞) |
| val value = Float.POSITIVE_INFINITY |
| val encoding = "0a 00 00 80 7f".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getFloat(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeFloat_negativeInfinity() { |
| // Single precision floating point negative infinity (-∞) |
| val value = Float.NEGATIVE_INFINITY |
| val encoding = "0a 00 00 80 ff".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| } |
| |
| @Test |
| fun encodeDouble_0() { |
| // Double precision floating point 0.0 |
| val value = 0.0 |
| val encoding = "0b 00 00 00 00 00 00 00 00".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getDouble(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeDouble_1third() { |
| // Double precision floating point (1.0 / 3.0) |
| val value = 1 / 3.toDouble() |
| val encoding = "0b 55 55 55 55 55 55 d5 3f".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getDouble(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeDouble_17_9() { |
| // Double precision floating point 17.9 |
| val value = 17.9 |
| val encoding = "0b 66 66 66 66 66 e6 31 40".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getDouble(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeDouble_positiveInfinity() { |
| // Double precision floating point infinity (∞) |
| val value = Double.POSITIVE_INFINITY |
| val encoding = "0b 00 00 00 00 00 00 f0 7f".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getDouble(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeDouble_negativeInfinity() { |
| // Double precision floating point negative infinity (-∞) |
| val value = Double.NEGATIVE_INFINITY |
| val encoding = "0b 00 00 00 00 00 00 f0 ff".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(AnonymousTag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getDouble(AnonymousTag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeStructure_empty() { |
| // Empty Structure, {} |
| val encoding = "15 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startStructure(AnonymousTag) |
| endStructure() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterStructure(AnonymousTag) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeStructure_empty_testEndOfContainer() { |
| // Empty Structure, {} |
| val encoding = "15 18".octetsToByteArray() |
| |
| TlvReader(encoding).apply { |
| assertThat(isEndOfContainer()).isEqualTo(false) |
| enterStructure(AnonymousTag) |
| assertThat(isEndOfContainer()).isEqualTo(true) |
| exitContainer() |
| assertFailsWith<TlvParsingException> { isEndOfContainer() } |
| } |
| } |
| |
| @Test |
| fun encodeStructure_notClosed_throwsTlvEncodingException() { |
| // Open Structure, { |
| TlvWriter().apply { |
| startStructure(AnonymousTag) |
| assertFailsWith<TlvEncodingException> { validateTlv() } |
| } |
| } |
| |
| @Test |
| fun encodeArray_empty() { |
| // Empty Array, [] |
| val encoding = "16 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startArray(AnonymousTag) |
| endArray() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterArray(AnonymousTag) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeArray_empty_closeUnopennedArray_throwsIllegalArgumentException() { |
| // Empty Array, []] |
| TlvWriter().apply { |
| startArray(AnonymousTag) |
| endArray() |
| // trying to closed container that is not openned |
| assertFailsWith<IllegalArgumentException> { endArray() } |
| } |
| } |
| |
| @Test |
| fun encodeList_empty() { |
| // Empty List, [] |
| val encoding = "17 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startList(AnonymousTag) |
| endList() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterList(AnonymousTag) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeStructure_intsWithContextTags() { |
| // Structure, two context specific tags, Signed Integer, 1 octet values, {0 = 42, 1 = -17} |
| val value0 = 42 |
| val value1 = -17 |
| val encoding = "15 20 00 2a 20 01 ef 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startStructure(AnonymousTag) |
| put(ContextSpecificTag(0), value0) |
| put(ContextSpecificTag(1), value1) |
| endStructure() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterStructure(AnonymousTag) |
| assertThat(getByte(ContextSpecificTag(0))).isEqualTo(value0) |
| assertThat(getByte(ContextSpecificTag(1))).isEqualTo(value1) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeArray_ints() { |
| // Array, Signed Integer, 1-octet values, [0, 1, 2, 3, 4] |
| val encoding = "16 00 00 00 01 00 02 00 03 00 04 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startArray(AnonymousTag) |
| put(AnonymousTag, 0) |
| put(AnonymousTag, 1) |
| put(AnonymousTag, 2) |
| put(AnonymousTag, 3) |
| put(AnonymousTag, 4) |
| endArray() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterArray(AnonymousTag) |
| assertThat(getInt(AnonymousTag)).isEqualTo(0) |
| assertThat(getInt(AnonymousTag)).isEqualTo(1) |
| assertThat(getInt(AnonymousTag)).isEqualTo(2) |
| assertThat(getInt(AnonymousTag)).isEqualTo(3) |
| assertThat(getInt(AnonymousTag)).isEqualTo(4) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeList_mixedInts() { |
| // List, mix of anonymous and context tags, Signed Integer, 1 octet values, |
| // [[1, 0 = 42, 2, 3, 0 = -17]] |
| val encoding = "17 00 01 20 00 2a 00 02 00 03 20 00 ef 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startList(AnonymousTag) |
| put(AnonymousTag, 1) |
| put(ContextSpecificTag(0), 42) |
| put(AnonymousTag, 2) |
| put(AnonymousTag, 3) |
| put(ContextSpecificTag(0), -17) |
| endList() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterList(AnonymousTag) |
| assertThat(getInt(AnonymousTag)).isEqualTo(1) |
| assertThat(getInt(ContextSpecificTag(0))).isEqualTo(42) |
| assertThat(getInt(AnonymousTag)).isEqualTo(2) |
| assertThat(getInt(AnonymousTag)).isEqualTo(3) |
| assertThat(getInt(ContextSpecificTag(0))).isEqualTo(-17) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeArray_mixedValues() { |
| // Array, mix of element types, [42, -170000, {}, 17.9, "Hello!"] |
| val encoding = |
| "16 00 2a 02 f0 67 fd ff 15 18 0a 33 33 8f 41 0c 06 48 65 6c 6c 6f 21 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startArray(AnonymousTag) |
| put(AnonymousTag, 42) |
| put(AnonymousTag, -170000) |
| startStructure(AnonymousTag) |
| endStructure() |
| put(AnonymousTag, 17.9f) |
| put(AnonymousTag, "Hello!") |
| endArray() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterArray(AnonymousTag) |
| assertThat(getInt(AnonymousTag)).isEqualTo(42) |
| assertThat(getInt(AnonymousTag)).isEqualTo(-170000) |
| enterStructure(AnonymousTag) |
| exitContainer() |
| assertThat(getFloat(AnonymousTag)).isEqualTo(17.9f) |
| assertThat(getUtf8String(AnonymousTag)).isEqualTo("Hello!") |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeAanonymousTag() { |
| // Anonymous tag, Unsigned Integer, 1-octet value, 42U |
| val value = 42U |
| var tag = AnonymousTag |
| var encoding = "04 2a".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(tag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getUInt(tag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeContextTag_withinStructure() { |
| // Context tag 1, Unsigned Integer, 1-octet value, {1 = 42U} |
| val value = 42U |
| var tag = ContextSpecificTag(1) |
| var encoding = "15 24 01 2a 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startStructure(AnonymousTag) |
| put(tag, value) |
| endStructure() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterStructure(AnonymousTag) |
| assertThat(getUInt(tag)).isEqualTo(value) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeContextTag_invalidContextTag_throwsIllegalArgumentException() { |
| // Context tag 1, Unsigned Integer, 1-octet value, {1 = 42U} |
| val value1 = 42U |
| val value2 = 17000 |
| var tag1 = ContextSpecificTag(UByte.MAX_VALUE.toInt()) |
| var tag2 = ContextSpecificTag(UByte.MAX_VALUE.toInt() + 1) |
| |
| TlvWriter().apply { |
| startStructure(AnonymousTag) |
| put(tag1, value1) |
| // tag2 exeeds valid context specific tag value |
| assertFailsWith<IllegalArgumentException> { put(tag2, value2) } |
| } |
| } |
| |
| @Test |
| fun encodeAnonymousTagInStructure_throwsIllegalArgumentException() { |
| // Anonymous tag 1, Unsigned Integer, 1-octet value, {1 = 42U} |
| TlvWriter().apply { |
| startStructure(AnonymousTag) |
| // anonymous tags are not allowed within structure elements |
| assertFailsWith<IllegalArgumentException> { put(AnonymousTag, 42U) } |
| } |
| } |
| |
| @Test |
| fun encodeContextTag_withinList() { |
| // Context tag 1, Unsigned Integer, 1-octet value, [[1 = 42U]] |
| val value = 42U |
| var tag = ContextSpecificTag(1) |
| var encoding = "17 24 01 2a 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startList(AnonymousTag) |
| put(tag, value) |
| endList() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterList(AnonymousTag) |
| assertThat(getUInt(tag)).isEqualTo(value) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeContextTag_withinArray_throwsIllegalArgumentException() { |
| // Context tag 1, Unsigned Integer, 1-octet value, [1 = 42U] |
| val value = 42U |
| var tag = ContextSpecificTag(1) |
| |
| // Array elements SHALL be of anonymous type |
| TlvWriter().apply { |
| startArray(AnonymousTag) |
| assertFailsWith<IllegalArgumentException> { put(tag, value) } |
| } |
| } |
| |
| @Test |
| fun encodeContextTag_notInContainer_throwsIllegalArgumentException() { |
| // Context tag 1, Unsigned Integer, 1-octet value, 1 = 42U |
| val value = 42U |
| var tag = ContextSpecificTag(1) |
| |
| // Context tag can only be used within a Structure or a List |
| assertFailsWith<IllegalArgumentException> { TlvWriter().put(tag, value) } |
| } |
| |
| @Test |
| fun encodeCommonProfileTag2() { |
| // Common profile tag 1, Unsigned Integer, 1-octet value, Matter::1 = 42U |
| val value = 42U |
| var tag = CommonProfileTag(2, 1u) |
| var encoding = "44 01 00 2a".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(tag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getUInt(tag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeCommonProfileTag4() { |
| // Common profile tag 100000, Unsigned Integer, 1-octet value, Matter::100000 = 42U |
| val value = 42U |
| var tag = CommonProfileTag(4, 100000u) |
| var encoding = "64 a0 86 01 00 2a".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(tag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getUInt(tag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeFullyQualifiedTag6() { |
| // Fully qualified tag, Vendor ID 0xFFF1/65521, profile number 0xDEED/57069, 2-octet tag 1, |
| // Unsigned Integer, 1-octet value 42, 65521::57069:1 = 42U |
| val value = 42U |
| var tag = FullyQualifiedTag(6, 0xFFF1u, 0xDEEDu, 1u) |
| var encoding = "c4 f1 ff ed de 01 00 2a".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(tag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getUInt(tag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeFullyQualifiedTag8() { |
| // Fully qualified tag, Vendor ID 0xFFF1/65521, profile number 0xDEED/57069, 4-octet tag |
| // 0xAA55FEED/2857762541, Unsigned Integer, 1-octet value 42, 65521::57069:2857762541 = 42U |
| val value = 42U |
| var tag = FullyQualifiedTag(8, 0xFFF1u, 0xDEEDu, 0xAA55FEEDu) |
| var encoding = "e4 f1 ff ed de ed fe 55 aa 2a".octetsToByteArray() |
| |
| TlvWriter().apply { |
| put(tag, value) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { assertThat(getUInt(tag)).isEqualTo(value) } |
| } |
| |
| @Test |
| fun encodeFullyQualifiedTags_withStructure() { |
| // Structure with the fully qualified tag, Vendor ID 0xFFF1/65521, profile number 0xDEED/57069, |
| // 2-octet tag 1. The structure contains a single element labeled using a fully qualified tag |
| // under the same profile, with 2-octet tag 0xAA55/43605.65521::57069:1 = {65521::57069:43605 = |
| // 42U} |
| val value = 42U |
| val structTag = FullyQualifiedTag(6, 0xFFF1u, 0xDEEDu, 1u) |
| var valueTag = FullyQualifiedTag(6, 0xFFF1u, 57069u, 43605u) |
| var encoding = "d5 f1 ff ed de 01 00 c4 f1 ff ed de 55 aa 2a 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| startStructure(structTag) |
| put(valueTag, value) |
| endStructure() |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterStructure(structTag) |
| assertThat(getUInt(valueTag)).isEqualTo(value) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun encodeArray_empty_useputSignedLongArray() { |
| // Empty Array, [] |
| val values = longArrayOf() |
| val encoding = "16 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| putSignedLongArray(AnonymousTag, values) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| } |
| |
| @Test |
| fun putSignedLongArray() { |
| // Anonymous Array of Signed Integers, [42, -17, -170000, 40000000000] |
| val values = longArrayOf(42, -17, -170000, 40000000000) |
| val encoding = "16 00 2a 00 ef 02 f0 67 fd ff 03 00 90 2f 50 09 00 00 00 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| putSignedLongArray(AnonymousTag, values) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterArray(AnonymousTag) |
| assertThat(getLong(AnonymousTag)).isEqualTo(values[0]) |
| assertThat(getLong(AnonymousTag)).isEqualTo(values[1]) |
| assertThat(getLong(AnonymousTag)).isEqualTo(values[2]) |
| assertThat(getLong(AnonymousTag)).isEqualTo(values[3]) |
| exitContainer() |
| } |
| } |
| |
| @Test |
| fun putUnsignedLongArray() { |
| // Anonymous Array of Signed Integers, [42, 170000, 40000000000] |
| val values = longArrayOf(42, 170000, 40000000000) |
| val encoding = "16 04 2a 06 10 98 02 00 07 00 90 2f 50 09 00 00 00 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| putUnsignedLongArray(AnonymousTag, values) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterArray(AnonymousTag) |
| assertThat(getULong(AnonymousTag)).isEqualTo(values[0].toULong()) |
| assertThat(getULong(AnonymousTag)).isEqualTo(values[1].toULong()) |
| assertThat(isEndOfContainer()).isFalse() |
| assertThat(getULong(AnonymousTag)).isEqualTo(values[2].toULong()) |
| assertThat(isEndOfContainer()).isTrue() |
| assertThat(isEndOfTlv()).isFalse() |
| exitContainer() |
| assertThat(isEndOfTlv()).isTrue() |
| } |
| } |
| |
| @Test |
| fun putByteStringArray() { |
| // Anonumous Array of Signed Integers, [{00 01 02 03 04}, {FF}, {4A EF 88}] |
| val values = |
| listOf<ByteArray>( |
| "0001020304".octetsToByteArray(), |
| "FF".octetsToByteArray(), |
| "4AEF88".octetsToByteArray() |
| ) |
| val encoding = "16 10 05 00 01 02 03 04 10 01 FF 10 03 4A EF 88 18".octetsToByteArray() |
| |
| TlvWriter().apply { |
| putByteStringArray(AnonymousTag, values) |
| assertThat(getEncoded()).isEqualTo(encoding) |
| } |
| |
| TlvReader(encoding).apply { |
| enterArray(AnonymousTag) |
| assertThat(getByteString(AnonymousTag)).isEqualTo(values[0]) |
| assertThat(getByteString(AnonymousTag)).isEqualTo(values[1]) |
| assertThat(getByteString(AnonymousTag)).isEqualTo(values[2]) |
| exitContainer() |
| } |
| } |
| } |
