Revert "[arm] Shorter test names for parameterized tests."

test/compiler-unittests/arm/instruction-selector-arm-unittest.cc

 // Copyright 2014 the V8 project 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 "test/compiler-unittests/instruction-selector-unittest.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
@@ skipping 100 matching lines @@
     1073741855,  1073741861,  1073741884,  1157627904,  1476395008,
     1476395010,  1610612741,  2030043136,  2080374785,  2097152000};
 
 }  // namespace
 
 
 // -----------------------------------------------------------------------------
 // Data processing instructions.
 
 
-namespace {
-
-class DPITest : public InstructionSelectorTestWithParam<DPI> {};
+typedef InstructionSelectorTestWithParam<DPI> InstructionSelectorDPITest;
 
 
-TEST_P(DPITest, Parameters) {
+TEST_P(InstructionSelectorDPITest, Parameters) {
   const DPI dpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   m.Return((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(2U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
 }
 
 
-TEST_P(DPITest, Immediate) {
+TEST_P(InstructionSelectorDPITest, Immediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     m.Return((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(1U, s[0]->OutputCount());
   }
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     m.Return((m.*dpi.constructor)(m.Int32Constant(imm), m.Parameter(0)));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.reverse_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(1U, s[0]->OutputCount());
   }
 }
 
 
-TEST_P(DPITest, ShiftByParameter) {
+TEST_P(InstructionSelectorDPITest, ShiftByParameter) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
     m.Return((m.*dpi.constructor)(
         m.Parameter(0),
         (m.*shift.constructor)(m.Parameter(1), m.Parameter(2))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(3U, s[0]->InputCount());
     EXPECT_EQ(1U, s[0]->OutputCount());
   }
   TRACED_FOREACH(Shift, shift, kShifts) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
     m.Return((m.*dpi.constructor)(
         (m.*shift.constructor)(m.Parameter(0), m.Parameter(1)),
         m.Parameter(2)));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.reverse_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(3U, s[0]->InputCount());
     EXPECT_EQ(1U, s[0]->OutputCount());
   }
 }
 
 
-TEST_P(DPITest, ShiftByImmediate) {
+TEST_P(InstructionSelectorDPITest, ShiftByImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
       StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
       m.Return((m.*dpi.constructor)(
           m.Parameter(0),
           (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm))));
       Stream s = m.Build();
       ASSERT_EQ(1U, s.size());
       EXPECT_EQ(dpi.arch_opcode, s[0]->arch_opcode());
@@ skipping 14 matching lines @@
       EXPECT_EQ(dpi.reverse_arch_opcode, s[0]->arch_opcode());
       EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
       ASSERT_EQ(3U, s[0]->InputCount());
       EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
       EXPECT_EQ(1U, s[0]->OutputCount());
     }
   }
 }
 
 
-TEST_P(DPITest, BranchWithParameters) {
+TEST_P(InstructionSelectorDPITest, BranchWithParameters) {
   const DPI dpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   MLabel a, b;
   m.Branch((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)), &a, &b);
   m.Bind(&a);
   m.Return(m.Int32Constant(1));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kNotEqual, s[0]->flags_condition());
 }
 
 
-TEST_P(DPITest, BranchWithImmediate) {
+TEST_P(InstructionSelectorDPITest, BranchWithImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     MLabel a, b;
     m.Branch((m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)), &a,
              &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
     m.Bind(&b);
     m.Return(m.Int32Constant(0));
@@ skipping 16 matching lines @@
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kNotEqual, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(DPITest, BranchWithShiftByParameter) {
+TEST_P(InstructionSelectorDPITest, BranchWithShiftByParameter) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
     MLabel a, b;
     m.Branch((m.*dpi.constructor)(
                  m.Parameter(0),
                  (m.*shift.constructor)(m.Parameter(1), m.Parameter(2))),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
@@ skipping 20 matching lines @@
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kNotEqual, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(DPITest, BranchWithShiftByImmediate) {
+TEST_P(InstructionSelectorDPITest, BranchWithShiftByImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
       StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
       MLabel a, b;
       m.Branch((m.*dpi.constructor)(m.Parameter(0),
                                     (m.*shift.constructor)(
                                         m.Parameter(1), m.Int32Constant(imm))),
                &a, &b);
       m.Bind(&a);
@@ skipping 28 matching lines @@
       EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
       ASSERT_EQ(5U, s[0]->InputCount());
       EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
       EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
       EXPECT_EQ(kNotEqual, s[0]->flags_condition());
     }
   }
 }
 
 
-TEST_P(DPITest, BranchIfZeroWithParameters) {
+TEST_P(InstructionSelectorDPITest, BranchIfZeroWithParameters) {
   const DPI dpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   MLabel a, b;
   m.Branch(m.Word32Equal((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)),
                          m.Int32Constant(0)),
            &a, &b);
   m.Bind(&a);
   m.Return(m.Int32Constant(1));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kEqual, s[0]->flags_condition());
 }
 
 
-TEST_P(DPITest, BranchIfNotZeroWithParameters) {
+TEST_P(InstructionSelectorDPITest, BranchIfNotZeroWithParameters) {
   const DPI dpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   MLabel a, b;
   m.Branch(
       m.Word32NotEqual((m.*dpi.constructor)(m.Parameter(0), m.Parameter(1)),
                        m.Int32Constant(0)),
       &a, &b);
   m.Bind(&a);
   m.Return(m.Int32Constant(1));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kNotEqual, s[0]->flags_condition());
 }
 
 
-TEST_P(DPITest, BranchIfZeroWithImmediate) {
+TEST_P(InstructionSelectorDPITest, BranchIfZeroWithImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     MLabel a, b;
     m.Branch(m.Word32Equal(
                  (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)),
                  m.Int32Constant(0)),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
@@ skipping 20 matching lines @@
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kEqual, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(DPITest, BranchIfNotZeroWithImmediate) {
+TEST_P(InstructionSelectorDPITest, BranchIfNotZeroWithImmediate) {
   const DPI dpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     MLabel a, b;
     m.Branch(m.Word32NotEqual(
                  (m.*dpi.constructor)(m.Parameter(0), m.Int32Constant(imm)),
                  m.Int32Constant(0)),
              &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(1));
@@ skipping 19 matching lines @@
     m.Return(m.Int32Constant(0));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(dpi.test_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kNotEqual, s[0]->flags_condition());
   }
 }
 
-}  // namespace
 
-
-INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, DPITest,
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorDPITest,
                         ::testing::ValuesIn(kDPIs));
 
 
 // -----------------------------------------------------------------------------
 // Data processing instructions with overflow.
 
 
-namespace {
-
-class ODPITest : public InstructionSelectorTestWithParam<ODPI> {};
+typedef InstructionSelectorTestWithParam<ODPI> InstructionSelectorODPITest;
 
 
-TEST_P(ODPITest, OvfWithParameters) {
+TEST_P(InstructionSelectorODPITest, OvfWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   m.Return(
       m.Projection(1, (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1))));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(2U, s[0]->InputCount());
   EXPECT_LE(1U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_set, s[0]->flags_mode());
   EXPECT_EQ(kOverflow, s[0]->flags_condition());
 }
 
 
-TEST_P(ODPITest, OvfWithImmediate) {
+TEST_P(InstructionSelectorODPITest, OvfWithImmediate) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     m.Return(m.Projection(
         1, (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
@@ skipping 12 matching lines @@
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_LE(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_set, s[0]->flags_mode());
     EXPECT_EQ(kOverflow, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(ODPITest, OvfWithShiftByParameter) {
+TEST_P(InstructionSelectorODPITest, OvfWithShiftByParameter) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
     m.Return(m.Projection(
         1, (m.*odpi.constructor)(
                m.Parameter(0),
                (m.*shift.constructor)(m.Parameter(1), m.Parameter(2)))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
@@ skipping 14 matching lines @@
     EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(3U, s[0]->InputCount());
     EXPECT_LE(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_set, s[0]->flags_mode());
     EXPECT_EQ(kOverflow, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(ODPITest, OvfWithShiftByImmediate) {
+TEST_P(InstructionSelectorODPITest, OvfWithShiftByImmediate) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
       StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
       m.Return(m.Projection(
           1, (m.*odpi.constructor)(m.Parameter(0),
                                    (m.*shift.constructor)(
                                        m.Parameter(1), m.Int32Constant(imm)))));
       Stream s = m.Build();
       ASSERT_EQ(1U, s.size());
@@ skipping 20 matching lines @@
       ASSERT_EQ(3U, s[0]->InputCount());
       EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
       EXPECT_LE(1U, s[0]->OutputCount());
       EXPECT_EQ(kFlags_set, s[0]->flags_mode());
       EXPECT_EQ(kOverflow, s[0]->flags_condition());
     }
   }
 }
 
 
-TEST_P(ODPITest, ValWithParameters) {
+TEST_P(InstructionSelectorODPITest, ValWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   m.Return(
       m.Projection(0, (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1))));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(2U, s[0]->InputCount());
   EXPECT_LE(1U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_none, s[0]->flags_mode());
 }
 
 
-TEST_P(ODPITest, ValWithImmediate) {
+TEST_P(InstructionSelectorODPITest, ValWithImmediate) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     m.Return(m.Projection(
         0, (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
@@ skipping 10 matching lines @@
     EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_LE(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_none, s[0]->flags_mode());
   }
 }
 
 
-TEST_P(ODPITest, ValWithShiftByParameter) {
+TEST_P(InstructionSelectorODPITest, ValWithShiftByParameter) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
     m.Return(m.Projection(
         0, (m.*odpi.constructor)(
                m.Parameter(0),
                (m.*shift.constructor)(m.Parameter(1), m.Parameter(2)))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
@@ skipping 12 matching lines @@
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(3U, s[0]->InputCount());
     EXPECT_LE(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_none, s[0]->flags_mode());
   }
 }
 
 
-TEST_P(ODPITest, ValWithShiftByImmediate) {
+TEST_P(InstructionSelectorODPITest, ValWithShiftByImmediate) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
       StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
       m.Return(m.Projection(
           0, (m.*odpi.constructor)(m.Parameter(0),
                                    (m.*shift.constructor)(
                                        m.Parameter(1), m.Int32Constant(imm)))));
       Stream s = m.Build();
       ASSERT_EQ(1U, s.size());
@@ skipping 18 matching lines @@
       EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
       ASSERT_EQ(3U, s[0]->InputCount());
       EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
       EXPECT_LE(1U, s[0]->OutputCount());
       EXPECT_EQ(kFlags_none, s[0]->flags_mode());
     }
   }
 }
 
 
-TEST_P(ODPITest, BothWithParameters) {
+TEST_P(InstructionSelectorODPITest, BothWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
   m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
   Stream s = m.Build();
   ASSERT_LE(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(2U, s[0]->InputCount());
   EXPECT_EQ(2U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_set, s[0]->flags_mode());
   EXPECT_EQ(kOverflow, s[0]->flags_condition());
 }
 
 
-TEST_P(ODPITest, BothWithImmediate) {
+TEST_P(InstructionSelectorODPITest, BothWithImmediate) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm));
     m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
     Stream s = m.Build();
     ASSERT_LE(1U, s.size());
     EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
@@ skipping 12 matching lines @@
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(2U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_set, s[0]->flags_mode());
     EXPECT_EQ(kOverflow, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(ODPITest, BothWithShiftByParameter) {
+TEST_P(InstructionSelectorODPITest, BothWithShiftByParameter) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
     Node* n = (m.*odpi.constructor)(
         m.Parameter(0), (m.*shift.constructor)(m.Parameter(1), m.Parameter(2)));
     m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
     Stream s = m.Build();
     ASSERT_LE(1U, s.size());
     EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
@@ skipping 12 matching lines @@
     EXPECT_EQ(odpi.reverse_arch_opcode, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(3U, s[0]->InputCount());
     EXPECT_EQ(2U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_set, s[0]->flags_mode());
     EXPECT_EQ(kOverflow, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(ODPITest, BothWithShiftByImmediate) {
+TEST_P(InstructionSelectorODPITest, BothWithShiftByImmediate) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(Shift, shift, kShifts) {
     TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
       StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
       Node* n = (m.*odpi.constructor)(
           m.Parameter(0),
           (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm)));
       m.Return(m.Word32Equal(m.Projection(0, n), m.Projection(1, n)));
       Stream s = m.Build();
       ASSERT_LE(1U, s.size());
@@ skipping 20 matching lines @@
       ASSERT_EQ(3U, s[0]->InputCount());
       EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
       EXPECT_EQ(2U, s[0]->OutputCount());
       EXPECT_EQ(kFlags_set, s[0]->flags_mode());
       EXPECT_EQ(kOverflow, s[0]->flags_condition());
     }
   }
 }
 
 
-TEST_P(ODPITest, BranchWithParameters) {
+TEST_P(InstructionSelectorODPITest, BranchWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   MLabel a, b;
   Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
   m.Branch(m.Projection(1, n), &a, &b);
   m.Bind(&a);
   m.Return(m.Int32Constant(0));
   m.Bind(&b);
   m.Return(m.Projection(0, n));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(4U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kOverflow, s[0]->flags_condition());
 }
 
 
-TEST_P(ODPITest, BranchWithImmediate) {
+TEST_P(InstructionSelectorODPITest, BranchWithImmediate) {
   const ODPI odpi = GetParam();
   TRACED_FOREACH(int32_t, imm, kImmediates) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     MLabel a, b;
     Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Int32Constant(imm));
     m.Branch(m.Projection(1, n), &a, &b);
     m.Bind(&a);
     m.Return(m.Int32Constant(0));
     m.Bind(&b);
     m.Return(m.Projection(0, n));
@@ skipping 22 matching lines @@
     EXPECT_EQ(kMode_Operand2_I, s[0]->addressing_mode());
     ASSERT_EQ(4U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
     EXPECT_EQ(kOverflow, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(ODPITest, BranchIfZeroWithParameters) {
+TEST_P(InstructionSelectorODPITest, BranchIfZeroWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   MLabel a, b;
   Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
   m.Branch(m.Word32Equal(m.Projection(1, n), m.Int32Constant(0)), &a, &b);
   m.Bind(&a);
   m.Return(m.Projection(0, n));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(4U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kNotOverflow, s[0]->flags_condition());
 }
 
 
-TEST_P(ODPITest, BranchIfNotZeroWithParameters) {
+TEST_P(InstructionSelectorODPITest, BranchIfNotZeroWithParameters) {
   const ODPI odpi = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   MLabel a, b;
   Node* n = (m.*odpi.constructor)(m.Parameter(0), m.Parameter(1));
   m.Branch(m.Word32NotEqual(m.Projection(1, n), m.Int32Constant(0)), &a, &b);
   m.Bind(&a);
   m.Return(m.Projection(0, n));
   m.Bind(&b);
   m.Return(m.Int32Constant(0));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(odpi.arch_opcode, s[0]->arch_opcode());
   EXPECT_EQ(kMode_Operand2_R, s[0]->addressing_mode());
   EXPECT_EQ(4U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_branch, s[0]->flags_mode());
   EXPECT_EQ(kOverflow, s[0]->flags_condition());
 }
 
 
-}  // namespace
-
-INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, ODPITest,
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorODPITest,
                         ::testing::ValuesIn(kODPIs));
 
 
 // -----------------------------------------------------------------------------
 // Shifts.
 
 
-namespace {
-
-class ShiftTest : public InstructionSelectorTestWithParam<Shift> {};
+typedef InstructionSelectorTestWithParam<Shift> InstructionSelectorShiftTest;
 
 
-TEST_P(ShiftTest, Parameters) {
+TEST_P(InstructionSelectorShiftTest, Parameters) {
   const Shift shift = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   m.Return((m.*shift.constructor)(m.Parameter(0), m.Parameter(1)));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(kArmMov, s[0]->arch_opcode());
   EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
   EXPECT_EQ(2U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
 }
 
 
-TEST_P(ShiftTest, Immediate) {
+TEST_P(InstructionSelectorShiftTest, Immediate) {
   const Shift shift = GetParam();
   TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     m.Return((m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm)));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(kArmMov, s[0]->arch_opcode());
     EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(1U, s[0]->OutputCount());
   }
 }
 
 
-TEST_P(ShiftTest, Word32EqualWithParameter) {
+TEST_P(InstructionSelectorShiftTest, Word32EqualWithParameter) {
   const Shift shift = GetParam();
   {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
     m.Return(
         m.Word32Equal(m.Parameter(0),
                       (m.*shift.constructor)(m.Parameter(1), m.Parameter(2))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
@@ skipping 12 matching lines @@
     EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
     EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
     EXPECT_EQ(3U, s[0]->InputCount());
     EXPECT_EQ(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_set, s[0]->flags_mode());
     EXPECT_EQ(kEqual, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(ShiftTest, Word32EqualWithParameterAndImmediate) {
+TEST_P(InstructionSelectorShiftTest, Word32EqualWithParameterAndImmediate) {
   const Shift shift = GetParam();
   TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
     m.Return(m.Word32Equal(
         (m.*shift.constructor)(m.Parameter(1), m.Int32Constant(imm)),
         m.Parameter(0)));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(kArmCmp, s[0]->arch_opcode());
     EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
@@ skipping 14 matching lines @@
     EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
     ASSERT_EQ(3U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
     EXPECT_EQ(1U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_set, s[0]->flags_mode());
     EXPECT_EQ(kEqual, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(ShiftTest, Word32EqualToZeroWithParameters) {
+TEST_P(InstructionSelectorShiftTest, Word32EqualToZeroWithParameters) {
   const Shift shift = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   m.Return(
       m.Word32Equal(m.Int32Constant(0),
                     (m.*shift.constructor)(m.Parameter(0), m.Parameter(1))));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(kArmMov, s[0]->arch_opcode());
   EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
   EXPECT_EQ(2U, s[0]->InputCount());
   EXPECT_EQ(2U, s[0]->OutputCount());
   EXPECT_EQ(kFlags_set, s[0]->flags_mode());
   EXPECT_EQ(kEqual, s[0]->flags_condition());
 }
 
 
-TEST_P(ShiftTest, Word32EqualToZeroWithImmediate) {
+TEST_P(InstructionSelectorShiftTest, Word32EqualToZeroWithImmediate) {
   const Shift shift = GetParam();
   TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
     m.Return(m.Word32Equal(
         m.Int32Constant(0),
         (m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(kArmMov, s[0]->arch_opcode());
     EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(2U, s[0]->OutputCount());
     EXPECT_EQ(kFlags_set, s[0]->flags_mode());
     EXPECT_EQ(kEqual, s[0]->flags_condition());
   }
 }
 
 
-TEST_P(ShiftTest, Word32NotWithParameters) {
+TEST_P(InstructionSelectorShiftTest, Word32NotWithParameters) {
   const Shift shift = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
   m.Return(m.Word32Not((m.*shift.constructor)(m.Parameter(0), m.Parameter(1))));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(kArmMvn, s[0]->arch_opcode());
   EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
   EXPECT_EQ(2U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
 }
 
 
-TEST_P(ShiftTest, Word32NotWithImmediate) {
+TEST_P(InstructionSelectorShiftTest, Word32NotWithImmediate) {
   const Shift shift = GetParam();
   TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
     StreamBuilder m(this, kMachInt32, kMachInt32);
     m.Return(m.Word32Not(
         (m.*shift.constructor)(m.Parameter(0), m.Int32Constant(imm))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(kArmMvn, s[0]->arch_opcode());
     EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
     ASSERT_EQ(2U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(1)));
     EXPECT_EQ(1U, s[0]->OutputCount());
   }
 }
 
 
-TEST_P(ShiftTest, Word32AndWithWord32NotWithParameters) {
+TEST_P(InstructionSelectorShiftTest, Word32AndWithWord32NotWithParameters) {
   const Shift shift = GetParam();
   StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
   m.Return(m.Word32And(m.Parameter(0), m.Word32Not((m.*shift.constructor)(
                                            m.Parameter(1), m.Parameter(2)))));
   Stream s = m.Build();
   ASSERT_EQ(1U, s.size());
   EXPECT_EQ(kArmBic, s[0]->arch_opcode());
   EXPECT_EQ(shift.r_mode, s[0]->addressing_mode());
   EXPECT_EQ(3U, s[0]->InputCount());
   EXPECT_EQ(1U, s[0]->OutputCount());
 }
 
 
-TEST_P(ShiftTest, Word32AndWithWord32NotWithImmediate) {
+TEST_P(InstructionSelectorShiftTest, Word32AndWithWord32NotWithImmediate) {
   const Shift shift = GetParam();
   TRACED_FORRANGE(int32_t, imm, shift.i_low, shift.i_high) {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32);
     m.Return(m.Word32And(m.Parameter(0),
                          m.Word32Not((m.*shift.constructor)(
                              m.Parameter(1), m.Int32Constant(imm)))));
     Stream s = m.Build();
     ASSERT_EQ(1U, s.size());
     EXPECT_EQ(kArmBic, s[0]->arch_opcode());
     EXPECT_EQ(shift.i_mode, s[0]->addressing_mode());
     ASSERT_EQ(3U, s[0]->InputCount());
     EXPECT_EQ(imm, s.ToInt32(s[0]->InputAt(2)));
     EXPECT_EQ(1U, s[0]->OutputCount());
   }
 }
 
 
-}  // namespace
-
-
-INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, ShiftTest,
+INSTANTIATE_TEST_CASE_P(InstructionSelectorTest, InstructionSelectorShiftTest,
                         ::testing::ValuesIn(kShifts));
 
 
 // -----------------------------------------------------------------------------
 // Miscellaneous.
 
 
 TEST_F(InstructionSelectorTest, Int32AddWithInt32Mul) {
   {
     StreamBuilder m(this, kMachInt32, kMachInt32, kMachInt32, kMachInt32);
@@ skipping 544 matching lines @@
       ASSERT_EQ(3U, s[0]->InputCount());
       EXPECT_EQ(lsb, s.ToInt32(s[0]->InputAt(1)));
       EXPECT_EQ(width, s.ToInt32(s[0]->InputAt(2)));
     }
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8