test_uint64{fn: sub_1_uint64, fnname: "sub_1_uint64", in: 1, want: 0},
	test_uint64{fn: sub_uint64_1, fnname: "sub_uint64_1", in: 1, want: 0},
	test_uint64{fn: sub_1_uint64, fnname: "sub_1_uint64", in: 4294967296, want: 18446744069414584321},
	test_uint64{fn: sub_uint64_1, fnname: "sub_uint64_1", in: 4294967296, want: 4294967295},
	test_uint64{fn: sub_1_uint64, fnname: "sub_1_uint64", in: 9223372036854775808, want: 9223372036854775809},

		return "false"
	}
	return "true"
}

func TestEverything(t *testing.T) {
	ResetForTesting(nil)
	Bool("test_bool", false, "bool value")
	Int("test_int", 0, "int value")
	Int64("test_int64", 0, "int64 value")
	Uint("test_uint", 0, "uint value")
	Uint64("test_uint64", 0, "uint64 value")
	String("test_string", "0", "string value")
	Float64("test_float64", 0, "float64 value")
	Duration("test_duration", 0, "time.Duration value")

  public void testDivideByZeroThrows() {
    for (int a : TEST_INTS) {
      try {
        UnsignedInteger unused = UnsignedInteger.fromIntBits(a).dividedBy(UnsignedInteger.ZERO);
        fail("Expected ArithmeticException");
      } catch (ArithmeticException expected) {
      }
    }
  }

  public void testMod() {
    for (int a : TEST_INTS) {
      for (int b : TEST_INTS) {
        if (b != 0) {

  public void testDivideByZeroThrows() {
    for (int a : TEST_INTS) {
      try {
        UnsignedInteger unused = UnsignedInteger.fromIntBits(a).dividedBy(UnsignedInteger.ZERO);
        fail("Expected ArithmeticException");
      } catch (ArithmeticException expected) {
      }
    }
  }

  public void testMod() {
    for (int a : TEST_INTS) {
      for (int b : TEST_INTS) {
        if (b != 0) {

		{
			name: "maxLength",
			in: &apiextensions.JSONSchemaProps{
				MaxLength: &testInt64,
			},
			expected: new(spec.Schema).
				WithMaxLength(testInt64),
		},
		{
			name: "minLength",
			in: &apiextensions.JSONSchemaProps{
				MinLength: &testInt64,
			},
			expected: new(spec.Schema).
				WithMinLength(testInt64),
		},
		{
			name: "pattern",
			in: &apiextensions.JSONSchemaProps{

	}
	if bad {
		panic("testint3")
	}
}

// Issue #63378.
func testint4() {
	for i := range -1 {
		_ = i
		panic("must not be executed")
	}
}

// Issue #64471.
func testint5() {
	for i := range 'a' {
		var _ *rune = &i // ensure i has type rune
	}
}

func main() {
	testint1()
	testint2()
	testint3()
	testint4()
	testint5()

    // CHECK-ROUNDTRIP:  %0 = stablehlo.composite "stablehlo.add_n" %arg0 {composite_attributes = {test_bool = false, test_int = 2 : i64, test_string = "test"}, decomposition = @add_n.impl} : (tensor<i64>) -> tensor<i64>
    %0 = stablehlo.composite "stablehlo.add_n" %arg0 { composite_attributes = { test_int = 2 : i64, test_bool = 0 : i1, test_string = "test"}, decomposition = @add_n.impl } : (tensor<i64>) -> tensor<i64>
    return %0 : tensor<i64>

#include "tensorflow/core/framework/tensor_shape.h"
#include "tensorflow/core/framework/types.pb.h"
#include "tensorflow/core/platform/test.h"

namespace tf {
namespace libtf {
namespace impl {

TEST(OStreamTest, TestInt64) {
  Int64 x(42);
  std::stringstream stream;
  stream << x;
  ASSERT_EQ(stream.str(), "42");
}

TEST(OStreamTest, TestFloat32) {
  Float32 x(0.375);  // Exactly representable as a float.

  ])
  def test_float(self, x):
    return constant_op.constant(3.0) * x

  @def_function.function(input_signature=[
      tensor_spec.TensorSpec(shape=(), dtype=dtypes.int32),
  ])
  def test_int(self, x):
    return constant_op.constant(3) * x

  @def_function.function(input_signature=[
      tensor_spec.TensorSpec(shape=(), dtype=dtypes.float32),
      tensor_spec.TensorSpec(shape=(), dtype=dtypes.float32),

  TF_ASSERT_OK_AND_ASSIGN(Object module,
                          runtime.Load(String(module_path.c_str())));

  TF_ASSERT_OK_AND_ASSIGN(Callable fn,
                          module.Get<Callable>(String("test_int")));

  // Call the function
  TF_ASSERT_OK_AND_ASSIGN(Tensor host_tensor,
                          runtime.CreateHostTensor<int>({}, TF_INT32, {2}));