ConfigProto::Experimental::MLIR_BRIDGE_ROLLOUT_UNSPECIFIED));
}

struct MatMulTestCase {
  std::string mat_mul_method;
};

using BatchMatMulTest = TestWithParam<MatMulTestCase>;

TEST_P(BatchMatMulTest, BatchMatMul) {
  const MatMulTestCase& test_case = GetParam();
  static constexpr char kMatMulModuleStr[] = R"(

}

class FusedBatchNormGradTest : public NNGradTest,
                               public ::testing::WithParamInterface<
                                   std::tuple<bool, bool, TensorShape>> {};

TEST_P(FusedBatchNormGradTest, FusedBatchNormV3Grad) {
  FusedBatchNormV3::Attrs attrs;
  attrs.is_training_ = std::get<0>(GetParam());
  bool channel_first = std::get<1>(GetParam());
  TensorShape shape = std::get<2>(GetParam());

  }
  return true;
}

using DeviceNames = llvm::SmallVector<std::string, 8>;

struct ParameterizedDeviceSetTest
    : ::testing::TestWithParam<std::tuple<DeviceNames, std::string>> {};

TEST_P(ParameterizedDeviceSetTest, BadDeviceSet) {
  llvm::SmallVector<Device, 8> devices;
  ASSERT_TRUE(DeviceNamesToParsedNames(std::get<0>(GetParam()), &devices));
  std::string topology_attr;

				buildService("test.com", tt.CIDR, protocol.TCP, tnow),
			}

			virtualService := config.Config{
				Meta: config.Meta{
					GroupVersionKind: gvk.VirtualService,
					Name:             "test_vs",
					Namespace:        "default",
				},
				Spec: virtualServiceSpec,
			}
			for _, p := range []*model.Proxy{getProxy(), &dualStackProxy} {

}

func TestEmptyVIPsExcluded(t *testing.T) {
	testSVC := corev1.Service{
		Spec: corev1.ServiceSpec{
			ClusterIP: "",
		},
		Status: corev1.ServiceStatus{
			LoadBalancer: corev1.LoadBalancerStatus{
				Ingress: []corev1.LoadBalancerIngress{
					{
						IP: "",
					},
				},
			},
		},
	}
	vips := getVIPs(&testSVC)

  RunTest({x}, {x_shape}, {y}, {y_shape});
}

class CumsumGradTest
    : public NaryGradTest,
      public ::testing::WithParamInterface<std::tuple<bool, bool, int>> {};

TEST_P(CumsumGradTest, CumsumGrad) {
  int axis = std::get<2>(GetParam());

  TensorShape shape({2, 3, 2});
  auto x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(shape));
  Cumsum::Attrs attrs;

//     // Can use GetParam() here.
//   }
//   virtual void SetUp() {
//     // Can use GetParam() here.
//   }
//   virtual void TearDown {
//     // Can use GetParam() here.
//   }
// };
// TEST_P(FooTest, DoesBar) {
//   // Can use GetParam() method here.
//   Foo foo;
//   ASSERT_TRUE(foo.DoesBar(GetParam()));
// }
// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));

//     // Can use GetParam() here.
//   }
//   virtual void SetUp() {
//     // Can use GetParam() here.
//   }
//   virtual void TearDown {
//     // Can use GetParam() here.
//   }
// };
// TEST_P(FooTest, DoesBar) {
//   // Can use GetParam() method here.
//   Foo foo;
//   ASSERT_TRUE(foo.DoesBar(GetParam()));
// }
// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10));

	TEQ_VS
	TEQ_VC
	TEQ_HI
	TEQ_LS
	TEQ_GE
	TEQ_LT
	TEQ_GT
	TEQ_LE
	TEQ
	TEQ_ZZ
	TST_EQ
	TST_NE
	TST_CS
	TST_CC
	TST_MI
	TST_PL
	TST_VS
	TST_VC
	TST_HI
	TST_LS
	TST_GE
	TST_LT
	TST_GT
	TST_LE
	TST
	TST_ZZ
	UADD16_EQ
	UADD16_NE
	UADD16_CS
	UADD16_CC
	UADD16_MI
	UADD16_PL
	UADD16_VS
	UADD16_VC

			}

			for _, qPodInfo := range tt.qPodInfoInPodBackoffQ {
				q.podBackoffQ.Add(qPodInfo)
			}

			// Activate specific pod according to the table
			q.Activate(logger, map[string]*v1.Pod{"test_pod": tt.qPodInfoToActivate.PodInfo.Pod})

			// Check the result after activation by the length of activeQ
			if wantLen := len(tt.want); q.activeQ.Len() != wantLen {