[strong] Refactor ObjectStrength into a replacement for strong boolean args

test/unittests/compiler/js-operator-unittest.cc

Index: test/unittests/compiler/js-operator-unittest.cc
diff --git a/test/unittests/compiler/js-operator-unittest.cc b/test/unittests/compiler/js-operator-unittest.cc
index 20b0367864bc304f5da3c49a2fd1622969822e31..f788c61955235dd93275ce11245be3e2b2a6e44d 100644
--- a/test/unittests/compiler/js-operator-unittest.cc
+++ b/test/unittests/compiler/js-operator-unittest.cc
@@ -14,7 +14,13 @@ namespace compiler {
 
 namespace {
 
-const LanguageMode kLanguageModes[] = {SLOPPY, STRICT, STRONG};
+
+const LanguageMode kLanguageModes[] = {
+    LanguageMode::SLOPPY, LanguageMode::STRICT, LanguageMode::STRONG};
+
+
+const LanguageMode kLanguageModesForStrength[] = {LanguageMode::SLOPPY,
+                                                  LanguageMode::STRONG};
 
 
 #if GTEST_HAS_COMBINE
@@ -155,15 +161,14 @@ INSTANTIATE_TEST_CASE_P(JSOperatorTest, JSSharedOperatorTest,
 
 
 // -----------------------------------------------------------------------------
-// Shared operators with language mode.
-
+// Shared operators with strength.
 
 #if GTEST_HAS_COMBINE
 
 namespace {
 
-struct SharedOperatorWithLanguageMode {
-  const Operator* (JSOperatorBuilder::*constructor)(LanguageMode);
+struct SharedOperatorWithStrength {
+  const Operator* (JSOperatorBuilder::*constructor)(Strength);
   IrOpcode::Value opcode;
   Operator::Properties properties;
   int value_input_count;
@@ -176,7 +181,7 @@ struct SharedOperatorWithLanguageMode {
 };
 
 
-const SharedOperatorWithLanguageMode kSharedOperatorsWithLanguageMode[] = {
+const SharedOperatorWithStrength kSharedOperatorsWithStrength[] = {
 #define SHARED(Name, properties, value_input_count, frame_state_input_count, \
                effect_input_count, control_input_count, value_output_count,  \
                effect_output_count, control_output_count)                    \
@@ -200,8 +205,116 @@ const SharedOperatorWithLanguageMode kSharedOperatorsWithLanguageMode[] = {
     SHARED(Subtract, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2),
     SHARED(Multiply, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2),
     SHARED(Divide, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2),
-    SHARED(Modulus, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2),
-    SHARED(StoreProperty, Operator::kNoProperties, 3, 2, 1, 1, 0, 1, 2),
+    SHARED(Modulus, Operator::kNoProperties, 2, 2, 1, 1, 1, 1, 2)
+#undef SHARED
+};
+
+
+std::ostream& operator<<(std::ostream& os,
+                         const SharedOperatorWithStrength& sop) {
+  return os << IrOpcode::Mnemonic(sop.opcode);
+}
+
+}  // namespace
+
+
+class JSSharedOperatorWithStrengthTest
+    : public JSOperatorTestWithLanguageModeAndParam<
+          SharedOperatorWithStrength> {};
+
+
+TEST_P(JSSharedOperatorWithStrengthTest, InstancesAreGloballyShared) {
+  const SharedOperatorWithStrength& sop = GetParam();
+  JSOperatorBuilder javascript1(zone());
+  JSOperatorBuilder javascript2(zone());
+  EXPECT_EQ((javascript1.*sop.constructor)(strength(language_mode())),
+            (javascript2.*sop.constructor)(strength(language_mode())));
+}
+
+
+TEST_P(JSSharedOperatorWithStrengthTest, NumberOfInputsAndOutputs) {
+  JSOperatorBuilder javascript(zone());
+  const SharedOperatorWithStrength& sop = GetParam();
+  const Operator* op = (javascript.*sop.constructor)(strength(language_mode()));
+
+  const int context_input_count = 1;
+  EXPECT_EQ(sop.value_input_count, op->ValueInputCount());
+  EXPECT_EQ(context_input_count, OperatorProperties::GetContextInputCount(op));
+  EXPECT_EQ(sop.frame_state_input_count,
+            OperatorProperties::GetFrameStateInputCount(op));
+  EXPECT_EQ(sop.effect_input_count, op->EffectInputCount());
+  EXPECT_EQ(sop.control_input_count, op->ControlInputCount());
+  EXPECT_EQ(sop.value_input_count + context_input_count +
+                sop.frame_state_input_count + sop.effect_input_count +
+                sop.control_input_count,
+            OperatorProperties::GetTotalInputCount(op));
+
+  EXPECT_EQ(sop.value_output_count, op->ValueOutputCount());
+  EXPECT_EQ(sop.effect_output_count, op->EffectOutputCount());
+  EXPECT_EQ(sop.control_output_count, op->ControlOutputCount());
+}
+
+
+TEST_P(JSSharedOperatorWithStrengthTest, OpcodeIsCorrect) {
+  JSOperatorBuilder javascript(zone());
+  const SharedOperatorWithStrength& sop = GetParam();
+  const Operator* op = (javascript.*sop.constructor)(strength(language_mode()));
+  EXPECT_EQ(sop.opcode, op->opcode());
+}
+
+
+TEST_P(JSSharedOperatorWithStrengthTest, Parameter) {
+  JSOperatorBuilder javascript(zone());
+  const SharedOperatorWithStrength& sop = GetParam();
+  const Operator* op = (javascript.*sop.constructor)(strength(language_mode()));
+  EXPECT_EQ(strength(language_mode()), OpParameter<Strength>(op));
+}
+
+
+TEST_P(JSSharedOperatorWithStrengthTest, Properties) {
+  JSOperatorBuilder javascript(zone());
+  const SharedOperatorWithStrength& sop = GetParam();
+  const Operator* op = (javascript.*sop.constructor)(strength(language_mode()));
+  EXPECT_EQ(sop.properties, op->properties());
+}
+
+
+INSTANTIATE_TEST_CASE_P(
+    JSOperatorTest, JSSharedOperatorWithStrengthTest,
+    ::testing::Combine(::testing::ValuesIn(kLanguageModesForStrength),
+                       ::testing::ValuesIn(kSharedOperatorsWithStrength)));
+
+
+// -----------------------------------------------------------------------------
+// Shared operators with language mode.
+
+namespace {
+
+struct SharedOperatorWithLanguageMode {
+  const Operator* (JSOperatorBuilder::*constructor)(LanguageMode);
+  IrOpcode::Value opcode;
+  Operator::Properties properties;
+  int value_input_count;
+  int frame_state_input_count;
+  int effect_input_count;
+  int control_input_count;
+  int value_output_count;
+  int effect_output_count;
+  int control_output_count;
+};
+
+
+const SharedOperatorWithLanguageMode kSharedOperatorsWithLanguageMode[] = {
+#define SHARED(Name, properties, value_input_count, frame_state_input_count, \
+               effect_input_count, control_input_count, value_output_count,  \
+               effect_output_count, control_output_count)                    \
+  {                                                                          \
+    &JSOperatorBuilder::Name, IrOpcode::kJS##Name, properties,               \
+        value_input_count, frame_state_input_count, effect_input_count,      \
+        control_input_count, value_output_count, effect_output_count,        \
+        control_output_count                                                 \
+  }
+    SHARED(StoreProperty, Operator::kNoProperties, 3, 2, 1, 1, 0, 1, 2)
 #undef SHARED
 };
 
@@ -280,6 +393,7 @@ INSTANTIATE_TEST_CASE_P(
     ::testing::Combine(::testing::ValuesIn(kLanguageModes),
                        ::testing::ValuesIn(kSharedOperatorsWithLanguageMode)));
 
+
 #endif  // GTEST_HAS_COMBINE
 
 }  // namespace compiler