/*
 *
 *    Copyright (c) 2020-2021 Project CHIP Authors
 *    Copyright (c) 2013-2017 Nest Labs, Inc.
 *    All rights reserved.
 *
 *    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.
 */

/**
 *    @file
 *      This file implements a process to effect a functional test for
 *      the CHIP Abstract Syntax Notifcation One (ASN1) encode and
 *      decode interfaces.
 *
 */
#include <gtest/gtest.h>

#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include <lib/asn1/ASN1.h>
#include <lib/asn1/ASN1Macros.h>
#include <lib/core/TLV.h>

using namespace chip;
using namespace chip::ASN1;
using namespace chip::TLV;

enum
{
    kTestVal_01_Bool      = false,
    kTestVal_02_Bool      = true,
    kTestVal_03_BitString = 0x0,
    kTestVal_04_BitString = 0x1,
    kTestVal_05_BitString = 0x3,
    kTestVal_06_BitString = 0x17,
    kTestVal_07_BitString = 0x37,
    kTestVal_08_BitString = 0x187,
    kTestVal_09_BitString = 0x3E7,
    kTestVal_10_Int       = 0,
    kTestVal_11_Int       = 1,
    kTestVal_12_Int       = -1,
    kTestVal_13_Int       = 0xFF00FF,
    kTestVal_14_Int       = -0xFF00FF,
    kTestVal_15_Int       = INT32_MAX,
    kTestVal_16_Int       = INT32_MIN,
    kTestVal_17_Int       = INT64_MAX,
    kTestVal_18_Int       = INT64_MIN,
    kTestVal_19_OID       = kOID_AttributeType_OrganizationName,
    kTestVal_23_OID       = kOID_AttributeType_CommonName,
    kTestVal_24_Int       = 42,
};

// clang-format off
static uint8_t kTestVal_09_BitString_AsOctetString[] = { 0xE7, 0xC0 };
static uint8_t kTestVal_20_OctetString[]        = { 0x01, 0x03, 0x05, 0x07, 0x10, 0x30, 0x50, 0x70, 0x00 };
static const char kTestVal_21_PrintableString[] = "Sudden death in Venice";
static const char kTestVal_22_UTFString[]       = "Ond bra\xCC\x8A""d do\xCC\x88""d i Venedig";
// clang-format on

// Manually copied from ASN1OID.h for testing.
static const uint8_t sOID_AttributeType_ChipNodeId[]         = { 0x2B, 0x06, 0x01, 0x04, 0x01, 0x82, 0xA2, 0x7C, 0x01, 0x01 };
static const uint8_t sOID_SigAlgo_ECDSAWithSHA256[]          = { 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x04, 0x03, 0x02 };
static const uint8_t sOID_EllipticCurve_prime256v1[]         = { 0x2A, 0x86, 0x48, 0xCE, 0x3D, 0x03, 0x01, 0x07 };
static const uint8_t sOID_Extension_AuthorityKeyIdentifier[] = { 0x55, 0x1D, 0x23 };
static const uint8_t sOID_Extension_BasicConstraints[]       = { 0x55, 0x1D, 0x13 };
static const uint8_t sOID_KeyPurpose_ServerAuth[]            = { 0x2B, 0x06, 0x01, 0x05, 0x05, 0x07, 0x03, 0x01 };

uint8_t TestASN1_EncodedData[] = {
    0x30, 0x81, 0xBA, 0x01, 0x01, 0x00, 0x01, 0x01, 0xFF, 0x31, 0x00, 0x03, 0x01, 0x00, 0x03, 0x02, 0x07, 0x80, 0x03, 0x02, 0x06,
    0xC0, 0x30, 0x16, 0x30, 0x0F, 0x30, 0x08, 0x03, 0x02, 0x03, 0xE8, 0x03, 0x02, 0x02, 0xEC, 0x03, 0x03, 0x07, 0xE1, 0x80, 0x03,
    0x03, 0x06, 0xE7, 0xC0, 0x02, 0x01, 0x00, 0x02, 0x01, 0x01, 0x02, 0x01, 0xFF, 0x02, 0x04, 0x00, 0xFF, 0x00, 0xFF, 0x02, 0x04,
    0xFF, 0x00, 0xFF, 0x01, 0x02, 0x04, 0x7F, 0xFF, 0xFF, 0xFF, 0x02, 0x04, 0x80, 0x00, 0x00, 0x00, 0x02, 0x08, 0x7F, 0xFF, 0xFF,
    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x02, 0x08, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x03, 0x55, 0x04, 0x0A, 0x04,
    0x09, 0x01, 0x03, 0x05, 0x07, 0x10, 0x30, 0x50, 0x70, 0x00, 0x04, 0x01, 0x01, 0x04, 0x00, 0x1B, 0x00, 0x13, 0x16, 0x53, 0x75,
    0x64, 0x64, 0x65, 0x6E, 0x20, 0x64, 0x65, 0x61, 0x74, 0x68, 0x20, 0x69, 0x6E, 0x20, 0x56, 0x65, 0x6E, 0x69, 0x63, 0x65, 0x0C,
    0x1A, 0x4F, 0x6E, 0x64, 0x20, 0x62, 0x72, 0x61, 0xCC, 0x8A, 0x64, 0x20, 0x64, 0x6F, 0xCC, 0x88, 0x64, 0x20, 0x69, 0x20, 0x56,
    0x65, 0x6E, 0x65, 0x64, 0x69, 0x67, 0x04, 0x0D, 0x30, 0x0B, 0x06, 0x03, 0x55, 0x04, 0x03, 0x03, 0x04, 0x00, 0x02, 0x01, 0x2A
};

static CHIP_ERROR EncodeASN1TestData(ASN1Writer & writer)
{
    CHIP_ERROR err = CHIP_NO_ERROR;

    ASN1_START_SEQUENCE
    {
        ASN1_ENCODE_BOOLEAN(kTestVal_01_Bool);
        ASN1_ENCODE_BOOLEAN(kTestVal_02_Bool);
        ASN1_START_SET {}
        ASN1_END_SET;
        ASN1_ENCODE_BIT_STRING(kTestVal_03_BitString);
        ASN1_ENCODE_BIT_STRING(kTestVal_04_BitString);
        ASN1_ENCODE_BIT_STRING(kTestVal_05_BitString);
        ASN1_START_SEQUENCE
        {
            ASN1_START_SEQUENCE
            {
                ASN1_START_SEQUENCE
                {
                    ASN1_ENCODE_BIT_STRING(kTestVal_06_BitString);
                    ASN1_ENCODE_BIT_STRING(kTestVal_07_BitString);
                }
                ASN1_END_SEQUENCE;
                ASN1_ENCODE_BIT_STRING(kTestVal_08_BitString);
            }
            ASN1_END_SEQUENCE;
            ASN1_ENCODE_BIT_STRING(kTestVal_09_BitString);
        }
        ASN1_END_SEQUENCE;
        ASN1_ENCODE_INTEGER(kTestVal_10_Int);
        ASN1_ENCODE_INTEGER(kTestVal_11_Int);
        ASN1_ENCODE_INTEGER(kTestVal_12_Int);
        ASN1_ENCODE_INTEGER(kTestVal_13_Int);
        ASN1_ENCODE_INTEGER(kTestVal_14_Int);
        ASN1_ENCODE_INTEGER(kTestVal_15_Int);
        ASN1_ENCODE_INTEGER(kTestVal_16_Int);
        ASN1_ENCODE_INTEGER(kTestVal_17_Int);
        ASN1_ENCODE_INTEGER(kTestVal_18_Int);
        ASN1_ENCODE_OBJECT_ID(kTestVal_19_OID);
        ASN1_ENCODE_OCTET_STRING(kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString));
        ASN1_ENCODE_OCTET_STRING(kTestVal_20_OctetString, 1);
        ASN1_ENCODE_OCTET_STRING(kTestVal_20_OctetString, 0);
        ASN1_ENCODE_STRING(kASN1UniversalTag_GeneralString, "", 0);
        ASN1_ENCODE_STRING(kASN1UniversalTag_PrintableString, kTestVal_21_PrintableString,
                           static_cast<uint16_t>(strlen(kTestVal_21_PrintableString)));
        ASN1_ENCODE_STRING(kASN1UniversalTag_UTF8String, kTestVal_22_UTFString,
                           static_cast<uint16_t>(strlen(kTestVal_22_UTFString)));
        ASN1_START_OCTET_STRING_ENCAPSULATED
        {
            ASN1_START_SEQUENCE
            {
                ASN1_ENCODE_OBJECT_ID(kTestVal_23_OID);
                ASN1_START_BIT_STRING_ENCAPSULATED
                {
                    ASN1_ENCODE_INTEGER(kTestVal_24_Int);
                }
                ASN1_END_ENCAPSULATED;
            }
            ASN1_END_SEQUENCE;
        }
        ASN1_END_ENCAPSULATED;
    }
    ASN1_END_SEQUENCE;

exit:
    return err;
}

TEST(TestASN1, Encode)
{
    CHIP_ERROR err;
    static uint8_t buf[2048];
    ASN1Writer writer;
    size_t encodedLen;

    writer.Init(buf);

    err = EncodeASN1TestData(writer);
    EXPECT_EQ(err, CHIP_NO_ERROR);

    encodedLen = writer.GetLengthWritten();
    EXPECT_EQ(encodedLen, sizeof(TestASN1_EncodedData));
    EXPECT_EQ(memcmp(buf, TestASN1_EncodedData, sizeof(TestASN1_EncodedData)), 0);

#define DUMP_HEX 0
#if DUMP_HEX
    for (uint16_t i = 0; i < encodedLen; i++)
    {
        if (i != 0 && i % 16 == 0)
            printf("\n");
        printf("0x%02X, ", buf[i]);
    }
    printf("\n");
#endif
}

TEST(TestASN1, Decode)
{
    CHIP_ERROR err = CHIP_NO_ERROR;
    ASN1Reader reader;
    bool boolVal;
    uint32_t bitStringVal;
    int64_t intVal;
    OID oidVal;

    reader.Init(TestASN1_EncodedData);

    ASN1_PARSE_ENTER_SEQUENCE
    {
        ASN1_PARSE_BOOLEAN(boolVal);
        EXPECT_EQ(boolVal, kTestVal_01_Bool);
        ASN1_PARSE_BOOLEAN(boolVal);
        EXPECT_EQ(boolVal, kTestVal_02_Bool);
        ASN1_PARSE_ENTER_SET {}
        ASN1_EXIT_SET;
        ASN1_PARSE_BIT_STRING(bitStringVal);
        EXPECT_EQ(bitStringVal, kTestVal_03_BitString);
        ASN1_PARSE_BIT_STRING(bitStringVal);
        EXPECT_EQ(bitStringVal, kTestVal_04_BitString);
        ASN1_PARSE_BIT_STRING(bitStringVal);
        EXPECT_EQ(bitStringVal, kTestVal_05_BitString);
        ASN1_PARSE_ENTER_SEQUENCE
        {
            ASN1_PARSE_ENTER_SEQUENCE
            {
                ASN1_PARSE_ENTER_SEQUENCE
                {
                    ASN1_PARSE_BIT_STRING(bitStringVal);
                    EXPECT_EQ(bitStringVal, kTestVal_06_BitString);
                    ASN1_PARSE_BIT_STRING(bitStringVal);
                    EXPECT_EQ(bitStringVal, kTestVal_07_BitString);
                }
                ASN1_EXIT_SEQUENCE;
                ASN1_PARSE_BIT_STRING(bitStringVal);
                EXPECT_EQ(bitStringVal, kTestVal_08_BitString);
            }
            ASN1_EXIT_SEQUENCE;
            ASN1_PARSE_BIT_STRING(bitStringVal);
            EXPECT_EQ(bitStringVal, kTestVal_09_BitString);
        }
        ASN1_EXIT_SEQUENCE;
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_10_Int);
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_11_Int);
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_12_Int);
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_13_Int);
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_14_Int);
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_15_Int);
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_16_Int);
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_17_Int);
        ASN1_PARSE_INTEGER(intVal);
        EXPECT_EQ(intVal, kTestVal_18_Int);
        ASN1_PARSE_OBJECT_ID(oidVal);
        EXPECT_EQ(oidVal, kTestVal_19_OID);
        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_OctetString);
        EXPECT_EQ(reader.GetValueLen(), sizeof(kTestVal_20_OctetString));
        EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString)), 0);
        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_OctetString);
        EXPECT_EQ(reader.GetValueLen(), 1u);
        EXPECT_EQ(reader.GetValue()[0], kTestVal_20_OctetString[0]);
        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_OctetString);
        EXPECT_EQ(reader.GetValueLen(), 0u);
        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_GeneralString);
        EXPECT_EQ(reader.GetValueLen(), 0u);
        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_PrintableString);
        EXPECT_EQ(reader.GetValueLen(), strlen(kTestVal_21_PrintableString));
        EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_21_PrintableString, strlen(kTestVal_21_PrintableString)), 0);
        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_UTF8String);
        EXPECT_EQ(reader.GetValueLen(), strlen(kTestVal_22_UTFString));
        EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_22_UTFString, strlen(kTestVal_22_UTFString)), 0);
        ASN1_PARSE_ENTER_ENCAPSULATED(kASN1TagClass_Universal, kASN1UniversalTag_OctetString)
        {
            ASN1_PARSE_ENTER_SEQUENCE
            {
                ASN1_PARSE_OBJECT_ID(oidVal);
                EXPECT_EQ(oidVal, kTestVal_23_OID);
                ASN1_PARSE_ENTER_ENCAPSULATED(kASN1TagClass_Universal, kASN1UniversalTag_BitString)
                {
                    ASN1_PARSE_INTEGER(intVal);
                    EXPECT_EQ(intVal, kTestVal_24_Int);
                }
                ASN1_EXIT_ENCAPSULATED;
            }
            ASN1_EXIT_SEQUENCE;
        }
        ASN1_EXIT_ENCAPSULATED;
    }
    ASN1_EXIT_SEQUENCE;

exit:
    EXPECT_EQ(err, CHIP_NO_ERROR);
}

TEST(TestASN1, NullWriter)
{
    CHIP_ERROR err;
    ASN1Writer writer;
    size_t encodedLen;

    writer.InitNullWriter();

    err = EncodeASN1TestData(writer);
    EXPECT_EQ(err, CHIP_NO_ERROR);

    encodedLen = writer.GetLengthWritten();
    EXPECT_EQ(encodedLen, 0u);

    // Methods that take a reader should still read from it,
    // even if the output is suppressed by the null writer.
    TLVReader emptyTlvReader;
    emptyTlvReader.Init(ByteSpan());
    err = writer.PutBitString(0, emptyTlvReader);
    EXPECT_EQ(err, CHIP_ERROR_WRONG_TLV_TYPE);

    emptyTlvReader.Init(ByteSpan());
    err = writer.PutOctetString(kASN1TagClass_ContextSpecific, 123, emptyTlvReader);
    EXPECT_EQ(err, CHIP_ERROR_WRONG_TLV_TYPE);
}

TEST(TestASN1, ASN1UniversalTime)
{
    struct ASN1TimeTestCase
    {
        ASN1UniversalTime asn1Time;
        const char * asn1TimeStr;
    };

    struct ASN1TimeErrorTestCase
    {
        const char * asn1TimeStr;
        CHIP_ERROR mExpectedResult;
    };

    // clang-format off
    static ASN1TimeTestCase sASN1TimeTestCases[] = {
        // ASN1 Universal Time           ASN1_TIME String
        // ====================================================
        {  { 2020, 10, 15, 14, 23, 43 },   "201015142343Z" },
        {  { 2020, 12,  1,  2, 34,  0 },   "201201023400Z" },
        {  { 1979,  1, 30, 12,  0,  0 },   "790130120000Z" },
        {  { 2079,  1, 30, 12,  0,  0 }, "20790130120000Z" },
        {  { 2049,  3, 31, 23, 59, 59 },   "490331235959Z" },
        {  { 1949,  3, 31, 23, 59, 59 }, "19490331235959Z" },
        {  { 1950,  3, 31, 23, 59, 59 },   "500331235959Z" },
    };
    // clang-format on

    // clang-format off
    static ASN1TimeErrorTestCase sASN1TimeErrorTestCases[] = {
        // ASN1_TIME String      Expected Result
        // =======================================================
        {    "201015142343z",    ASN1_ERROR_UNSUPPORTED_ENCODING },
        {    "20105142343Z",     ASN1_ERROR_UNSUPPORTED_ENCODING },
        {    "2010115142343Z",   ASN1_ERROR_UNSUPPORTED_ENCODING },
        {    "201014415142343Z", ASN1_ERROR_UNSUPPORTED_ENCODING },
        {    "201O15142343Z",    ASN1_ERROR_INVALID_ENCODING     },
        {    "200015142343Z",    ASN1_ERROR_INVALID_ENCODING     },
        {    "201315142343Z",    ASN1_ERROR_INVALID_ENCODING     },
        {    "201000142343Z",    ASN1_ERROR_INVALID_ENCODING     },
        {    "201032142343Z",    ASN1_ERROR_INVALID_ENCODING     },
        {    "201015242343Z",    ASN1_ERROR_INVALID_ENCODING     },
        {    "201015146043Z",    ASN1_ERROR_INVALID_ENCODING     },
        {    "201015142360Z",    ASN1_ERROR_INVALID_ENCODING     },
    };
    // clang-format on

    for (auto & testCase : sASN1TimeTestCases)
    {
        CharSpan testStr = CharSpan(testCase.asn1TimeStr, strlen(testCase.asn1TimeStr));
        ASN1UniversalTime result;

        EXPECT_EQ(result.ImportFrom_ASN1_TIME_string(testStr), CHIP_NO_ERROR);

        EXPECT_EQ(result.Year, testCase.asn1Time.Year);
        EXPECT_EQ(result.Month, testCase.asn1Time.Month);
        EXPECT_EQ(result.Day, testCase.asn1Time.Day);
        EXPECT_EQ(result.Hour, testCase.asn1Time.Hour);
        EXPECT_EQ(result.Minute, testCase.asn1Time.Minute);
        EXPECT_EQ(result.Second, testCase.asn1Time.Second);

        char buf[ASN1UniversalTime::kASN1TimeStringMaxLength];
        MutableCharSpan resultTimeStr(buf);
        EXPECT_EQ(result.ExportTo_ASN1_TIME_string(resultTimeStr), CHIP_NO_ERROR);
        EXPECT_TRUE(resultTimeStr.data_equal(testStr));
    }

    for (auto & testCase : sASN1TimeErrorTestCases)
    {
        CharSpan testStr = CharSpan(testCase.asn1TimeStr, strlen(testCase.asn1TimeStr));
        ASN1UniversalTime result;

        EXPECT_EQ(result.ImportFrom_ASN1_TIME_string(testStr), testCase.mExpectedResult);
    }
}

TEST(TestASN1, ObjectID)
{
    CHIP_ERROR err;
    static uint8_t buf[2048];
    ASN1Writer writer;
    ASN1Reader reader;
    size_t encodedLen;

    writer.Init(buf, sizeof(buf));

    ASN1_START_SEQUENCE
    {
        ASN1_ENCODE_OBJECT_ID(kOID_AttributeType_MatterNodeId);
        ASN1_ENCODE_OBJECT_ID(kOID_SigAlgo_ECDSAWithSHA256);
        ASN1_ENCODE_OBJECT_ID(kOID_EllipticCurve_prime256v1);
        ASN1_ENCODE_OBJECT_ID(kOID_Extension_AuthorityKeyIdentifier);
        ASN1_ENCODE_OBJECT_ID(kOID_Extension_BasicConstraints);
        ASN1_ENCODE_OBJECT_ID(kOID_KeyPurpose_ServerAuth);
    }
    ASN1_END_SEQUENCE;

    encodedLen = writer.GetLengthWritten();
    EXPECT_GT(encodedLen, 0u);

    reader.Init(buf, encodedLen);

    // Parse and check OIDs as actual ASN1 encoded values.
    ASN1_PARSE_ENTER_SEQUENCE
    {
        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
        EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_AttributeType_ChipNodeId));
        EXPECT_EQ(memcmp(reader.GetValue(), sOID_AttributeType_ChipNodeId, sizeof(sOID_AttributeType_ChipNodeId)), 0);

        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
        EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_SigAlgo_ECDSAWithSHA256));
        EXPECT_EQ(memcmp(reader.GetValue(), sOID_SigAlgo_ECDSAWithSHA256, sizeof(sOID_SigAlgo_ECDSAWithSHA256)), 0);

        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
        EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_EllipticCurve_prime256v1));
        EXPECT_EQ(memcmp(reader.GetValue(), sOID_EllipticCurve_prime256v1, sizeof(sOID_EllipticCurve_prime256v1)), 0);

        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
        EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_Extension_AuthorityKeyIdentifier));
        EXPECT_EQ(memcmp(reader.GetValue(), sOID_Extension_AuthorityKeyIdentifier, sizeof(sOID_Extension_AuthorityKeyIdentifier)),
                  0);

        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
        EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_Extension_BasicConstraints));
        EXPECT_EQ(memcmp(reader.GetValue(), sOID_Extension_BasicConstraints, sizeof(sOID_Extension_BasicConstraints)), 0);

        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_ObjectId);
        EXPECT_EQ(reader.GetValueLen(), sizeof(sOID_KeyPurpose_ServerAuth));
        EXPECT_EQ(memcmp(reader.GetValue(), sOID_KeyPurpose_ServerAuth, sizeof(sOID_KeyPurpose_ServerAuth)), 0);
    }
    ASN1_EXIT_SEQUENCE;

exit:
    EXPECT_EQ(err, CHIP_NO_ERROR);
}

TEST(TestASN1, FromTLVReader)
{
    CHIP_ERROR err;
    static uint8_t tlvBuf[128];
    static uint8_t asn1Buf1[128];
    static uint8_t asn1Buf2[128];
    TLVWriter tlvWriter;
    TLVReader tlvReader;
    ASN1Writer writer;
    ASN1Reader reader;
    MutableByteSpan tlvEncodedData(tlvBuf);
    MutableByteSpan asn1EncodedData1(asn1Buf1);
    MutableByteSpan asn1EncodedData2(asn1Buf2);
    TLVType outerContainerType;

    // Construct TLV Encoded Structure.
    {
        tlvWriter.Init(tlvEncodedData);

        err = tlvWriter.StartContainer(AnonymousTag(), kTLVType_Structure, outerContainerType);
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvWriter.PutBytes(TLV::ContextTag(1), kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString));
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvWriter.PutBytes(TLV::ContextTag(2), kTestVal_09_BitString_AsOctetString,
                                 sizeof(kTestVal_09_BitString_AsOctetString));
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvWriter.PutString(TLV::ContextTag(3), kTestVal_21_PrintableString);
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvWriter.EndContainer(outerContainerType);
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvWriter.Finalize();
        EXPECT_EQ(err, CHIP_NO_ERROR);
    }

    // Construct first ASN1 SEQUESNCE using values.
    writer.Init(asn1EncodedData1);
    ASN1_START_SEQUENCE
    {
        ASN1_ENCODE_OCTET_STRING(kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString));

        ASN1_ENCODE_BIT_STRING(kTestVal_09_BitString);

        err = writer.PutValue(kASN1TagClass_Universal, kASN1UniversalTag_PrintableString, false,
                              reinterpret_cast<const uint8_t *>(kTestVal_21_PrintableString),
                              static_cast<uint16_t>(strlen(kTestVal_21_PrintableString)));
        EXPECT_EQ(err, CHIP_NO_ERROR);
    }
    ASN1_END_SEQUENCE;
    asn1EncodedData1.reduce_size(writer.GetLengthWritten());

    // Construct second ASN1 SEQUENCE from TLVReader.
    tlvReader.Init(tlvEncodedData);
    writer.Init(asn1EncodedData2);
    ASN1_START_SEQUENCE
    {
        err = tlvReader.Next(kTLVType_Structure, AnonymousTag());
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvReader.EnterContainer(outerContainerType);
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvReader.Next(kTLVType_ByteString, ContextTag(1));
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = writer.PutOctetString(kASN1TagClass_Universal, kASN1UniversalTag_OctetString, tlvReader);
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvReader.Next(kTLVType_ByteString, ContextTag(2));
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = writer.PutBitString(6, tlvReader);
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvReader.Next(kTLVType_UTF8String, ContextTag(3));
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = writer.PutValue(kASN1TagClass_Universal, kASN1UniversalTag_PrintableString, false, tlvReader);
        EXPECT_EQ(err, CHIP_NO_ERROR);

        err = tlvReader.ExitContainer(outerContainerType);
        EXPECT_EQ(err, CHIP_NO_ERROR);
    }
    ASN1_END_SEQUENCE;
    asn1EncodedData2.reduce_size(writer.GetLengthWritten());

    // Compare two ASN1 SEQUENCEs.
    EXPECT_TRUE(asn1EncodedData2.data_equal(asn1EncodedData1));

    // Initialize ASN1Reader and test data.
    reader.Init(asn1EncodedData2);
    ASN1_PARSE_ENTER_SEQUENCE
    {
        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_OctetString);
        ASSERT_NE(reader.GetValue(), nullptr);
        EXPECT_EQ(reader.GetValueLen(), sizeof(kTestVal_20_OctetString));
        EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_20_OctetString, sizeof(kTestVal_20_OctetString)), 0);

        uint32_t val;
        ASN1_PARSE_BIT_STRING(val);
        EXPECT_EQ(val, kTestVal_09_BitString);

        ASN1_PARSE_ELEMENT(kASN1TagClass_Universal, kASN1UniversalTag_PrintableString);
        ASSERT_NE(reader.GetValue(), nullptr);
        EXPECT_EQ(reader.GetValueLen(), strlen(kTestVal_21_PrintableString));
        EXPECT_EQ(memcmp(reader.GetValue(), kTestVal_21_PrintableString, strlen(kTestVal_21_PrintableString)), 0);
    }
    ASN1_EXIT_SEQUENCE;

exit:
    EXPECT_EQ(err, CHIP_NO_ERROR);
}