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: |
18 void TestAssembleToStreamDisassemble(const std::string& file, | 21 void TestAssembleToStreamDisassemble(const std::string& file, |
19 size_t expected_encoded_length) const; | 22 size_t expected_encoded_length) const; |
20 }; | 23 }; |
21 | 24 |
22 void EncodeDecodeTest::TestAssembleToStreamDisassemble( | 25 void EncodeDecodeTest::TestAssembleToStreamDisassemble( |
23 const std::string& file, | 26 const std::string& file, |
24 size_t expected_encoded_length) const { | 27 size_t expected_encoded_length) const { |
25 const uint8_t* original_buffer = | 28 const uint8_t* original_data = reinterpret_cast<const uint8_t*>(file.data()); |
26 reinterpret_cast<const uint8_t*>(file.data()); | |
27 size_t original_length = file.length(); | 29 size_t original_length = file.length(); |
| 30 CourgetteFlow flow; |
28 | 31 |
29 std::unique_ptr<courgette::AssemblyProgram> program; | 32 // Convert executable to encoded assembly. |
30 const courgette::Status parse_status = courgette::ParseDetectedExecutable( | 33 RegionBuffer original_buffer(Region(original_data, original_length)); |
31 original_buffer, original_length, &program); | 34 flow.ReadAssemblyProgramFromBuffer(flow.ONLY, original_buffer, false); |
32 EXPECT_EQ(courgette::C_OK, parse_status); | 35 EXPECT_EQ(C_OK, flow.status()); |
| 36 EXPECT_TRUE(nullptr != flow.data(flow.ONLY)->program.get()); |
33 | 37 |
34 std::unique_ptr<courgette::EncodedProgram> encoded; | 38 flow.CreateEncodedProgramFromAssemblyProgram(flow.ONLY); |
35 const courgette::Status encode_status = Encode(*program, &encoded); | 39 EXPECT_EQ(C_OK, flow.status()); |
36 EXPECT_EQ(courgette::C_OK, encode_status); | 40 EXPECT_TRUE(nullptr != flow.data(flow.ONLY)->encoded.get()); |
37 | 41 |
38 program.reset(); | 42 flow.DestroyAssemblyProgram(flow.ONLY); |
| 43 EXPECT_EQ(C_OK, flow.status()); |
| 44 EXPECT_TRUE(nullptr == flow.data(flow.ONLY)->program.get()); |
39 | 45 |
40 courgette::SinkStreamSet sinks; | 46 flow.WriteSinkStreamSetFromEncodedProgram(flow.ONLY); |
41 const courgette::Status write_status = | 47 EXPECT_EQ(C_OK, flow.status()); |
42 WriteEncodedProgram(encoded.get(), &sinks); | |
43 EXPECT_EQ(courgette::C_OK, write_status); | |
44 | 48 |
45 encoded.reset(); | 49 flow.DestroyEncodedProgram(flow.ONLY); |
| 50 EXPECT_EQ(C_OK, flow.status()); |
| 51 EXPECT_TRUE(nullptr == flow.data(flow.ONLY)->encoded.get()); |
46 | 52 |
47 courgette::SinkStream sink; | 53 SinkStream sink; |
48 bool can_collect = sinks.CopyTo(&sink); | 54 flow.WriteSinkStreamFromSinkStreamSet(flow.ONLY, &sink); |
49 EXPECT_TRUE(can_collect); | 55 EXPECT_EQ(C_OK, flow.status()); |
50 | 56 |
51 const void* buffer = sink.Buffer(); | 57 const void* encoded_data = sink.Buffer(); |
52 size_t length = sink.Length(); | 58 size_t encoded_length = sink.Length(); |
| 59 EXPECT_EQ(expected_encoded_length, encoded_length); |
53 | 60 |
54 EXPECT_EQ(expected_encoded_length, length); | 61 // Convert encoded assembly back to executable. |
| 62 RegionBuffer encoded_buffer(Region(encoded_data, encoded_length)); |
| 63 flow.ReadSourceStreamSetFromBuffer(flow.ONLY, encoded_buffer); |
| 64 EXPECT_EQ(C_OK, flow.status()); |
55 | 65 |
56 courgette::SourceStreamSet sources; | 66 flow.ReadEncodedProgramFromSourceStreamSet(flow.ONLY); |
57 bool can_get_source_streams = sources.Init(buffer, length); | 67 EXPECT_EQ(C_OK, flow.status()); |
58 EXPECT_TRUE(can_get_source_streams); | 68 EXPECT_TRUE(nullptr != flow.data(flow.ONLY)->encoded.get()); |
59 | 69 |
60 std::unique_ptr<courgette::EncodedProgram> encoded2; | 70 SinkStream executable; |
61 const courgette::Status read_status = ReadEncodedProgram(&sources, &encoded2); | 71 flow.WriteExecutableFromEncodedProgram(flow.ONLY, &executable); |
62 EXPECT_EQ(courgette::C_OK, read_status); | 72 EXPECT_EQ(C_OK, flow.status()); |
63 | 73 |
64 courgette::SinkStream assembled; | 74 flow.DestroyEncodedProgram(flow.ONLY); |
65 const courgette::Status assemble_status = | 75 EXPECT_EQ(C_OK, flow.status()); |
66 Assemble(encoded2.get(), &assembled); | 76 EXPECT_TRUE(nullptr == flow.data(flow.ONLY)->encoded.get()); |
67 EXPECT_EQ(courgette::C_OK, assemble_status); | 77 EXPECT_TRUE(flow.ok()); |
| 78 EXPECT_FALSE(flow.failed()); |
68 | 79 |
69 encoded2.reset(); | 80 const void* executable_data = executable.Buffer(); |
| 81 size_t executable_length = executable.Length(); |
| 82 EXPECT_EQ(original_length, executable_length); |
70 | 83 |
71 const void* assembled_buffer = assembled.Buffer(); | 84 EXPECT_EQ(0, memcmp(original_data, executable_data, original_length)); |
72 size_t assembled_length = assembled.Length(); | |
73 | |
74 EXPECT_EQ(original_length, assembled_length); | |
75 EXPECT_EQ(0, memcmp(original_buffer, assembled_buffer, original_length)); | |
76 } | 85 } |
77 | 86 |
78 TEST_F(EncodeDecodeTest, PE) { | 87 TEST_F(EncodeDecodeTest, PE) { |
79 std::string file = FileContents("setup1.exe"); | 88 std::string file = FileContents("setup1.exe"); |
80 TestAssembleToStreamDisassemble(file, 972845); | 89 TestAssembleToStreamDisassemble(file, 972845); |
81 } | 90 } |
82 | 91 |
83 TEST_F(EncodeDecodeTest, PE64) { | 92 TEST_F(EncodeDecodeTest, PE64) { |
84 std::string file = FileContents("chrome64_1.exe"); | 93 std::string file = FileContents("chrome64_1.exe"); |
85 TestAssembleToStreamDisassemble(file, 810090); | 94 TestAssembleToStreamDisassemble(file, 810090); |
86 } | 95 } |
87 | 96 |
88 TEST_F(EncodeDecodeTest, Elf_Small) { | 97 TEST_F(EncodeDecodeTest, Elf_Small) { |
89 std::string file = FileContents("elf-32-1"); | 98 std::string file = FileContents("elf-32-1"); |
90 TestAssembleToStreamDisassemble(file, 136201); | 99 TestAssembleToStreamDisassemble(file, 136201); |
91 } | 100 } |
92 | 101 |
93 TEST_F(EncodeDecodeTest, Elf_HighBSS) { | 102 TEST_F(EncodeDecodeTest, Elf_HighBSS) { |
94 std::string file = FileContents("elf-32-high-bss"); | 103 std::string file = FileContents("elf-32-high-bss"); |
95 TestAssembleToStreamDisassemble(file, 7308); | 104 TestAssembleToStreamDisassemble(file, 7308); |
96 } | 105 } |
97 | 106 |
98 TEST_F(EncodeDecodeTest, Elf_Arm) { | 107 TEST_F(EncodeDecodeTest, Elf_Arm) { |
99 std::string file = FileContents("elf-armv7"); | 108 std::string file = FileContents("elf-armv7"); |
100 TestAssembleToStreamDisassemble(file, 8531); | 109 TestAssembleToStreamDisassemble(file, 8531); |
101 } | 110 } |
| 111 |
| 112 } // namespace courgette |
OLD | NEW |