server.start()

        scriptUrl = "${server.uri}/${scriptName}"
        scriptFile = file("remote-script.gradle") << """
            println 'loaded remote script'
        """
        server.expectGet "/$scriptName", scriptFile

        buildFile << """
            apply from: '$scriptUrl'
            task ok
        """

        configurationCache = newConfigurationCacheFixture()
    }

                }
            }
        """

        file("src/main/java/Foo.java") << "public class Foo {}"

        server.expectHead("/path/toolchain.zip", toolchainArchive)
        server.expectGet("/path/toolchain.zip", toolchainArchive)

        when:
        failure = executer
                .withTasks("compileJava")
                .requireOwnGradleUserHomeDir("needs to be able to provision fresh toolchains")

        TestFile script = testFile('external.gradle')
        server.expectUserAgent(UserAgentMatcher.matchesNameAndVersion("Gradle", GradleVersion.current().getVersion()))
        server.expectGet('/external.gradle', script)
        server.start()

        script << """
            task doStuff
            assert buildscript.sourceFile == null

Ben Leggett <******@****.***> 1716316321 -0400

  ASSERT_TRUE(status.ok()) << status.message();

  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);
  EXPECT_EQ(tensor_view[5], 29);

  EXPECT_EQ(quantized_fraction, 19661);
  EXPECT_EQ(shift, 1);

  EXPECT_TRUE(succeeded(QuantizeMultiplier(15.5, quantized_fraction, shift)));
  EXPECT_EQ(quantized_fraction, 31744);
  EXPECT_EQ(shift, 4);

  EXPECT_TRUE(succeeded(QuantizeMultiplier(1, quantized_fraction, shift)));
  EXPECT_EQ(quantized_fraction, 16384);
  EXPECT_EQ(shift, 1);
}

	tests := []struct {
		name        string
		expectRet   bool
		audToCheck  []string
		audExpected []string
	}{
		{
			name:        "audience is in the expected set",
			expectRet:   true,
			audToCheck:  []string{"aud1"},
			audExpected: []string{"aud1", "aud2"},
		},
		{
			name:        "audience is NOT in the expected set",
			expectRet:   false,
			audToCheck:  []string{"aud3"},

  // Expect 2 bins: [0, 2), [2, 4].
  EXPECT_EQ(num_bins, 2);
}

TEST(CalibrationParametersTest, CalculateNumBinsNotDivisible) {
  int32_t num_bins = CalculateActualNumBins(
      /*min_value=*/0.0, /*max_value=*/5.0, /*bin_width=*/2.0);

  // Expect 3 bins: [0, 2), [2, 4), [4, 6].
  EXPECT_EQ(num_bins, 3);
}

TEST(CalibrationParametersTest, CalculateBinIndex) {

  CellReader<int64_t> counts(kBridgeStatusCounter);

  auto result = CompileMlirModule(kMlirModuleStr);

  ASSERT_THAT(result, IsOkOrFiltered());
  EXPECT_EQ(mlir_bridge_legalize_count.Delta("tf.Acos"), 0);
  EXPECT_THAT(result,
              IncrementedOrFiltered(counts.Delta(kMlirCombinedMlirSuccess), 1));
  EXPECT_THAT(result,

      "/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"(