| /* |
| * |
| * Copyright (c) 2023 Project CHIP Authors |
| * Copyright (c) 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.jsontlv |
| |
| import com.google.common.truth.Truth.assertThat |
| import com.google.gson.JsonParser |
| import kotlin.test.assertFailsWith |
| import org.junit.Test |
| import org.junit.runner.RunWith |
| import org.junit.runners.JUnit4 |
| import chip.tlv.* |
| import chip.jsontlv.fromJsonString |
| import chip.jsontlv.toJsonString |
| |
| @RunWith(JUnit4::class) |
| class JsonToTlvToJsonTest { |
| |
| private fun String.octetsToByteArray(): ByteArray = |
| replace(" ", "").chunked(2).map { it.toInt(16) and 0xFF }.map { it.toByte() }.toByteArray() |
| |
| private fun checkValidConversion( |
| jsonOriginal: String, |
| tlvEncoding: ByteArray, |
| jsonExpected: String = jsonOriginal |
| ) { |
| assertThat(TlvWriter().fromJsonString(jsonOriginal)).isEqualTo(tlvEncoding) |
| assertThat(TlvReader(tlvEncoding).toJsonString()) |
| .isEqualTo(JsonParser.parseString(jsonExpected).asJsonObject.toString()) |
| if (jsonOriginal != jsonExpected) { |
| assertThat(TlvWriter().fromJsonString(jsonExpected)).isEqualTo(tlvEncoding) |
| } |
| } |
| |
| @Test |
| fun convertBoolean_false() { |
| // Boolean false |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(0), false) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "0:BOOL" : false |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertBoolean_true() { |
| // Boolean true |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), true) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:BOOL" : true |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertSignedInt_1BytePositive() { |
| // Signed Integer 42, 1-octet |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(2), 42) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "2:INT" : 42 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertSignedInt_1ByteNegative() { |
| // Signed Integer -17, 1-octet |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(3), -17) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "3:INT" : -17 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertUnsignedInt_1Byte() { |
| // Unsigned Integer 42, 1-octet |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(4), 42U) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "value:4:UINT" : 42 |
| } |
| """ |
| val expectedJson = """ |
| { |
| "4:UINT" : 42 |
| } |
| """ |
| |
| checkValidConversion(json, encoding, expectedJson) |
| } |
| |
| @Test |
| fun convertSignedInt_1Byte2octet() { |
| // Signed Integer 42, 1-byte encoded as 2-octet |
| val encoding = "15 21 06 2a 00 18".octetsToByteArray() |
| val expectedJson = """ |
| { |
| "6:INT" : 42 |
| } |
| """ |
| |
| // Note: the current implementation follows the minimum encoding policy, which encodes this |
| // value as 1-octet. Testing only decoding. |
| assertThat(TlvReader(encoding).toJsonString()) |
| .isEqualTo(JsonParser.parseString(expectedJson).asJsonObject.toString()) |
| } |
| |
| @Test |
| fun convertSignedInt_2Bytes() { |
| // Signed Integer 4242, 2-octet |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(7), 4242) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "7:INT" : 4242 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertSignedInt_4Bytes() { |
| // Signed Integer -170000, 4-octet |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(80), -170000) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "80:INT" : -170000 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertSignedInt_8Bytes() { |
| // Signed Integer (Long) 40000000000, 8-octet |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(202), 40000000000) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "202:INT" : "40000000000" |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertUnsignedInt_8Bytes() { |
| // Unsigned Integer (Long) 40000000000, 8-octet |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(222), 40000000000U) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "222:UINT" : "40000000000" |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertUtf8String_hello() { |
| // UTF-8 String, 1-octet length, "Hello!" |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(0), "Hello!") |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "0:STRING" : "Hello!" |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertUtf8String_tschuh() { |
| // UTF-8 String, 1-octet length, "Tschüs" |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(250), "Tschüs") |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "250:STRING" : "Tschüs" |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertOctetString() { |
| // Octet String, 1-octet length, octets 00 01 02 03 04 |
| val value = "0001020304".octetsToByteArray() |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), value) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:BYTES" : "AAECAwQ=" |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertNull() { |
| // Null |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .putNull(ContextSpecificTag(1)) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:NULL" : null |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertFloat_0() { |
| // Single precision floating point 0.0 |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), 0.0f) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:FLOAT" : 0.0 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertFloat_1third() { |
| // Single precision floating point (1.0 / 3.0) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(100), 1.0f / 3.0f) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "100:FLOAT" : 0.33333334 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertFloat_17_9() { |
| // Single precision floating point 17.9 |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(101), 17.9f) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "101:FLOAT" : 17.9 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertFloat_positiveInfinity_throwsIllegalArgumentException() { |
| // Single precision floating point infinity (∞) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), Float.POSITIVE_INFINITY) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Throws exception because the encoded value is unsupported Infinity value |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertFloat_negativeInfinity_throwsIllegalArgumentException() { |
| // Single precision floating point negative infinity (-∞) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), Float.NEGATIVE_INFINITY) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Throws exception because the encoded value is unsupported Infinity value |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertDouble_0() { |
| // Double precision floating point 0.0 |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), 0.0) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:DOUBLE" : 0.0 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertDouble_1third() { |
| // Double precision floating point (1.0 / 3.0) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), 1.0 / 3.0) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:DOUBLE" : 0.3333333333333333 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertDouble_17_9() { |
| // Double precision floating point 17.9 |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), 17.9) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:DOUBLE" : 17.9 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertDouble_positiveInfinity_throwsIllegalArgumentException() { |
| // Double precision floating point infinity (∞) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), Double.POSITIVE_INFINITY) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Throws exception because the encoded value is unsupported Infinity value |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertDouble_negativeInfinity_throwsIllegalArgumentException() { |
| // Double precision floating point negative infinity (-∞) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(1), Double.NEGATIVE_INFINITY) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Throws exception because the encoded value is unsupported Infinity value |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertEmptyStructure() { |
| // Empty Structure, {} |
| val encoding = |
| TlvWriter().startStructure(AnonymousTag).endStructure().validateTlv().getEncoded() |
| val json = """ |
| { |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertEmptyStructureWithinStructure() { |
| // Empty Structure, {} |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startStructure(ContextSpecificTag(1)) |
| .endStructure() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:STRUCT" : {} |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertEmptyStructureWithCommonProfileTag_throwsIllegalArgumentException() { |
| // Empty Structure, {} |
| val encoding = |
| TlvWriter() |
| .startStructure(CommonProfileTag(2, 1000u)) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Throws exception because top level element must be anonymous Structure |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertTopLevelArray_throwsIllegalArgumentException() { |
| // Empty Array, [] |
| val tag = AnonymousTag |
| val encoding = TlvWriter().startArray(tag).endArray().validateTlv().getEncoded() |
| |
| // Throws exception because top level element must be anonymous Structure |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertTopLevelInt_throwsIllegalArgumentException() { |
| // Empty Array, [] |
| val value = 42 |
| val tag = CommonProfileTag(2, 1000u) |
| val encoding = TlvWriter().put(tag, value).validateTlv().getEncoded() |
| |
| // Throws exception because top level element must be anonymous Structure |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertArray_empty() { |
| // Empty Array, [] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(ContextSpecificTag(1)) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1:ARRAY-?" : [] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArrayWithCommonProfileTag2_empty() { |
| // Empty Array, [] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(CommonProfileTag(2, 10000u)) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "value:10000:ARRAY-?" : [] |
| } |
| """ |
| val expectedJson = """ |
| { |
| "10000:ARRAY-?" : [] |
| } |
| """ |
| |
| checkValidConversion(json, encoding, expectedJson) |
| } |
| |
| @Test |
| fun convertArrayWithCommonProfileTag4_empty() { |
| // Empty Array, [] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(CommonProfileTag(4, 1000000u)) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1000000:ARRAY-?" : [] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertList_empty_throwsIllegalArgumentException() { |
| // Empty List, [] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startList(ContextSpecificTag(1)) |
| .endList() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Throws exception because TLV Lists are not supported |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertIntegersWithContextTags() { |
| // Structure, two context specific tags, Signed Integer, 1 octet values, {0 = 42, 1 = -17} |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(0), 42) |
| .put(ContextSpecificTag(1), -17) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "0:INT" : 42, |
| "1:INT" : -17 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertStructure_intsWithContextTags() { |
| // Structure, two context specific tags, Signed Integer, 1 octet values, {0 = 42, 1 = -17} |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startStructure(ContextSpecificTag(0)) |
| .put(ContextSpecificTag(0), 42) |
| .put(ContextSpecificTag(1), -17) |
| .endStructure() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:STRUCT" : { |
| "0:INT" : 42, |
| "1:INT" : -17 |
| } |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArray_ints() { |
| // Array of Signed Integers (1-octet values): [0, 1, 2, 3, 4] |
| val values = longArrayOf(0, 1, 2, 3, 4) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .putSignedLongArray(ContextSpecificTag(0), values) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-INT" : [ |
| 0, |
| 1, |
| 2, |
| 3, |
| 4 |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArray_double() { |
| // Array of Doubles: [1.1, 134.2763, -12345.87] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(ContextSpecificTag(0)) |
| .put(AnonymousTag, 1.1) |
| .put(AnonymousTag, 134.2763) |
| .put(AnonymousTag, -12345.87) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-DOUBLE" : [ |
| 1.1, |
| 134.2763, |
| -12345.87 |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArray_float() { |
| // Array of Floats: [1.1, 134.2763, -12345.87] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(CommonProfileTag(2, 1000u)) |
| .put(AnonymousTag, 1.1f) |
| .put(AnonymousTag, 134.2763f) |
| .put(AnonymousTag, -12345.87f) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "1000:ARRAY-FLOAT" : [ |
| 1.1, |
| 134.2763, |
| -12345.87 |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArray_string() { |
| // Array of Strings: ["ABC", "Options", "more"] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(CommonProfileTag(4, 100000u)) |
| .put(AnonymousTag, "ABC") |
| .put(AnonymousTag, "Options") |
| .put(AnonymousTag, "more") |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "100000:ARRAY-STRING" : [ |
| "ABC", |
| "Options", |
| "more" |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArray_boolean() { |
| // Array of Booleans: [true, false, false] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(ContextSpecificTag(255)) |
| .put(AnonymousTag, true) |
| .put(AnonymousTag, false) |
| .put(AnonymousTag, false) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "255:ARRAY-BOOL" : [ |
| true, |
| false, |
| false |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArray_null() { |
| // Array of Nulls: [null, null] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(ContextSpecificTag(1)) |
| .putNull(AnonymousTag) |
| .putNull(AnonymousTag) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "1:ARRAY-NULL" : [ |
| null, |
| null |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArray_boolean_throwsIllegalArgumentException() { |
| // Array of bools: error type doesn't match |
| val json = |
| """ |
| { |
| "value:1:ARRAY-BOOL" : [ |
| "yes", |
| "no" |
| ] |
| } |
| """ |
| |
| // Throws exception because subtype encoded in the Json key (Boolean) doesn't match the String |
| // type of the elements in the array |
| assertFailsWith<IllegalArgumentException> { TlvWriter().fromJsonString(json) } |
| } |
| |
| @Test |
| fun convertArray_uint_throwsIllegalArgumentException() { |
| // Array of unsigned integers: error type doesn't match |
| val json = |
| """ |
| { |
| "value:1:ARRAY-UINT" : [ |
| "yes", |
| "no" |
| ] |
| } |
| """ |
| |
| // Throws exception because subtype encoded in the Json key (Boolean) doesn't match the String |
| // type of the elements in the array |
| assertFailsWith<IllegalArgumentException> { TlvWriter().fromJsonString(json) } |
| } |
| |
| @Test |
| fun convertArray_float_throwsIllegalArgumentException() { |
| // Array of floats: error type doesn't match |
| val json = |
| """ |
| { |
| "1:ARRAY-FLOAT" : [ |
| { |
| "1" : 22, |
| "2" : 23 |
| } |
| ] |
| } |
| """ |
| |
| // Throws exception because subtype encoded in the Json key (Float) doesn't match the Structure |
| // type of the elements in the array |
| assertFailsWith<IllegalArgumentException> { TlvWriter().fromJsonString(json) } |
| } |
| |
| @Test |
| fun convertArray_uint2_throwsIllegalArgumentException() { |
| // Array of unsigned integer: error type doesn't match |
| val json = """ |
| { |
| "2:ARRAY-UINT" : [ |
| null |
| ] |
| } |
| """ |
| |
| // Throws exception because subtype encoded in the Json key (UInt) doesn't match the Null |
| // type of the elements in the array |
| assertFailsWith<IllegalArgumentException> { TlvWriter().fromJsonString(json) } |
| } |
| |
| @Test |
| fun convertByteStringArray_throwsIllegalArgumentException() { |
| // Anonymous Array of ByteString, [{00 01 02 03 04}, {FF}, {4A EF 88}] |
| val json = |
| """ |
| { |
| "value:ARRAY-BYTES": [ |
| "AA45ECAwQ=" |
| ] |
| } |
| """ |
| |
| // Throws exception because string is invalid base64 encoded value |
| assertFailsWith<IllegalArgumentException> { TlvWriter().fromJsonString(json) } |
| } |
| |
| @Test |
| fun convertArray_mixedValues_throwsIllegalArgumentException() { |
| // Array of mixed elements: [42, -170000, {}, 17.9, "Hello!"] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(ContextSpecificTag(0)) |
| .put(AnonymousTag, 42) |
| .put(AnonymousTag, -170000) |
| .startStructure(AnonymousTag) |
| .endStructure() |
| .put(AnonymousTag, 17.9) |
| .put(AnonymousTag, "Hello!") |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Throws exception because TLV Array Must have same type elements |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertAnonymousTag_throwsIllegalArgumentException() { |
| // Anonymous tag, Unsigned Integer, 1-octet value, 42U |
| val json = """ |
| { |
| "value:UINT" : 42 |
| } |
| """ |
| |
| // Throws exception because element within structure cannot have anonymous tag |
| assertFailsWith<IllegalArgumentException> { TlvWriter().fromJsonString(json) } |
| } |
| |
| @Test |
| fun convertKeyWithoutTag_throwsIllegalArgumentException2() { |
| // Anonymous tag, Unsigned Integer, 1-octet value, 42U |
| val json = """ |
| { |
| "UINT" : 42 |
| } |
| """ |
| |
| // Throws exception because Json key must have valid tag field |
| assertFailsWith<IllegalArgumentException> { TlvWriter().fromJsonString(json) } |
| } |
| |
| @Test |
| fun convertContextTag_withinStructure() { |
| // Context tag 255 (max), Unsigned Integer, 1-octet value: {255 = 42U} |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startStructure(ContextSpecificTag(0)) |
| .put(ContextSpecificTag(255), 42U) |
| .endStructure() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "value:0:STRUCT": { |
| "name:255:UINT" : 42 |
| } |
| } |
| """ |
| val expectedJson = |
| """ |
| { |
| "0:STRUCT": { |
| "255:UINT" : 42 |
| } |
| } |
| """ |
| |
| checkValidConversion(json, encoding, expectedJson) |
| } |
| |
| @Test |
| fun convertStructWithMixedTags() { |
| // Context and Common Profile tags, Unsigned Integer structure: {255 = 42, 256 = 17000, 65535 = |
| // 1, 65536 = 345678, 4294967295 = 500000000000} |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startStructure(ContextSpecificTag(0)) |
| .put(ContextSpecificTag(UByte.MAX_VALUE.toInt()), 42U) |
| .put(CommonProfileTag(2, UByte.MAX_VALUE + 1U), 17000U) |
| .put(CommonProfileTag(2, UShort.MAX_VALUE.toUInt()), 1U) |
| .put(CommonProfileTag(4, UShort.MAX_VALUE + 1U), 345678U) |
| .put(CommonProfileTag(4, UInt.MAX_VALUE), 500000000000U) |
| .endStructure() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:STRUCT": { |
| "255:UINT" : 42, |
| "256:UINT" : 17000, |
| "65535:UINT" : 1, |
| "65536:UINT" : 345678, |
| "4294967295:UINT" : "500000000000" |
| } |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertContextTag_invalidContextTag_throwsIllegalArgumentException() { |
| // Context and Common Profile tags, Unsigned Integer structure: {255 = 42, 256 = 17000, 65535 = |
| // 1, 65536 = 345678, 4294967295 = 500000000000, , 4294967296 = 34} |
| val json = |
| """ |
| { |
| "0:STRUCT": { |
| "255:UINT" : 42, |
| "256:UINT" : 17000, |
| "65535:UINT" : 1, |
| "65536:UINT" : 345678, |
| "4294967295:UINT" : "500000000000", |
| "invalid:4294967296:UINT" : 34 |
| } |
| } |
| """ |
| |
| // 4294967296 exceeds valid context specific or common profile tag value of 32-bits |
| assertFailsWith<IllegalArgumentException> { TlvWriter().fromJsonString(json) } |
| } |
| |
| @Test |
| fun convertCommonProfileTag2() { |
| // Common profile tag 1, Unsigned Integer, 1-octet value, Matter::1 = 42U |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(CommonProfileTag(2, 1000u), 42U) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "1000:UINT" : 42 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun encodeCommonProfileTag4() { |
| // Common profile tag 100000, Unsigned Integer, 1-octet value, Matter::100000 = 42U |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(CommonProfileTag(4, 100000u), 42U) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = """ |
| { |
| "100000:UINT" : 42 |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertFullyQualifiedTag8_throwsIllegalArgumentException() { |
| // 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 encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(FullyQualifiedTag(8, 0xFFF1u, 0xDEEDu, 0xAA55FEEDu), 42U) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Fully qualified tags are not supported |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertFullyQualifiedTags_throwsIllegalArgumentException() { |
| // 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) |
| val valueTag = FullyQualifiedTag(6, 0xFFF1u, 57069u, 43605u) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startStructure(structTag) |
| .put(valueTag, value) |
| .endStructure() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| |
| // Fully qualified tags are not supported |
| assertFailsWith<IllegalArgumentException> { TlvReader(encoding).toJsonString() } |
| } |
| |
| @Test |
| fun convertSignedLongArray() { |
| // Anonymous Array of Signed Integers: [42, -17, -170000, 40000000000] |
| val values = longArrayOf(42, -17, -170000, 40000000000) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .putSignedLongArray(ContextSpecificTag(0), values) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-INT": [ |
| 42, |
| -17, |
| -170000, |
| "40000000000" |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertUnsignedLongArray() { |
| // Anonymous Array of Unigned Integers: [42, 170000, 40000000000] |
| val values = longArrayOf(42, 170000, 40000000000) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .putUnsignedLongArray(ContextSpecificTag(0), values) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-UINT": [ |
| 42, |
| 170000, |
| "40000000000" |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertByteStringArray() { |
| // Anonymous Array of ByteArray, [{00 01 02 03 04}, {FF}, {4A EF 88}] |
| val values = |
| listOf<ByteArray>( |
| "0001020304".octetsToByteArray(), |
| "FF".octetsToByteArray(), |
| "4AEF88".octetsToByteArray() |
| ) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .putByteStringArray(ContextSpecificTag(0), values) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-BYTES": [ |
| "AAECAwQ=", |
| "/w==", |
| "Su+I" |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertStructure_Mixed() { |
| // Structure with mixed elements |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startStructure(ContextSpecificTag(0)) |
| .put(ContextSpecificTag(0), 20.toLong()) |
| .put(ContextSpecificTag(1), true) |
| .put(ContextSpecificTag(2), 0.toULong()) |
| .put(ContextSpecificTag(3), "Test ByteString Value".toByteArray()) |
| .put(ContextSpecificTag(4), "hello") |
| .put(ContextSpecificTag(5), -500000) |
| .put(ContextSpecificTag(6), 17.9) |
| .put(ContextSpecificTag(7), 17.9f) |
| .endStructure() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:STRUCT": { |
| "0:INT": 20, |
| "1:BOOL": true, |
| "2:UINT": 0, |
| "3:BYTES": "VGVzdCBCeXRlU3RyaW5nIFZhbHVl", |
| "4:STRING": "hello", |
| "5:INT": -500000, |
| "6:DOUBLE": 17.9, |
| "7:FLOAT": 17.9 |
| } |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArrayofStructureWithMixedElements() { |
| // Array of structures with mixed elements |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(CommonProfileTag(2, 1000U)) |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(0), 20) |
| .put(ContextSpecificTag(1), true) |
| .put(ContextSpecificTag(2), 0.toULong()) |
| .put(ContextSpecificTag(3), "Test ByteString Value 1".toByteArray()) |
| .put(ContextSpecificTag(4), "hello1") |
| .put(ContextSpecificTag(5), -500000) |
| .put(ContextSpecificTag(6), 17.9) |
| .put(ContextSpecificTag(7), 17.9f) |
| .endStructure() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(0), -10) |
| .put(ContextSpecificTag(1), false) |
| .put(ContextSpecificTag(2), 128.toULong()) |
| .put(ContextSpecificTag(3), "Test ByteString Value 2".toByteArray()) |
| .put(ContextSpecificTag(4), "hello2") |
| .put(ContextSpecificTag(5), 40000000000) |
| .put(ContextSpecificTag(6), -1754.923) |
| .put(ContextSpecificTag(7), 97.945f) |
| .endStructure() |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "1000:ARRAY-STRUCT": [ |
| { |
| "0:INT": 20, |
| "1:BOOL": true, |
| "2:UINT": 0, |
| "3:BYTES": "VGVzdCBCeXRlU3RyaW5nIFZhbHVlIDE=", |
| "4:STRING": "hello1", |
| "5:INT": -500000, |
| "6:DOUBLE": 17.9, |
| "7:FLOAT": 17.9 |
| }, |
| { |
| "0:INT": -10, |
| "1:BOOL": false, |
| "2:UINT": 128, |
| "3:BYTES": "VGVzdCBCeXRlU3RyaW5nIFZhbHVlIDI=", |
| "4:STRING": "hello2", |
| "5:INT": "40000000000", |
| "6:DOUBLE": -1754.923, |
| "7:FLOAT": 97.945 |
| } |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertingStructureWithMixedElementsAndNames() { |
| // Array of structures with mixed elements |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startStructure(CommonProfileTag(4, 444444U)) |
| .startStructure(ContextSpecificTag(0)) |
| .put(ContextSpecificTag(0), "Test String Element #0") |
| .put(ContextSpecificTag(1), 1) |
| .put(ContextSpecificTag(2), true) |
| .endStructure() |
| .put(ContextSpecificTag(1), 17.4f) |
| .startStructure(ContextSpecificTag(2)) |
| .put(ContextSpecificTag(0), "Test String Element #2") |
| .put(ContextSpecificTag(3), "Test ByteString Element #3".toByteArray()) |
| .endStructure() |
| .endStructure() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "value_name:444444:STRUCT": { |
| "0:STRUCT": { |
| "name0:0:STRING": "Test String Element #0", |
| "name1:1:INT": 1, |
| "name2:2:BOOL": true |
| }, |
| "name2:1:FLOAT": 17.4, |
| "2:STRUCT": { |
| "name0:0:STRING": "Test String Element #2", |
| "3:BYTES": "VGVzdCBCeXRlU3RyaW5nIEVsZW1lbnQgIzM=" |
| } |
| } |
| } |
| """ |
| val expectedJson = |
| """ |
| { |
| "444444:STRUCT": { |
| "0:STRUCT": { |
| "0:STRING": "Test String Element #0", |
| "1:INT": 1, |
| "2:BOOL": true |
| }, |
| "1:FLOAT": 17.4, |
| "2:STRUCT": { |
| "0:STRING": "Test String Element #2", |
| "3:BYTES": "VGVzdCBCeXRlU3RyaW5nIEVsZW1lbnQgIzM=" |
| } |
| } |
| } |
| """ |
| |
| checkValidConversion(json, encoding, expectedJson) |
| } |
| |
| @Test |
| fun convertArrayOfStrings() { |
| // Array of String elements |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(ContextSpecificTag(0)) |
| .put(AnonymousTag, "Test array member 0") |
| .put(AnonymousTag, "Test array member 1") |
| .put(AnonymousTag, "Test array member 2") |
| .put(AnonymousTag, "Test array member 3") |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-STRING": [ |
| "Test array member 0", |
| "Test array member 1", |
| "Test array member 2", |
| "Test array member 3" |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArrayOfByteStrings() { |
| // Array of ByteArray elements |
| val values = |
| listOf<ByteArray>( |
| "Test array member 0".toByteArray(), |
| "Test array member 1".toByteArray(), |
| "Test array member 2".toByteArray(), |
| "Test array member 3".toByteArray(), |
| ) |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .putByteStringArray(ContextSpecificTag(0), values) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-BYTES": [ |
| "VGVzdCBhcnJheSBtZW1iZXIgMA==", |
| "VGVzdCBhcnJheSBtZW1iZXIgMQ==", |
| "VGVzdCBhcnJheSBtZW1iZXIgMg==", |
| "VGVzdCBhcnJheSBtZW1iZXIgMw==" |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertTopLevelMixedValues() { |
| // Top level elements with mixed values |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .put(ContextSpecificTag(0), 42) |
| .put(ContextSpecificTag(1), "Test array member 0".toByteArray()) |
| .put(ContextSpecificTag(2), 156.398) |
| .put(ContextSpecificTag(3), 73709551615U) |
| .put(ContextSpecificTag(4), true) |
| .putNull(ContextSpecificTag(5)) |
| .startStructure(ContextSpecificTag(6)) |
| .put(ContextSpecificTag(1), "John") |
| .put(ContextSpecificTag(2), 34U) |
| .put(ContextSpecificTag(3), true) |
| .startArray(ContextSpecificTag(4)) |
| .put(AnonymousTag, 5) |
| .put(AnonymousTag, 9) |
| .put(AnonymousTag, 10) |
| .endArray() |
| .startArray(ContextSpecificTag(5)) |
| .put(AnonymousTag, "Ammy") |
| .put(AnonymousTag, "David") |
| .put(AnonymousTag, "Larry") |
| .endArray() |
| .startArray(ContextSpecificTag(6)) |
| .put(AnonymousTag, true) |
| .put(AnonymousTag, false) |
| .put(AnonymousTag, true) |
| .endArray() |
| .endStructure() |
| .put(ContextSpecificTag(7), 0.0f) |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "value:0:INT": 42, |
| "value:1:BYTES": "VGVzdCBhcnJheSBtZW1iZXIgMA==", |
| "value:2:DOUBLE": 156.398, |
| "value:3:UINT": "73709551615", |
| "value:4:BOOL": true, |
| "value:5:NULL": null, |
| "value:6:STRUCT": { |
| "name:1:STRING": "John", |
| "age:2:UINT": 34, |
| "approved:3:BOOL": true, |
| "kids:4:ARRAY-INT": [ |
| 5, |
| 9, |
| 10 |
| ], |
| "names:5:ARRAY-STRING": [ |
| "Ammy", |
| "David", |
| "Larry" |
| ], |
| "6:ARRAY-BOOL": [ |
| true, |
| false, |
| true |
| ] |
| }, |
| "value:7:FLOAT": 0.0 |
| } |
| """ |
| val expectedJson = |
| """ |
| { |
| "0:INT": 42, |
| "1:BYTES": "VGVzdCBhcnJheSBtZW1iZXIgMA==", |
| "2:DOUBLE": 156.398, |
| "3:UINT": "73709551615", |
| "4:BOOL": true, |
| "5:NULL": null, |
| "6:STRUCT": { |
| "1:STRING": "John", |
| "2:UINT": 34, |
| "3:BOOL": true, |
| "4:ARRAY-INT": [ |
| 5, |
| 9, |
| 10 |
| ], |
| "5:ARRAY-STRING": [ |
| "Ammy", |
| "David", |
| "Larry" |
| ], |
| "6:ARRAY-BOOL": [ |
| true, |
| false, |
| true |
| ] |
| }, |
| "7:FLOAT": 0.0 |
| } |
| """ |
| |
| checkValidConversion(json, encoding, expectedJson) |
| } |
| |
| @Test |
| fun convertArray_UIntMinMax() { |
| // Array of Unsigned Integers, where each element represents MAX possible value for unsigned |
| // integere |
| // types UByte, UShort, UInt, and ULong: [0xFF, 0xFFFF, 0xFFFFFFFF, 0xFFFFFFFF_FFFFFFFF] |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(ContextSpecificTag(0)) |
| .put(AnonymousTag, UByte.MAX_VALUE) |
| .put(AnonymousTag, UShort.MAX_VALUE) |
| .put(AnonymousTag, UInt.MAX_VALUE) |
| .put(AnonymousTag, ULong.MAX_VALUE) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-UINT": [ |
| 255, |
| 65535, |
| 4294967295, |
| "18446744073709551615" |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| |
| @Test |
| fun convertArray_IntMinMax() { |
| // Array of Integers, where each element represents MIN or MAX possible value for integere |
| // types Byte, Short, Int, and Long |
| val encoding = |
| TlvWriter() |
| .startStructure(AnonymousTag) |
| .startArray(ContextSpecificTag(0)) |
| .put(AnonymousTag, Byte.MIN_VALUE) |
| .put(AnonymousTag, Byte.MAX_VALUE) |
| .put(AnonymousTag, Short.MIN_VALUE) |
| .put(AnonymousTag, Short.MAX_VALUE) |
| .put(AnonymousTag, Int.MIN_VALUE) |
| .put(AnonymousTag, Int.MAX_VALUE) |
| .put(AnonymousTag, Long.MIN_VALUE) |
| .put(AnonymousTag, Long.MAX_VALUE) |
| .endArray() |
| .endStructure() |
| .validateTlv() |
| .getEncoded() |
| val json = |
| """ |
| { |
| "0:ARRAY-INT": [ |
| -128, |
| 127, |
| -32768, |
| 32767, |
| -2147483648, |
| 2147483647, |
| "-9223372036854775808", |
| "9223372036854775807" |
| ] |
| } |
| """ |
| |
| checkValidConversion(json, encoding) |
| } |
| } |
