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 <stddef.h> | 5 #include <stddef.h> |
6 | 6 |
7 #include <memory> | 7 #include <memory> |
8 | 8 |
9 #include "courgette/assembly_program.h" | 9 #include "courgette/assembly_program.h" |
10 #include "courgette/base_test_unittest.h" | 10 #include "courgette/base_test_unittest.h" |
11 #include "courgette/courgette.h" | 11 #include "courgette/courgette.h" |
12 #include "courgette/courgette_flow.h" | |
12 #include "courgette/encoded_program.h" | 13 #include "courgette/encoded_program.h" |
13 #include "courgette/program_detector.h" | 14 #include "courgette/program_detector.h" |
14 #include "courgette/streams.h" | 15 #include "courgette/streams.h" |
15 | 16 |
17 namespace courgette { | |
18 | |
16 class EncodeDecodeTest : public BaseTest { | 19 class EncodeDecodeTest : public BaseTest { |
17 public: | 20 public: |
21 // Use direct calls to Courgette functions. | |
22 void TestAssembleToStreamDisassembleRaw(const std::string& file, | |
23 size_t expected_encoded_length) const; | |
24 | |
25 // Use CourgetteFlow. | |
26 void TestAssembleToStreamDisassembleFlow( | |
27 const std::string& file, | |
28 size_t expected_encoded_length) const; | |
chrisha
2017/04/24 18:15:50
Do you need to test the direct calls *and* the flo
huangs
2017/04/24 20:08:14
Flow mechanism replaces the old stuff. So yeah it'
| |
29 | |
18 void TestAssembleToStreamDisassemble(const std::string& file, | 30 void TestAssembleToStreamDisassemble(const std::string& file, |
19 size_t expected_encoded_length) const; | 31 size_t expected_encoded_length) const; |
20 }; | 32 }; |
21 | 33 |
22 void EncodeDecodeTest::TestAssembleToStreamDisassemble( | 34 void EncodeDecodeTest::TestAssembleToStreamDisassembleRaw( |
23 const std::string& file, | 35 const std::string& file, |
24 size_t expected_encoded_length) const { | 36 size_t expected_encoded_length) const { |
25 const uint8_t* original_buffer = | 37 const uint8_t* original_buffer = |
26 reinterpret_cast<const uint8_t*>(file.data()); | 38 reinterpret_cast<const uint8_t*>(file.data()); |
27 size_t original_length = file.length(); | 39 size_t original_length = file.length(); |
28 | 40 |
29 std::unique_ptr<courgette::AssemblyProgram> program; | 41 std::unique_ptr<AssemblyProgram> program; |
30 const courgette::Status parse_status = courgette::ParseDetectedExecutable( | 42 const Status parse_status = |
31 original_buffer, original_length, &program); | 43 ParseDetectedExecutable(original_buffer, original_length, &program); |
32 EXPECT_EQ(courgette::C_OK, parse_status); | 44 EXPECT_EQ(C_OK, parse_status); |
33 | 45 |
34 std::unique_ptr<courgette::EncodedProgram> encoded; | 46 std::unique_ptr<EncodedProgram> encoded; |
35 const courgette::Status encode_status = Encode(*program, &encoded); | 47 const Status encode_status = Encode(*program, &encoded); |
36 EXPECT_EQ(courgette::C_OK, encode_status); | 48 EXPECT_EQ(C_OK, encode_status); |
37 | 49 |
38 program.reset(); | 50 program.reset(); |
39 | 51 |
40 courgette::SinkStreamSet sinks; | 52 SinkStreamSet sinks; |
41 const courgette::Status write_status = | 53 const Status write_status = WriteEncodedProgram(encoded.get(), &sinks); |
42 WriteEncodedProgram(encoded.get(), &sinks); | 54 EXPECT_EQ(C_OK, write_status); |
43 EXPECT_EQ(courgette::C_OK, write_status); | |
44 | 55 |
45 encoded.reset(); | 56 encoded.reset(); |
46 | 57 |
47 courgette::SinkStream sink; | 58 SinkStream sink; |
48 bool can_collect = sinks.CopyTo(&sink); | 59 bool can_collect = sinks.CopyTo(&sink); |
49 EXPECT_TRUE(can_collect); | 60 EXPECT_TRUE(can_collect); |
50 | 61 |
51 const void* buffer = sink.Buffer(); | 62 const void* buffer = sink.Buffer(); |
52 size_t length = sink.Length(); | 63 size_t length = sink.Length(); |
53 | 64 |
54 EXPECT_EQ(expected_encoded_length, length); | 65 EXPECT_EQ(expected_encoded_length, length); |
55 | 66 |
56 courgette::SourceStreamSet sources; | 67 SourceStreamSet sources; |
57 bool can_get_source_streams = sources.Init(buffer, length); | 68 bool can_get_source_streams = sources.Init(buffer, length); |
58 EXPECT_TRUE(can_get_source_streams); | 69 EXPECT_TRUE(can_get_source_streams); |
59 | 70 |
60 std::unique_ptr<courgette::EncodedProgram> encoded2; | 71 std::unique_ptr<EncodedProgram> encoded2; |
61 const courgette::Status read_status = ReadEncodedProgram(&sources, &encoded2); | 72 const Status read_status = ReadEncodedProgram(&sources, &encoded2); |
62 EXPECT_EQ(courgette::C_OK, read_status); | 73 EXPECT_EQ(C_OK, read_status); |
63 | 74 |
64 courgette::SinkStream assembled; | 75 SinkStream assembled; |
65 const courgette::Status assemble_status = | 76 const Status assemble_status = Assemble(encoded2.get(), &assembled); |
66 Assemble(encoded2.get(), &assembled); | 77 EXPECT_EQ(C_OK, assemble_status); |
67 EXPECT_EQ(courgette::C_OK, assemble_status); | |
68 | 78 |
69 encoded2.reset(); | 79 encoded2.reset(); |
70 | 80 |
71 const void* assembled_buffer = assembled.Buffer(); | 81 const void* assembled_buffer = assembled.Buffer(); |
72 size_t assembled_length = assembled.Length(); | 82 size_t assembled_length = assembled.Length(); |
83 EXPECT_EQ(original_length, assembled_length); | |
73 | 84 |
85 EXPECT_EQ(0, memcmp(original_buffer, assembled_buffer, original_length)); | |
86 } | |
87 | |
88 void EncodeDecodeTest::TestAssembleToStreamDisassembleFlow( | |
89 const std::string& file, | |
90 size_t expected_encoded_length) const { | |
91 const uint8_t* original_buffer = | |
92 reinterpret_cast<const uint8_t*>(file.data()); | |
93 size_t original_length = file.length(); | |
94 | |
95 RegionBuffer only_buffer(Region(original_buffer, original_length)); | |
96 CourgetteFlow flow; | |
97 flow.ReadAssemblyProgramFromBuffer(flow.ONLY, only_buffer, false); | |
98 EXPECT_EQ(C_OK, flow.status()); | |
99 | |
100 flow.CreateEncodedProgramFromAssemblyProgram(flow.ONLY); | |
101 EXPECT_EQ(C_OK, flow.status()); | |
102 | |
103 flow.DestroyAssemblyProgram(flow.ONLY); | |
104 EXPECT_EQ(C_OK, flow.status()); | |
105 | |
106 flow.WriteSinkStreamSetFromEncodedProgram(flow.ONLY); | |
107 EXPECT_EQ(C_OK, flow.status()); | |
108 | |
109 flow.DestroyEncodedProgram(flow.ONLY); | |
110 EXPECT_EQ(C_OK, flow.status()); | |
111 | |
112 SinkStream sink; | |
113 flow.WriteSinkStreamFromSinkStreamSet(flow.ONLY, &sink); | |
114 EXPECT_EQ(C_OK, flow.status()); | |
115 | |
116 const void* buffer = sink.Buffer(); | |
117 size_t length = sink.Length(); | |
118 EXPECT_EQ(expected_encoded_length, length); | |
119 | |
120 SourceStreamSet sources; | |
121 bool can_get_source_streams = sources.Init(buffer, length); | |
122 EXPECT_TRUE(can_get_source_streams); | |
123 | |
124 flow.ReadEncodedProgramFromSourceStreamSet(flow.ONLY, &sources); | |
125 EXPECT_EQ(C_OK, flow.status()); | |
126 | |
127 SinkStream assembled; | |
128 flow.WriteExecutableFromEncodedProgram(flow.ONLY, &assembled); | |
129 EXPECT_EQ(C_OK, flow.status()); | |
130 | |
131 flow.DestroyEncodedProgram(flow.ONLY); | |
132 EXPECT_EQ(C_OK, flow.status()); | |
133 EXPECT_TRUE(flow.ok()); | |
134 EXPECT_FALSE(flow.failed()); | |
135 | |
136 const void* assembled_buffer = assembled.Buffer(); | |
137 size_t assembled_length = assembled.Length(); | |
74 EXPECT_EQ(original_length, assembled_length); | 138 EXPECT_EQ(original_length, assembled_length); |
139 | |
75 EXPECT_EQ(0, memcmp(original_buffer, assembled_buffer, original_length)); | 140 EXPECT_EQ(0, memcmp(original_buffer, assembled_buffer, original_length)); |
76 } | 141 } |
77 | 142 |
143 void EncodeDecodeTest::TestAssembleToStreamDisassemble( | |
144 const std::string& file, | |
145 size_t expected_encoded_length) const { | |
146 TestAssembleToStreamDisassembleRaw(file, expected_encoded_length); | |
147 TestAssembleToStreamDisassembleFlow(file, expected_encoded_length); | |
148 } | |
149 | |
78 TEST_F(EncodeDecodeTest, PE) { | 150 TEST_F(EncodeDecodeTest, PE) { |
79 std::string file = FileContents("setup1.exe"); | 151 std::string file = FileContents("setup1.exe"); |
80 TestAssembleToStreamDisassemble(file, 972845); | 152 TestAssembleToStreamDisassemble(file, 972845); |
81 } | 153 } |
82 | 154 |
83 TEST_F(EncodeDecodeTest, PE64) { | 155 TEST_F(EncodeDecodeTest, PE64) { |
84 std::string file = FileContents("chrome64_1.exe"); | 156 std::string file = FileContents("chrome64_1.exe"); |
85 TestAssembleToStreamDisassemble(file, 810090); | 157 TestAssembleToStreamDisassemble(file, 810090); |
86 } | 158 } |
87 | 159 |
88 TEST_F(EncodeDecodeTest, Elf_Small) { | 160 TEST_F(EncodeDecodeTest, Elf_Small) { |
89 std::string file = FileContents("elf-32-1"); | 161 std::string file = FileContents("elf-32-1"); |
90 TestAssembleToStreamDisassemble(file, 136201); | 162 TestAssembleToStreamDisassemble(file, 136201); |
91 } | 163 } |
92 | 164 |
93 TEST_F(EncodeDecodeTest, Elf_HighBSS) { | 165 TEST_F(EncodeDecodeTest, Elf_HighBSS) { |
94 std::string file = FileContents("elf-32-high-bss"); | 166 std::string file = FileContents("elf-32-high-bss"); |
95 TestAssembleToStreamDisassemble(file, 7308); | 167 TestAssembleToStreamDisassemble(file, 7308); |
96 } | 168 } |
97 | 169 |
98 TEST_F(EncodeDecodeTest, Elf_Arm) { | 170 TEST_F(EncodeDecodeTest, Elf_Arm) { |
99 std::string file = FileContents("elf-armv7"); | 171 std::string file = FileContents("elf-armv7"); |
100 TestAssembleToStreamDisassemble(file, 8531); | 172 TestAssembleToStreamDisassemble(file, 8531); |
101 } | 173 } |
174 | |
175 } // namespace courgette | |
OLD | NEW |