[Courgette] Refactor: Add CourgetteFlow; improve courgette_tool.cc help text.

courgette/encode_decode_unittest.cc

 // Copyright (c) 2011 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 <stddef.h>
 
 #include <memory>
 
 #include "courgette/assembly_program.h"
 #include "courgette/base_test_unittest.h"
 #include "courgette/courgette.h"
+#include "courgette/courgette_flow.h"
 #include "courgette/encoded_program.h"
 #include "courgette/program_detector.h"
 #include "courgette/streams.h"
 
+namespace courgette {
+
 class EncodeDecodeTest : public BaseTest {
  public:
+  // Use direct calls to Courgette functions.
+  void TestAssembleToStreamDisassembleRaw(const std::string& file,
+                                          size_t expected_encoded_length) const;
+
+  // Use CourgetteFlow.
+  void TestAssembleToStreamDisassembleFlow(
+      const std::string& file,
+      size_t expected_encoded_length) const;

[chrisha, 2017/04/24 18:15:50]

Do you need to test the direct calls *and* the flow mechanism? Or is using the
flow mechanism sufficient?

[huangs, 2017/04/24 20:08:14]

Flow mechanism replaces the old stuff. So yeah it's better to remove duplicate.
Also updating encode_program_fuzz_unittests.cc (currently Fuzz fails though; fix
that later).

+
   void TestAssembleToStreamDisassemble(const std::string& file,
                                        size_t expected_encoded_length) const;
 };
 
-void EncodeDecodeTest::TestAssembleToStreamDisassemble(
+void EncodeDecodeTest::TestAssembleToStreamDisassembleRaw(
     const std::string& file,
     size_t expected_encoded_length) const {
   const uint8_t* original_buffer =
       reinterpret_cast<const uint8_t*>(file.data());
   size_t original_length = file.length();
 
-  std::unique_ptr<courgette::AssemblyProgram> program;
-  const courgette::Status parse_status = courgette::ParseDetectedExecutable(
-      original_buffer, original_length, &program);
-  EXPECT_EQ(courgette::C_OK, parse_status);
+  std::unique_ptr<AssemblyProgram> program;
+  const Status parse_status =
+      ParseDetectedExecutable(original_buffer, original_length, &program);
+  EXPECT_EQ(C_OK, parse_status);
 
-  std::unique_ptr<courgette::EncodedProgram> encoded;
-  const courgette::Status encode_status = Encode(*program, &encoded);
-  EXPECT_EQ(courgette::C_OK, encode_status);
+  std::unique_ptr<EncodedProgram> encoded;
+  const Status encode_status = Encode(*program, &encoded);
+  EXPECT_EQ(C_OK, encode_status);
 
   program.reset();
 
-  courgette::SinkStreamSet sinks;
-  const courgette::Status write_status =
-      WriteEncodedProgram(encoded.get(), &sinks);
-  EXPECT_EQ(courgette::C_OK, write_status);
+  SinkStreamSet sinks;
+  const Status write_status = WriteEncodedProgram(encoded.get(), &sinks);
+  EXPECT_EQ(C_OK, write_status);
 
   encoded.reset();
 
-  courgette::SinkStream sink;
+  SinkStream sink;
   bool can_collect = sinks.CopyTo(&sink);
   EXPECT_TRUE(can_collect);
 
   const void* buffer = sink.Buffer();
   size_t length = sink.Length();
 
   EXPECT_EQ(expected_encoded_length, length);
 
-  courgette::SourceStreamSet sources;
+  SourceStreamSet sources;
   bool can_get_source_streams = sources.Init(buffer, length);
   EXPECT_TRUE(can_get_source_streams);
 
-  std::unique_ptr<courgette::EncodedProgram> encoded2;
-  const courgette::Status read_status = ReadEncodedProgram(&sources, &encoded2);
-  EXPECT_EQ(courgette::C_OK, read_status);
+  std::unique_ptr<EncodedProgram> encoded2;
+  const Status read_status = ReadEncodedProgram(&sources, &encoded2);
+  EXPECT_EQ(C_OK, read_status);
 
-  courgette::SinkStream assembled;
-  const courgette::Status assemble_status =
-      Assemble(encoded2.get(), &assembled);
-  EXPECT_EQ(courgette::C_OK, assemble_status);
+  SinkStream assembled;
+  const Status assemble_status = Assemble(encoded2.get(), &assembled);
+  EXPECT_EQ(C_OK, assemble_status);
 
   encoded2.reset();
 
   const void* assembled_buffer = assembled.Buffer();
   size_t assembled_length = assembled.Length();
+  EXPECT_EQ(original_length, assembled_length);
 
+  EXPECT_EQ(0, memcmp(original_buffer, assembled_buffer, original_length));
+}
+
+void EncodeDecodeTest::TestAssembleToStreamDisassembleFlow(
+    const std::string& file,
+    size_t expected_encoded_length) const {
+  const uint8_t* original_buffer =
+      reinterpret_cast<const uint8_t*>(file.data());
+  size_t original_length = file.length();
+
+  RegionBuffer only_buffer(Region(original_buffer, original_length));
+  CourgetteFlow flow;
+  flow.ReadAssemblyProgramFromBuffer(flow.ONLY, only_buffer, false);
+  EXPECT_EQ(C_OK, flow.status());
+
+  flow.CreateEncodedProgramFromAssemblyProgram(flow.ONLY);
+  EXPECT_EQ(C_OK, flow.status());
+
+  flow.DestroyAssemblyProgram(flow.ONLY);
+  EXPECT_EQ(C_OK, flow.status());
+
+  flow.WriteSinkStreamSetFromEncodedProgram(flow.ONLY);
+  EXPECT_EQ(C_OK, flow.status());
+
+  flow.DestroyEncodedProgram(flow.ONLY);
+  EXPECT_EQ(C_OK, flow.status());
+
+  SinkStream sink;
+  flow.WriteSinkStreamFromSinkStreamSet(flow.ONLY, &sink);
+  EXPECT_EQ(C_OK, flow.status());
+
+  const void* buffer = sink.Buffer();
+  size_t length = sink.Length();
+  EXPECT_EQ(expected_encoded_length, length);
+
+  SourceStreamSet sources;
+  bool can_get_source_streams = sources.Init(buffer, length);
+  EXPECT_TRUE(can_get_source_streams);
+
+  flow.ReadEncodedProgramFromSourceStreamSet(flow.ONLY, &sources);
+  EXPECT_EQ(C_OK, flow.status());
+
+  SinkStream assembled;
+  flow.WriteExecutableFromEncodedProgram(flow.ONLY, &assembled);
+  EXPECT_EQ(C_OK, flow.status());
+
+  flow.DestroyEncodedProgram(flow.ONLY);
+  EXPECT_EQ(C_OK, flow.status());
+  EXPECT_TRUE(flow.ok());
+  EXPECT_FALSE(flow.failed());
+
+  const void* assembled_buffer = assembled.Buffer();
+  size_t assembled_length = assembled.Length();
   EXPECT_EQ(original_length, assembled_length);
+
   EXPECT_EQ(0, memcmp(original_buffer, assembled_buffer, original_length));
 }
 
+void EncodeDecodeTest::TestAssembleToStreamDisassemble(
+    const std::string& file,
+    size_t expected_encoded_length) const {
+  TestAssembleToStreamDisassembleRaw(file, expected_encoded_length);
+  TestAssembleToStreamDisassembleFlow(file, expected_encoded_length);
+}
+
 TEST_F(EncodeDecodeTest, PE) {
   std::string file = FileContents("setup1.exe");
   TestAssembleToStreamDisassemble(file, 972845);
 }
 
 TEST_F(EncodeDecodeTest, PE64) {
   std::string file = FileContents("chrome64_1.exe");
   TestAssembleToStreamDisassemble(file, 810090);
 }
 
 TEST_F(EncodeDecodeTest, Elf_Small) {
   std::string file = FileContents("elf-32-1");
   TestAssembleToStreamDisassemble(file, 136201);
 }
 
 TEST_F(EncodeDecodeTest, Elf_HighBSS) {
   std::string file = FileContents("elf-32-high-bss");
   TestAssembleToStreamDisassemble(file, 7308);
 }
 
 TEST_F(EncodeDecodeTest, Elf_Arm) {
   std::string file = FileContents("elf-armv7");
   TestAssembleToStreamDisassemble(file, 8531);
 }
+
+}  // namespace courgette