OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include <memory> | 5 #include <memory> |
6 #include <string> | 6 #include <string> |
7 #include <utility> | 7 #include <utility> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
| 10 #include "base/bind.h" |
10 #include "base/strings/string_util.h" | 11 #include "base/strings/string_util.h" |
11 #include "courgette/assembly_program.h" | 12 #include "courgette/assembly_program.h" |
12 #include "courgette/courgette.h" | 13 #include "courgette/courgette.h" |
13 #include "courgette/encoded_program.h" | 14 #include "courgette/encoded_program.h" |
14 #include "courgette/image_utils.h" | 15 #include "courgette/image_utils.h" |
15 #include "courgette/streams.h" | 16 #include "courgette/streams.h" |
16 | 17 |
17 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
18 | 19 |
| 20 namespace courgette { |
| 21 |
| 22 namespace { |
| 23 |
19 class AdjustmentMethodTest : public testing::Test { | 24 class AdjustmentMethodTest : public testing::Test { |
20 public: | 25 public: |
21 void Test1() const; | 26 void Test1() const; |
22 | 27 |
23 private: | 28 private: |
24 void SetUp() { | 29 void SetUp() { |
25 } | 30 } |
26 | 31 |
27 void TearDown() { | 32 void TearDown() { |
28 } | 33 } |
29 | 34 |
30 // Returns one of two similar simple programs. These differ only in Label | 35 // Returns one of two similar simple programs. These differ only in Label |
31 // assignment, so it is possible to make them look identical. | 36 // assignment, so it is possible to make them look identical. |
32 std::unique_ptr<courgette::AssemblyProgram> MakeProgram(int kind) const { | 37 std::unique_ptr<AssemblyProgram> MakeProgram(int kind) const { |
33 std::unique_ptr<courgette::AssemblyProgram> prog( | 38 std::unique_ptr<AssemblyProgram> prog(new AssemblyProgram(EXE_WIN_32_X86)); |
34 new courgette::AssemblyProgram(courgette::EXE_WIN_32_X86)); | |
35 prog->set_image_base(0x00400000); | 39 prog->set_image_base(0x00400000); |
36 | 40 |
37 courgette::RVA kRvaA = 0x00410000; | 41 RVA kRvaA = 0x00410000; |
38 courgette::RVA kRvaB = 0x00410004; | 42 RVA kRvaB = 0x00410004; |
39 | 43 |
40 std::vector<courgette::RVA> abs32_rvas; | 44 std::vector<RVA> abs32_rvas; |
41 abs32_rvas.push_back(kRvaA); | 45 abs32_rvas.push_back(kRvaA); |
42 abs32_rvas.push_back(kRvaB); | 46 abs32_rvas.push_back(kRvaB); |
43 std::vector<courgette::RVA> rel32_rvas; // Stub. | 47 std::vector<RVA> rel32_rvas; // Stub. |
44 | 48 |
45 courgette::TrivialRvaVisitor abs32_visitor(abs32_rvas); | 49 TrivialRvaVisitor abs32_visitor(abs32_rvas); |
46 courgette::TrivialRvaVisitor rel32_visitor(rel32_rvas); | 50 TrivialRvaVisitor rel32_visitor(rel32_rvas); |
47 prog->PrecomputeLabels(&abs32_visitor, &rel32_visitor); | 51 prog->PrecomputeLabels(&abs32_visitor, &rel32_visitor); |
48 | 52 |
49 courgette::Label* labelA = prog->FindAbs32Label(kRvaA); | 53 Label* labelA = prog->FindAbs32Label(kRvaA); |
50 courgette::Label* labelB = prog->FindAbs32Label(kRvaB); | 54 Label* labelB = prog->FindAbs32Label(kRvaB); |
51 | 55 |
52 EXPECT_TRUE(prog->EmitAbs32(labelA)); | 56 AssemblyProgram::InstructionGenerator gen = base::Bind( |
53 EXPECT_TRUE(prog->EmitAbs32(labelA)); | 57 [](Label* labelA, Label* labelB, AssemblyProgram* prog, |
54 EXPECT_TRUE(prog->EmitAbs32(labelB)); | 58 InstructionReceptor* receptor) -> CheckBool { |
55 EXPECT_TRUE(prog->EmitAbs32(labelA)); | 59 EXPECT_TRUE(receptor->EmitAbs32(labelA)); |
56 EXPECT_TRUE(prog->EmitAbs32(labelA)); | 60 EXPECT_TRUE(receptor->EmitAbs32(labelA)); |
57 EXPECT_TRUE(prog->EmitAbs32(labelB)); | 61 EXPECT_TRUE(receptor->EmitAbs32(labelB)); |
| 62 EXPECT_TRUE(receptor->EmitAbs32(labelA)); |
| 63 EXPECT_TRUE(receptor->EmitAbs32(labelA)); |
| 64 EXPECT_TRUE(receptor->EmitAbs32(labelB)); |
| 65 return true; |
| 66 }, |
| 67 labelA, labelB); |
| 68 |
| 69 EXPECT_TRUE(prog->GenerateInstructions(gen)); |
58 | 70 |
59 if (kind == 0) { | 71 if (kind == 0) { |
60 labelA->index_ = 0; | 72 labelA->index_ = 0; |
61 labelB->index_ = 1; | 73 labelB->index_ = 1; |
62 } else { | 74 } else { |
63 labelA->index_ = 1; | 75 labelA->index_ = 1; |
64 labelB->index_ = 0; | 76 labelB->index_ = 0; |
65 } | 77 } |
66 prog->AssignRemainingIndexes(); | 78 prog->AssignRemainingIndexes(); |
67 | 79 |
68 return prog; | 80 return prog; |
69 } | 81 } |
70 | 82 |
71 std::unique_ptr<courgette::AssemblyProgram> MakeProgramA() const { | 83 std::unique_ptr<AssemblyProgram> MakeProgramA() const { |
72 return MakeProgram(0); | 84 return MakeProgram(0); |
73 } | 85 } |
74 std::unique_ptr<courgette::AssemblyProgram> MakeProgramB() const { | 86 std::unique_ptr<AssemblyProgram> MakeProgramB() const { |
75 return MakeProgram(1); | 87 return MakeProgram(1); |
76 } | 88 } |
77 | 89 |
78 // Returns a string that is the serialized version of |program|. | 90 // Returns a string that is the serialized version of |program|. |
79 // Deletes |program|. | 91 // Deletes |program|. |
80 std::string Serialize( | 92 std::string Serialize(std::unique_ptr<AssemblyProgram> program) const { |
81 std::unique_ptr<courgette::AssemblyProgram> program) const { | 93 std::unique_ptr<EncodedProgram> encoded; |
82 std::unique_ptr<courgette::EncodedProgram> encoded; | |
83 | 94 |
84 const courgette::Status encode_status = Encode(*program, &encoded); | 95 const Status encode_status = Encode(*program, &encoded); |
85 EXPECT_EQ(courgette::C_OK, encode_status); | 96 EXPECT_EQ(C_OK, encode_status); |
86 | 97 |
87 program.reset(); | 98 program.reset(); |
88 | 99 |
89 courgette::SinkStreamSet sinks; | 100 SinkStreamSet sinks; |
90 const courgette::Status write_status = | 101 const Status write_status = WriteEncodedProgram(encoded.get(), &sinks); |
91 WriteEncodedProgram(encoded.get(), &sinks); | 102 EXPECT_EQ(C_OK, write_status); |
92 EXPECT_EQ(courgette::C_OK, write_status); | |
93 | 103 |
94 encoded.reset(); | 104 encoded.reset(); |
95 | 105 |
96 courgette::SinkStream sink; | 106 SinkStream sink; |
97 bool can_collect = sinks.CopyTo(&sink); | 107 bool can_collect = sinks.CopyTo(&sink); |
98 EXPECT_TRUE(can_collect); | 108 EXPECT_TRUE(can_collect); |
99 | 109 |
100 return std::string(reinterpret_cast<const char *>(sink.Buffer()), | 110 return std::string(reinterpret_cast<const char *>(sink.Buffer()), |
101 sink.Length()); | 111 sink.Length()); |
102 } | 112 } |
103 }; | 113 }; |
104 | 114 |
105 void AdjustmentMethodTest::Test1() const { | 115 void AdjustmentMethodTest::Test1() const { |
106 std::unique_ptr<courgette::AssemblyProgram> prog1 = MakeProgramA(); | 116 std::unique_ptr<AssemblyProgram> prog1 = MakeProgramA(); |
107 std::unique_ptr<courgette::AssemblyProgram> prog2 = MakeProgramB(); | 117 std::unique_ptr<AssemblyProgram> prog2 = MakeProgramB(); |
108 std::string s1 = Serialize(std::move(prog1)); | 118 std::string s1 = Serialize(std::move(prog1)); |
109 std::string s2 = Serialize(std::move(prog2)); | 119 std::string s2 = Serialize(std::move(prog2)); |
110 | 120 |
111 // Don't use EXPECT_EQ because strings are unprintable. | 121 // Don't use EXPECT_EQ because strings are unprintable. |
112 EXPECT_FALSE(s1 == s2); // Unadjusted A and B differ. | 122 EXPECT_FALSE(s1 == s2); // Unadjusted A and B differ. |
113 | 123 |
114 std::unique_ptr<courgette::AssemblyProgram> prog5 = MakeProgramA(); | 124 std::unique_ptr<AssemblyProgram> prog5 = MakeProgramA(); |
115 std::unique_ptr<courgette::AssemblyProgram> prog6 = MakeProgramB(); | 125 std::unique_ptr<AssemblyProgram> prog6 = MakeProgramB(); |
116 courgette::Status can_adjust = Adjust(*prog5, prog6.get()); | 126 Status can_adjust = Adjust(*prog5, prog6.get()); |
117 EXPECT_EQ(courgette::C_OK, can_adjust); | 127 EXPECT_EQ(C_OK, can_adjust); |
118 std::string s5 = Serialize(std::move(prog5)); | 128 std::string s5 = Serialize(std::move(prog5)); |
119 std::string s6 = Serialize(std::move(prog6)); | 129 std::string s6 = Serialize(std::move(prog6)); |
120 | 130 |
121 EXPECT_TRUE(s1 == s5); // Adjustment did not change A (prog5) | 131 EXPECT_TRUE(s1 == s5); // Adjustment did not change A (prog5) |
122 EXPECT_TRUE(s5 == s6); // Adjustment did change B into A | 132 EXPECT_TRUE(s5 == s6); // Adjustment did change B into A |
123 } | 133 } |
124 | 134 |
125 TEST_F(AdjustmentMethodTest, All) { | 135 TEST_F(AdjustmentMethodTest, All) { |
126 Test1(); | 136 Test1(); |
127 } | 137 } |
| 138 |
| 139 } // namespace |
| 140 |
| 141 } // namespace courgette |
OLD | NEW |