diff --git a/tensorflow/core/kernels/mlir_generated/gpu_binary_ops_test.cc b/tensorflow/core/kernels/mlir_generated/gpu_binary_ops_test.cc
index 736472cc6c2..29a9fec8371 100644
--- a/tensorflow/core/kernels/mlir_generated/gpu_binary_ops_test.cc
+++ b/tensorflow/core/kernels/mlir_generated/gpu_binary_ops_test.cc
@@ -314,65 +314,57 @@ class GpuBinaryOpTest : public OpsTestBase {
 // Macros to easily generate common test cases. For specific inputs, please
 // define your own test fixtures.
 
-#define GENERATE_DEFAULT_TESTS_2(op_name, test_name, T, BaselineT, OutT,    \
-                                 BaselineOutT, baseline_callback, config)   \
-  TEST_F(GpuBinaryOpTest, op_name##EqShapes##test_name) {                   \
-    TestEqualShapes<T, BaselineT, OutT, BaselineOutT>(                      \
-        #op_name, /*shape=*/test::DefaultInputShape(),                      \
-        /*lhs_input=*/test::DefaultInput<T>(#op_name),                      \
-        /*rhs_input=*/test::DefaultInput<T>(#op_name), baseline_callback,   \
-        config);                                                            \
-  }                                                                         \
-                                                                            \
-  TEST_F(GpuBinaryOpTest, op_name##OneScalar##test_name) {                  \
-    TestOneScalar<T, BaselineT, OutT, BaselineOutT>(                        \
-        #op_name, /*scalar_input=*/test::DefaultInput<T>(#op_name).front(), \
-        /*other_shape=*/test::DefaultInputShape(),                          \
-        /*other_input=*/test::DefaultInput<T>(#op_name), baseline_callback, \
-        config);                                                            \
-  }                                                                         \
-                                                                            \
-  TEST_F(GpuBinaryOpTest, op_name##IncompatibleShapes##test_name) {         \
-    TestIncompatibleShapes<T, OutT>(                                        \
-        #op_name, /*lhs_input=*/test::DefaultInput<T>(#op_name),            \
-        /*rhs_input=*/test::DefaultInput<T>(#op_name), config);             \
-  }                                                                         \
-                                                                            \
-  TEST_F(GpuBinaryOpTest, op_name##BroadcastingExpand##test_name) {         \
-    TestBroadcastingExpand<T, BaselineT, OutT, BaselineOutT>(               \
-        #op_name, /*lhs_input=*/test::DefaultInput<T>(#op_name),            \
-        /*rhs_input=*/test::DefaultInput<T>(#op_name), baseline_callback,   \
-        config);                                                            \
-  }                                                                         \
-                                                                            \
-  TEST_F(GpuBinaryOpTest, op_name##BroadcastingInDim##test_name) {          \
-    TestBroadcastingInDim<T, BaselineT, OutT, BaselineOutT>(                \
-        #op_name, /*lhs_input=*/test::DefaultInput<T>(#op_name),            \
-        /*rhs_input=*/test::DefaultInput<T>(#op_name), baseline_callback,   \
-        config);                                                            \
-  }                                                                         \
-                                                                            \
-  TEST_F(GpuBinaryOpTest, op_name##Broadcasting##test_name) {               \
-    TestBroadcasting<T, BaselineT, OutT, BaselineOutT>(                     \
-        #op_name, /*lhs_input=*/test::DefaultInput<T>(#op_name),            \
-        /*rhs_input=*/test::DefaultInput<T>(#op_name), baseline_callback,   \
-        config);                                                            \
-  }                                                                         \
-                                                                            \
-  TEST_F(GpuBinaryOpTest, op_name##EmptyShapeBroadcasting##test_name) {     \
-    TestEmptyShapeBroadcasting<T, BaselineT, OutT, BaselineOutT>(           \
-        #op_name, /*lhs_input=*/test::DefaultInput<T>(#op_name),            \
-        /*rhs_input=*/test::DefaultInput<T>(#op_name), config);             \
+#define GENERATE_DEFAULT_TESTS_2(op_name, test_name, T, BaselineT, OutT,      \
+                                 BaselineOutT, lhs_input, rhs_input,          \
+                                 baseline_callback, config)                   \
+  TEST_F(GpuBinaryOpTest, op_name##EqShapes##test_name) {                     \
+    TestEqualShapes<T, BaselineT, OutT, BaselineOutT>(                        \
+        #op_name, /*shape=*/test::DefaultInputShape(), lhs_input, rhs_input,  \
+        baseline_callback, config);                                           \
+  }                                                                           \
+                                                                              \
+  TEST_F(GpuBinaryOpTest, op_name##OneScalar##test_name) {                    \
+    TestOneScalar<T, BaselineT, OutT, BaselineOutT>(                          \
+        #op_name, /*scalar_input=*/lhs_input.front(),                         \
+        /*other_shape=*/test::DefaultInputShape(), /*other_input=*/rhs_input, \
+        baseline_callback, config);                                           \
+  }                                                                           \
+                                                                              \
+  TEST_F(GpuBinaryOpTest, op_name##IncompatibleShapes##test_name) {           \
+    TestIncompatibleShapes<T, OutT>(#op_name, lhs_input, rhs_input, config);  \
+  }                                                                           \
+                                                                              \
+  TEST_F(GpuBinaryOpTest, op_name##BroadcastingExpand##test_name) {           \
+    TestBroadcastingExpand<T, BaselineT, OutT, BaselineOutT>(                 \
+        #op_name, lhs_input, rhs_input, baseline_callback, config);           \
+  }                                                                           \
+                                                                              \
+  TEST_F(GpuBinaryOpTest, op_name##BroadcastingInDim##test_name) {            \
+    TestBroadcastingInDim<T, BaselineT, OutT, BaselineOutT>(                  \
+        #op_name, lhs_input, rhs_input, baseline_callback, config);           \
+  }                                                                           \
+                                                                              \
+  TEST_F(GpuBinaryOpTest, op_name##Broadcasting##test_name) {                 \
+    TestBroadcasting<T, BaselineT, OutT, BaselineOutT>(                       \
+        #op_name, lhs_input, rhs_input, baseline_callback, config);           \
+  }                                                                           \
+                                                                              \
+  TEST_F(GpuBinaryOpTest, op_name##EmptyShapeBroadcasting##test_name) {       \
+    TestEmptyShapeBroadcasting<T, BaselineT, OutT, BaselineOutT>(             \
+        #op_name, lhs_input, rhs_input, config);                              \
   }
 
 #define GENERATE_DEFAULT_TESTS(op_name, test_name, T, OutT, baseline_callback) \
   GENERATE_DEFAULT_TESTS_2(op_name, test_name, T, T, OutT, OutT,               \
-                           baseline_callback,                                  \
+                           test::DefaultInput<T>(#op_name),                    \
+                           test::DefaultInput<T>(#op_name), baseline_callback, \
                            test::GpuOpsTestConfig().ExpectStrictlyEqual())
 
-#define GENERATE_DEFAULT_TESTS_SAME_INPUT_AND_OUTPUT_TYPE( \
-    op_name, test_name, T, baseline_callback)              \
-  GENERATE_DEFAULT_TESTS(op_name, test_name, T, T, baseline_callback)
+#define GENERATE_DEFAULT_TESTS_WITH_SPECIFIC_INPUT_VALUES(                  \
+    op_name, test_name, T, OutT, lhs_input, rhs_input, baseline_callback)   \
+  GENERATE_DEFAULT_TESTS_2(op_name, test_name, T, T, OutT, OutT, lhs_input, \
+                           rhs_input, baseline_callback,                    \
+                           test::GpuOpsTestConfig().ExpectStrictlyEqual())
 
 /// Test `tf.AddV2`.
 
@@ -440,22 +432,33 @@ GENERATE_DEFAULT_TESTS(BitwiseXor,
                        /*test_name=*/Int64, int64, int64, baseline_bitwise_xor)
 
 /// Test `tf.Div`.
+
 template <typename T>
 T baseline_div(T lhs, T rhs) {
   return lhs / rhs;
 }
 
-GENERATE_DEFAULT_TESTS(Div,
-                       /*test_name=*/Half, Eigen::half, Eigen::half,
-                       baseline_div);
-GENERATE_DEFAULT_TESTS(Div,
-                       /*test_name=*/Float, float, float, baseline_div);
-GENERATE_DEFAULT_TESTS(Div,
-                       /*test_name=*/Double, double, double, baseline_div);
-GENERATE_DEFAULT_TESTS(Div,
-                       /*test_name=*/Int16, int16, int16, baseline_div);
-GENERATE_DEFAULT_TESTS(Div,
-                       /*test_name=*/Int64, int64, int64, baseline_div);
+GENERATE_DEFAULT_TESTS_WITH_SPECIFIC_INPUT_VALUES(
+    Div,
+    /*test_name=*/Half, Eigen::half, Eigen::half,
+    test::DefaultInput<Eigen::half>("Div"),
+    test::DefaultInputNonZero<Eigen::half>(), baseline_div);
+GENERATE_DEFAULT_TESTS_WITH_SPECIFIC_INPUT_VALUES(
+    Div,
+    /*test_name=*/Float, float, float, test::DefaultInput<float>("Div"),
+    test::DefaultInputNonZero<float>(), baseline_div);
+GENERATE_DEFAULT_TESTS_WITH_SPECIFIC_INPUT_VALUES(
+    Div,
+    /*test_name=*/Double, double, double, test::DefaultInput<double>("Div"),
+    test::DefaultInputNonZero<double>(), baseline_div);
+GENERATE_DEFAULT_TESTS_WITH_SPECIFIC_INPUT_VALUES(
+    Div,
+    /*test_name=*/Int16, int16, int16, test::DefaultInput<int16>("Div"),
+    test::DefaultInputNonZero<int16>(), baseline_div);
+GENERATE_DEFAULT_TESTS_WITH_SPECIFIC_INPUT_VALUES(
+    Div,
+    /*test_name=*/Int64, int64, int64, test::DefaultInput<int64>("Div"),
+    test::DefaultInputNonZero<int64>(), baseline_div);
 
 /// Test `tf.Equal`.
 
@@ -591,7 +594,10 @@ bool baseline_logical_and(bool lhs, bool rhs) { return lhs && rhs; }
 
 GENERATE_DEFAULT_TESTS_2(LogicalAnd, /*test_name=*/Bool, /*T=*/bool,
                          /*BaselineT=*/bool, /*OutT=*/bool,
-                         /*BaselineOutT=*/bool, baseline_logical_and,
+                         /*BaselineOutT=*/bool,
+                         test::DefaultInput<bool>("LogicalAnd"),
+                         test::DefaultInput<bool>("LogicalAnd"),
+                         baseline_logical_and,
                          test::GpuOpsTestConfig().ExpectStrictlyEqual().NoT())
 
 /// Test `tf.LogicalOr`.
@@ -600,7 +606,10 @@ bool baseline_logical_or(bool lhs, bool rhs) { return lhs || rhs; }
 
 GENERATE_DEFAULT_TESTS_2(LogicalOr, /*test_name=*/Bool, /*T=*/bool,
                          /*BaselineT=*/bool, /*OutT=*/bool,
-                         /*BaselineOutT=*/bool, baseline_logical_or,
+                         /*BaselineOutT=*/bool,
+                         test::DefaultInput<bool>("LogicalOr"),
+                         test::DefaultInput<bool>("LogicalOr"),
+                         baseline_logical_or,
                          test::GpuOpsTestConfig().ExpectStrictlyEqual().NoT())
 
 /// Test `tf.Mul`.
diff --git a/tensorflow/core/kernels/mlir_generated/gpu_ops_test_util.h b/tensorflow/core/kernels/mlir_generated/gpu_ops_test_util.h
index 429c4d3ae55..62e5b811036 100644
--- a/tensorflow/core/kernels/mlir_generated/gpu_ops_test_util.h
+++ b/tensorflow/core/kernels/mlir_generated/gpu_ops_test_util.h
@@ -118,6 +118,22 @@ absl::InlinedVector<T, 10> DefaultInputGreaterOrEqualToZero() {
                                          0.2, 0.3, 0.5, 0.7, 0.9, 9.0, 18.0});
 }
 
+template <typename T, std::enable_if_t<
+                          llvm::is_one_of<T, Eigen::half, float, double>::value,
+                          bool> = true>
+absl::InlinedVector<T, 10> DefaultInputNonZero() {
+  return test::InputAsVector<T, double>({18.0, 9.0, 1e-6, -0.1, 0.1, 1e-6, 0.1,
+                                         0.2, 0.3, 0.5, 0.7, 0.9, 9.0, 18.0});
+}
+
+template <typename T,
+          std::enable_if_t<llvm::is_one_of<T, int8, int16, int32, int64>::value,
+                           bool> = true>
+absl::InlinedVector<T, 10> DefaultInputNonZero() {
+  return test::InputAsVector<T, double>(
+      {-18, -9, -1, 1, 3, 4, 5, 7, 9, 10, 18});
+}
+
 /// Helper functions to get default input data.
 
 template <typename T,
@@ -131,9 +147,6 @@ absl::InlinedVector<T, 10> DefaultInput(absl::string_view op_name) {
     for (auto i = 0; i < max_shift; ++i) v.push_back(i);
     return v;
   }
-  if (op_name == "Div") {
-    return InputAsVector<T, int>({-18, -9, 9, 18});
-  }
   return InputAsVector<T, int>({-18, -9, -1, 0, 0, 1, 1, 2, 3, 5, 7, 9, 9, 18});
 }
 
@@ -141,7 +154,7 @@ template <typename T, std::enable_if_t<
                           llvm::is_one_of<T, Eigen::half, float, double>::value,
                           bool> = true>
 absl::InlinedVector<T, 10> DefaultInput(absl::string_view op_name) {
-  if (op_name == "Div" || op_name == "FloorDiv") {
+  if (op_name == "FloorDiv") {
     return InputAsVector<T, double>({-18.0, -9.0, -1e-6, -0.1, 0.1, 1e-6, 0.1,
                                      0.2, 0.3, 0.5, 0.7, 0.9, 9.0, 18.0});
   }