diff --git a/compiler/optimizing/optimizing_unit_test.h b/compiler/optimizing/optimizing_unit_test.h
index e5f6941..0157126 100644
--- a/compiler/optimizing/optimizing_unit_test.h
+++ b/compiler/optimizing/optimizing_unit_test.h
@@ -194,8 +194,7 @@
   ImprovedOptimizingUnitTest() : graph_(CreateGraph()),
                                  entry_block_(nullptr),
                                  return_block_(nullptr),
-                                 exit_block_(nullptr),
-                                 parameter_(nullptr) {}
+                                 exit_block_(nullptr) {}
 
   virtual ~ImprovedOptimizingUnitTest() {}
 
@@ -214,11 +213,11 @@
     entry_block_->AddSuccessor(return_block_);
     return_block_->AddSuccessor(exit_block_);
 
-    parameter_ = new (GetAllocator()) HParameterValue(graph_->GetDexFile(),
-                                                      dex::TypeIndex(0),
-                                                      0,
-                                                      DataType::Type::kInt32);
-    entry_block_->AddInstruction(parameter_);
+    CreateParameters();
+    for (HInstruction* parameter : parameters_) {
+      entry_block_->AddInstruction(parameter);
+    }
+
     return_block_->AddInstruction(new (GetAllocator()) HReturnVoid());
     exit_block_->AddInstruction(new (GetAllocator()) HExit());
   }
@@ -250,13 +249,17 @@
   }
 
  protected:
+  // Create parameters to be added to the graph entry block.
+  // Subclasses can override it to create parameters they need.
+  virtual void CreateParameters() { /* do nothing */ }
+
   HGraph* graph_;
 
   HBasicBlock* entry_block_;
   HBasicBlock* return_block_;
   HBasicBlock* exit_block_;
 
-  HInstruction* parameter_;
+  std::vector<HInstruction*> parameters_;
 };
 
 // Naive string diff data type.
