// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "discovery/mdns/mdns_reader.h"

#include <memory>

#include "discovery/common/config.h"
#include "discovery/mdns/testing/mdns_test_util.h"
#include "gmock/gmock.h"
#include "gtest/gtest.h"

namespace openscreen {
namespace discovery {

namespace {

constexpr std::chrono::seconds kTtl{120};

template <class T>
void TestReadEntrySucceeds(const uint8_t* data,
                           size_t size,
                           const T& expected) {
  Config config;
  MdnsReader reader(config, data, size);
  T entry;
  EXPECT_TRUE(reader.Read(&entry));
  EXPECT_EQ(entry, expected);
  EXPECT_EQ(reader.remaining(), UINT64_C(0));
}

template <>
void TestReadEntrySucceeds<MdnsMessage>(const uint8_t* data,
                                        size_t size,
                                        const MdnsMessage& expected) {
  MdnsReader reader(Config{}, data, size);
  const ErrorOr<MdnsMessage> message = reader.Read();
  EXPECT_TRUE(message.is_value());
  EXPECT_EQ(message.value(), expected);
  EXPECT_EQ(reader.remaining(), UINT64_C(0));
}

template <class T>
void TestReadEntryFails(const uint8_t* data, size_t size) {
  Config config;
  MdnsReader reader(config, data, size);
  T entry;
  EXPECT_FALSE(reader.Read(&entry));
  // There should be no side effects for failing to read an entry. The
  // underlying pointer should not have changed.
  EXPECT_EQ(reader.offset(), UINT64_C(0));
}

template <>
void TestReadEntryFails<MdnsMessage>(const uint8_t* data, size_t size) {
  Config config;
  MdnsReader reader(config, data, size);
  const ErrorOr<MdnsMessage> message = reader.Read();
  EXPECT_TRUE(message.is_error());

  // There should be no side effects for failing to read an entry. The
  // underlying pointer should not have changed.
  EXPECT_EQ(reader.offset(), UINT64_C(0));
}
}  // namespace

TEST(MdnsReaderTest, ReadDomainName) {
  constexpr uint8_t kMessage[] = {
      // First name
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',  // Byte: 0
      0x05, 'l', 'o', 'c', 'a', 'l',            // Byte: 8
      0x00,                                     // Byte: 14
      // Second name
      0x07, 's', 'e', 'r', 'v', 'i', 'c', 'e',  // Byte: 15
      0xc0, 0x00,                               // Byte: 23
      // Third name
      0x06, 'd', 'e', 'v', 'i', 'c', 'e',  // Byte: 25
      0xc0, 0x0f,                          // Byte: 32
      // Fourth name
      0xc0, 0x20,  // Byte: 34
  };
  Config config;
  MdnsReader reader(config, kMessage, sizeof(kMessage));
  EXPECT_EQ(reader.begin(), kMessage);
  EXPECT_EQ(reader.length(), sizeof(kMessage));
  EXPECT_EQ(reader.offset(), 0u);
  DomainName name;
  EXPECT_TRUE(reader.Read(&name));
  EXPECT_EQ(name.ToString(), "testing.local");
  EXPECT_TRUE(reader.Read(&name));
  EXPECT_EQ(name.ToString(), "service.testing.local");
  EXPECT_TRUE(reader.Read(&name));
  EXPECT_EQ(name.ToString(), "device.service.testing.local");
  EXPECT_TRUE(reader.Read(&name));
  EXPECT_EQ(name.ToString(), "service.testing.local");
  EXPECT_EQ(reader.offset(), sizeof(kMessage));
  EXPECT_EQ(0UL, reader.remaining());
  EXPECT_FALSE(reader.Read(&name));
}

TEST(MdnsReaderTest, ReadDomainName_Empty) {
  constexpr uint8_t kDomainName[] = {0x00};
  TestReadEntrySucceeds(kDomainName, sizeof(kDomainName), DomainName());
}

TEST(MdnsReaderTest, ReadDomainName_TooShort) {
  // Length 0x03 is longer than available data for the domain name
  constexpr uint8_t kDomainName[] = {0x03, 'a', 'b'};
  TestReadEntryFails<DomainName>(kDomainName, sizeof(kDomainName));
}

TEST(MdnsReaderTest, ReadDomainName_TooLong) {
  std::vector<uint8_t> kDomainName;
  for (uint8_t letter = 'a'; letter <= 'z'; ++letter) {
    constexpr uint8_t repetitions = 10;
    kDomainName.push_back(repetitions);
    kDomainName.insert(kDomainName.end(), repetitions, letter);
  }
  kDomainName.push_back(0);
  TestReadEntryFails<DomainName>(kDomainName.data(), kDomainName.size());
}

TEST(MdnsReaderTest, ReadDomainName_LabelPointerOutOfBounds) {
  constexpr uint8_t kDomainName[] = {0xc0, 0x02};
  TestReadEntryFails<DomainName>(kDomainName, sizeof(kDomainName));
}

TEST(MdnsReaderTest, ReadDomainName_InvalidLabel) {
  constexpr uint8_t kDomainName[] = {0x80};
  TestReadEntryFails<DomainName>(kDomainName, sizeof(kDomainName));
}

TEST(MdnsReaderTest, ReadDomainName_CircularCompression) {
  // clang-format off
  constexpr uint8_t kDomainName[] = {
      // NOTE: Circular label pointer at end of name.
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',  // Byte: 0
      0x05, 'l', 'o', 'c', 'a', 'l',            // Byte: 8
      0xc0, 0x00,                               // Byte: 14
  };
  // clang-format on
  TestReadEntryFails<DomainName>(kDomainName, sizeof(kDomainName));
}

TEST(MdnsReaderTest, ReadRawRecordRdata) {
  // clang-format off
  constexpr uint8_t kRawRecordRdata[] = {
      0x00, 0x08,  // RDLENGTH = 8 bytes
      0x05, 'c', 'n', 'a', 'm', 'e', 0xc0, 0x00,
  };
  // clang-format on
  TestReadEntrySucceeds(
      kRawRecordRdata, sizeof(kRawRecordRdata),
      RawRecordRdata(kRawRecordRdata + 2, sizeof(kRawRecordRdata) - 2));
}

TEST(MdnsReaderTest, ReadRawRecordRdata_TooLong) {
  // clang-format off
  constexpr uint8_t kRawRecordRdata[] = {
      0x00, 0x08,  // RDLENGTH = 8 bytes
      0x05, 'c', 'n', 'a', 'm', 'e', 0xc0, 0x00,
  };
  // clang-format on

  Config config;
  config.maximum_valid_rdata_size = 1;
  MdnsReader reader(config, kRawRecordRdata, sizeof(kRawRecordRdata));
  RawRecordRdata entry;
  EXPECT_FALSE(reader.Read(&entry));
  // There should be no side effects for failing to read an entry. The
  // underlying pointer should not have changed.
  EXPECT_EQ(reader.offset(), UINT64_C(0));
}

TEST(MdnsReaderTest, ReadRawRecord_Empty) {
  // clang-format off
  constexpr uint8_t kRawRecordRdata[] = {
      0x00, 0x00,  // RDLENGTH = 0 bytes
  };
  // clang-format on
  TestReadEntrySucceeds(kRawRecordRdata, sizeof(kRawRecordRdata),
                        RawRecordRdata());
}

TEST(MdnsReaderTest, ReadRawRecordRdata_TooShort) {
  // clang-format off
  constexpr uint8_t kRawRecordRdata[] = {
      0x00, 0x05,  // RDLENGTH = 5 bytes is longer that available data
      0x03, 'f', 'o', 'o'
  };
  // clang-format on
  TestReadEntryFails<RawRecordRdata>(kRawRecordRdata, sizeof(kRawRecordRdata));
}

TEST(MdnsReaderTest, ReadSrvRecordRdata) {
  // clang-format off
  constexpr uint8_t kSrvRecordRdata[] = {
      0x00, 0x15,  // RDLENGTH = 21
      0x00, 0x05,  // PRIORITY = 5
      0x00, 0x06,  // WEIGHT = 6
      0x1f, 0x49,  // PORT = 8009
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l', 0x00,
  };
  // clang-format on
  TestReadEntrySucceeds(
      kSrvRecordRdata, sizeof(kSrvRecordRdata),
      SrvRecordRdata(5, 6, 8009, DomainName{"testing", "local"}));
}

TEST(MdnsReaderTest, ReadSrvRecordRdata_TooShort) {
  // clang-format off
  constexpr uint8_t kSrvRecordRdata[] = {
      0x00, 0x14,  // RDLENGTH = 21
      0x00, 0x05,  // PRIORITY = 5
      0x00, 0x06,  // WEIGHT = 6
                   // Missing bytes
  };
  // clang-format on
  TestReadEntryFails<SrvRecordRdata>(kSrvRecordRdata, sizeof(kSrvRecordRdata));
}

TEST(MdnsReaderTest, ReadSrvRecordRdata_WrongLength) {
  // clang-format off
  constexpr uint8_t kSrvRecordRdata[] = {
      0x00, 0x14,  // RDLENGTH = 20
      0x00, 0x05,  // PRIORITY = 5
      0x00, 0x06,  // WEIGHT = 6
      0x1f, 0x49,  // PORT = 8009
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l', 0x00,
  };
  // clang-format on
  TestReadEntryFails<SrvRecordRdata>(kSrvRecordRdata, sizeof(kSrvRecordRdata));
}

TEST(MdnsReaderTest, ReadARecordRdata) {
  constexpr uint8_t kARecordRdata[] = {
      0x00, 0x4,               // RDLENGTH = 4
      0x08, 0x08, 0x08, 0x08,  // ADDRESS = 8.8.8.8
  };
  TestReadEntrySucceeds(kARecordRdata, sizeof(kARecordRdata),
                        ARecordRdata(IPAddress{8, 8, 8, 8}));
}

TEST(MdnsReaderTest, ReadARecordRdata_TooShort) {
  constexpr uint8_t kARecordRdata[] = {
      0x00, 0x4,   // RDLENGTH = 4
      0x08, 0x08,  // Address missing bytes
  };
  TestReadEntryFails<ARecordRdata>(kARecordRdata, sizeof(kARecordRdata));
}

TEST(MdnsReaderTest, ReadARecordRdata_WrongLength) {
  constexpr uint8_t kARecordRdata[] = {
      0x00, 0x5,               // RDLENGTH = 5
      0x08, 0x08, 0x08, 0x08,  // ADDRESS = 8.8.8.8
  };
  TestReadEntryFails<ARecordRdata>(kARecordRdata, sizeof(kARecordRdata));
}

TEST(MdnsReaderTest, ReadAAAARecordRdata) {
  // clang-format off
  constexpr uint8_t kAAAARecordRdata[] = {
      0x00, 0x10,  // RDLENGTH = 16
      // ADDRESS = FE80:0000:0000:0000:0202:B3FF:FE1E:8329
      0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x02, 0x02, 0xb3, 0xff, 0xfe, 0x1e, 0x83, 0x29,
  };
  // clang-format on
  TestReadEntrySucceeds(kAAAARecordRdata, sizeof(kAAAARecordRdata),
                        AAAARecordRdata(IPAddress(IPAddress::Version::kV6,
                                                  kAAAARecordRdata + 2)));
}

TEST(MdnsReaderTest, ReadAAAARecordRdata_TooShort) {
  // clang-format off
  constexpr uint8_t kAAAARecordRdata[] = {
      0x00, 0x10,  // RDLENGTH = 16
      // ADDRESS missing bytes
      0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  };
  // clang-format on
  TestReadEntryFails<AAAARecordRdata>(kAAAARecordRdata,
                                      sizeof(kAAAARecordRdata));
}

TEST(MdnsReaderTest, ReadAAAARecordRdata_WrongLength) {
  // clang-format off
  constexpr uint8_t kAAAARecordRdata[] = {
      0x00, 0x11,  // RDLENGTH = 17
      // ADDRESS = FE80:0000:0000:0000:0202:B3FF:FE1E:8329
      0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
      0x02, 0x02, 0xb3, 0xff, 0xfe, 0x1e, 0x83, 0x29,
  };
  // clang-format on
  TestReadEntryFails<AAAARecordRdata>(kAAAARecordRdata,
                                      sizeof(kAAAARecordRdata));
}

TEST(MdnsReaderTest, ReadPtrRecordRdata) {
  // clang-format off
  constexpr uint8_t kPtrRecordRdata[] = {
      0x00, 0x18,  // RDLENGTH = 24
      0x08, 'm', 'y', 'd', 'e', 'v', 'i', 'c', 'e',
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a',  'l',
      0x00,
  };
  // clang-format on
  TestReadEntrySucceeds(
      kPtrRecordRdata, sizeof(kPtrRecordRdata),
      PtrRecordRdata(DomainName{"mydevice", "testing", "local"}));
}

TEST(MdnsReaderTest, ReadPtrRecordRdata_TooShort) {
  // clang-format off
  constexpr uint8_t kPtrRecordRdata[] = {
      0x00, 0x18,  // RDLENGTH = 24
      0x08, 'm', 'y', 'd', 'e', 'v', 'i', 'c', 'e',
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c'
      // Missing bytes
  };
  // clang-format on
  TestReadEntryFails<PtrRecordRdata>(kPtrRecordRdata, sizeof(kPtrRecordRdata));
}

TEST(MdnsReaderTest, ReadPtrRecordRdata_WrongLength) {
  // clang-format off
  constexpr uint8_t kPtrRecordRdata[] = {
      0x00, 0x18,  // RDLENGTH = 24
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a',  'l',
      0x00,
  };
  // clang-format on
  TestReadEntryFails<PtrRecordRdata>(kPtrRecordRdata, sizeof(kPtrRecordRdata));
}

TEST(MdnsReaderTest, ReadTxtRecordRdata) {
  // clang-format off
  constexpr uint8_t kTxtRecordRdata[] = {
      0x00, 0x0C,  // RDLENGTH = 12
      0x05, 'f', 'o', 'o', '=', '1',
      0x05, 'b', 'a', 'r', '=', '2',
  };
  // clang-format on
  TestReadEntrySucceeds(kTxtRecordRdata, sizeof(kTxtRecordRdata),
                        MakeTxtRecord({"foo=1", "bar=2"}));
}

TEST(MdnsReaderTest, ReadTxtRecordRdata_Empty) {
  constexpr uint8_t kTxtRecordRdata[] = {
      0x00, 0x01,  // RDLENGTH = 1
      0x00,        // empty string
  };
  TestReadEntrySucceeds(kTxtRecordRdata, sizeof(kTxtRecordRdata),
                        TxtRecordRdata());
}

TEST(MdnsReaderTest, ReadTxtRecordRdata_WithNullInTheMiddle) {
  // clang-format off
  constexpr uint8_t kTxtRecordRdata[] = {
      0x00, 0x10,  // RDLENGTH = 16
      0x09, 'w', 'i', 't', 'h', '\0', 'N', 'U', 'L', 'L',
      0x05, 'o', 't', 'h', 'e', 'r',
  };
  // clang-format on
  TestReadEntrySucceeds(
      kTxtRecordRdata, sizeof(kTxtRecordRdata),
      MakeTxtRecord({absl::string_view("with\0NULL", 9), "other"}));
}

TEST(MdnsReaderTest, ReadTxtRecordRdata_EmptyEntries) {
  // clang-format off
  constexpr uint8_t kTxtRecordRdata[] = {
      0x00, 0x0F,  // RDLENGTH = 12
      0x05, 'f', 'o', 'o', '=', '1',
      0x00,
      0x00,
      0x05, 'b', 'a', 'r', '=', '2',
      0x00,
  };
  // clang-format on
  TestReadEntrySucceeds(kTxtRecordRdata, sizeof(kTxtRecordRdata),
                        MakeTxtRecord({"foo=1", "bar=2"}));
}

TEST(MdnsReaderTest, ReadTxtRecordRdata_TooLong) {
  // clang-format off
  constexpr uint8_t kTxtRecordRdata[] = {
      0x00, 0x0C,  // RDLENGTH = 12
      0x05, 'f', 'o', 'o', '=', '1',
      0x05, 'b', 'a', 'r', '=', '2',
  };
  // clang-format on

  Config config;
  config.maximum_valid_rdata_size = 1;
  MdnsReader reader(config, kTxtRecordRdata, sizeof(kTxtRecordRdata));
  TxtRecordRdata entry;
  EXPECT_FALSE(reader.Read(&entry));
  // There should be no side effects for failing to read an entry. The
  // underlying pointer should not have changed.
  EXPECT_EQ(reader.offset(), UINT64_C(0));
}

TEST(MdnsReaderTest, ReadNsecRecordRdata) {
  // clang-format off
  constexpr uint8_t kExpectedRdata[] = {
    0x00, 0x20,  // RDLENGTH = 32
    0x08, 'm', 'y', 'd', 'e', 'v', 'i', 'c', 'e',
    0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
    0x05, 'l', 'o', 'c', 'a',  'l',
    0x00,
    // It takes 8 bytes to encode the kA and kSRV records because:
    // - Both record types have value less than 256, so they are both in window
    //   block 1.
    // - The bitmap length for this block is always a single byte
    // - DnsTypes have the following values:
    //   - kA = 1 (encoded in byte 1)
    //     kTXT = 16 (encoded in byte 3)
    //   - kSRV = 33 (encoded in byte 5)
    //   - kNSEC = 47 (encoded in 6 bytes)
    // - The largest of these is 47, so 6 bytes are needed to encode this data.
    // So the full encoded version is:
    //   00000000 00000110 01000000 00000000 10000000 00000000 0100000  00000001
    //   |window| | size | | 0-7  | | 8-15 | |16-23 | |24-31 | |32-39 | |40-47 |
          0x00,    0x06,    0x40,    0x00,    0x80,    0x00,    0x40,    0x01
  };
  // clang-format on
  TestReadEntrySucceeds(
      kExpectedRdata, sizeof(kExpectedRdata),
      NsecRecordRdata(DomainName{"mydevice", "testing", "local"}, DnsType::kA,
                      DnsType::kTXT, DnsType::kSRV, DnsType::kNSEC));
}

TEST(MdnsReaderTest, ReadNsecRecordRdata_TooShort) {
  // clang-format off
  constexpr uint8_t kNsecRecordRdata[] = {
    0x00, 0x20,  // RDLENGTH = 32
    0x08, 'm', 'y', 'd', 'e', 'v', 'i', 'c', 'e',
    0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
    0x05, 'l', 'o', 'c', 'a',  'l',
    0x00,
    0x00, 0x06, 0x40, 0x00
  };
  // clang-format on
  TestReadEntryFails<NsecRecordRdata>(kNsecRecordRdata,
                                      sizeof(kNsecRecordRdata));
}

TEST(MdnsReaderTest, ReadNsecRecordRdata_WrongLength) {
  // clang-format off
  constexpr uint8_t kNsecRecordRdata[] = {
    0x00, 0x21,  // RDLENGTH = 33
    0x08, 'm', 'y', 'd', 'e', 'v', 'i', 'c', 'e',
    0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
    0x05, 'l', 'o', 'c', 'a',  'l',
    0x00,
    0x00, 0x06, 0x40, 0x00, 0x80, 0x00, 0x40, 0x01
  };
  // clang-format on
  TestReadEntryFails<NsecRecordRdata>(kNsecRecordRdata,
                                      sizeof(kNsecRecordRdata));
}

TEST(MdnsReaderTest, ReadMdnsRecord_ARecordRdata) {
  // clang-format off
  constexpr uint8_t kTestRecord[] = {
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      0x00, 0x01,              // TYPE = A (1)
      0x80, 0x01,              // CLASS = IN (1) | CACHE_FLUSH_BIT
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x04,              // RDLENGTH = 4 bytes
      0x08, 0x08, 0x08, 0x08,  // RDATA = 8.8.8.8
  };
  // clang-format on
  TestReadEntrySucceeds(kTestRecord, sizeof(kTestRecord),
                        MdnsRecord(DomainName{"testing", "local"}, DnsType::kA,
                                   DnsClass::kIN, RecordType::kUnique, kTtl,
                                   ARecordRdata(IPAddress{8, 8, 8, 8})));
}

TEST(MdnsReaderTest, ReadMdnsRecord_UnknownRecordType) {
  // clang-format off
  constexpr uint8_t kTestRecord[] = {
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      0x00, 0x05,              // TYPE = CNAME (5)
      0x80, 0x01,              // CLASS = IN (1) | CACHE_FLUSH_BIT
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x08,              // RDLENGTH = 8 bytes
      0x05, 'c', 'n', 'a', 'm', 'e', 0xc0, 0x00,
  };
  constexpr uint8_t kCnameRdata[] = {
      0x05, 'c', 'n', 'a', 'm', 'e', 0xc0, 0x00,
  };
  // clang-format on
  TestReadEntrySucceeds(
      kTestRecord, sizeof(kTestRecord),
      MdnsRecord(DomainName{"testing", "local"},
                 static_cast<DnsType>(5) /*CNAME class*/, DnsClass::kIN,
                 RecordType::kUnique, kTtl,
                 RawRecordRdata(kCnameRdata, sizeof(kCnameRdata))));
}

TEST(MdnsReaderTest, ReadMdnsRecord_CompressedNames) {
  // clang-format off
  constexpr uint8_t kTestRecord[] = {
      // First message
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      0x00, 0x0c,              // TYPE = PTR (12)
      0x00, 0x01,              // CLASS = IN (1)
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x06,              // RDLENGTH = 6 bytes
      0x03, 'p',  't',  'r',
      0xc0, 0x00,              // Domain name label pointer to byte 0
      // Second message
      0x03, 'o', 'n', 'e',
      0x03, 't', 'w', 'o',
      0xc0, 0x00,              // Domain name label pointer to byte 0
      0x00, 0x01,              // TYPE = A (1)
      0x80, 0x01,              // CLASS = IN (1) | CACHE_FLUSH_BIT
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x04,              // RDLENGTH = 4 bytes
      0x08, 0x08, 0x08, 0x08,  // RDATA = 8.8.8.8
  };
  // clang-format on
  Config config;
  MdnsReader reader(config, kTestRecord, sizeof(kTestRecord));

  MdnsRecord record;
  EXPECT_TRUE(reader.Read(&record));
  EXPECT_EQ(record,
            MdnsRecord(DomainName{"testing", "local"}, DnsType::kPTR,
                       DnsClass::kIN, RecordType::kShared, kTtl,
                       PtrRecordRdata(DomainName{"ptr", "testing", "local"})));
  EXPECT_TRUE(reader.Read(&record));
  EXPECT_EQ(record, MdnsRecord(DomainName{"one", "two", "testing", "local"},
                               DnsType::kA, DnsClass::kIN, RecordType::kUnique,
                               kTtl, ARecordRdata(IPAddress{8, 8, 8, 8})));
}

TEST(MdnsReaderTest, ReadMdnsRecord_MissingRdata) {
  // clang-format off
  constexpr uint8_t kTestRecord[] = {
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      0x00, 0x01,              // TYPE = A (1)
      0x00, 0x01,              // CLASS = IN (1)
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x04,              // RDLENGTH = 4 bytes
                               // Missing RDATA
  };
  // clang-format on
  TestReadEntryFails<MdnsRecord>(kTestRecord, sizeof(kTestRecord));
}

TEST(MdnsReaderTest, ReadMdnsRecord_InvalidHostName) {
  // clang-format off
  constexpr uint8_t kTestRecord[] = {
      // Invalid NAME: length byte too short
      0x03, 'i', 'n', 'v', 'a', 'l', 'i', 'd',
      0x00,
      0x00, 0x01,              // TYPE = A (1)
      0x00, 0x01,              // CLASS = IN (1)
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x04,              // RDLENGTH = 4 bytes
      0x08, 0x08, 0x08, 0x08,  // RDATA = 8.8.8.8
  };
  // clang-format on
  TestReadEntryFails<MdnsRecord>(kTestRecord, sizeof(kTestRecord));
}

TEST(MdnsReaderTest, ReadMdnsQuestion) {
  // clang-format off
  constexpr uint8_t kTestQuestion[] = {
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      0x00, 0x01,  // TYPE = A (1)
      0x80, 0x01,  // CLASS = IN (1) | UNICAST_BIT
  };
  // clang-format on
  TestReadEntrySucceeds(
      kTestQuestion, sizeof(kTestQuestion),
      MdnsQuestion(DomainName{"testing", "local"}, DnsType::kA, DnsClass::kIN,
                   ResponseType::kUnicast));
}

TEST(MdnsReaderTest, ReadMdnsQuestion_CompressedNames) {
  // clang-format off
  constexpr uint8_t kTestQuestions[] = {
      // First Question
      0x05, 'f', 'i', 'r', 's', 't',
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      0x00, 0x01,  // TYPE = A (1)
      0x80, 0x01,  // CLASS = IN (1) | UNICAST_BIT
      // Second Question
      0x06, 's', 'e', 'c', 'o', 'n', 'd',
      0xc0, 0x06,  // Domain name label pointer
      0x00, 0x0c,  // TYPE = PTR (12)
      0x00, 0x01,  // CLASS = IN (1)
  };
  // clang-format on
  Config config;
  MdnsReader reader(config, kTestQuestions, sizeof(kTestQuestions));
  MdnsQuestion question;
  EXPECT_TRUE(reader.Read(&question));
  EXPECT_EQ(question, MdnsQuestion(DomainName{"first", "local"}, DnsType::kA,
                                   DnsClass::kIN, ResponseType::kUnicast));
  EXPECT_TRUE(reader.Read(&question));
  EXPECT_EQ(question, MdnsQuestion(DomainName{"second", "local"}, DnsType::kPTR,
                                   DnsClass::kIN, ResponseType::kMulticast));
  EXPECT_EQ(reader.remaining(), UINT64_C(0));
}

TEST(MdnsReaderTest, ReadMdnsQuestion_InvalidHostName) {
  // clang-format off
  constexpr uint8_t kTestQuestion[] = {
      // Invalid NAME: length byte too short
      0x03, 'i', 'n', 'v', 'a', 'l', 'i', 'd',
      0x00,
      0x00, 0x01,  // TYPE = A (1)
      0x00, 0x01,  // CLASS = IN (1)
  };
  // clang-format on
  TestReadEntryFails<MdnsQuestion>(kTestQuestion, sizeof(kTestQuestion));
}

TEST(MdnsReaderTest, ReadMdnsMessage) {
  // clang-format off
  constexpr uint8_t kTestMessage[] = {
      // Header
      0x00, 0x01,  // ID = 1
      0x84, 0x00,  // FLAGS = AA | RESPONSE
      0x00, 0x00,  // Questions = 0
      0x00, 0x01,  // Answers = 1
      0x00, 0x00,  // Authority = 0
      0x00, 0x01,  // Additional = 1
      // Record 1
      0x07, 'r', 'e', 'c', 'o', 'r', 'd', '1',
      0x00,
      0x00, 0x0c,              // TYPE = PTR (12)
      0x00, 0x01,              // CLASS = IN (1)
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x0f,              // RDLENGTH = 15 bytes
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      // Record 2
      0x07, 'r', 'e', 'c', 'o', 'r', 'd', '2',
      0x00,
      0x00, 0x01,              // TYPE = A (1)
      0x00, 0x01,              // CLASS = IN (1)
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x04,              // RDLENGTH = 4 bytes
      0xac, 0x00, 0x00, 0x01,  // 172.0.0.1
  };
  // clang-format on

  MdnsRecord record1(DomainName{"record1"}, DnsType::kPTR, DnsClass::kIN,
                     RecordType::kShared, kTtl,
                     PtrRecordRdata(DomainName{"testing", "local"}));
  MdnsRecord record2(DomainName{"record2"}, DnsType::kA, DnsClass::kIN,
                     RecordType::kShared, kTtl,
                     ARecordRdata(IPAddress{172, 0, 0, 1}));
  MdnsMessage message(1, MessageType::Response, std::vector<MdnsQuestion>{},
                      std::vector<MdnsRecord>{record1},
                      std::vector<MdnsRecord>{},
                      std::vector<MdnsRecord>{record2});
  TestReadEntrySucceeds(kTestMessage, sizeof(kTestMessage), message);
}

TEST(MdnsReaderTest, ReadMdnsMessage_MissingAnswerRecord) {
  // clang-format off
  constexpr uint8_t kInvalidMessage[] = {
      0x00, 0x00,  // ID = 0
      0x00, 0x00,  // FLAGS = 0
      0x00, 0x01,  // Questions = 1
      0x00, 0x01,  // Answers = 1
      0x00, 0x00,  // Authority = 0
      0x00, 0x00,  // Additional = 0
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      0x00, 0x0c,  // TYPE = PTR (12)
      0x00, 0x01,  // CLASS = IN (1)
      // NOTE: Missing answer record
  };
  // clang-format on
  TestReadEntryFails<MdnsMessage>(kInvalidMessage, sizeof(kInvalidMessage));
}

TEST(MdnsReaderTest, ReadMdnsMessage_MissingAdditionalRecord) {
  // clang-format off
  constexpr uint8_t kInvalidMessage[] = {
      0x00, 0x00,  // ID = 0
      0x00, 0x00,  // FLAGS = 0
      0x00, 0x00,  // Questions = 0
      0x00, 0x00,  // Answers = 0
      0x00, 0x00,  // Authority = 0
      0x00, 0x02,  // Additional = 2
      0x07, 't', 'e', 's', 't', 'i', 'n', 'g',
      0x05, 'l', 'o', 'c', 'a', 'l',
      0x00,
      0x00, 0x0c,              // TYPE = PTR (12)
      0x00, 0x01,              // CLASS = IN (1)
      0x00, 0x00, 0x00, 0x78,  // TTL = 120 seconds
      0x00, 0x00,              // RDLENGTH = 0
      // NOTE: Only 1 answer record is given.
  };
  // clang-format on
  TestReadEntryFails<MdnsMessage>(kInvalidMessage, sizeof(kInvalidMessage));
}

}  // namespace discovery
}  // namespace openscreen