path: root/equivalence_map_unittest.cc

// 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/equivalence_map.h"

#include <cstring>
#include <deque>
#include <map>
#include <string>
#include <utility>
#include <vector>

#include "components/zucchini/encoded_view.h"
#include "components/zucchini/image_index.h"
#include "components/zucchini/suffix_array.h"
#include "components/zucchini/targets_affinity.h"
#include "components/zucchini/test_disassembler.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace zucchini {

namespace {

using OffsetVector = std::vector<offset_t>;

// Make all references 2 bytes long.
constexpr offset_t kReferenceSize = 2;

// Creates and initialize an ImageIndex from |a| and with 2 types of references.
// The result is populated with |refs0| and |refs1|. |a| is expected to be a
// string literal valid for the lifetime of the object.
ImageIndex MakeImageIndexForTesting(const char* a,
                                    std::vector<Reference>&& refs0,
                                    std::vector<Reference>&& refs1) {
  TestDisassembler disasm(
      {kReferenceSize, TypeTag(0), PoolTag(0)}, std::move(refs0),
      {kReferenceSize, TypeTag(1), PoolTag(0)}, std::move(refs1),
      {kReferenceSize, TypeTag(2), PoolTag(1)}, {});

  ImageIndex image_index(
      ConstBufferView(reinterpret_cast<const uint8_t*>(a), std::strlen(a)));

  EXPECT_TRUE(image_index.Initialize(&disasm));
  return image_index;
}

std::vector<TargetsAffinity> MakeTargetsAffinitiesForTesting(
    const ImageIndex& old_image_index,
    const ImageIndex& new_image_index,
    const EquivalenceMap& equivalence_map) {
  std::vector<TargetsAffinity> target_affinities(old_image_index.PoolCount());
  for (const auto& old_pool_tag_and_targets : old_image_index.target_pools()) {
    PoolTag pool_tag = old_pool_tag_and_targets.first;
    target_affinities[pool_tag.value()].InferFromSimilarities(
        equivalence_map, old_pool_tag_and_targets.second.targets(),
        new_image_index.pool(pool_tag).targets());
  }
  return target_affinities;
}

}  // namespace

TEST(EquivalenceMapTest, GetTokenSimilarity) {
  ImageIndex old_index = MakeImageIndexForTesting(
      "ab1122334455", {{2, 0}, {4, 1}, {6, 2}, {8, 2}}, {{10, 3}});
  // Note: {4, 1} -> {6, 3} and {6, 2} -> {4, 1}, then result is sorted.
  ImageIndex new_index = MakeImageIndexForTesting(
      "a11b33224455", {{1, 0}, {4, 1}, {6, 3}, {8, 1}}, {{10, 2}});
  std::vector<TargetsAffinity> affinities = MakeTargetsAffinitiesForTesting(
      old_index, new_index,
      EquivalenceMap({{{0, 0, 1}, 1.0}, {{1, 3, 1}, 1.0}}));

  // Raw match.
  EXPECT_LT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 0, 0));
  // Raw mismatch.
  EXPECT_GT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 0, 1));
  EXPECT_GT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 1, 0));

  // Type mismatch.
  EXPECT_EQ(kMismatchFatal,
            GetTokenSimilarity(old_index, new_index, affinities, 0, 1));
  EXPECT_EQ(kMismatchFatal,
            GetTokenSimilarity(old_index, new_index, affinities, 2, 0));
  EXPECT_EQ(kMismatchFatal,
            GetTokenSimilarity(old_index, new_index, affinities, 2, 10));
  EXPECT_EQ(kMismatchFatal,
            GetTokenSimilarity(old_index, new_index, affinities, 10, 1));

  // Reference strong match.
  EXPECT_LT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 2, 1));
  EXPECT_LT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 4, 6));

  // Reference weak match.
  EXPECT_LT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 6, 4));
  EXPECT_LT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 6, 8));
  EXPECT_LT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 8, 4));

  // Weak match is not greater than strong match.
  EXPECT_LE(GetTokenSimilarity(old_index, new_index, affinities, 6, 4),
            GetTokenSimilarity(old_index, new_index, affinities, 2, 1));

  // Reference mismatch.
  EXPECT_GT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 2, 4));
  EXPECT_GT(0.0, GetTokenSimilarity(old_index, new_index, affinities, 2, 6));
}

TEST(EquivalenceMapTest, GetEquivalenceSimilarity) {
  ImageIndex image_index =
      MakeImageIndexForTesting("abcdef1122", {{6, 0}}, {{8, 1}});
  std::vector<TargetsAffinity> affinities =
      MakeTargetsAffinitiesForTesting(image_index, image_index, {});

  // Sanity check. These are no-op with length-0 equivalences.
  EXPECT_EQ(0.0, GetEquivalenceSimilarity(image_index, image_index, affinities,
                                          {0, 0, 0}));
  EXPECT_EQ(0.0, GetEquivalenceSimilarity(image_index, image_index, affinities,
                                          {0, 3, 0}));
  EXPECT_EQ(0.0, GetEquivalenceSimilarity(image_index, image_index, affinities,
                                          {3, 0, 0}));

  // Now examine larger equivalences.
  EXPECT_LT(0.0, GetEquivalenceSimilarity(image_index, image_index, affinities,
                                          {0, 0, 3}));
  EXPECT_GE(0.0, GetEquivalenceSimilarity(image_index, image_index, affinities,
                                          {0, 3, 3}));
  EXPECT_GE(0.0, GetEquivalenceSimilarity(image_index, image_index, affinities,
                                          {3, 0, 3}));

  EXPECT_LT(0.0, GetEquivalenceSimilarity(image_index, image_index, affinities,
                                          {6, 6, 4}));
}

TEST(EquivalenceMapTest, ExtendEquivalenceForward) {
  auto test_extend_forward =
      [](const ImageIndex old_index, const ImageIndex new_index,
         const EquivalenceCandidate& equivalence, double base_similarity) {
        return ExtendEquivalenceForward(
                   old_index, new_index,
                   MakeTargetsAffinitiesForTesting(old_index, new_index, {}),
                   equivalence, base_similarity)
            .eq;
      };

  EXPECT_EQ(Equivalence({0, 0, 0}),
            test_extend_forward(MakeImageIndexForTesting("", {}, {}),
                                MakeImageIndexForTesting("", {}, {}),
                                {{0, 0, 0}, 0.0}, 8.0));

  EXPECT_EQ(Equivalence({0, 0, 0}),
            test_extend_forward(MakeImageIndexForTesting("banana", {}, {}),
                                MakeImageIndexForTesting("zzzz", {}, {}),
                                {{0, 0, 0}, 0.0}, 8.0));

  EXPECT_EQ(Equivalence({0, 0, 6}),
            test_extend_forward(MakeImageIndexForTesting("banana", {}, {}),
                                MakeImageIndexForTesting("banana", {}, {}),
                                {{0, 0, 0}, 0.0}, 8.0));

  EXPECT_EQ(Equivalence({2, 2, 4}),
            test_extend_forward(MakeImageIndexForTesting("banana", {}, {}),
                                MakeImageIndexForTesting("banana", {}, {}),
                                {{2, 2, 0}, 0.0}, 8.0));

  EXPECT_EQ(Equivalence({0, 0, 6}),
            test_extend_forward(MakeImageIndexForTesting("bananaxx", {}, {}),
                                MakeImageIndexForTesting("bananayy", {}, {}),
                                {{0, 0, 0}, 0.0}, 8.0));

  EXPECT_EQ(
      Equivalence({0, 0, 8}),
      test_extend_forward(MakeImageIndexForTesting("banana11", {{6, 0}}, {}),
                          MakeImageIndexForTesting("banana11", {{6, 0}}, {}),
                          {{0, 0, 0}, 0.0}, 8.0));

  EXPECT_EQ(
      Equivalence({0, 0, 6}),
      test_extend_forward(MakeImageIndexForTesting("banana11", {{6, 0}}, {}),
                          MakeImageIndexForTesting("banana22", {}, {{6, 0}}),
                          {{0, 0, 0}, 0.0}, 8.0));

  EXPECT_EQ(
      Equivalence({0, 0, 17}),
      test_extend_forward(MakeImageIndexForTesting("bananaxxpineapple", {}, {}),
                          MakeImageIndexForTesting("bananayypineapple", {}, {}),
                          {{0, 0, 0}, 0.0}, 8.0));

  EXPECT_EQ(
      Equivalence({3, 0, 19}),
      test_extend_forward(
          MakeImageIndexForTesting("foobanana11xxpineapplexx", {{9, 0}}, {}),
          MakeImageIndexForTesting("banana11yypineappleyy", {{6, 0}}, {}),
          {{3, 0, 0}, 0.0}, 8.0));
}

TEST(EquivalenceMapTest, ExtendEquivalenceBackward) {
  auto test_extend_backward =
      [](const ImageIndex old_index, const ImageIndex new_index,
         const EquivalenceCandidate& equivalence, double base_similarity) {
        return ExtendEquivalenceBackward(
                   old_index, new_index,
                   MakeTargetsAffinitiesForTesting(old_index, new_index, {}),
                   equivalence, base_similarity)
            .eq;
      };

  EXPECT_EQ(Equivalence({0, 0, 0}),
            test_extend_backward(MakeImageIndexForTesting("", {}, {}),
                                 MakeImageIndexForTesting("", {}, {}),
                                 {{0, 0, 0}, 0.0}, 8.0));

  EXPECT_EQ(Equivalence({6, 4, 0}),
            test_extend_backward(MakeImageIndexForTesting("banana", {}, {}),
                                 MakeImageIndexForTesting("zzzz", {}, {}),
                                 {{6, 4, 0}, 0.0}, 8.0));

  EXPECT_EQ(Equivalence({0, 0, 6}),
            test_extend_backward(MakeImageIndexForTesting("banana", {}, {}),
                                 MakeImageIndexForTesting("banana", {}, {}),
                                 {{6, 6, 0}, 0.0}, 8.0));

  EXPECT_EQ(Equivalence({2, 2, 6}),
            test_extend_backward(MakeImageIndexForTesting("xxbanana", {}, {}),
                                 MakeImageIndexForTesting("yybanana", {}, {}),
                                 {{8, 8, 0}, 0.0}, 8.0));

  EXPECT_EQ(
      Equivalence({0, 0, 8}),
      test_extend_backward(MakeImageIndexForTesting("11banana", {{0, 0}}, {}),
                           MakeImageIndexForTesting("11banana", {{0, 0}}, {}),
                           {{8, 8, 0}, 0.0}, 8.0));

  EXPECT_EQ(
      Equivalence({2, 2, 6}),
      test_extend_backward(MakeImageIndexForTesting("11banana", {{0, 0}}, {}),
                           MakeImageIndexForTesting("22banana", {}, {{0, 0}}),
                           {{8, 8, 0}, 0.0}, 8.0));

  EXPECT_EQ(Equivalence({0, 0, 17}),
            test_extend_backward(
                MakeImageIndexForTesting("bananaxxpineapple", {}, {}),
                MakeImageIndexForTesting("bananayypineapple", {}, {}),
                {{8, 8, 9}, 9.0}, 8.0));

  EXPECT_EQ(
      Equivalence({3, 0, 19}),
      test_extend_backward(
          MakeImageIndexForTesting("foobanana11xxpineapplexx", {{9, 0}}, {}),
          MakeImageIndexForTesting("banana11yypineappleyy", {{6, 0}}, {}),
          {{22, 19, 0}, 0.0}, 8.0));
}

TEST(EquivalenceMapTest, PruneEquivalencesAndSortBySource) {
  auto PruneEquivalencesAndSortBySourceTest =
      [](std::vector<Equivalence>&& equivalences) {
        OffsetMapper::PruneEquivalencesAndSortBySource(&equivalences);
        return std::move(equivalences);
      };

  EXPECT_EQ(std::vector<Equivalence>(),
            PruneEquivalencesAndSortBySourceTest({}));
  EXPECT_EQ(std::vector<Equivalence>({{0, 10, 1}}),
            PruneEquivalencesAndSortBySourceTest({{0, 10, 1}}));
  EXPECT_EQ(std::vector<Equivalence>(),
            PruneEquivalencesAndSortBySourceTest({{0, 10, 0}}));
  EXPECT_EQ(std::vector<Equivalence>({{0, 10, 1}, {1, 11, 1}}),
            PruneEquivalencesAndSortBySourceTest({{0, 10, 1}, {1, 11, 1}}));
  EXPECT_EQ(std::vector<Equivalence>({{0, 10, 2}, {2, 13, 1}}),
            PruneEquivalencesAndSortBySourceTest({{0, 10, 2}, {1, 12, 2}}));
  EXPECT_EQ(std::vector<Equivalence>({{0, 10, 2}}),
            PruneEquivalencesAndSortBySourceTest({{0, 10, 2}, {1, 12, 1}}));
  EXPECT_EQ(std::vector<Equivalence>({{0, 10, 2}, {2, 14, 1}}),
            PruneEquivalencesAndSortBySourceTest({{0, 10, 2}, {1, 13, 2}}));
  EXPECT_EQ(std::vector<Equivalence>({{0, 10, 1}, {1, 12, 3}}),
            PruneEquivalencesAndSortBySourceTest({{0, 10, 2}, {1, 12, 3}}));
  EXPECT_EQ(std::vector<Equivalence>({{0, 10, 3}, {3, 16, 2}}),
            PruneEquivalencesAndSortBySourceTest(
                {{0, 10, 3}, {1, 13, 3}, {3, 16, 2}}));  // Pruning is greedy

  // Consider following pattern that may cause O(n^2) behavior if not handled
  // properly.
  //  ***************
  //            **********
  //             ********
  //              ******
  //               ****
  //                **
  //                 ***************
  // This test case makes sure the function does not stall on a large instance
  // of this pattern.
  EXPECT_EQ(std::vector<Equivalence>({{0, 10, +300000}, {300000, 30, +300000}}),
            PruneEquivalencesAndSortBySourceTest([] {
              std::vector<Equivalence> equivalenses;
              equivalenses.push_back({0, 10, +300000});
              for (offset_t i = 0; i < 100000; ++i)
                equivalenses.push_back({200000 + i, 20, +200000 - 2 * i});
              equivalenses.push_back({300000, 30, +300000});
              return equivalenses;
            }()));
}

TEST(EquivalenceMapTest, NaiveExtendedForwardProject) {
  constexpr size_t kOldImageSize = 1000U;
  constexpr size_t kNewImageSize = 1000U;
  OffsetMapper offset_mapper(std::vector<Equivalence>(), kOldImageSize,
                             kNewImageSize);

  // Convenience function to declutter.
  auto project = [&offset_mapper](const Equivalence& eq, offset_t offset) {
    return offset_mapper.NaiveExtendedForwardProject(eq, offset);
  };

  // Equivalence with delta = 0.
  Equivalence eq_stay = {10, 10, +5};  // [10,15) -> [10,15).
  for (offset_t offset = 0U; offset < 1000U; ++offset) {
    EXPECT_EQ(offset, project(eq_stay, offset));
  }
  // Saturate since result would overflow "new".
  EXPECT_EQ(999U, project(eq_stay, 1000U));
  EXPECT_EQ(999U, project(eq_stay, 2000U));
  EXPECT_EQ(999U, project(eq_stay, kOffsetBound - 1));

  // Equivalence with delta = -10.
  Equivalence eq_dec = {20, 10, +12};  // [20,32) --> [10,22).
  // Offsets in "old" block.
  EXPECT_EQ(10U, project(eq_dec, 20U));
  EXPECT_EQ(11U, project(eq_dec, 21U));
  EXPECT_EQ(21U, project(eq_dec, 31U));
  // Offsets before "old" block, no underflow
  EXPECT_EQ(9U, project(eq_dec, 19U));
  EXPECT_EQ(1U, project(eq_dec, 11U));
  EXPECT_EQ(0U, project(eq_dec, 10U));
  // Offsets before "old" block, underflow (possible since delta < 0).
  EXPECT_EQ(0U, project(eq_dec, 9U));
  EXPECT_EQ(0U, project(eq_dec, 5U));
  EXPECT_EQ(0U, project(eq_dec, 0U));
  // Offsets after "old" block, no overflow.
  EXPECT_EQ(20U, project(eq_dec, 30U));
  EXPECT_EQ(64U, project(eq_dec, 74U));
  EXPECT_EQ(90U, project(eq_dec, 100U));
  EXPECT_EQ(490U, project(eq_dec, 500U));
  EXPECT_EQ(999U, project(eq_dec, 1009U));
  // Offsets after "old" block, overflow.
  EXPECT_EQ(999U, project(eq_dec, 1010U));
  EXPECT_EQ(999U, project(eq_dec, 2000U));
  EXPECT_EQ(999U, project(eq_dec, kOffsetBound - 1));

  // Equivalence with delta = +10.
  Equivalence eq_inc = {7, 17, +80};  // [7,87) --> [17,97).
  // Offsets in "old" block.
  EXPECT_EQ(17U, project(eq_inc, 7U));
  EXPECT_EQ(60U, project(eq_inc, 50U));
  EXPECT_EQ(96U, project(eq_inc, 86U));
  // Offsets before "old" block, underflow impossible since delta >= 0.
  EXPECT_EQ(16U, project(eq_inc, 6U));
  EXPECT_EQ(10U, project(eq_inc, 0U));
  // Offsets after "old" block, no overflow.
  EXPECT_EQ(97U, project(eq_inc, 87U));
  EXPECT_EQ(510U, project(eq_inc, 500U));
  EXPECT_EQ(999U, project(eq_inc, 989U));
  // Offsets after "old" block, overflow.
  EXPECT_EQ(999U, project(eq_inc, 990U));
  EXPECT_EQ(999U, project(eq_inc, 2000U));
  EXPECT_EQ(999U, project(eq_inc, kOffsetBound - 1));
}

TEST(EquivalenceMapTest, ExtendedForwardProject) {
  // EquivalenceMaps provided must be sorted by "old" offset, and pruned.
  // [0,2) --> [10,12), [2,3) --> [13,14), [4,6) --> [16,18).
  OffsetMapper offset_mapper1({{0, 10, +2}, {2, 13, +1}, {4, 16, +2}}, 20U,
                              25U);
  EXPECT_EQ(10U, offset_mapper1.ExtendedForwardProject(0U));
  EXPECT_EQ(11U, offset_mapper1.ExtendedForwardProject(1U));
  EXPECT_EQ(13U, offset_mapper1.ExtendedForwardProject(2U));
  EXPECT_EQ(14U, offset_mapper1.ExtendedForwardProject(3U));  // Previous equiv.
  EXPECT_EQ(16U, offset_mapper1.ExtendedForwardProject(4U));
  EXPECT_EQ(17U, offset_mapper1.ExtendedForwardProject(5U));
  EXPECT_EQ(18U, offset_mapper1.ExtendedForwardProject(6U));  // Previous equiv.
  // Fake offsets.
  EXPECT_EQ(25U, offset_mapper1.ExtendedForwardProject(20U));
  EXPECT_EQ(26U, offset_mapper1.ExtendedForwardProject(21U));
  EXPECT_EQ(1005U, offset_mapper1.ExtendedForwardProject(1000U));
  EXPECT_EQ(kOffsetBound - 1,
            offset_mapper1.ExtendedForwardProject(kOffsetBound - 1));

  // [0,2) --> [10,12), [13,14) --> [2,3), [16,18) --> [4,6).
  OffsetMapper offset_mapper2({{0, 10, +2}, {13, 2, +1}, {16, 4, +2}}, 25U,
                              20U);
  EXPECT_EQ(10U, offset_mapper2.ExtendedForwardProject(0U));
  EXPECT_EQ(11U, offset_mapper2.ExtendedForwardProject(1U));
  EXPECT_EQ(2U, offset_mapper2.ExtendedForwardProject(13U));
  EXPECT_EQ(3U, offset_mapper2.ExtendedForwardProject(14U));  // Previous equiv.
  EXPECT_EQ(4U, offset_mapper2.ExtendedForwardProject(16U));
  EXPECT_EQ(5U, offset_mapper2.ExtendedForwardProject(17U));
  EXPECT_EQ(6U, offset_mapper2.ExtendedForwardProject(18U));  // Previous equiv.
  // Fake offsets.
  EXPECT_EQ(20U, offset_mapper2.ExtendedForwardProject(25U));
  EXPECT_EQ(21U, offset_mapper2.ExtendedForwardProject(26U));
  EXPECT_EQ(995U, offset_mapper2.ExtendedForwardProject(1000U));
  EXPECT_EQ(kOffsetBound - 1 - 5,
            offset_mapper2.ExtendedForwardProject(kOffsetBound - 1));
}

TEST(EquivalenceMapTest, ExtendedForwardProjectEncoding) {
  // Tests OffsetMapper::ExtendedForwardProject(), which maps every "old" offset
  // to a "new" offset, with possible overlap (even though blocks don't
  // overlap). Not testing real offsets only (no fake offsets).
  // |old_spec| is a string like "<<aaAAaabbBBbcCCc>>":
  // - Upper case letters are covered "old" offsets.
  // - Lower case letters are non-covered offsets that are properly mapped using
  //   nearest "old" block.
  // - '<' denotes underflow (clamped to 0).
  // - '>' denotes overflow (clampled to "new" size - 1).
  // |new_spec| is a string like "aaAA(ab)(ab)BBb..cCCc":
  // - Upper and lower case letters are mapped "new" targets, occurring in the
  //   order that they appear in |old_spec|.
  // - '.' are "new" offsets that appear as output.
  // - '(' and ')' surround a single "new" location that are repeated as output.
  int case_no = 0;
  auto run_test = [&case_no](std::vector<Equivalence>&& equivalences,
                             const std::string& old_spec,
                             const std::string& new_spec) {
    const size_t old_size = old_spec.length();
    // Build expected "new" offsets, queue up for each letter.
    std::map<char, std::deque<offset_t>> expected;
    offset_t cur_new_offset = 0;
    char state = ')';  // ')' = increase offset, '(' = stay.
    for (char ch : new_spec) {
      if (ch == '(' || ch == ')')
        state = ch;
      else
        expected[ch].push_back(cur_new_offset);
      cur_new_offset += (state == ')') ? 1 : 0;
    }
    const size_t new_size = cur_new_offset;
    // Forward-project for each "old" index, pull from queue from matching
    // letter, and compare.
    OffsetMapper offset_mapper(std::move(equivalences), old_size, new_size);
    for (offset_t old_offset = 0; old_offset < old_size; ++old_offset) {
      offset_t new_offset = offset_mapper.ExtendedForwardProject(old_offset);
      char ch = old_spec[old_offset];
      if (ch == '<') {  // Special case: Underflow.
        EXPECT_EQ(0U, new_offset) << "in case " << case_no;
      } else if (ch == '>') {  // Special case: Overflow.
        EXPECT_EQ(static_cast<offset_t>(new_size - 1), new_offset)
            << "in case " << case_no;
      } else {
        std::deque<offset_t>& q = expected[ch];
        ASSERT_FALSE(q.empty());
        EXPECT_EQ(q.front(), new_offset) << "in case " << case_no;
        q.pop_front();
        if (q.empty())
          expected.erase(ch);
      }
    }
    // Clear useless '.', and ensure everything is consumed.
    expected.erase('.');
    EXPECT_TRUE(expected.empty()) << "in case " << case_no;
    ++case_no;
  };

  // Trivial: [5,9) --> [5,9).
  run_test({{5, 5, +4}}, "aaaaaAAAAaaaaa", "aaaaaAAAAaaaaa");
  // Swap: [0,4) --> [6,10), [4,10) --> [0,6).
  run_test({{0, 6, +4}, {4, 0, +6}}, "AAAABBBBBB", "BBBBBBAAAA");
  // Overlap: [0,4) --> [2,6), [4,10) --> [3,9).
  run_test({{0, 2, +4}, {4, 3, +6}}, "AAAABBBBBB", "..A(AB)(AB)(AB)BBB.");
  // Converge: [1,3) --> [2,4), [7,8) --> [6,7).
  run_test({{1, 2, +2}, {7, 6, +1}}, "aAAaabbBbb", ".aAA(ab)(ab)Bbb.");
  // Converge with tie-breaker: [1,3) --> [2,4), [8,9) --> [7,8).
  run_test({{1, 2, +2}, {8, 7, +1}}, "aAAaaabbBb", ".aAAa(ab)(ab)Bb.");
  // Shift left: [6,8) --> [2,4): Underflow occurs.
  run_test({{6, 2, +2}}, "<<<<aaAAaa", "aaAAaa....");
  // Shift right: [2,5) --> [6,9): Overflow occurs.
  run_test({{2, 6, +3}}, "aaAAAa>>>>", "....aaAAAa");
  // Diverge: [3,5) --> [1,3], [7,9) --> [9,11).
  run_test({{3, 1, +2}, {7, 9, +2}}, "<<aAAabBBb>>", "aAAa....bBBb");
  // Pile-up: [0,2) --> [7,9), [9,11) --> [9,11), [18,20) --> [11,13).
  run_test({{0, 7, +2}, {9, 9, +2}, {18, 11, +2}}, "AAaaaabbbBBbbbbcccCC",
           "......b(Ab)(Abc)(Bac)(Bac)(Cab)(Cab)bb.....");
  // Inverse pile-up: [7,9) --> [0,2), [9,11) --> [9,11), [13,15) --> [18,20).
  run_test({{7, 0, +2}, {9, 9, +2}, {11, 18, +2}}, "<<<<<<<AABBCC>>>>>>>",
           "AA.......BB.......CC");
  // Sparse rotate: [3,4) -> [10,11), [10,11) --> [17,18), [17,18) --> [3,4).
  run_test({{3, 10, +1}, {10, 17, +1}, {17, 3, +1}}, "aaaAaaabbbBbbbcccCccc",
           "cccCcccaaaAaaabbbBbbb");
  // Messy swap: [2,4) --> [10,12), [12,16) --> [3,7).
  run_test({{2, 10, +2}, {12, 3, +4}}, "aaAAaa>><bbbBBBBbb",
           "bbbBBBBb(ab)aAAaa");
  // Messy expand: [6,8) --> [3,5), [10,11) -> [11,12), [14,17) --> [16,19).
  run_test({{6, 3, +2}, {10, 11, +1}, {14, 16, +3}}, "<<<aaaAAabBbbcCCCc>>>>>",
           "aaaAAa....bBbb.cCCCc");
  // Interleave: [1,2) --> [0,1), [5,6) --> [10,11), [6,8) --> [3,5),
  //             [11,13) --> [12,14), [14,16) --> [6,8), [17,18) --> [17,18).
  run_test({{1, 0, +1},
            {5, 10, +1},
            {6, 3, +2},
            {11, 12, +2},
            {14, 6, +2},
            {17, 17, +1}},
           "<AaabBCCccdDDdEEeFf>", "AaaCCc(Ec)EebBdDDd..Ff");
}

TEST(EquivalenceMapTest, ForwardProjectAll) {
  auto ForwardProjectAllTest = [](const OffsetMapper& offset_mapper,
                                  std::initializer_list<offset_t> offsets) {
    OffsetVector offsets_vec(offsets);
    offset_mapper.ForwardProjectAll(&offsets_vec);
    return offsets_vec;
  };

  // [0,2) --> [10,12), [2,3) --> [13,14), [4,6) --> [16,18).
  OffsetMapper offset_mapper1({{0, 10, +2}, {2, 13, +1}, {4, 16, +2}}, 100U,
                              100U);
  EXPECT_EQ(OffsetVector({10}), ForwardProjectAllTest(offset_mapper1, {0}));
  EXPECT_EQ(OffsetVector({13}), ForwardProjectAllTest(offset_mapper1, {2}));
  EXPECT_EQ(OffsetVector({}), ForwardProjectAllTest(offset_mapper1, {3}));
  EXPECT_EQ(OffsetVector({10, 13}),
            ForwardProjectAllTest(offset_mapper1, {0, 2}));
  EXPECT_EQ(OffsetVector({11, 13, 17}),
            ForwardProjectAllTest(offset_mapper1, {1, 2, 5}));
  EXPECT_EQ(OffsetVector({11, 17}),
            ForwardProjectAllTest(offset_mapper1, {1, 3, 5}));
  EXPECT_EQ(OffsetVector({10, 11, 13, 16, 17}),
            ForwardProjectAllTest(offset_mapper1, {0, 1, 2, 3, 4, 5, 6}));

  // [0,2) --> [10,12), [13,14) --> [2,3), [16,18) --> [4,6).
  OffsetMapper offset_mapper2({{0, 10, +2}, {13, 2, +1}, {16, 4, +2}}, 100U,
                              100U);
  EXPECT_EQ(OffsetVector({2}), ForwardProjectAllTest(offset_mapper2, {13}));
  EXPECT_EQ(OffsetVector({10, 2}),
            ForwardProjectAllTest(offset_mapper2, {0, 13}));
  EXPECT_EQ(OffsetVector({11, 2, 5}),
            ForwardProjectAllTest(offset_mapper2, {1, 13, 17}));
  EXPECT_EQ(OffsetVector({11, 5}),
            ForwardProjectAllTest(offset_mapper2, {1, 14, 17}));
  EXPECT_EQ(OffsetVector({10, 11, 2, 4, 5}),
            ForwardProjectAllTest(offset_mapper2, {0, 1, 13, 14, 16, 17, 18}));
}

TEST(EquivalenceMapTest, Build) {
  auto test_build_equivalence = [](const ImageIndex old_index,
                                   const ImageIndex new_index,
                                   double minimum_similarity) {
    auto affinities = MakeTargetsAffinitiesForTesting(old_index, new_index, {});

    EncodedView old_view(old_index);
    EncodedView new_view(new_index);

    for (const auto& old_pool_tag_and_targets : old_index.target_pools()) {
      PoolTag pool_tag = old_pool_tag_and_targets.first;
      std::vector<uint32_t> old_labels;
      std::vector<uint32_t> new_labels;
      size_t label_bound = affinities[pool_tag.value()].AssignLabels(
          1.0, &old_labels, &new_labels);
      old_view.SetLabels(pool_tag, std::move(old_labels), label_bound);
      new_view.SetLabels(pool_tag, std::move(new_labels), label_bound);
    }

    std::vector<offset_t> old_sa =
        MakeSuffixArray<InducedSuffixSort>(old_view, old_view.Cardinality());

    EquivalenceMap equivalence_map;
    equivalence_map.Build(old_sa, old_view, new_view, affinities,
                          minimum_similarity);

    offset_t current_dst_offset = 0;
    offset_t coverage = 0;
    for (const auto& candidate : equivalence_map) {
      EXPECT_GE(candidate.eq.dst_offset, current_dst_offset);
      EXPECT_GT(candidate.eq.length, offset_t(0));
      EXPECT_LE(candidate.eq.src_offset + candidate.eq.length,
                old_index.size());
      EXPECT_LE(candidate.eq.dst_offset + candidate.eq.length,
                new_index.size());
      EXPECT_GE(candidate.similarity, minimum_similarity);
      current_dst_offset = candidate.eq.dst_offset;
      coverage += candidate.eq.length;
    }
    return coverage;
  };

  EXPECT_EQ(0U,
            test_build_equivalence(MakeImageIndexForTesting("", {}, {}),
                                   MakeImageIndexForTesting("", {}, {}), 4.0));

  EXPECT_EQ(0U, test_build_equivalence(
                    MakeImageIndexForTesting("", {}, {}),
                    MakeImageIndexForTesting("banana", {}, {}), 4.0));

  EXPECT_EQ(0U,
            test_build_equivalence(MakeImageIndexForTesting("banana", {}, {}),
                                   MakeImageIndexForTesting("", {}, {}), 4.0));

  EXPECT_EQ(0U, test_build_equivalence(
                    MakeImageIndexForTesting("banana", {}, {}),
                    MakeImageIndexForTesting("zzzz", {}, {}), 4.0));

  EXPECT_EQ(6U, test_build_equivalence(
                    MakeImageIndexForTesting("banana", {}, {}),
                    MakeImageIndexForTesting("banana", {}, {}), 4.0));

  EXPECT_EQ(6U, test_build_equivalence(
                    MakeImageIndexForTesting("bananaxx", {}, {}),
                    MakeImageIndexForTesting("bananayy", {}, {}), 4.0));

  EXPECT_EQ(8U, test_build_equivalence(
                    MakeImageIndexForTesting("banana11", {{6, 0}}, {}),
                    MakeImageIndexForTesting("banana11", {{6, 0}}, {}), 4.0));

  EXPECT_EQ(6U, test_build_equivalence(
                    MakeImageIndexForTesting("banana11", {{6, 0}}, {}),
                    MakeImageIndexForTesting("banana22", {}, {{6, 0}}), 4.0));

  EXPECT_EQ(
      15U,
      test_build_equivalence(
          MakeImageIndexForTesting("banana11pineapple", {{6, 0}}, {}),
          MakeImageIndexForTesting("banana22pineapple", {}, {{6, 0}}), 4.0));

  EXPECT_EQ(
      15U,
      test_build_equivalence(
          MakeImageIndexForTesting("bananaxxxxxxxxpineapple", {}, {}),
          MakeImageIndexForTesting("bananayyyyyyyypineapple", {}, {}), 4.0));

  EXPECT_EQ(
      19U,
      test_build_equivalence(
          MakeImageIndexForTesting("foobanana11xxpineapplexx", {{9, 0}}, {}),
          MakeImageIndexForTesting("banana11yypineappleyy", {{6, 0}}, {}),
          4.0));
}

}  // namespace zucchini