"100");
}

TEST_F(WhileLoopTest, UnsetCondOutput) {
  Init(1);
  CreateLoop([](const Scope& s, const std::vector<Output>& inputs,
                Output* output) { return s.status(); },
             AddOneBody, error::INVALID_ARGUMENT, "Node is null");
}

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

TEST_F(WhileLoopTest, NullBodyOutputNode) {
  Init(1);

    ASSERT_TRUE(errors::IsInvalidArgument(s));
  }
};

// Test for resource leaks related to TensorFlow session closing requirements
// when loading and unloading large numbers of SavedModelBundles.
// TODO(sukritiramesh): Increase run iterations and move outside of the test
// suite.
TEST_F(LoaderTest, ResourceLeakTest) {
  SavedModelBundleLite bundle;
  SessionOptions session_options;

  std::unique_ptr<mlir::Builder> builder_;
};

TEST_F(PerceptionUtilsTest, VerifySignatureValid) {
  mlir::TFL::ConvertMaxUnpoolingFunc convert(fused_max_unpooling_func_,
                                             func_attr_);

  EXPECT_FALSE(failed(convert.VerifySignature()));
}

TEST_F(PerceptionUtilsTest, VerifySignatureInvalid) {

namespace mlir::quant::stablehlo {
namespace {

using ::testing::IsEmpty;
using ::testing::Pair;
using ::testing::UnorderedElementsAre;

using UpdateFunctionAliasesTest = ::mlir::quant::QuantizationTestBase;

TEST_F(UpdateFunctionAliasesTest, NoAliasesReturnsEmptyMap) {
  // MLIR @main function corresponds to the TF function "main_original".
  OwningOpRef<ModuleOp> module_op = ParseModuleOpString(R"mlir(

  EXPECT_EQ(tf2xla_fallback_count, 322);
  EXPECT_EQ(non_categorized_count, 428);
}

// Just a counter test to see which ops have duplicate lowerings. This isn't a
// correctness test versus a test to easily ensure the op registry is kept
// in sync.
TEST_F(LegalizationOpConfigTest, CountTypesWhichHaveBothMlirAndTf2xlaFallback) {
  int double_lowering_count = 0;

  DialectRegistry dialect_registry;

        then:
        1 * factory.create() >> delegate
        then:
        1 * delegate.startProcessing(resultProcessor)
        then:
        1 * delegate.processTestClass(test1)
        0 * _._
    }

    def 'ends processing on delegate processor on nth test'() {
        when:
        processor.startProcessing(resultProcessor)
        processor.processTestClass(test1)

Russ Cox <******@****.***> 1488850797 -0500

Russ Cox <******@****.***> 1488850797 -0500

    EXPECT_LT(max_error, 1e-3);
  }

  Scope scope_;
};

TEST_F(LinalgGradTest, Einsum_Transpose) {
  TensorShape x_shape({2, 3});
  Output x = Placeholder(scope_, DT_FLOAT, Placeholder::Shape(x_shape));
  auto y = Einsum(scope_, {x}, "ij->ji");
  TensorShape y_shape({3, 2});
  RunTest({x}, {x_shape}, {y}, {y_shape});
}

TEST_F(LinalgGradTest, Einsum_TransposeBroadcast) {
  TensorShape x_shape({3, 2, 3});

import XCTest

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