{"2.2ms", 2200 * Microsecond},
	{"3.3s", 3300 * Millisecond},
	{"4m5s", 4*Minute + 5*Second},
	{"4m5.001s", 4*Minute + 5001*Millisecond},
	{"5h6m7.001s", 5*Hour + 6*Minute + 7001*Millisecond},
	{"8m0.000000001s", 8*Minute + 1*Nanosecond},
	{"2562047h47m16.854775807s", 1<<63 - 1},
	{"-2562047h47m16.854775808s", -1 << 63},
}

func TestDurationString(t *testing.T) {
	for _, tt := range durationTests {

		{s: time.Unix(1, 2).UTC(), d: &scanstr, wantstr: "1970-01-01T00:00:01.000000002Z"},
		{s: time.Time{}, d: &scanstr, wantstr: "0001-01-01T00:00:00Z"},
		{s: time.Unix(1, 2).UTC(), d: &scanbytes, wantbytes: []byte("1970-01-01T00:00:01.000000002Z")},
		{s: time.Unix(1, 2).UTC(), d: &scaniface, wantiface: time.Unix(1, 2).UTC()},

		// To []byte
		{s: nil, d: &scanbytes, wantbytes: nil},

}{
	// 9 digits
	{"2021-09-29T16:04:33.000000000Z", 0},
	{"2021-09-29T16:04:33.000000001Z", 1},
	{"2021-09-29T16:04:33.100000000Z", 100_000_000},
	{"2021-09-29T16:04:33.100000001Z", 100_000_001},
	{"2021-09-29T16:04:33.999999999Z", 999_999_999},
	{"2021-09-29T16:04:33.012345678Z", 12_345_678},
	// 10 digits, truncates
	{"2021-09-29T16:04:33.0000000000Z", 0},
	{"2021-09-29T16:04:33.0000000001Z", 0},

	timestampListLiteral = "[timestamp('2011-01-01T00:00:00.000+01:00'), timestamp('2011-01-02T00:00:00.000+01:00'), " +
		"timestamp('2011-01-03T00:00:00.000+01:00'), timestamp('2011-01-04T00:00:00.000+01:00'), " +
		"timestamp('2011-01-05T00:00:00.000+01:00')]"
	stringLiteral = "'01234567890123456789012345678901234567890123456789'"
)

type comparableCost struct {

        assertEquals(0, new BigDecimal("0.000000123").compareTo(BigDecimalConversionUtil.toBigDecimal(new Double(0.000000123D))));
        assertEquals(0, new BigDecimal("0.0000000123").compareTo(BigDecimalConversionUtil.toBigDecimal(new Double(0.0000000123D))));
        assertEquals(0, new BigDecimal("0.00000000123").compareTo(BigDecimalConversionUtil.toBigDecimal(new Double(0.00000000123D))));

		[]byte("192.0.2.1"),
		nil,
	},
	{
		IP{0, 0, 0, 0},
		"0.0.0.0",
		[]byte("0.0.0.0"),
		nil,
	},

	// IPv4-mapped IPv6 address
	{
		IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 0, 2, 1},
		"192.0.2.1",
		[]byte("192.0.2.1"),
		nil,
	},
	{
		IP{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 0, 0, 0},
		"0.0.0.0",
		[]byte("0.0.0.0"),
		nil,
	},

    -> (tensor<4x256xf16>) {
  // expected-warning @+1 {{Could not convert batch_norm epsilon to target fp type: opStatus = 24}}
  %0 = "mhlo.batch_norm_inference"(%x, %scale, %offset, %mean, %variance)
      {epsilon = 0.00000001 : f32, feature_index = 1 : i64} :
      (tensor<4x256xf16>, tensor<256xf16>, tensor<256xf16>, tensor<256xf16>,
        tensor<256xf16>) -> tensor<4x256xf16>
  func.return %0 : tensor<4x256xf16>
}

00000000  17 03 03 00 1a 2d 7a c5  d0 12 79 e8 a2 05 d3 a4  |.....-z...y.....|
00000010  51 80 8f 28 37 b9 75 64  f3 11 4c 78 de 0c f3 15  |Q..(7.ud..Lx....|
00000020  03 03 00 16 43 89 2c 8b  9e dc c5 5d 4c ca 7b 4e  |....C.,....]L.{N|

00000010  f8 21 2a 34 c9 6b 54 76  aa d2 cf 5e 07 7a aa e2  |.!*4.kTv...^.z..|
00000020  10 cb 3e ed 87 f4 3e 70  44 d0 35 20 6e b4 f0 71  |..>...>pD.5 n..q|
00000030  76 96 1e 2a 57 74 4b db  9a 11 0a af 06 ea 3b 20  |v..*WtK.......; |
00000040  a8 81 51 9d 41 ef f1 f9  23 87 18 cb c0 2c 00 00  |..Q.A...#....,..|
00000050  11 ff 01 00 01 00 00 0b  00 04 03 00 01 02 00 17  |................|

00000010  e2 56 80 e2 f3 20 5b 7d  52 f3 67 1f 01 0d ad 30  |.V... [}R.g....0|
00000020  36 a6 43 c2 ed 5e 34 c5  24 89 e1 20 c7 4c 5d 06  |6.C..^4.$.. .L].|
00000030  01 7a 80 aa 84 0c 46 48  63 36 49 4a 9b 3f 8d ba  |.z....FHc6IJ.?..|
00000040  78 1b cd f9 ef 03 df cd  ee 2c b1 79 c0 09 00 00  |x........,.y....|
00000050  11 ff 01 00 01 00 00 0b  00 04 03 00 01 02 00 17  |................|
00000060  00 00 16 03 03 02 0e 0b  00 02 0a 00 02 07 00 02  |................|