certificate_tag_unittest.cc | Explore in Territory

// 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.

#ifdef UNSAFE_BUFFERS_BUILD
// TODO(crbug.com/40285824): Remove this and convert code to safer constructs.
#pragma allow_unsafe_buffers
#endif

#include "chrome/updater/certificate_tag.h"

#include <cstdint>
#include <cstring>
#include <functional>
#include <memory>
#include <optional>
#include <vector>

#include "base/containers/span.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/memory_mapped_file.h"
#include "chrome/updater/certificate_tag_internal.h"
#include "chrome/updater/test/unit_test_util.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/zlib/google/compression_utils.h"

namespace updater::tagging {

TEST(CertificateTag, RoundTrip) { … }

namespace internal {

struct CertificateTagMsiIsLastInSectorTestCase { … };

class CertificateTagMsiIsLastInSectorTest
    : public ::testing::TestWithParam<CertificateTagMsiIsLastInSectorTestCase> { … };

INSTANTIATE_TEST_SUITE_P(…);

TEST_P(CertificateTagMsiIsLastInSectorTest, TestCases) { … }

struct CertificateTagMsiFirstFreeFatEntryTestCase { … };

class CertificateTagMsiFirstFreeFatEntryTest
    : public ::testing::TestWithParam<
          CertificateTagMsiFirstFreeFatEntryTestCase> { … };

INSTANTIATE_TEST_SUITE_P(…);

TEST_P(CertificateTagMsiFirstFreeFatEntryTest, TestCases) { … }

std::vector<uint32_t> GetFatEntries(int sectors, int free_entries) { … }

std::vector<uint32_t> GetDifatEntries(int sectors, int free_entries) { … }

MSIBinary GetMsiBinary(const std::vector<uint32_t>& fat_entries,
                       const std::vector<uint32_t>& difat_entries) { … }

std::vector<uint32_t> VerifyAndRemoveDifatChaining(
    std::vector<uint32_t> entries) { … }

void VerifyEntries(size_t added,
                   const std::vector<uint32_t>& changed_entries,
                   std::vector<uint32_t> old_entries,
                   std::vector<uint32_t> new_entries,
                   bool is_difat) { … }

struct CertificateTagMsiEnsureFreeDifatEntryTestCase { … };

class CertificateTagMsiEnsureFreeDifatEntryTest
    : public ::testing::TestWithParam<
          CertificateTagMsiEnsureFreeDifatEntryTestCase> { … };

INSTANTIATE_TEST_SUITE_P(…);

TEST_P(CertificateTagMsiEnsureFreeDifatEntryTest, TestCases) { … }

struct CertificateTagMsiEnsureFreeFatEntriesTestCase { … };

class CertificateTagMsiEnsureFreeFatEntriesTest
    : public ::testing::TestWithParam<
          CertificateTagMsiEnsureFreeFatEntriesTestCase> { … };

INSTANTIATE_TEST_SUITE_P(…);

TEST_P(CertificateTagMsiEnsureFreeFatEntriesTest, TestCases) { … }

struct CertificateTagMsiAssignDifatEntryTestCase { … };

class CertificateTagMsiAssignDifatEntryTest
    : public ::testing::TestWithParam<
          CertificateTagMsiAssignDifatEntryTestCase> { … };

INSTANTIATE_TEST_SUITE_P(…);

TEST_P(CertificateTagMsiAssignDifatEntryTest, TestCases) { … }

// Checks the provided `bin` MSIBinary for internal consistency. Additionally,
// if `other` MSIBinary is provided, checks that the data streams in `other` are
// bitwise identical to `bin`.
void Validate(const MSIBinary& bin,
              std::optional<std::reference_wrapper<const MSIBinary>> other) { … }

struct CertificateTagMsiValidateTestCase { … };

class CertificateTagMsiValidateTest
    : public ::testing::TestWithParam<CertificateTagMsiValidateTestCase> { … };

INSTANTIATE_TEST_SUITE_P(
    CertificateTagMsiValidateTestCases,
    CertificateTagMsiValidateTest,
    ::testing::ValuesIn(std::vector<CertificateTagMsiValidateTestCase>{ … };

TEST_P(CertificateTagMsiValidateTest, TestCases) { … }

}  // namespace internal

}  // namespace updater::tagging
chromium/chrome/updater/certificate_tag_unittest.cc
