public void run(RunNotifier runNotifier) {
        // Run tests in 'parallel'
        Description test1 = Description.createTestDescription(type, 'broken')
        Description test2 = Description.createTestDescription(type, 'ok')
        runNotifier.fireTestStarted(test1)
        runNotifier.fireTestStarted(test2)
        runNotifier.fireTestFailure(new Failure(test1, failure.rawFailure))
        runNotifier.fireTestFinished(test2)

	"testing"

	"golang.org/x/mod/module"
)

func TestIsToolchain(t *testing.T) { test1(t, isToolchainTests, "IsToolchain", IsToolchain) }

var isToolchainTests = []testCase1[string, bool]{
	{"go", true},
	{"toolchain", true},
	{"anything", false},
	{"golang.org/toolchain", false},
}

func TestModCompare(t *testing.T) { test3(t, modCompareTests, "ModCompare", ModCompare) }

#include "tensorflow/core/tpu/kernels/tpu_compile_op_support.h"
#include "tsl/lib/core/status_test_util.h"

namespace mlir::quant::stablehlo {
namespace {

using ::testing::Test;

class LegalizeTFQuantTest : public Test {
 protected:
  void TestBridgeLowering(llvm::StringRef mlir_module_string,
                          llvm::ArrayRef<tensorflow::TensorShape> arg_shapes,

  EXPECT_THAT(saver_def->save_tensor_name(), "tf_quant__save_op_0:0");
}

TEST(CreateSaverDefTest, ReturnsNulloptIfNoSaverDefRelatedNodesExist) {
  TF_ASSERT_OK_AND_ASSIGN(
      const std::optional<SaverDef> saver_def,
      CreateSaverDef(/*control_ret_node_names=*/{}, GraphDef()));
  EXPECT_EQ(saver_def, std::nullopt);
}

TEST(CreateSaverDefTest, ReturnsErrorStatusIfSaverDefNodesPartiallyExist) {

    float max_error;
    TF_ASSERT_OK((ComputeGradientError<float, float, float>(
        scope_, xs, x_shapes, ys, y_shapes, &max_error)));
    EXPECT_LT(max_error, 1e-4);
  }

  Scope scope_;
};

TEST_F(DataFlowGradTest, DynamicPartitionGrad) {
  TensorShape data_shape({2, 3, 2});
  auto data = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(data_shape));
  auto partitions = Const(scope_, {{2, 1, 0}, {1, 2, 0}});

    for (int i = 0; i < out_tensors.size(); ++i) {
      test::ExpectTensorEqual<T>(
          out_tensors[i], test::AsTensor<T>({expected_grad_values[i]}, {}));
    }
  }

  Scope scope_;
  std::vector<Output> inputs_;
  std::vector<Output> outputs_;
  std::vector<Output> grad_outputs_;
};

TEST_F(WhileGradientsTest, Basic) {
  // Create loop: while (i < 10) i += 1
  Init(1);
  CreateLoop(

  -->
  <url>https://maven.apache.org/${test}
  </url>
  <properties>
    <test>FAILED</test>
    <property>${test}</property>
  </properties>

  <profiles>
    <profile>
      <id>interpolation-profile</id>
      <!-- This profile defines the properties to use for interpolation. -->
      <properties>
        <test>PASSED</test>
        <test1>PASSED</test1>
      </properties>
    </profile>
  </profiles>

  EXPECT_TRUE(status.ok());
  auto decomposed = test_ctx_->ExpandNode(test_node, "test");
  EXPECT_TRUE(decomposed.ok());
  std::vector<NodeAndType> expected_results{{"Identity", DT_FLOAT}};
  EXPECT_THAT(NodesSequenceOf(decomposed.value()),
              ElementsAreArray(expected_results));
}

TEST_F(TFRDecomposeContextTest, FLOAT_3_ins) {
  std::vector<NodeDefBuilder::NodeOut> src_list;

#include "tensorflow/core/lib/monitoring/cell_reader.h"
#include "tensorflow/core/platform/test.h"
#include "tensorflow/core/public/session_options.h"

namespace tensorflow {

using ::testing::_;
using ::testing::NiceMock;
using ::testing::Return;
using ::testing::Test;

constexpr char kOk[] = "OK";
constexpr char kInvalidArgument[] = "INVALID_ARGUMENT";
constexpr char kSuccess[] = "kSuccess";

      &device_tensor, "", device_.get(), &dest_cpu_tensor));

  tensorflow::test::ExpectClose(origin_cpu_tensor, dest_cpu_tensor);
  device_context->Unref();
}

TEST_F(XlaHostSendRecvDeviceContextTest, CopyCPUTensorToDevice) {
  SetDevice("GPU");
  Tensor origin_cpu_tensor(host_allocator_, DT_FLOAT, TensorShape({2, 2}));
  test::FillValues<float>(&origin_cpu_tensor, {1.2, 2.3, 3.4, 4.5});