chromium/third_party/openscreen/src/discovery/mdns/public/mdns_reader_unittest.cc

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

#include "discovery/mdns/public/mdns_reader.h"

#include <memory>
#include <sstream>
#include <string_view>

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

namespace openscreen::discovery {

namespace {

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

template <class T>
void TestReadEntrySucceeds(const uint8_t* data,
                           size_t size,
                           const T& expected) { … }

template <>
void TestReadEntrySucceeds<MdnsMessage>(const uint8_t* data,
                                        size_t size,
                                        const MdnsMessage& expected) { … }

template <class T>
void TestReadEntryFails(const uint8_t* data, size_t size) { … }

template <>
void TestReadEntryFails<MdnsMessage>(const uint8_t* data, size_t size) { … }
}  // namespace

TEST(MdnsReaderTest, ReadDomainName) { … }

TEST(MdnsReaderTest, ReadDomainName_Empty) { … }

TEST(MdnsReaderTest, ReadDomainName_TooShort) { … }

TEST(MdnsReaderTest, ReadDomainName_TooLong) { … }

TEST(MdnsReaderTest, ReadDomainName_LabelPointerOutOfBounds) { … }

TEST(MdnsReaderTest, ReadDomainName_InvalidLabel) { … }

TEST(MdnsReaderTest, ReadDomainName_CircularCompression) { … }

TEST(MdnsReaderTest, ReadRawRecordRdata) { … }

TEST(MdnsReaderTest, ReadRawRecordRdata_TooLong) { … }

TEST(MdnsReaderTest, ReadRawRecord_Empty) { … }

TEST(MdnsReaderTest, ReadRawRecordRdata_TooShort) { … }

TEST(MdnsReaderTest, ReadSrvRecordRdata) { … }

TEST(MdnsReaderTest, ReadSrvRecordRdata_TooShort) { … }

TEST(MdnsReaderTest, ReadSrvRecordRdata_WrongLength) { … }

TEST(MdnsReaderTest, ReadARecordRdata) { … }

TEST(MdnsReaderTest, ReadARecordRdata_TooShort) { … }

TEST(MdnsReaderTest, ReadARecordRdata_WrongLength) { … }

TEST(MdnsReaderTest, ReadAAAARecordRdata) { … }

TEST(MdnsReaderTest, ReadAAAARecordRdata_TooShort) { … }

TEST(MdnsReaderTest, ReadAAAARecordRdata_WrongLength) { … }

TEST(MdnsReaderTest, ReadPtrRecordRdata) { … }

TEST(MdnsReaderTest, ReadPtrRecordRdata_TooShort) { … }

TEST(MdnsReaderTest, ReadPtrRecordRdata_WrongLength) { … }

TEST(MdnsReaderTest, ReadTxtRecordRdata) { … }

TEST(MdnsReaderTest, ReadTxtRecordRdata_Empty) { … }

TEST(MdnsReaderTest, ReadTxtRecordRdata_WithNullInTheMiddle) { … }

TEST(MdnsReaderTest, ReadTxtRecordRdata_EmptyEntries) { … }

TEST(MdnsReaderTest, ReadTxtRecordRdata_TooLong) { … }

TEST(MdnsReaderTest, ReadNsecRecordRdata) { … }

TEST(MdnsReaderTest, ReadNsecRecordRdata_TooShort) { … }

TEST(MdnsReaderTest, ReadNsecRecordRdata_WrongLength) { … }

TEST(MdnsReaderTest, ReadMdnsRecord_ARecordRdata) { … }

TEST(MdnsReaderTest, ReadMdnsRecord_UnknownRecordType) { … }

TEST(MdnsReaderTest, ReadMdnsRecord_CompressedNames) { … }

TEST(MdnsReaderTest, ReadMdnsRecord_MissingRdata) { … }

TEST(MdnsReaderTest, ReadMdnsRecord_InvalidHostName) { … }

TEST(MdnsReaderTest, ReadMdnsQuestion) { … }

TEST(MdnsReaderTest, ReadMdnsQuestion_CompressedNames) { … }

TEST(MdnsReaderTest, ReadMdnsQuestion_InvalidHostName) { … }

TEST(MdnsReaderTest, ReadMdnsMessage) { … }

TEST(MdnsReaderTest, ReadMdnsMessage_MissingAnswerRecord) { … }

TEST(MdnsReaderTest, ReadMdnsMessage_MissingAdditionalRecord) { … }

}  // namespace openscreen::discovery