diff --git a/source/opt/CMakeLists.txt b/source/opt/CMakeLists.txt
index aa85eb2..2fab5fc 100644
--- a/source/opt/CMakeLists.txt
+++ b/source/opt/CMakeLists.txt
@@ -27,6 +27,7 @@
   module.h
   null_pass.h
   reflect.h
+  optimizer.hpp
   pass.h
   passes.h
   pass_manager.h
@@ -47,6 +48,7 @@
   libspirv.cpp
   module.cpp
   set_spec_constant_default_value_pass.cpp
+  optimizer.cpp
   pass_manager.cpp
   strip_debug_info_pass.cpp
   types.cpp
diff --git a/source/opt/eliminate_dead_constant_pass.h b/source/opt/eliminate_dead_constant_pass.h
index 6e9a278..6107cad 100644
--- a/source/opt/eliminate_dead_constant_pass.h
+++ b/source/opt/eliminate_dead_constant_pass.h
@@ -21,11 +21,7 @@
 namespace spvtools {
 namespace opt {
 
-// The optimization pass to remove dead constants, including front-end
-// contants: defined by OpConstant, OpConstantComposite, OpConstantTrue and
-// OpConstantFalse; and spec constants: defined by OpSpecConstant,
-// OpSpecConstantComposite, OpSpecConstantTrue, OpSpecConstantFalse and
-// OpSpecConstantOp.
+// See optimizer.hpp for documentation.
 class EliminateDeadConstantPass : public Pass {
  public:
   const char* name() const override { return "eliminate-dead-const"; }
diff --git a/source/opt/fold_spec_constant_op_and_composite_pass.h b/source/opt/fold_spec_constant_op_and_composite_pass.h
index 7b07fbf..8bca3e5 100644
--- a/source/opt/fold_spec_constant_op_and_composite_pass.h
+++ b/source/opt/fold_spec_constant_op_and_composite_pass.h
@@ -29,25 +29,7 @@
 namespace spvtools {
 namespace opt {
 
-// The optimization pass that folds "Spec Constants", which are defined by
-// OpSpecConstantOp and OpSpecConstantComposite instruction, to "Normal
-// Constants", which are defined by OpConstantTrue, OpConstantFalse,
-// OpConstant, OpConstantNull and OpConstantComposite instructions. Note that
-// Spec Constants defined with OpSpecConstant, OpSpecConstantTrue and
-// OpSpecConstantFalse instructions are not handled, as these instructions
-// indicate their value are not determined and can be changed in future.  A
-// Spec Constant is foldable if all of its value(s) can be determined from the
-// module. For example, an Integer Spec Constant defined with OpSpecConstantOp
-// instruction can be folded if its value won't change later. This pass will
-// replace the original OpSpecContantOp instruction with an OpConstant
-// instruction. When folding composite type Spec Constants, new instructions
-// may be inserted to define the components of the composite constant first,
-// then the original Spec Constants will be replace with OpConstantComposite
-// instructions.
-// There are some operations not supported:
-//  OpSConvert, OpFConvert, OpQuantizeToF16 and all the operations under Kernel
-//  capability.
-// TODO(qining): Add support for the operations listed above.
+// See optimizer.hpp for documentation.
 class FoldSpecConstantOpAndCompositePass : public Pass {
  public:
   FoldSpecConstantOpAndCompositePass();
diff --git a/source/opt/freeze_spec_constant_value_pass.h b/source/opt/freeze_spec_constant_value_pass.h
index 5e74a42..a04ff03 100644
--- a/source/opt/freeze_spec_constant_value_pass.h
+++ b/source/opt/freeze_spec_constant_value_pass.h
@@ -21,14 +21,7 @@
 namespace spvtools {
 namespace opt {
 
-// The transformation pass that specializes the value of spec constants to
-// their default values. This pass only processes the spec constants that have
-// Spec ID decorations (defined by OpSpecConstant, OpSpecConstantTrue and
-// OpSpecConstantFalse instructions) and replaces them with their front-end
-// version counterparts (OpConstant, OpConstantTrue and OpConstantFalse). The
-// corresponding Spec ID annotation instructions will also be removed. This
-// pass does not fold the newly added front-end constants and does not process
-// other spec constants defined by OpSpecConstantComposite or OpSpecConstantOp.
+// See optimizer.hpp for documentation.
 class FreezeSpecConstantValuePass : public Pass {
  public:
   const char* name() const override { return "freeze-spec-const"; }
diff --git a/source/opt/null_pass.h b/source/opt/null_pass.h
index a3306b5..832e891 100644
--- a/source/opt/null_pass.h
+++ b/source/opt/null_pass.h
@@ -21,7 +21,7 @@
 namespace spvtools {
 namespace opt {
 
-// A null pass that does nothing.
+// See optimizer.hpp for documentation.
 class NullPass : public Pass {
  public:
   const char* name() const override { return "null"; }
diff --git a/source/opt/optimizer.cpp b/source/opt/optimizer.cpp
new file mode 100644
index 0000000..da337db
--- /dev/null
+++ b/source/opt/optimizer.cpp
@@ -0,0 +1,121 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "optimizer.hpp"
+
+#include "build_module.h"
+#include "make_unique.h"
+#include "pass_manager.h"
+#include "passes.h"
+
+namespace spvtools {
+
+struct Optimizer::PassToken::Impl {
+  Impl(std::unique_ptr<opt::Pass> p) : pass(std::move(p)) {}
+
+  std::unique_ptr<opt::Pass> pass;  // Internal implementation pass.
+};
+
+Optimizer::PassToken::PassToken(
+    std::unique_ptr<Optimizer::PassToken::Impl> impl)
+    : impl_(std::move(impl)) {}
+Optimizer::PassToken::PassToken(PassToken&& that)
+    : impl_(std::move(that.impl_)) {}
+
+Optimizer::PassToken& Optimizer::PassToken::operator=(PassToken&& that) {
+  impl_ = std::move(that.impl_);
+  return *this;
+}
+
+Optimizer::PassToken::~PassToken() {}
+
+struct Optimizer::Impl {
+  explicit Impl(spv_target_env env) : target_env(env), pass_manager() {}
+
+  const spv_target_env target_env;  // Target environment.
+  opt::PassManager pass_manager;    // Internal implementation pass manager.
+};
+
+Optimizer::Optimizer(spv_target_env env) : impl_(new Impl(env)) {}
+
+Optimizer::~Optimizer() {}
+
+void Optimizer::SetMessageConsumer(MessageConsumer c) {
+  // All passes' message consumer needs to be updated.
+  for (uint32_t i = 0; i < impl_->pass_manager.NumPasses(); ++i) {
+    impl_->pass_manager.GetPass(i)->SetMessageConsumer(c);
+  }
+  impl_->pass_manager.SetMessageConsumer(std::move(c));
+}
+
+Optimizer& Optimizer::RegisterPass(PassToken&& p) {
+  // Change to use the pass manager's consumer.
+  p.impl_->pass->SetMessageConsumer(impl_->pass_manager.consumer());
+  impl_->pass_manager.AddPass(std::move(p.impl_->pass));
+  return *this;
+}
+
+bool Optimizer::Run(const uint32_t* original_binary,
+                    const size_t original_binary_size,
+                    std::vector<uint32_t>* optimized_binary) const {
+  std::unique_ptr<ir::Module> module =
+      BuildModule(impl_->target_env, impl_->pass_manager.consumer(),
+                  original_binary, original_binary_size);
+  if (module == nullptr) return false;
+
+  auto status = impl_->pass_manager.Run(module.get());
+  if (status == opt::Pass::Status::SuccessWithChange) {
+    optimized_binary->clear();
+    module->ToBinary(optimized_binary, /* skip_nop = */ true);
+  }
+
+  return status != opt::Pass::Status::Failure;
+}
+
+Optimizer::PassToken CreateNullPass() {
+  return MakeUnique<Optimizer::PassToken::Impl>(MakeUnique<opt::NullPass>());
+}
+
+Optimizer::PassToken CreateStripDebugInfoPass() {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::StripDebugInfoPass>());
+}
+
+Optimizer::PassToken CreateSetSpecConstantDefaultValuePass(
+    const std::unordered_map<uint32_t, std::string>& id_value_map) {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::SetSpecConstantDefaultValuePass>(id_value_map));
+}
+
+Optimizer::PassToken CreateFreezeSpecConstantValuePass() {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::FreezeSpecConstantValuePass>());
+}
+
+Optimizer::PassToken CreateFoldSpecConstantOpAndCompositePass() {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::FoldSpecConstantOpAndCompositePass>());
+}
+
+Optimizer::PassToken CreateUnifyConstantPass() {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::UnifyConstantPass>());
+}
+
+Optimizer::PassToken CreateEliminateDeadConstantPass() {
+  return MakeUnique<Optimizer::PassToken::Impl>(
+      MakeUnique<opt::EliminateDeadConstantPass>());
+}
+
+}  // namespace spvtools
diff --git a/source/opt/optimizer.hpp b/source/opt/optimizer.hpp
new file mode 100644
index 0000000..8a84dfd
--- /dev/null
+++ b/source/opt/optimizer.hpp
@@ -0,0 +1,173 @@
+// Copyright (c) 2016 Google Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef SPIRV_TOOLS_OPTIMIZER_HPP_
+#define SPIRV_TOOLS_OPTIMIZER_HPP_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
+
+#include "libspirv.hpp"
+#include "message.h"
+
+namespace spvtools {
+
+// C++ interface for SPIR-V optimization functionalities. It wraps the context
+// (including target environment and the corresponding SPIR-V grammar) and
+// provides methods for registering optimization passes and optimizing.
+//
+// Instances of this class provides basic thread-safety guarantee.
+class Optimizer {
+ public:
+  // The token for an optimization pass. It is returned via one of the
+  // Create*Pass() standalone functions at the end of this header file and
+  // consumed by the RegisterPass() method. Tokens are one-time objects that
+  // only support move; copying is not allowed.
+  struct PassToken {
+    struct Impl;  // Opaque struct for holding inernal data.
+
+    PassToken(std::unique_ptr<Impl>);
+
+    // Tokens can only be moved. Copying is disabled.
+    PassToken(const PassToken&) = delete;
+    PassToken(PassToken&&);
+    PassToken& operator=(const PassToken&) = delete;
+    PassToken& operator=(PassToken&&);
+
+    ~PassToken();
+
+    std::unique_ptr<Impl> impl_;  // Unique pointer to internal data.
+  };
+
+  // Constructs an instance with the given target |env|, which is used to decode
+  // the binaries to be optimized later.
+  //
+  // The constructed instance will have an empty message consumer, which just
+  // ignores all messages from the library. Use SetMessageConsumer() to supply
+  // one if messages are of concern.
+  explicit Optimizer(spv_target_env env);
+
+  // Disables copy/move constructor/assignment operations.
+  Optimizer(const Optimizer&) = delete;
+  Optimizer(Optimizer&&) = delete;
+  Optimizer& operator=(const Optimizer&) = delete;
+  Optimizer& operator=(Optimizer&&) = delete;
+
+  // Destructs this instance.
+  ~Optimizer();
+
+  // Sets the message consumer to the given |consumer|. The |consumer| will be
+  // invoked once for each message communicated from the library.
+  void SetMessageConsumer(MessageConsumer consumer);
+
+  // Registers the given |pass| to this optimizer. Passes will be run in the
+  // exact order of registration. The token passed in will be consumed by this
+  // method.
+  Optimizer& RegisterPass(PassToken&& pass);
+
+  // Optimizes the given SPIR-V module |original_binary| and writes the
+  // optimized binary into |optimized_binary|.
+  // Returns true on successful optimization, whether or not the module is
+  // modified. Returns false if errors occur when processing |original_binary|
+  // using any of the registered passes. In that case, no further passes are
+  // excuted and the contents in |optimized_binary| may be invalid.
+  //
+  // It's allowed to alias |original_binary| to the start of |optimized_binary|.
+  bool Run(const uint32_t* original_binary, size_t original_binary_size,
+           std::vector<uint32_t>* optimized_binary) const;
+
+ private:
+  struct Impl;                  // Opaque struct for holding internal data.
+  std::unique_ptr<Impl> impl_;  // Unique pointer to internal data.
+};
+
+// Creates a null pass.
+// A null pass does nothing to the SPIR-V module to be optimized.
+Optimizer::PassToken CreateNullPass();
+
+// Creates a strip-debug-info pass.
+// A strip-debug-info pass removes all debug instructions (as documented in
+// Section 3.32.2 of the SPIR-V spec) of the SPIR-V module to be optimized.
+Optimizer::PassToken CreateStripDebugInfoPass();
+
+// Creates a set-spec-constant-default-value pass.
+// A set-spec-constant-default-value pass sets the default values for the
+// spec constants that have SpecId decorations (i.e., those defined by
+// OpSpecConstant{|True|False} instructions).
+Optimizer::PassToken CreateSetSpecConstantDefaultValuePass(
+    const std::unordered_map<uint32_t, std::string>& id_value_map);
+
+// Creates a freeze-spec-constant-value pass.
+// A freeze-spec-constant pass specializes the value of spec constants to
+// their default values. This pass only processes the spec constants that have
+// SpecId decorations (defined by OpSpecConstant, OpSpecConstantTrue, or
+// OpSpecConstantFalse instructions) and replaces them with their normal
+// counterparts (OpConstant, OpConstantTrue, or OpConstantFalse). The
+// corresponding SpecId annotation instructions will also be removed. This
+// pass does not fold the newly added normal constants and does not process
+// other spec constants defined by OpSpecConstantComposite or
+// OpSpecConstantOp.
+Optimizer::PassToken CreateFreezeSpecConstantValuePass();
+
+// Creates a fold-spec-constant-op-and-composite pass.
+// A fold-spec-constant-op-and-composite pass folds spec constants defined by
+// OpSpecConstantOp or OpSpecConstantComposite instruction, to normal Constants
+// defined by OpConstantTrue, OpConstantFalse, OpConstant, OpConstantNull, or
+// OpConstantComposite instructions. Note that spec constants defined with
+// OpSpecConstant, OpSpecConstantTrue, or OpSpecConstantFalse instructions are
+// not handled, as these instructions indicate their value are not determined
+// and can be changed in future. A spec constant is foldable if all of its
+// value(s) can be determined from the module. E.g., an integer spec constant
+// defined with OpSpecConstantOp instruction can be folded if its value won't
+// change later. This pass will replace the original OpSpecContantOp instruction
+// with an OpConstant instruction. When folding composite spec constants,
+// new instructions may be inserted to define the components of the composite
+// constant first, then the original spec constants will be replaced by
+// OpConstantComposite instructions.
+//
+// There are some operations not supported yet:
+//   OpSConvert, OpFConvert, OpQuantizeToF16 and
+//   all the operations under Kernel capability.
+// TODO(qining): Add support for the operations listed above.
+Optimizer::PassToken CreateFoldSpecConstantOpAndCompositePass();
+
+// Creates a unify-constant pass.
+// A unify-constant pass de-duplicates the constants. Constants with the exact
+// same value and identical form will be unified and only one constant will
+// be kept for each unique pair of type and value.
+// There are several cases not handled by this pass:
+//  1) Constants defined by OpConstantNull instructions (null constants) and
+//  constants defined by OpConstantFalse, OpConstant or OpConstantComposite
+//  with value 0 (zero-valued normal constants) are not considered equivalent.
+//  So null constants won't be used to replace zero-valued normal constants,
+//  vice versa.
+//  2) Whenever there are decorations to the constant's result id id, the
+//  constant won't be handled, which means, it won't be used to replace any
+//  other constants, neither can other constants replace it.
+//  3) NaN in float point format with different bit patterns are not unified.
+Optimizer::PassToken CreateUnifyConstantPass();
+
+// Creates a eliminate-dead-constant pass.
+// A eliminate-dead-constant pass removes dead constants, including normal
+// contants defined by OpConstant, OpConstantComposite, OpConstantTrue, or
+// OpConstantFalse and spec constants defined by OpSpecConstant,
+// OpSpecConstantComposite, OpSpecConstantTrue, OpSpecConstantFalse or
+// OpSpecConstantOp.
+Optimizer::PassToken CreateEliminateDeadConstantPass();
+
+}  // namespace spvtools
+
+#endif  // SPIRV_TOOLS_OPTIMIZER_HPP_
diff --git a/source/opt/set_spec_constant_default_value_pass.h b/source/opt/set_spec_constant_default_value_pass.h
index 89e6b28..ad6b142 100644
--- a/source/opt/set_spec_constant_default_value_pass.h
+++ b/source/opt/set_spec_constant_default_value_pass.h
@@ -25,9 +25,7 @@
 namespace spvtools {
 namespace opt {
 
-// The optimization pass that sets the default values for the spec constants
-// that have SpecId decorations (i.e. those defined by
-// OpSpecConstant{|True|False} instructions).
+// See optimizer.hpp for documentation.
 class SetSpecConstantDefaultValuePass : public Pass {
  public:
   using SpecIdToValueStrMap = std::unordered_map<uint32_t, std::string>;
diff --git a/source/opt/strip_debug_info_pass.h b/source/opt/strip_debug_info_pass.h
index 0c3216d..626f9a8 100644
--- a/source/opt/strip_debug_info_pass.h
+++ b/source/opt/strip_debug_info_pass.h
@@ -21,8 +21,7 @@
 namespace spvtools {
 namespace opt {
 
-// The optimization pass for removing debug instructions (as documented in
-// Section 3.32.2 of the SPIR-V spec).
+// See optimizer.hpp for documentation.
 class StripDebugInfoPass : public Pass {
  public:
   const char* name() const override { return "strip-debug"; }
diff --git a/source/opt/unify_const_pass.h b/source/opt/unify_const_pass.h
index 1a45089..4fd8c64 100644
--- a/source/opt/unify_const_pass.h
+++ b/source/opt/unify_const_pass.h
@@ -21,19 +21,7 @@
 namespace spvtools {
 namespace opt {
 
-// The optimization pass to de-duplicate the constants. Constants with exactly
-// same values and identical form will be unified and only one constant will be
-// kept for each unique pair of type and value.
-// There are several cases not handled by this pass:
-//  1) Constants defined by OpConstantNull instructions (null constants) and
-//  constants defined by OpConstantFalse, OpConstant or OpConstantComposite
-//  with value(s) 0 (zero-valued normal constants) are not considered
-//  equivalent. So null constants won't be used to replace zero-valued normal
-//  constants, and other constants won't replace the null constants either.
-//  2) Whenever there are decorations to the constant's result id or its type
-//  id, the constants won't be handled, which means, it won't be used to
-//  replace any other constants, neither can other constants replace it.
-//  3) NaN in float point format with different bit patterns are not unified.
+// See optimizer.hpp for documentation.
 class UnifyConstantPass : public Pass {
  public:
   const char* name() const override { return "unify-const"; }
diff --git a/test/cpp_interface.cpp b/test/cpp_interface.cpp
index ce0d5be..c24c35a 100644
--- a/test/cpp_interface.cpp
+++ b/test/cpp_interface.cpp
@@ -15,7 +15,7 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-#include "opt/libspirv.hpp"
+#include "opt/optimizer.hpp"
 #include "spirv/1.1/spirv.h"
 
 namespace {
@@ -160,4 +160,104 @@
   EXPECT_EQ(1, invocation_count);
 }
 
+// Checks that after running the given optimizer |opt| on the given |original|
+// source code, we can get the given |optimized| source code.
+void CheckOptimization(const char* original, const char* optimized,
+                       const Optimizer& opt) {
+  SpvTools t(SPV_ENV_UNIVERSAL_1_1);
+  std::vector<uint32_t> original_binary;
+  ASSERT_TRUE(t.Assemble(original, &original_binary));
+
+  std::vector<uint32_t> optimized_binary;
+  EXPECT_TRUE(opt.Run(original_binary.data(), original_binary.size(),
+                      &optimized_binary));
+
+  std::string optimized_text;
+  EXPECT_TRUE(t.Disassemble(optimized_binary, &optimized_text));
+  EXPECT_EQ(optimized, optimized_text);
+}
+
+TEST(CppInterface, OptimizeEmptyModule) {
+  SpvTools t(SPV_ENV_UNIVERSAL_1_1);
+  std::vector<uint32_t> binary;
+  EXPECT_TRUE(t.Assemble("", &binary));
+
+  Optimizer o(SPV_ENV_UNIVERSAL_1_1);
+  o.RegisterPass(CreateStripDebugInfoPass());
+  EXPECT_TRUE(o.Run(binary.data(), binary.size(), &binary));
+}
+
+TEST(CppInterface, OptimizeModifiedModule) {
+  Optimizer o(SPV_ENV_UNIVERSAL_1_1);
+  o.RegisterPass(CreateStripDebugInfoPass());
+  CheckOptimization("OpSource GLSL 450", "", o);
+}
+
+TEST(CppInterface, OptimizeMulitplePasses) {
+  const char* original_text =
+      "OpSource GLSL 450 "
+      "OpDecorate %true SpecId 1 "
+      "%bool = OpTypeBool "
+      "%true = OpSpecConstantTrue %bool";
+
+  Optimizer o(SPV_ENV_UNIVERSAL_1_1);
+  o.RegisterPass(CreateStripDebugInfoPass())
+      .RegisterPass(CreateFreezeSpecConstantValuePass());
+
+  const char* expected_text =
+      "%bool = OpTypeBool\n"
+      "%1 = OpConstantTrue %bool\n";
+
+  CheckOptimization(original_text, expected_text, o);
+}
+
+TEST(CppInterface, OptimizeDoNothingWithPassToken) {
+  CreateFreezeSpecConstantValuePass();
+  auto token = CreateUnifyConstantPass();
+}
+
+TEST(CppInterface, OptimizeReassignPassToken) {
+  auto token = CreateNullPass();
+  token = CreateStripDebugInfoPass();
+
+  CheckOptimization(
+      "OpSource GLSL 450", "",
+      Optimizer(SPV_ENV_UNIVERSAL_1_1).RegisterPass(std::move(token)));
+}
+
+TEST(CppInterface, OptimizeMoveConstructPassToken) {
+  auto token1 = CreateStripDebugInfoPass();
+  Optimizer::PassToken token2(std::move(token1));
+
+  CheckOptimization(
+      "OpSource GLSL 450", "",
+      Optimizer(SPV_ENV_UNIVERSAL_1_1).RegisterPass(std::move(token2)));
+}
+
+TEST(CppInterface, OptimizeMoveAssignPassToken) {
+  auto token1 = CreateStripDebugInfoPass();
+  auto token2 = CreateNullPass();
+  token2 = std::move(token1);
+
+  CheckOptimization(
+      "OpSource GLSL 450", "",
+      Optimizer(SPV_ENV_UNIVERSAL_1_1).RegisterPass(std::move(token2)));
+}
+
+TEST(CppInterface, OptimizeSameAddressForOriginalOptimizedBinary) {
+  SpvTools t(SPV_ENV_UNIVERSAL_1_1);
+  std::vector<uint32_t> binary;
+  ASSERT_TRUE(t.Assemble("OpSource GLSL 450", &binary));
+
+  EXPECT_TRUE(Optimizer(SPV_ENV_UNIVERSAL_1_1)
+                  .RegisterPass(CreateStripDebugInfoPass())
+                  .Run(binary.data(), binary.size(), &binary));
+
+  std::string optimized_text;
+  EXPECT_TRUE(t.Disassemble(binary, &optimized_text));
+  EXPECT_EQ("", optimized_text);
+}
+
+// TODO(antiagainst): tests for SetMessageConsumer().
+
 }  // anonymous namespace