// Copyright 2017 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 "components/zucchini/zucchini_gen.h"

#include <stdint.h>

#include <utility>
#include <vector>

#include "components/zucchini/equivalence_map.h"
#include "components/zucchini/image_index.h"
#include "components/zucchini/image_utils.h"
#include "components/zucchini/test_disassembler.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace zucchini {

namespace {

using OffsetVector = std::vector<offset_t>;

// In normal usage, 0.0 is an unrealistic similarity value for an
// EquivalenceCandiate. Since similarity doesn't affect results for various unit
// tests in this file, we use this dummy value for simplicity.
constexpr double kDummySim = 0.0;

// Helper function wrapping GenerateReferencesDelta().
std::vector<int32_t> GenerateReferencesDeltaTest(
    std::vector<Reference>&& old_references,
    std::vector<Reference>&& new_references,
    std::vector<offset_t>&& exp_old_targets,
    std::vector<offset_t>&& exp_projected_old_targets,
    EquivalenceMap&& equivalence_map) {
  // OffsetMapper needs image sizes for forward-projection overflow check. These
  // are tested elsewhere, so just use arbitrary large value.
  constexpr offset_t kOldImageSize = 1000000;
  constexpr offset_t kNewImageSize = 1001000;

  ReferenceDeltaSink reference_delta_sink;

  TargetPool old_targets;
  old_targets.InsertTargets(old_references);
  ReferenceSet old_refs({1, TypeTag(0), PoolTag(0)}, old_targets);
  old_refs.InitReferences(old_references);
  EXPECT_EQ(exp_old_targets, old_targets.targets());

  TargetPool new_targets;
  new_targets.InsertTargets(new_references);
  ReferenceSet new_refs({1, TypeTag(0), PoolTag(0)}, new_targets);
  new_refs.InitReferences(new_references);

  OffsetMapper offset_mapper(equivalence_map, kOldImageSize, kNewImageSize);
  TargetPool projected_old_targets = old_targets;
  projected_old_targets.FilterAndProject(offset_mapper);

  std::vector<offset_t> extra_target =
      FindExtraTargets(projected_old_targets, new_targets);
  projected_old_targets.InsertTargets(extra_target);
  EXPECT_EQ(exp_projected_old_targets, projected_old_targets.targets());

  GenerateReferencesDelta(old_refs, new_refs, projected_old_targets,
                          offset_mapper, equivalence_map,
                          &reference_delta_sink);

  // Serialize |reference_delta_sink| to patch format, and read it back as
  // std::vector<int32_t>.
  std::vector<uint8_t> buffer(reference_delta_sink.SerializedSize());
  BufferSink sink(buffer.data(), buffer.size());
  reference_delta_sink.SerializeInto(&sink);

  BufferSource source(buffer.data(), buffer.size());
  ReferenceDeltaSource reference_delta_source;
  EXPECT_TRUE(reference_delta_source.Initialize(&source));
  std::vector<int32_t> delta_vec;
  for (auto delta = reference_delta_source.GetNext(); delta.has_value();
       delta = reference_delta_source.GetNext()) {
    delta_vec.push_back(*delta);
  }
  EXPECT_TRUE(reference_delta_source.Done());
  return delta_vec;
}

}  // namespace

TEST(ZucchiniGenTest, FindExtraTargets) {
  EXPECT_EQ(OffsetVector(), FindExtraTargets({}, {}));
  EXPECT_EQ(OffsetVector(), FindExtraTargets(TargetPool({3}), {}));
  EXPECT_EQ(OffsetVector(), FindExtraTargets(TargetPool({3}), TargetPool({3})));
  EXPECT_EQ(OffsetVector({4}),
            FindExtraTargets(TargetPool({3}), TargetPool({4})));
  EXPECT_EQ(OffsetVector({4}),
            FindExtraTargets(TargetPool({3}), TargetPool({3, 4})));
  EXPECT_EQ(OffsetVector({4}),
            FindExtraTargets(TargetPool({2, 3}), TargetPool({3, 4})));
  EXPECT_EQ(OffsetVector({3, 5}),
            FindExtraTargets(TargetPool({2, 4}), TargetPool({3, 5})));
}

TEST(ZucchiniGenTest, GenerateReferencesDelta) {
  // No equivalences.
  EXPECT_EQ(std::vector<int32_t>(),
            GenerateReferencesDeltaTest({}, {}, {}, {}, EquivalenceMap()));
  EXPECT_EQ(std::vector<int32_t>(),
            GenerateReferencesDeltaTest({{10, 0}}, {{20, 0}}, {0}, {0},
                                        EquivalenceMap()));

  // Simple cases with one equivalence.
  EXPECT_EQ(
      std::vector<int32_t>({0}),  // {0 - 0}.
      GenerateReferencesDeltaTest(
          {{10, 3}}, {{20, 3}}, {3}, {3},
          EquivalenceMap({{{3, 3, 1}, kDummySim}, {{10, 20, 4}, kDummySim}})));
  EXPECT_EQ(
      std::vector<int32_t>({-1}),  // {0 - 1}.
      GenerateReferencesDeltaTest(
          {{10, 3}}, {{20, 3}}, {3}, {3, 4},
          EquivalenceMap({{{3, 4, 1}, kDummySim}, {{10, 20, 4}, kDummySim}})));
  EXPECT_EQ(
      std::vector<int32_t>({1}),  // {1 - 0}.
      GenerateReferencesDeltaTest(
          {{10, 3}}, {{20, 3}}, {3}, {2, 3},
          EquivalenceMap({{{3, 2, 1}, kDummySim}, {{10, 20, 4}, kDummySim}})));
  EXPECT_EQ(std::vector<int32_t>({1, -1}),  // {1 - 0, 0 - 1}.
            GenerateReferencesDeltaTest(
                {{10, 3}, {11, 4}}, {{20, 3}, {21, 4}}, {3, 4}, {2, 3, 4, 5},
                EquivalenceMap({{{3, 2, 1}, kDummySim},
                                {{4, 5, 1}, kDummySim},
                                {{10, 20, 4}, kDummySim}})));

  EXPECT_EQ(
      std::vector<int32_t>({0, 0}),  // {1 - 1, 2 - 2}.
      GenerateReferencesDeltaTest(
          {{10, 3}, {11, 4}, {12, 5}, {13, 6}},
          {{20, 3}, {21, 4}, {22, 5}, {23, 6}}, {3, 4, 5, 6}, {3, 4, 5, 6},
          EquivalenceMap({{{3, 3, 4}, kDummySim}, {{11, 21, 2}, kDummySim}})));

  // Multiple equivalences.
  EXPECT_EQ(std::vector<int32_t>({-1, 1}),  // {0 - 1, 1 - 0}.
            GenerateReferencesDeltaTest(
                {{10, 0}, {12, 1}}, {{10, 0}, {12, 1}}, {0, 1}, {0, 1},
                EquivalenceMap({{{0, 0, 2}, kDummySim},
                                {{12, 10, 2}, kDummySim},
                                {{10, 12, 2}, kDummySim}})));
  EXPECT_EQ(
      std::vector<int32_t>({0, 0}),  // {0 - 0, 1 - 1}.
      GenerateReferencesDeltaTest(
          {{0, 0}, {2, 2}}, {{0, 0}, {2, 2}}, {0, 2}, {0, 2},
          EquivalenceMap({{{2, 0, 2}, kDummySim}, {{0, 2, 2}, kDummySim}})));

  EXPECT_EQ(std::vector<int32_t>({-2, 2}),  // {0 - 2, 2 - 0}.
            GenerateReferencesDeltaTest(
                {{10, 0}, {12, 1}, {14, 2}}, {{10, 0}, {12, 1}, {14, 2}},
                {0, 1, 2}, {0, 1, 2},
                EquivalenceMap({{{0, 0, 3}, kDummySim},
                                {{14, 10, 2}, kDummySim},
                                {{10, 14, 2}, kDummySim}})));

  EXPECT_EQ(std::vector<int32_t>({-2, 2}),  // {0 - 2, 2 - 0}.
            GenerateReferencesDeltaTest(
                {{11, 0}, {14, 1}, {17, 2}}, {{11, 0}, {14, 1}, {17, 2}},
                {0, 1, 2}, {0, 1, 2},
                EquivalenceMap({{{0, 0, 3}, kDummySim},
                                {{16, 10, 3}, kDummySim},
                                {{10, 16, 3}, kDummySim}})));

  EXPECT_EQ(
      std::vector<int32_t>({-2, 2}),  // {0 - 2, 2 - 0}.
      GenerateReferencesDeltaTest({{10, 0}, {14, 2}, {16, 1}},
                                  {{10, 0}, {14, 2}}, {0, 1, 2}, {0, 1, 2},
                                  EquivalenceMap({{{0, 0, 3}, kDummySim},
                                                  {{14, 10, 2}, kDummySim},
                                                  {{12, 12, 2}, kDummySim},
                                                  {{10, 14, 2}, kDummySim}})));
}

// TODO(huangs): Add more tests.

}  // namespace zucchini