[Courgette] Refactor LabelManager.

courgette/label_manager_unittest.cc

 // Copyright 2015 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 "courgette/label_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <iterator>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "courgette/image_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace courgette {
 
 namespace {
 
-// Test version of RvaVisitor: Just wrap std::vector<RVA>.
-class TestRvaVisitor : public LabelManagerImpl::RvaVisitor {
+class TestLabelManager : public LabelManager {
  public:
-  explicit TestRvaVisitor(std::vector<RVA>::const_iterator rva_begin,
-                          std::vector<RVA>::const_iterator rva_end)
-      : rva_it_(rva_begin), rva_end_(rva_end) {}
-
-  ~TestRvaVisitor() override {}
-
-  size_t Remaining() const override { return std::distance(rva_it_, rva_end_); }
-
-  RVA Get() const override { return *rva_it_; }
-
-  void Next() override { ++rva_it_; }
-
- private:
-  std::vector<RVA>::const_iterator rva_it_;
-  std::vector<RVA>::const_iterator rva_end_;
+  void SetLabels(const LabelVector& labels) {
+    labels_ = labels;
+  };
 };
 
 void CheckLabelManagerContent(LabelManager* label_manager,
                               const std::map<RVA, int32_t>& expected) {
-  EXPECT_EQ(expected.size(), label_manager->Size());
+  EXPECT_EQ(expected.size(), label_manager->Labels().size());
   for (const auto& rva_and_count : expected) {
     Label* label = label_manager->Find(rva_and_count.first);
     EXPECT_TRUE(label != nullptr);
     EXPECT_EQ(rva_and_count.first, label->rva_);
     EXPECT_EQ(rva_and_count.second, label->count_);
   }
 }
 
 // Instantiates a LabelVector with |n| instances. The |rva_| fields are assigned
 // 0, ..., |n| - 1. The other fields are uninitialized.
@@ skipping 46 matching lines @@
     else if (label.index_ >= 0 && label.index_ <= 'Z' - 'A')
       encoded += static_cast<char>(label.index_ + 'A');
     else
       NOTREACHED();
   }
   return encoded;
 }
 
 }  // namespace
 
-TEST(LabelManagerTest, GetIndexBound_LabelVector) {
+TEST(LabelManagerTest, GetLabelIndexBound) {
   LabelVector labels0;
-  EXPECT_EQ(0, LabelManager::GetIndexBound(labels0));
+  EXPECT_EQ(0, LabelManager::GetLabelIndexBound(labels0));
 
   LabelVector labels1_uninit = CreateLabelVectorBasic(1);
   ASSERT_EQ(1U, labels1_uninit.size());
-  EXPECT_EQ(0, LabelManager::GetIndexBound(labels1_uninit));
+  EXPECT_EQ(0, LabelManager::GetLabelIndexBound(labels1_uninit));
 
   LabelVector labels1_init = CreateLabelVectorBasic(1);
   ASSERT_EQ(1U, labels1_init.size());
   labels1_init[0].index_ = 99;
-  EXPECT_EQ(100, LabelManager::GetIndexBound(labels1_init));
+  EXPECT_EQ(100, LabelManager::GetLabelIndexBound(labels1_init));
 
   LabelVector labels6_mixed = CreateLabelVectorBasic(6);
   ASSERT_EQ(6U, labels6_mixed.size());
   labels6_mixed[1].index_ = 5;
   labels6_mixed[2].index_ = 2;
   labels6_mixed[4].index_ = 15;
   labels6_mixed[5].index_ = 7;
-  EXPECT_EQ(16, LabelManager::GetIndexBound(labels6_mixed));
-}
-
-TEST(LabelManagerTest, GetIndexBound_RVAToLabel) {
-  RVAToLabel labels_map0;
-  EXPECT_EQ(0, LabelManager::GetIndexBound(labels_map0));
-
-  RVAToLabel labels1_map_init;
-  Label label1(static_cast<RVA>(0), 99, 1);
-  labels1_map_init[label1.rva_] = &label1;
-  EXPECT_EQ(100, LabelManager::GetIndexBound(labels1_map_init));
-
-  RVAToLabel labels_map6_mixed;
-  Label labels6[] = {
-    Label(static_cast<RVA>(1), 5, 1),
-    Label(static_cast<RVA>(2), 2, 1),
-    Label(static_cast<RVA>(4), 15, 1),
-    Label(static_cast<RVA>(5), 7, 1)
-  };
-  for (Label& label : labels6)
-    labels_map6_mixed[label.rva_] = &label;
-  EXPECT_EQ(16, LabelManager::GetIndexBound(labels_map6_mixed));
+  EXPECT_EQ(16, LabelManager::GetLabelIndexBound(labels6_mixed));
 }
 
 TEST(LabelManagerTest, Basic) {
   static const RVA kTestTargetsRaw[] = {
     0x04000010,
     0x04000030,
     0x04000020,
     0x04000010,  // Redundant.
     0xFEEDF00D,
     0x04000030,  // Redundant.
     0xFEEDF00D,  // Redundant.
     0x00000110,
     0x04000010,  // Redundant.
     0xABCD1234
   };
   std::vector<RVA> test_targets(std::begin(kTestTargetsRaw),
                                 std::end(kTestTargetsRaw));
-  TestRvaVisitor visitor(test_targets.begin(), test_targets.end());
+  TrivialRvaVisitor visitor(test_targets);
 
   // Preallocate targets, then populate.
-  LabelManagerImpl label_manager;
+  TestLabelManager label_manager;
   label_manager.Read(&visitor);
 
   static const std::pair<RVA, int32_t> kExpected1Raw[] = {
       {0x00000110, 1}, {0x04000010, 3}, {0x04000020, 1},
       {0x04000030, 2}, {0xABCD1234, 1}, {0xFEEDF00D, 2}};
   std::map<RVA, int32_t> expected1(std::begin(kExpected1Raw),
                                    std::end(kExpected1Raw));
 
   CheckLabelManagerContent(&label_manager, expected1);
 
@@ skipping 12 matching lines @@
   std::map<RVA, int32_t> expected2(std::begin(kExpected2Raw),
                                    std::end(kExpected2Raw));
   CheckLabelManagerContent(&label_manager, expected2);
 }
 
 TEST(LabelManagerTest, Single) {
   const RVA kRva = 12U;
   for (int dup = 1; dup < 8; ++dup) {
     // Test data: |dup| copies of kRva.
     std::vector<RVA> test_targets(dup, kRva);
-    TestRvaVisitor visitor(test_targets.begin(), test_targets.end());
-    LabelManagerImpl label_manager;
+    TrivialRvaVisitor visitor(test_targets);
+    TestLabelManager label_manager;
     label_manager.Read(&visitor);
-    EXPECT_EQ(1U, label_manager.Size());  // Deduped to 1 Label.
+    EXPECT_EQ(1U, label_manager.Labels().size());  // Deduped to 1 Label.
 
     Label* label = label_manager.Find(kRva);
     EXPECT_NE(nullptr, label);
     EXPECT_EQ(kRva, label->rva_);
     EXPECT_EQ(dup, label->count_);
 
     for (RVA rva = 0U; rva < 16U; ++rva) {
       if (rva != kRva)
         EXPECT_EQ(nullptr, label_manager.Find(rva));
     }
   }
 }
 
 TEST(LabelManagerTest, Empty) {
   std::vector<RVA> empty_test_targets;
-  TestRvaVisitor visitor(empty_test_targets.begin(), empty_test_targets.end());
-  LabelManagerImpl label_manager;
+  TrivialRvaVisitor visitor(empty_test_targets);
+  TestLabelManager label_manager;
   label_manager.Read(&visitor);
-  EXPECT_EQ(0U, label_manager.Size());
+  EXPECT_EQ(0U, label_manager.Labels().size());
   for (RVA rva = 0U; rva < 16U; ++rva)
     EXPECT_EQ(nullptr, label_manager.Find(rva));
 }
 
 TEST(LabelManagerTest, EmptyAssign) {
-  LabelManagerImpl label_manager_empty;
+  TestLabelManager label_manager_empty;
   label_manager_empty.DefaultAssignIndexes();
   label_manager_empty.UnassignIndexes();
   label_manager_empty.AssignRemainingIndexes();
 }
 
 TEST(LabelManagerTest, TrivialAssign) {
   for (size_t size = 0; size < 20; ++size) {
-    LabelManagerImpl label_manager;
+    TestLabelManager label_manager;
     label_manager.SetLabels(CreateLabelVectorBasic(size));
 
     // Sanity check.
     for (size_t i = 0; i < size; ++i)
       EXPECT_EQ(Label::kNoIndex, label_manager.Labels()[i].index_);
 
     // Default assign.
     label_manager.DefaultAssignIndexes();
     for (size_t i = 0; i < size; ++i)
       EXPECT_EQ(static_cast<int>(i), label_manager.Labels()[i].index_);
 
     // Heuristic assign, but since everything's assigned, so no change.
     label_manager.AssignRemainingIndexes();
     for (size_t i = 0; i < size; ++i)
       EXPECT_EQ(static_cast<int>(i), label_manager.Labels()[i].index_);
 
     // Unassign.
     label_manager.UnassignIndexes();
     for (size_t i = 0; i < size; ++i)
       EXPECT_EQ(Label::kNoIndex, label_manager.Labels()[i].index_);
   }
 }
 
 // Tests SimpleIndexAssigner fill strategies independently.
 TEST(LabelManagerTest, SimpleIndexAssigner) {
-  using SimpleIndexAssigner = LabelManagerImpl::SimpleIndexAssigner;
+  using SimpleIndexAssigner = LabelManager::SimpleIndexAssigner;
   // See CreateLabelVectorWithIndexes() explanation on how we encode LabelVector
   // |index_| values as a string.
   const struct TestCase {
     const char* input;
     const char* expect_forward;
     const char* expect_backward;
     const char* expect_in;
   } kTestCases[] = {
     {"", "", "", ""},
     {".", "A", "A", "A"},
@@ skipping 96 matching lines @@
     {"DA.....", "DABCEFG"},  // Forward: "BC"; backward: "EFG".
     // Backward fill and infill.
     {"G....DA", "GEFBCDA"},  // Backward: "BC"; in: "EF".
     {"..ZBA..", "XYZBACD"},  // Backward: "XY"; in: "CD".
     // All.
     {".....ZED.", "ABCXYZEDF"},  // Forward: "ABC"; backward: "XY"; in: "F".
     {".....GD.", "ABCHFGDE"},  // Forward: "ABC", "E"; backward: "F"; in: "H".
     {"..FE..GD..", "ABFECHGDIJ"}, // Forward: "AB"; backward: "IJ"; in: "CH".
   };
   for (const auto& test_case : kTestCases) {
-    LabelManagerImpl label_manager;
+    TestLabelManager label_manager;
     label_manager.SetLabels(CreateLabelVectorWithIndexes(test_case.input));
 
     label_manager.AssignRemainingIndexes();
     std::string result = EncodeLabelIndexes(label_manager.Labels());
     EXPECT_EQ(test_case.expect, result);
   }
 }
 
 }  // namespace courgette