// Copyright 2026 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
//
//    https://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.
//

#include "crypto/default/cms/ber_parser.h"

#include <cstring>
#include <limits>
#include <string>

#include "crypto/default/cms/cms_error_code.h"
#include "gtest/gtest.h"
#include "openssl/base.h"
#include "openssl/bytestring.h"

namespace credentio_cms {
namespace {

TEST(BerParser, NoData) {
  BerParser parser(nullptr, 0);
  EXPECT_TRUE(parser.ok());
  EXPECT_TRUE(parser.IsNullOrEmpty());
  EXPECT_EQ(ErrorCode::OK, parser.status());
  EXPECT_EQ("", parser.error_message());
  EXPECT_FALSE(parser.GetOptionalTag(0));
  EXPECT_TRUE(parser.ok());
  // Trying to read a tag should set an error.
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());
}

TEST(BerParser, GetTagNonConstructedOk) {
  uint8_t data[] = {// BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    // OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33};
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_TRUE(parser.ok());
  EXPECT_EQ(ErrorCode::OK, parser.status());
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_TRUE(parser.ok());
  EXPECT_EQ(ErrorCode::OK, parser.status());
  // Reading past the end
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());

  // Reading the wrong tag.
  BerParser parser2(data, sizeof(data));
  parser2.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());
}

TEST(BerParser, GetTagDefiniteLengthConstructedOk) {
  uint8_t data[] = {// SEQUENCE {
                    0x30, 8,
                    //   BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    //   OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33,
                    // }
                    // INTEGER { 0x55 }
                    0x2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SEQUENCE);
  EXPECT_TRUE(parser.ok());
  // We should now read inside the sequence.
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_TRUE(parser.ok());
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_TRUE(parser.ok());
  EXPECT_TRUE(parser.IsNullOrEmpty());
  // Trying to read past the end of the sequence without calling CloseTag should
  // fail.
  parser.GetTag(CBS_ASN1_INTEGER);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());
}

TEST(BerParser, GetTagIndefiniteLengthConstructedOk) {
  uint8_t data[] = {// SEQUENCE (indefinite) {
                    0x30, 0x80,
                    //   BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    //   OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33,
                    // }
                    0, 0,
                    // INTEGER { 0x55 }
                    0x2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SEQUENCE);
  EXPECT_TRUE(parser.ok());
  // We should now read inside the sequence.
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_TRUE(parser.ok());
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_TRUE(parser.ok());
  EXPECT_TRUE(parser.IsNullOrEmpty());
  // Trying to read past the end of the sequence without calling CloseTag should
  // fail.
  parser.GetTag(CBS_ASN1_INTEGER);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());
}

TEST(BerParser, GetTagNoDataInElement) {
  // Making sure that an element with with no data is not seen as having
  // indefinite length.
  uint8_t data[] = {// NULL {}
                    5, 0,
                    // INTEGER { 0x55 }
                    2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  parser.GetTag(5);
  EXPECT_TRUE(parser.ok());
  parser.GetTag(CBS_ASN1_INTEGER);
  EXPECT_TRUE(parser.ok());
}

TEST(BerParser, GetTagBrokenEncoding) {
  uint8_t data[] = {1, 2, 0xFF};  // BOOLEAN { TRUE }
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SEQUENCE);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());
}

TEST(BerParser, GetTagMalformedData) {
  uint8_t data[] = {1};  // BOOLEAN { missing value / error }
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());
}

TEST(BerParser, GetTagReadAfterError) {
  uint8_t data[] = {// BOOLEAN { TRUE }
                    1, 1, 0xFF,
                    // OCTET STRING { "\x11\x22\x33" }
                    4, 3, 0x11, 0x22, 0x33};
  BerParser parser(data, sizeof(data));
  // Expecting the wrong tag.
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());
  // Now that the parser is in an error state reading the correct tag
  // should leave it in the error state.
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::ASN1_PARSING_ERROR, parser.status());
}

TEST(BerParser, GetOptionalTag) {
  uint8_t data[] = {// BOOLEAN { TRUE }
                    1, 1, 0xFF,
                    // OCTET STRING { "\x11\x22\x33" }
                    4, 3, 0x11, 0x22, 0x33};
  BerParser parser(data, sizeof(data));
  EXPECT_FALSE(parser.GetOptionalTag(CBS_ASN1_OCTETSTRING));
  EXPECT_TRUE(parser.ok());
  EXPECT_TRUE(parser.GetOptionalTag(CBS_ASN1_BOOLEAN));
  EXPECT_TRUE(parser.ok());
  EXPECT_FALSE(parser.GetOptionalTag(CBS_ASN1_BOOLEAN));
  EXPECT_TRUE(parser.GetOptionalTag(CBS_ASN1_OCTETSTRING));
  // Reading and optional tag at the end doesn't set an error.
  EXPECT_FALSE(parser.GetOptionalTag(CBS_ASN1_OCTETSTRING));
  EXPECT_TRUE(parser.ok());
}

TEST(BerParser, GetElementDataOk) {
  uint8_t data[] = {// BOOLEAN { TRUE }
                    1, 1, 0xFF,
                    // OCTET STRING { "\x11\x22\x33" }
                    4, 3, 0x11, 0x22, 0x33};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);  // harmless dummy values.

  parser.GetElementData(CBS_ASN1_BOOLEAN, &out);
  EXPECT_TRUE(parser.ok());
  EXPECT_EQ(1, CBS_len(&out));
  EXPECT_EQ(data + 2, CBS_data(&out));
  parser.GetElementData(CBS_ASN1_OCTETSTRING, &out);
  EXPECT_TRUE(parser.ok());
  EXPECT_EQ(3, CBS_len(&out));
  EXPECT_EQ(data + 5, CBS_data(&out));
  // Read past the end, it should set an error and clear 'out'.
  parser.GetElementData(CBS_ASN1_OCTETSTRING, &out);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
}

TEST(BerParser, GetElementDataReadAfterError) {
  uint8_t data[] = {// BOOLEAN { TRUE }
                    1, 1, 0xFF,
                    // OCTET STRING { "\x11\x22\x33" }
                    4, 3, 0x11, 0x22, 0x33};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);  // harmless dummy values.

  // Expect the wrong tag.
  parser.GetElementData(CBS_ASN1_OCTETSTRING, &out);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
  // Now all reads will fail and 'out' will be empty.
  parser.GetElementData(CBS_ASN1_BOOLEAN, &out);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
}

TEST(BerParser, GetElementDataConstructedDefiniteTag) {
  uint8_t data[] = {// SEQUENCE {
                    0x30, 8,
                    //   BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    //   OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33,
                    // }
                    // INTEGER { 0x55 }
                    0x2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);

  parser.GetElementData(CBS_ASN1_SEQUENCE, &out);
  EXPECT_TRUE(parser.ok());
  EXPECT_EQ(8, CBS_len(&out));
  EXPECT_EQ(data + 2, CBS_data(&out));

  parser.GetElementData(CBS_ASN1_BOOLEAN, &out);
  EXPECT_TRUE(parser.ok());
  EXPECT_EQ(1, CBS_len(&out));
  EXPECT_EQ(data + 4, CBS_data(&out));
  EXPECT_EQ(0, memcmp(CBS_data(&out), "\xFF", 1));

  parser.GetElementData(CBS_ASN1_OCTETSTRING, &out);
  EXPECT_TRUE(parser.ok());
  EXPECT_EQ(3, CBS_len(&out));
  EXPECT_EQ(data + 7, CBS_data(&out));
  EXPECT_EQ(0, memcmp(CBS_data(&out), "\x11\x22\x33", 3));

  // Reading past the end of the sequence.
  EXPECT_TRUE(parser.IsNullOrEmpty());
  parser.GetElementData(CBS_ASN1_INTEGER, &out);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
}

TEST(BerParser, GetElementDataConstructedIndefiniteLengthTag) {
  uint8_t data[] = {// SEQUENCE (indefinite) {
                    0x30, 0x80,
                    //   BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    //   OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33,
                    // }
                    0, 0,
                    // INTEGER { 0x55 }
                    0x2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  // We don't support reading element data for indefinite length elements.
  parser.GetElementData(CBS_ASN1_SEQUENCE, &out);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
}

TEST(BerParse, GetElementDataNullPointer) {
  uint8_t data[] = {1, 1, 0xFF};  // BOOLEAN { TRUE }
  BerParser parser(data, sizeof(data));
  parser.GetElementData(CBS_ASN1_BOOLEAN, nullptr);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::INVALID_PARAMETER, parser.status());
}

TEST(BerParser, GetElementDataMalformedData) {
  uint8_t data[] = {1};  // BOOLEAN { missing value / error }
  BerParser parser(data, sizeof(data));
  parser.GetElementData(CBS_ASN1_BOOLEAN, nullptr);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::INVALID_PARAMETER, parser.status());
}

TEST(BerParser, GetOptionalElementData) {
  uint8_t data[] = {1, 1, 0xFF};  // BOOLEAN { TRUE }
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  EXPECT_FALSE(parser.GetOptionalElementData(CBS_ASN1_OCTETSTRING, &out));
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
  // Not finding the optional tag should not set an error.
  EXPECT_TRUE(parser.ok());

  EXPECT_TRUE(parser.GetOptionalElementData(CBS_ASN1_BOOLEAN, &out));
  EXPECT_EQ(1, CBS_len(&out));
  EXPECT_EQ(0, memcmp(CBS_data(&out), "\xff", 1));
  EXPECT_TRUE(parser.ok());
  // Make sure that reading after an error clears 'out'
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_FALSE(parser.ok());
  CBS_init(&out, data, 5);
  EXPECT_FALSE(parser.GetOptionalElementData(CBS_ASN1_BOOLEAN, &out));
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
}

TEST(BerParse, GetOptionalElementDataNullPointer) {
  uint8_t data[] = {1, 1, 0xFF};  // BOOLEAN { TRUE }
  BerParser parser(data, sizeof(data));
  parser.GetOptionalElementData(CBS_ASN1_BOOLEAN, nullptr);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(ErrorCode::INVALID_PARAMETER, parser.status());
}

TEST(BerParser, GetAnyElementAndSkipChildrenConstructed) {
  uint8_t data[] = {// SET {
                    0x31, 8,
                    //   BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    //   OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33,
                    // }
                    // INTEGER { 0x55 }
                    0x2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  parser.GetAnyElementAndSkipChildren(&out);
  EXPECT_EQ(10, CBS_len(&out));
  EXPECT_EQ(data, CBS_data(&out));
  EXPECT_TRUE(parser.ok());
  // The next read should be the INTEGER since the contents of the set are not
  // parsed.
  parser.GetAnyElementAndSkipChildren(&out);
  EXPECT_EQ(3, CBS_len(&out));
  EXPECT_EQ(0, memcmp(CBS_data(&out), "\x02\x01\x55", 1));
  EXPECT_TRUE(parser.ok());
  // And it should fail when reading past the end.
  parser.GetAnyElementAndSkipChildren(&out);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
}

TEST(BerParser, GetAnyElementAndSkipChildrenConstructedIndefiniteLength) {
  uint8_t data[] = {// SEQUENCE (indefinite) {
                    0x30, 0x80,
                    //   BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    //   OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33,
                    // }
                    0, 0,
                    // INTEGER { 0x55 }
                    0x2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  parser.GetAnyElementAndSkipChildren(&out);
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
}

TEST(BerParser, GetAnyElementAndSkipChildrenReadAfterError) {
  uint8_t data[] = {4, 3, 0x11, 0x22, 0x33};  // OCTET STRING { "\x11\x22\x33" }
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  parser.GetAnyElementAndSkipChildren(&out);
  EXPECT_EQ(sizeof(data), CBS_len(&out));
  EXPECT_EQ(data, CBS_data(&out));
  EXPECT_TRUE(parser.ok());

  BerParser parser2(data, sizeof(data));
  parser2.GetTag(CBS_ASN1_SEQUENCE);
  EXPECT_FALSE(parser2.ok());
  // The read should fail and out be initialized.
  parser2.GetAnyElementAndSkipChildren(&out);
  EXPECT_FALSE(parser2.ok());
  EXPECT_EQ(0, CBS_len(&out));
  EXPECT_EQ(nullptr, CBS_data(&out));
}

TEST(BerParser, Peek) {
  uint8_t data[] = {4, 3, 0x11, 0x22, 0x33};  // OCTET STRING { "\x11\x22\x33" }
  BerParser parser(data, sizeof(data));
  EXPECT_TRUE(parser.Peek(CBS_ASN1_OCTETSTRING));
  // Peek doesn't read so it can be repeated.
  EXPECT_TRUE(parser.Peek(CBS_ASN1_OCTETSTRING));
  EXPECT_FALSE(parser.Peek(CBS_ASN1_INTEGER));
  // Create an error condition.
  parser.GetTag(CBS_ASN1_SEQUENCE);
  EXPECT_FALSE(parser.ok());
  EXPECT_FALSE(parser.Peek(CBS_ASN1_OCTETSTRING));
}

TEST(BerParser, IsNullOrEmpty) {
  uint8_t data[] = {4, 3, 0x11, 0x22, 0x33};  // OCTET STRING { "\x11\x22\x33" }
  BerParser parser(data, sizeof(data));
  EXPECT_FALSE(parser.IsNullOrEmpty());
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_TRUE(parser.IsNullOrEmpty());

  BerParser parser2(nullptr, 0);
  EXPECT_TRUE(parser2.IsNullOrEmpty());
}

TEST(BerParser, IsNullOrEmptyAfterError) {
  uint8_t data[] = {4, 3, 0x11, 0x22, 0x33};  // OCTET STRING { "\x11\x22\x33" }
  BerParser parser(data, sizeof(data));
  EXPECT_FALSE(parser.IsNullOrEmpty());
  parser.GetTag(CBS_ASN1_INTEGER);
  EXPECT_FALSE(parser.ok());
  EXPECT_TRUE(parser.IsNullOrEmpty());
}

TEST(BerParser, IsNullOrEmptyDefiniteLengthConstructed) {
  uint8_t data[] = {// SEQUENCE {
                    0x30, 8,
                    //   BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    //   OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33,
                    // }
                    // INTEGER { 0x55 }
                    0x2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  parser.GetTag(CBS_ASN1_SEQUENCE);
  EXPECT_FALSE(parser.IsNullOrEmpty());
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_FALSE(parser.IsNullOrEmpty());
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_TRUE(parser.IsNullOrEmpty());
  EXPECT_TRUE(parser.ok());
}

TEST(BerParser, IsNullOrEmptyConstructedWithNull) {
  uint8_t data[] = {// SET {
                    0x31, 5,
                    //   BOOLEAN { TRUE }
                    1, 1, 0xFF,
                    //   NULL {}
                    5, 0,
                    // }
                    // INTEGER { 0x55 }
                    2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  parser.GetTag(CBS_ASN1_SET);
  EXPECT_FALSE(parser.IsNullOrEmpty());
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_TRUE(parser.Peek(5 /* NULL */));
  EXPECT_TRUE(parser.IsNullOrEmpty());
  // Make sure that IsNullOrEmpty consumed the NULL.
  EXPECT_FALSE(parser.Peek(5 /* NULL */));
  EXPECT_TRUE(parser.ok());
}

TEST(BerParser, IsNullOrEmptyConstructedWithBrokenNull) {
  uint8_t data[] = {// SET {
                    0x31, 5,
                    //   BOOLEAN { TRUE }
                    1, 1, 0xFF,
                    //   NULL with invalid length
                    5, 1,
                    // }
                    // INTEGER { 0x55 }
                    2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  parser.GetTag(CBS_ASN1_SET);
  EXPECT_FALSE(parser.IsNullOrEmpty());
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_TRUE(parser.Peek(5 /* NULL */));
  EXPECT_TRUE(parser.IsNullOrEmpty());
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, IsNullOrEmptyIndefiniteLengthConstructed) {
  uint8_t data[] = {// SEQUENCE (indefinite) {
                    0x30, 0x80,
                    //   BOOLEAN { TRUE }
                    0x1, 1, 0xFF,
                    //   OCTET STRING { "\x11\x22\x33" }
                    0x4, 3, 0x11, 0x22, 0x33,
                    // }
                    0, 0,
                    // INTEGER { 0x55 }
                    0x2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  CBS out;
  CBS_init(&out, data, 5);
  parser.GetTag(CBS_ASN1_SEQUENCE);
  EXPECT_FALSE(parser.IsNullOrEmpty());
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_FALSE(parser.IsNullOrEmpty());
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_TRUE(parser.IsNullOrEmpty());
  EXPECT_TRUE(parser.ok());
}

TEST(BerParser, GetInt) {
  uint8_t data[] = {2, 1, 0x55};  // INTEGER { 0x55 }
  BerParser parser(data, sizeof(data));
  EXPECT_EQ(0x55, parser.GetInt());
  EXPECT_TRUE(parser.ok());
  // Reading after an error should just clear the value passed in.
  EXPECT_EQ(0, parser.GetInt());
  EXPECT_FALSE(parser.ok());
  EXPECT_EQ(0, parser.GetInt());
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, GetIntWrongTag) {
  uint8_t data[] = {1, 1, 0x55};  // BOOLEAN { TRUE }
  BerParser parser(data, sizeof(data));
  EXPECT_EQ(0, parser.GetInt());
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, GetIntNegative) {
  uint8_t data[100] = {2 /* INTEGER */};
  static_assert(sizeof(int) + 2 < sizeof(data), "The int size is too large");
  data[1] = sizeof(int);
  for (int i = 0; i < sizeof(int); ++i) {
    data[i + 2] = 0xFF;
  }
  BerParser parser(data, sizeof(data));
  EXPECT_EQ(0, parser.GetInt());
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, GetIntMaxValue) {
  uint8_t data[100] = {2 /* INTEGER */};
  static_assert(sizeof(int) + 2 < sizeof(data), "The int size is too large");
  data[1] = sizeof(int);
  for (int i = 0; i < sizeof(int); ++i) {
    data[i + 2] = 0xFF;
  }
  data[2] = 0x7F;
  BerParser parser(data, sizeof(data));
  EXPECT_EQ(std::numeric_limits<int>::max(), parser.GetInt());
  EXPECT_TRUE(parser.ok());
}

TEST(BerParser, GetIntValueTooLarge) {
  // The value doesn't fit in an uint64_t.
  uint8_t data[100] = {2 /* INTEGER */, 9, 1};
  static_assert(sizeof(uint64_t) == 8, "Unexpected uint64_t size.");
  BerParser parser(data, sizeof(data));
  EXPECT_EQ(0, parser.GetInt());
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, GetIntMaxValuePlusOne) {
  uint8_t data[100] = {2 /* INTEGER */};
  static_assert(sizeof(int) + 2 < sizeof(data), "The int size is too large");
  data[1] = sizeof(int);
  data[2] = 0x80;
  BerParser parser(data, sizeof(data));
  EXPECT_EQ(0, parser.GetInt());
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, EndConstructed) {
  uint8_t data[] = {
      // SET {
      0x31, 5,
      //   OCTET STRING { "\x11\x22\x33" }
      4, 3, 0x11, 0x22, 0x33,
      //   INTEGER { 0x55 }
      2, 1, 0x55
      // }
  };
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SET);
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_FALSE(parser.Peek(CBS_ASN1_INTEGER));
  parser.EndConstructed();
  EXPECT_TRUE(parser.ok());
  EXPECT_TRUE(parser.Peek(CBS_ASN1_INTEGER));
}

TEST(BerParser, EndConstructedTwoLevels) {
  uint8_t data[] = {// SEQUENCE {
                    0x30, 10,
                    //   SET {
                    0x31, 5,
                    //     OCTET STRING { "\x11\x22\x33" }
                    4, 3, 0x11, 0x22, 0x33,
                    //   }
                    //   BOOLEAN { TRUE }
                    1, 1, 0xFF,
                    // }
                    // INTEGER { 0x55 }
                    2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SEQUENCE);
  parser.GetTag(CBS_ASN1_SET);
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_FALSE(parser.Peek(CBS_ASN1_BOOLEAN));
  parser.EndConstructed();
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_FALSE(parser.Peek(CBS_ASN1_INTEGER));
  parser.EndConstructed();
  parser.GetTag(CBS_ASN1_INTEGER);
  EXPECT_TRUE(parser.ok());
}

TEST(BerParser, EndConstructedUnexpectedData) {
  uint8_t data[] = {// SET {
                    0x31, 5,
                    //   OCTET STRING { "\x11\x22\x33" }
                    4, 3, 0x11, 0x22, 0x33,
                    // }
                    // INTEGER { 0x55 }
                    2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SET);
  parser.EndConstructed();
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, EndConstructedIndefiniteLength) {
  uint8_t data[] = {// SEQUENCE (indefinite) {
                    0x30, 0x80,
                    //   SET (indefinite) {
                    0x31, 0x80,
                    //     OCTET STRING { "\x11\x22\x33" }
                    4, 3, 0x11, 0x22, 0x33,
                    //   }
                    0, 0,
                    //   BOOLEAN { TRUE }
                    1, 1, 0xFF,
                    // }
                    0, 0,
                    // INTEGER { 0x55 }
                    2, 1, 0x55};
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SEQUENCE);
  parser.GetTag(CBS_ASN1_SET);
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_FALSE(parser.Peek(CBS_ASN1_BOOLEAN));
  parser.EndConstructed();
  parser.GetTag(CBS_ASN1_BOOLEAN);
  EXPECT_FALSE(parser.Peek(CBS_ASN1_INTEGER));
  parser.EndConstructed();
  parser.GetTag(CBS_ASN1_INTEGER);
  EXPECT_TRUE(parser.ok());
}

TEST(BerParser, EndConstructedIndefiniteLengthUnexpectedData) {
  uint8_t data[] = {
      // SET (indefinite) {
      0x31,
      0x80,
      //   OCTET STRING { "\x11\x22\x33" }
      4,
      3,
      0x11,
      0x22,
      0x33,
      //   INTEGER { 0x55 }
      2,
      1,
      0x55,
      // The SET is missing the EOC.
  };
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SET);
  parser.EndConstructed();
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, EndConstructedMissingEOC) {
  uint8_t data[] = {
      // SET (indefinite) {
      0x31,
      0x80,
      //   OCTET STRING { "\x11\x22\x33" }
      4,
      3,
      0x11,
      0x22,
      0x33,
      // The SET is missing the EOC.
  };
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SET);
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  parser.EndConstructed();
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, EndConstructedIncompleteEOC) {
  uint8_t data[] = {// SET (indefinite) {
                    0x31, 0x80,
                    //   OCTET STRING { "\x11\x22\x33" }
                    4, 3, 0x11, 0x22, 0x33,
                    // Incomplete EOC for the SET.
                    0};
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SET);
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  parser.EndConstructed();
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, EndConstructedIndefiniteLengthEOCInNextTag) {
  uint8_t data[] = {
      // SET {
      0x31, 7,
      //   SET (indefinite) {
      0x31, 0x80,
      //     OCTET STRING { "\x11\x22\x33" }
      4, 3, 0x11, 0x22, 0x33,
      // This is the EOC for the inner set, but it is past the end of the outer
      // one, which is invalid.
      0, 0};
  BerParser parser(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SET);
  parser.GetTag(CBS_ASN1_SET);
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  EXPECT_TRUE(parser.ok());
  parser.EndConstructed();
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, EndConstructedTooManyCalls) {
  BerParser parser(nullptr, 0);
  EXPECT_TRUE(parser.ok());
  parser.EndConstructed();
  EXPECT_FALSE(parser.ok());

  // This is the following structure, missing the SET's EOC:
  //
  //   SET (indefinite) { OCTET STRING { "\x11" }
  uint8_t data[] = {0x31, 0x80, 4, 1, 0x11};
  BerParser parser2(data, sizeof(data));
  parser.GetTag(CBS_ASN1_SET);
  parser.GetTag(CBS_ASN1_OCTETSTRING);
  parser.EndConstructed();
  EXPECT_FALSE(parser.ok());
  parser.EndConstructed();
  EXPECT_FALSE(parser.ok());
}

TEST(BerParser, SetError) {
  BerParser parser(nullptr, 0);
  EXPECT_TRUE(parser.ok());
  parser.SetError(ErrorCode::UNSUPPORTED, "foo");
  EXPECT_EQ(ErrorCode::UNSUPPORTED, parser.status());
  EXPECT_FALSE(parser.ok());
  EXPECT_GE(parser.error_message().find("foo"), 0);
  // Make sure that the error can't be reset.
  parser.SetError(ErrorCode::OK, "bar");
  EXPECT_EQ(ErrorCode::UNSUPPORTED, parser.status());
  EXPECT_FALSE(parser.ok());
  EXPECT_GE(parser.error_message().find("foo"), 0);
}

TEST(BerParser, SetElementName) {
  uint8_t data[] = {// SET (indefinite {
                    0x31, 0x80,
                    //   OCTET STRING { \x11 }
                    4, 1, 0x11,
                    // }
                    0, 0};
  BerParser parser(data, sizeof(data));
  parser.SetElementName("@1@");
  parser.GetInt();
  EXPECT_FALSE(parser.ok());
  EXPECT_GE(parser.error_message().find("@1@"), 0);

  BerParser parser2(data, sizeof(data));
  parser2.SetElementName("@1@");
  parser2.GetTag(CBS_ASN1_SET);
  parser2.SetElementName("@2@");
  parser2.GetInt();
  EXPECT_FALSE(parser2.ok());
  EXPECT_GE(parser2.error_message().find("@1@"), 0);
  EXPECT_GE(parser2.error_message().find("@2@"), 0);

  // Check that the names are not in the error string once their context is
  // poped.
  BerParser parser3(data, sizeof(data));
  parser3.SetElementName("@1@");
  parser3.GetTag(CBS_ASN1_SET);
  parser3.SetElementName("@2@");
  parser3.GetTag(CBS_ASN1_OCTETSTRING);
  parser3.EndConstructed();
  EXPECT_TRUE(parser3.ok());
  parser3.GetInt();
  EXPECT_FALSE(parser2.ok());
  EXPECT_GE(parser3.error_message().find("@1@"), 0);
  EXPECT_EQ(std::string::npos, parser3.error_message().find("@2@"));
}

}  // namespace
}  // namespace credentio_cms