List<XCTestSourceFileElement> getTestSuites() {
            return [
                new XCTestSourceFileElement("CombinedTests") {
                    final delegate = new SwiftLibTest(main, main.greeter, main.sum, main.multiply)

                    @Override
                    List<XCTestCaseElement> getTestCases() {
                        return delegate.sumTest.testCases + delegate.greeterTest.testCases + delegate.multiplyTest.testCases

        }
        return new Amount<>(units.scaleTo(value, other.units).subtract(other.value), other.units);
    }

    public Amount<Q> multiply(BigDecimal other) {
        return new Amount<>(value.multiply(other), units);
    }

    public Amount<Q> div(long other) {
        return div(BigDecimal.valueOf(other));
    }
    public Amount<Q> div(BigDecimal other) {

  %10 = mhlo.add %arg0, %5 : tensor<2xf32>
  %11 = mhlo.clamp %7, %10, %3 : tensor<2xf32>
  %12 = mhlo.clamp %9, %11, %1 : tensor<2xf32>
  %13 = mhlo.multiply %arg0, %12 : tensor<2xf32>
  %14 = mhlo.divide %13, %1 : tensor<2xf32>
  return %14 : tensor<2xf32>
}

// CHECK-LABEL:   func.func @hardswish(

// It also runs ssa/check and gccheck to be sure that those are checked at least a
// little in each run.bash.  It does not check or run the generated code.
// The test file is however a useful example of fused-vs-cascaded multiply-add.
func TestFmaHash(t *testing.T) {
	switch runtime.GOOS {
	case "linux", "darwin":
	default:
		t.Skipf("Slow test, usually avoid it, os=%s not linux or darwin", runtime.GOOS)
	}
	switch runtime.GOARCH {

	}
	timeToExpire := cert.NotAfter.Sub(now)
	if timeToExpire < 0 {
		return time.Duration(0), fmt.Errorf("certificate already expired at %s, but now is %s",
			cert.NotAfter, now)
	}
	// Note: multiply time.Duration(int64) by an int (gracePeriodPercentage) will cause overflow (e.g.,
	// when duration is time.Hour * 90000). So float64 is used instead.

  static final double LARGE_INTEGER_VALUES_MEAN =
      BigInteger.valueOf(Integer.MAX_VALUE)
          .multiply(BigInteger.valueOf(3L))
          .divide(BigInteger.valueOf(4L))
          .doubleValue();
  static final double LARGE_INTEGER_VALUES_POPULATION_VARIANCE =
      BigInteger.valueOf(Integer.MAX_VALUE)
          .multiply(BigInteger.valueOf(Integer.MAX_VALUE))
          .divide(BigInteger.valueOf(16L))
          .doubleValue();

// CHECK-NEXT:    %0 = stablehlo.custom_call @Sharding(%arg0) {mhlo.sharding = ""} : (tensor<2x3xi32>) -> tensor<2x3xi32>
// CHECK-NEXT:    %1 = stablehlo.multiply %0, %0 : tensor<2x3xi32>
// CHECK-NEXT:    return %1 : tensor<2x3xi32>
// CHECK-NEXT:  }

    def "adds source dependencies Swift module of test component to Xcode indexer search path"() {
        def library = new SwiftLib()
        def test = new SwiftLibTest(library, library.greeter, library.sum, library.multiply)

        given:
        buildTestFixture.withBuildInSubDir()
        singleProjectBuild("greeter") {
            buildFile << """
                apply plugin: 'swift-library'
            """

#include "mlir/Transforms/DialectConversion.h"  // from @llvm-project

namespace mlir {
namespace odml {
// Converts mhlo.dot_general to tfl.BatchMatMul. Reshape and Transpose ops will
// be inserted to convert to well-formed matrix multiply; i.e., mhlo.dot_general
// -> tfl.batch_matmul(mhlo.transpose(mhlo.reshape(operand)), ...).
// Note:
// 1) Reshape/transpose are inserted because tfl.BatchMatMul requires

        if (flakinessRate == null || baseDuration == null) {
            return baseDuration;
        }
        return baseDuration + flakinessRate.multiply(BigDecimal.valueOf(baseDuration)).longValue();
    }