TF_Graph* graph_;
  TF_Graph* expected_graph_;
};

TEST_F(CApiGradientsTest, Gradients_GradInputs) { TestGradientsSuccess(true); }

TEST_F(CApiGradientsTest, Gradients_NoGradInputs) {
  TestGradientsSuccess(false);
}

TEST_F(CApiGradientsTest, OpWithNoGradientRegistered_GradInputs) {
  TestGradientsError(true);
}

TEST_F(CApiGradientsTest, OpWithNoGradientRegistered_NoGradInputs) {

using ::testing::ElementsAre;
using ::testing::HasSubstr;
using ::testing::Key;
using ::testing::SizeIs;
using ::tsl::testing::StatusIs;

class CalibrationStatisticsSaverTest : public OpsTestBase {};

TEST_F(CalibrationStatisticsSaverTest, MissingOutputPath) {
  std::vector<std::string> ids{"1"};
  std::vector<int32_t> calibration_methods{
      CalibrationOptions::CALIBRATION_METHOD_AVERAGE_MIN_MAX};

  EXPECT_TRUE(
      xla_device_compiler->persistor()->persistent_cache_directory().empty());
}

// TODO(b/255826209): Look into using an actual TPU device for the unit test,
// and move this out of OSS.
TEST_F(XlaPlatformInfoTest,
       GetOrCreatePjRtDeviceCompilerAndProfilerTpuDeviceNoCompilationCache) {
  tensorflow::GetMarkForCompilationPassFlags()
      ->tf_xla_persistent_cache_directory = "/tmp/xla_cache";

        System.out.println("TestFactory[" + data + "].beforeClass()");
    }

    @Test
    public void test1() {
        System.out.println("TestFactory[" + data + "].test1()");
    }

    @Test(dependsOnMethods = {"test1"})
    public void test2() {
        System.out.println("TestFactory[" + data + "].test2()");
    }

    @AfterClass
    public void afterClass() {

class BaseTest : public ::testing::Test {
  // You can inherit all the usual members for a non-parameterized test
  // fixture here.
};

class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> {
  // The usual test fixture members go here too.
};

TEST_F(BaseTest, HasFoo) {
  // This is an ordinary non-parameterized test.
}

import XCTest

class SomeIntegTest: XCTestCase {
    public static var allTests = [
        ("test1", test1),
        ("test2", test2)
    ]
    func test1() {}
    func test2() {}

//               "output(s)");
// }

// TODO(skyewm): test bad body output shape

TEST_F(CApiWhileLoopTest, NullName) {
  Init(1);
  CreateCondGraph();
  params_->body_outputs[0] = params_->body_inputs[0];
  params_->name = nullptr;
  ExpectError(TF_INVALID_ARGUMENT, "TF_WhileParams `name` field is null");
}

TEST_F(CApiWhileLoopTest, WrongGraph) {
  Init(1);
  CreateCondGraph();

                    value = 1;
                }
            }
        """.stripIndent()
        file('src/test/java/org/gradle/Test1.java') << """
            package org.gradle;

            ${testFrameworkImports}

            public class Test1 extends AbstractTest {

                @Test
                public void shouldPass() {
                    assertEquals(1, value);
                }
            }

import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

public class Test1 {

    @BeforeClass
    public void beforeClass() {
        System.out.println("Test1.beforeClass()");
    }

    @Test
    public void test1() {
        System.out.println("Test1.test1()");
    }

    @Test(dependsOnMethods = {"test1"})
    public void test2() {

  ASSERT_FALSE(xla_call_module_ops.empty());

  // Test that `GetQuantizationMethod` returns a valid `Method` corresponding to
  // `"no_quantization {}"`.
  const absl::StatusOr<Method> method =
      GetQuantizationMethod(*xla_call_module_ops.begin());
  ASSERT_THAT(method, IsOk());
  EXPECT_TRUE(method->has_no_quantization());
}

TEST_F(LiftAsFunctionCallTest,