EXPECT_THAT(remat.GetMemProfile(), ElementsAreArray({1, 2, 2, 3, 3, 2, 3}));
}

TEST_F(GreedyRematTest, MlpBinary) {
  StrictMock<MlpRemat> remat(std::vector<int>({1, 2, 4, 8}));
  // (o)ut, (i)n, (l)ive: 0 1 2 3 4 5 6 7 Sum of live sizes
  // %0 = f0()            o               1
  // %1 = f1(%0)          i o             3
  // %2 = f2(%1)          l i o           7
  // %3 = f3(%2)          l l i o         15

import (
	"bytes"
	"fmt"
	"io"
	"strings"
	"testing"
)

type encDecTest struct {
	enc string
	dec []byte
}

var encDecTests = []encDecTest{
	{"", []byte{}},
	{"0001020304050607", []byte{0, 1, 2, 3, 4, 5, 6, 7}},
	{"08090a0b0c0d0e0f", []byte{8, 9, 10, 11, 12, 13, 14, 15}},
	{"f0f1f2f3f4f5f6f7", []byte{0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7}},
	{"f8f9fafbfcfdfeff", []byte{0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff}},

        def class1 = Stub(TestClassResult) {
            getClassName() >> 'class-1'
            getResults() >> Collections.singletonList(new TestMethodResult(101, 'methodFoo', TestResult.ResultType.SUCCESS, 10, 123456))
            getStartTime() >> startTimeLater
        }
        def class2 = Stub(TestClassResult) {
            getClassName() >> 'class-1'

    }

    def "build fails if key is provided via env var but not long enough"() {
        given:
        def insufficientlyLongEncryptionKey = Base64.encoder.encodeToString("01234567".getBytes(StandardCharsets.UTF_8))

        when:
        runWithEncryption(EncryptionKind.ENV_VAR, ["help"], [], [(GRADLE_ENCRYPTION_KEY_ENV_KEY): insufficientlyLongEncryptionKey], this::configurationCacheFails)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package test

import (
	"encoding/binary"
	"testing"
)

var gv = [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8}

//go:noinline
func readGlobalUnaligned() uint64 {
	return binary.LittleEndian.Uint64(gv[1:])
}

func TestUnalignedGlobal(t *testing.T) {

	// 10
	// [0 1 2 3]
	// 4
	// 4
}

func ExampleConcat() {
	s1 := []int{0, 1, 2, 3}
	s2 := []int{4, 5, 6}
	concat := slices.Concat(s1, s2)
	fmt.Println(concat)
	// Output:
	// [0 1 2 3 4 5 6]
}

func ExampleContains() {
	numbers := []int{0, 1, 2, 3}
	fmt.Println(slices.Contains(numbers, 2))
	fmt.Println(slices.Contains(numbers, 4))
	// Output:
	// true
	// false
}

  %read0 = "tf.ReadVariableOp"(%vh0) : (!tf_res) -> tensor<i1>
  // expected-remark@below {{Result #0, ID 4 : Unknown}}
  // expected-remark@below {{Result #1, ID 5 : 0, 1, 2, 3, 4, 5, 6, 8}}
  // expected-remark@below {{Result #2, ID 6 : 1, 2, 4, 5, 6, 7, 8}}
  %if:3 = "tf.IfRegion"(%read0) ({
            // expected-remark@below {{Result #0, ID 1 : Unknown}}

  func.return
}

// -----

// Tests TPIv2 with a "partially tiled" XLA annotation where:
//   type: OTHER
//   tile_assignment_dimensions: [4, 1, 1, 1, 2]
//   tile_assignment_devices: [0, 1, 2, 3, 4, 5, 6, 7]
//   replicate_on_last_tile_dim: true
// Serialized string:
//   "\08\03\1A\05\04\01\01\01\02\22\08\00\01\02\03\04\05\06\070\01"

// CHECK-LABEL: func @partial_tile_partitioned_variable

		// Zeros
		{"0", 0, nil},
		{"0i", 0, nil},
		{"-0.0i", 0, nil},
		{"0+0.0i", 0, nil},
		{"0e+0i", 0, nil},
		{"0e-0+0i", 0, nil},
		{"-0.0-0.0i", 0, nil},
		{"0e+012345", 0, nil},
		{"0x0p+012345i", 0, nil},
		{"0x0.00p-012345i", 0, nil},
		{"+0e-0+0e-0i", 0, nil},
		{"0e+0+0e+0i", 0, nil},
		{"-0e+0-0e+0i", 0, nil},

		// Regular non-zeroes
		{"0.1", 0.1, nil},
		{"0.1i", 0 + 0.1i, nil},

}

var marshalTests = []marshalTest{
	{10, "02010a"},
	{127, "02017f"},
	{128, "02020080"},
	{-128, "020180"},
	{-129, "0202ff7f"},
	{intStruct{64}, "3003020140"},
	{bigIntStruct{big.NewInt(0x123456)}, "30050203123456"},
	{twoIntStruct{64, 65}, "3006020140020141"},
	{nestedStruct{intStruct{127}}, "3005300302017f"},
	{[]byte{1, 2, 3}, "0403010203"},
	{implicitTagTest{64}, "3003850140"},