/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "WinHeaderOnlyUtils.h"

#include <algorithm>

#include "gtest/gtest.h"
#include "mozilla/gtest/MozHelpers.h"

using namespace mozilla;

struct TestAcl {
  ACL acl{ACL_REVISION, 0, sizeof(TestAcl), 3, 0};
  ACCESS_ALLOWED_ACE ace1{
      {ACCESS_ALLOWED_ACE_TYPE, OBJECT_INHERIT_ACE, sizeof(ACCESS_ALLOWED_ACE)},
      GENERIC_READ,
      0};
  ACCESS_ALLOWED_OBJECT_ACE ace2{{ACCESS_ALLOWED_OBJECT_ACE_TYPE, INHERITED_ACE,
                                  sizeof(ACCESS_ALLOWED_OBJECT_ACE)},
                                 GENERIC_READ,
                                 0};
  ACCESS_DENIED_ACE ace3{
      {ACCESS_DENIED_ACE_TYPE, INHERITED_ACE, sizeof(ACCESS_DENIED_ACE)},
      GENERIC_READ,
      0};
  NotNull<ACL*> AsAclPtr() { return WrapNotNull(reinterpret_cast<ACL*>(this)); }
};

TEST(AclAceRange, SimpleCount)
{
  TestAcl testAcl;
  int aceCount = 0;
  for (const auto& aceHeader : AclAceRange(testAcl.AsAclPtr())) {
    Unused << aceHeader;
    ++aceCount;
  }

  ASSERT_EQ(aceCount, 3);
}

TEST(AclAceRange, SameAsGetAce)
{
  TestAcl testAcl;
  int aceIdx = 0;
  for (const auto& aceHeader : AclAceRange(testAcl.AsAclPtr())) {
    VOID* pGetAceHeader = nullptr;
    EXPECT_TRUE(::GetAce(testAcl.AsAclPtr(), aceIdx, &pGetAceHeader));
    auto* getAceHeader = static_cast<ACE_HEADER*>(pGetAceHeader);
    EXPECT_EQ(getAceHeader->AceType, aceHeader.AceType);
    EXPECT_EQ(getAceHeader->AceFlags, aceHeader.AceFlags);
    EXPECT_EQ(getAceHeader->AceSize, aceHeader.AceSize);
    ++aceIdx;
  }
}

TEST(AclAceRange, WithFlagCount)
{
  TestAcl testAcl;
  int aceCount = 0;
  for (const auto& aceHeader : AclAceRange(testAcl.AsAclPtr())) {
    if (aceHeader.AceFlags & INHERITED_ACE) {
      ++aceCount;
    }
  }

  ASSERT_EQ(aceCount, 2);
}

TEST(AclAceRange, AclSizeCheckedAsWellAsCount)
{
  TestAcl testAcl;
  testAcl.acl.AclSize -= sizeof(ACCESS_DENIED_ACE);
  int aceCount = 0;
  for (const auto& aceHeader : AclAceRange(testAcl.AsAclPtr())) {
    if (aceHeader.AceFlags & INHERITED_ACE) {
      ++aceCount;
    }
  }

  ASSERT_EQ(aceCount, 1);
}

TEST(AclAceRange, ChecksAceHeaderSizeInAclSize)
{
  TestAcl testAcl;
  testAcl.acl.AclSize -= 1;
  int aceCount = 0;
  for (const auto& aceHeader : AclAceRange(testAcl.AsAclPtr())) {
    if (aceHeader.AceFlags & INHERITED_ACE) {
      ++aceCount;
    }
  }

  ASSERT_EQ(aceCount, 1);
}

TEST(AclAceRange, AceCountOfZeroResultsInNoIterations)
{
  TestAcl testAcl;
  testAcl.acl.AceCount = 0;
  int aceCount = 0;
  for (const auto& aceHeader : AclAceRange(testAcl.AsAclPtr())) {
    Unused << aceHeader;
    ++aceCount;
  }

  ASSERT_EQ(aceCount, 0);
}

TEST(AclAceRange, AclSizeTooSmallForAnyAcesResultsInNoIterations)
{
  TestAcl testAcl;
  testAcl.acl.AclSize = sizeof(ACCESS_ALLOWED_ACE) - 1;
  int aceCount = 0;
  for (const auto& aceHeader : AclAceRange(testAcl.AsAclPtr())) {
    Unused << aceHeader;
    ++aceCount;
  }

  ASSERT_EQ(aceCount, 0);
}

TEST(AclAceRange, weakly_incrementable)
{
  TestAcl testAcl;
  AclAceRange aclAceRange(testAcl.AsAclPtr());
  auto iter = aclAceRange.begin();

  EXPECT_TRUE(std::addressof(++iter) == std::addressof(iter))
      << "addressof pre-increment result should match iterator";

  // pre and post increment advance iterator.
  EXPECT_EQ(iter->AceType, testAcl.ace2.Header.AceType);
  EXPECT_EQ(iter->AceFlags, testAcl.ace2.Header.AceFlags);
  EXPECT_EQ(iter->AceSize, testAcl.ace2.Header.AceSize);
  iter++;
  EXPECT_EQ(iter->AceType, testAcl.ace3.Header.AceType);
  EXPECT_EQ(iter->AceFlags, testAcl.ace3.Header.AceFlags);
  EXPECT_EQ(iter->AceSize, testAcl.ace3.Header.AceSize);

  // Moveable.
  auto moveConstructedIter(std::move(iter));
  EXPECT_EQ(moveConstructedIter->AceType, testAcl.ace3.Header.AceType);
  EXPECT_EQ(moveConstructedIter->AceFlags, testAcl.ace3.Header.AceFlags);
  EXPECT_EQ(moveConstructedIter->AceSize, testAcl.ace3.Header.AceSize);
  auto moveAssignedIter = std::move(iter);
  EXPECT_EQ(moveAssignedIter->AceType, testAcl.ace3.Header.AceType);
  EXPECT_EQ(moveAssignedIter->AceFlags, testAcl.ace3.Header.AceFlags);
  EXPECT_EQ(moveAssignedIter->AceSize, testAcl.ace3.Header.AceSize);
}

TEST(AclAceRange, incrementable)
{
  TestAcl testAcl;
  AclAceRange aclAceRange1(testAcl.AsAclPtr());
  AclAceRange aclAceRange2(testAcl.AsAclPtr());
  auto it1 = aclAceRange1.begin();
  auto it2 = aclAceRange2.begin();

  // bool(a == b) implies bool(a++ == b)
  EXPECT_TRUE(it1 == it2) << "begin iterators for same ACL should be equal";
  EXPECT_TRUE(it1++ == it2);
  EXPECT_FALSE(it1 == it2);
  EXPECT_FALSE(it1++ == it2);

  // bool(a == b) implies bool(((void)a++, a) == ++b)
  it1 = aclAceRange1.begin();
  EXPECT_TRUE(it1 == it2);
  EXPECT_TRUE(((void)it1++, it1) == ++it2);
  it1 = aclAceRange1.begin();
  EXPECT_FALSE(it1 == it2);
  EXPECT_FALSE(((void)it1++, it1) == ++it2);

  // Copyable.
  auto copyConstructedIter(it2);
  EXPECT_EQ(copyConstructedIter->AceType, testAcl.ace3.Header.AceType);
  EXPECT_EQ(copyConstructedIter->AceFlags, testAcl.ace3.Header.AceFlags);
  EXPECT_EQ(copyConstructedIter->AceSize, testAcl.ace3.Header.AceSize);
  auto copyAssignedIter = it2;
  EXPECT_EQ(copyAssignedIter->AceType, testAcl.ace3.Header.AceType);
  EXPECT_EQ(copyAssignedIter->AceFlags, testAcl.ace3.Header.AceFlags);
  EXPECT_EQ(copyAssignedIter->AceSize, testAcl.ace3.Header.AceSize);

  // Default constructable.
  AclAceRange::Iterator defaultConstructed;
  EXPECT_TRUE(defaultConstructed == aclAceRange1.end());
}

TEST(AclAceRange, AlgorithmCountIf)
{
  TestAcl testAcl;
  AclAceRange aclAceRange(testAcl.AsAclPtr());
  auto aceCount = std::count_if(
      aclAceRange.begin(), aclAceRange.end(),
      [](const auto& hdr) { return hdr.AceFlags & INHERITED_ACE; });

  ASSERT_EQ(aceCount, 2);
}

TEST(AclAceRange, AlgorithmAnyOf)
{
  TestAcl testAcl;
  AclAceRange aclAceRange(testAcl.AsAclPtr());
  auto anyInherited =
      std::any_of(aclAceRange.begin(), aclAceRange.end(),
                  [](const auto& hdr) { return hdr.AceFlags & INHERITED_ACE; });

  ASSERT_TRUE(anyInherited);
}

TEST(AclAceRange, DereferenceAtEndIsFatal)
{
#if DEBUG
  const auto* msg =
      "Assertion failure: mAceCount \\(Trying to dereference past end of "
      "AclAceRange\\)";
#else
  const auto* msg = "";
#endif

  EXPECT_DEATH_WRAP(
      {
        TestAcl testAcl;
        AclAceRange aclAceRange(testAcl.AsAclPtr());
        auto aceItCurrent = aclAceRange.begin();
        for (; aceItCurrent != aclAceRange.end(); ++aceItCurrent) {
        }
        *aceItCurrent;
      },
      msg);
}

TEST(AclAceRange, DebugAssertForIteratingPastEnd)
{
  EXPECT_DEBUG_DEATH_WRAP(
      {
        TestAcl testAcl;
        AclAceRange aclAceRange(testAcl.AsAclPtr());
        auto aceItCurrent = aclAceRange.begin();
        for (; aceItCurrent != aclAceRange.end(); ++aceItCurrent) {
        }
        ++aceItCurrent;
      },
      "Assertion failure: mAceCount \\(Iterating past end of AclAceRange\\)");
}