"/tensorflow/core/tf2xla/v1/mlir_failed_xla_legalize_tf_pass_count");

  auto status = BuildAndRunPipeline(kMlirIllegalOpStr, legalizeTFPasses());

  EXPECT_TRUE(status);
  EXPECT_EQ(legalize_failure_count.Read("tf.DoesntExist", "Unknown"), 1);
}

TEST(XlaLegalizeTest, LegalOp) {
  // We expect legalization to fail for legal op with dynamic shapes:
  static constexpr char kMlirLegalOpStr[] = R"(

  EXPECT_EQ(Explain(add.node(), NodeWith(Inputs())),
            "\nexpected 0 inputs but node has 2");
  EXPECT_EQ(
      Explain(add.node(), NodeWith(Inputs(Out(NodeWith(Name("blah"))), _))),
      "\ninput 0 does not match expected:\nname: blah, \nsource does not match "
      "expected name: blah\n\t\nexpected name blah but found placeholder_a");
  EXPECT_EQ(

  EXPECT_EQ(revived_tensor->Type(), expected.dtype());
  EXPECT_EQ(revived_tensor->NumElements(), expected.NumElements());
  EXPECT_EQ(revived_tensor->NumDims(), expected.dims());
  for (int i = 0; i < expected.dims(); ++i) {
    EXPECT_EQ(revived_tensor->Dim(i), expected.dim_size(i));
  }

  testing::CheckBufferDataIsEqual(expected.dtype(), expected.NumElements(),

  string upper_snake;
};

void TestSingleVariation(const string &str, Variations expected,
                         char delimiter = '_') {
  EXPECT_EQ(expected.lower_camel, toLowerCamel(str, delimiter));
  EXPECT_EQ(expected.lower_snake, toLowerSnake(str, delimiter));
  EXPECT_EQ(expected.upper_camel, toUpperCamel(str, delimiter));
  EXPECT_EQ(expected.upper_snake, toUpperSnake(str, delimiter));
}

				}
				if !strings.Contains(err.Error(), tc.ExpectErr) {
					t.Fatalf("expected error %s, got %v", tc.ExpectErr, err)
				}
				return
			}
			if len(tc.ExpectErr) > 0 {
				t.Fatalf("expected error %s, got none", tc.ExpectErr)
			}
			if !reflect.DeepEqual(tc.Out, tc.ExpectOut) {
				t.Fatalf("unexpected result:\n %s", cmp.Diff(tc.ExpectOut, tc.Out))
			}
		})
	}
}

	expectInt(t, completions.Load, 2)

	close(stop)
}

func expectInt(t *testing.T, f func() int32, expected int32) {
	t.Helper()
	retry.UntilSuccessOrFail(t, func() error {
		got := f()
		if got != expected {
			return fmt.Errorf("unexpected count: %v, want %v", got, expected)
		}
		return nil
	}, retry.Timeout(time.Second))
}

func TestLeaderElectionDisabled(t *testing.T) {

  EXPECT_EQ(tensor.dims(), 1);
  EXPECT_EQ(tensor.dtype(), dtype);
  absl::Span<const typename TypeParam::type> tensor_view(
      reinterpret_cast<typename TypeParam::type*>(tensor.data()), value.size());
  EXPECT_EQ(tensor_view[0], 42);
  EXPECT_EQ(tensor_view[1], 100);
  EXPECT_EQ(tensor_view[2], 0);
  EXPECT_EQ(tensor_view[3], 1);
  EXPECT_EQ(tensor_view[4], 4);

    InstantiationResultForTest result;
    TF_EXPECT_OK(InstantiateFunctionForTest(function, flib_def, &result));

    EXPECT_EQ((DataTypeVector{DT_INT32, DT_FLOAT, DT_INT32, DT_FLOAT,
                              DT_RESOURCE, DT_RESOURCE, DT_RESOURCE}),
              result.arg_types);
    EXPECT_EQ((DataTypeVector{DT_FLOAT, DT_INT32, DT_FLOAT, DT_FLOAT}),
              result.ret_types);

                  .ok());
  ASSERT_TRUE(worker_server2->Start().ok());

  TFE_ContextSetServerDef(context.get(), 0, serialized.data(),
                          serialized.size(), status.get());
  EXPECT_EQ(TF_OK, TF_GetCode(status.get())) << TF_Message(status.get());

  BasicTestsForTwoDevices(context.get(),
                          "/job:worker/replica:0/task:1/device:CPU:0",

  TF_EXPECT_OK(CompileWithComputation(function_to_hlo_args).status());

  Histogram histogram =
      compilation_time.Delta("graph_old_bridge_has_function_to_hlo");

  EXPECT_EQ(histogram.num(), 1);
  EXPECT_EQ(compilation_status.Delta("kOldBridgeNoMlirSuccess"), 1);
}

TEST_F(CompileTFGraphTest, SuccessfullyCompilesWithManualSharding) {
  // MLIR module from failing test.