expect:
        HashCode.fromString("12345678").toZeroPaddedString(8) == "12345678"
        HashCode.fromString("12345678").toZeroPaddedString(7) == "12345678"
        HashCode.fromString("12345678").toZeroPaddedString(0) == "12345678"
        HashCode.fromString("12345678").toZeroPaddedString(9) == "012345678"
        HashCode.fromString("12345678").toZeroPaddedString(16) == "0000000012345678"

		_ = a == c
	}
}

const size = 16

type T1 struct {
	a [size]byte
}

func BenchmarkEqStruct(b *testing.B) {
	x, y := T1{}, T1{}
	x.a = [size]byte{1, 2, 3, 4, 5, 6, 7, 8}
	y.a = [size]byte{2, 3, 4, 5, 6, 7, 8, 9}

	for i := 0; i < b.N; i++ {
		f := x == y
		if f {
			println("hello")
		}
	}

			in:   "1",
			want: 1,
		},
		{
			desc: "numeric-zero",
			in:   "0",
			want: 0,
		},
		{
			desc: "numeric-large",
			in:   "12345678",
			want: 12345678,
		},
		{
			desc: "numeric-negative",
			in:   "-12345678",
			want: -12345678,
		},
		{
			desc: "float",
			in:   "1.23456",
			want: 1.23456,
		},
		{
			desc: "float-zero",
			in:   "0.00",
			want: 0.00,
		},

 * Tests {@link ImmutableFilteredList}.
 */
class ImmutableFilteredListTest extends Specification {

    def "can construct from an existing list"() {
        when:
        def list = ImmutableFilteredList.allOf([1, 2, 3, 4, 5, 6, 7, 8])

        then:
        list.size() == 8
        for (int i = 0; i < 8; i++) {
            assert list.get(i) == i + 1
        }
    }

    def "list equality works"() {
        expect:

public class AbstractByteHasherTest extends TestCase {

  public void testBytes() {
    TestHasher hasher = new TestHasher(); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    hasher.putByte((byte) 1);
    hasher.putBytes(new byte[] {2, 3, 4, 5, 6});
    hasher.putByte((byte) 7);
    hasher.putBytes(new byte[] {});
    hasher.putBytes(new byte[] {8});
    hasher.assertBytes(expected);
  }

)

func TestTerminationOrderingSidecarStopAfterMain(t *testing.T) {
	restartPolicy := v1.ContainerRestartPolicyAlways
	pod := &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			UID:       "12345678",
			Name:      "bar",
			Namespace: "new",
		},
		Spec: v1.PodSpec{
			InitContainers: []v1.Container{
				{
					Name:            "init",
					Image:           "busybox",

  // CHECK: return %[[RES_TRANSPOSE]]

  %0 = "tf.Conv2D"(%input, %filter)
       {
         data_format = "NHWC",
         dilations = [1, 2, 3, 4],
         explicit_paddings = [1, 2, 3, 4, 5, 6, 7, 8],
         padding = "EXPLICIT",
         strides = [5, 6, 7, 8]
       } : (tensor<1x32x32x3xf32>, tensor<1x1x3x8xf32>) -> tensor<1x7x7x8xf32>

  func.return %0 : tensor<1x7x7x8xf32>
}

        Describables.of("one", "two", "three").capitalizedDisplayName == "One two three"

        Describables.of(123, 456, 789).displayName == "123 456 789"
        Describables.of(123, 456, 789).toString() == "123 456 789"
        Describables.of(123, 456, 789).capitalizedDisplayName == "123 456 789"
    }

    def "creates from describable"() {
        def d1 = Mock(Describable)
        def d2 = Mock(DisplayName)

 */
public class AbstractStreamingHasherTest extends TestCase {
  public void testBytes() {
    Sink sink = new Sink(4); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    sink.putByte((byte) 1);
    sink.putBytes(new byte[] {2, 3, 4, 5, 6});
    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);

	SHA256ROUND0(3, 0xe9b5dba5, 5, 6, 7, 0, 1, 2, 3, 4)
	SHA256ROUND0(4, 0x3956c25b, 4, 5, 6, 7, 0, 1, 2, 3)
	SHA256ROUND0(5, 0x59f111f1, 3, 4, 5, 6, 7, 0, 1, 2)
	SHA256ROUND0(6, 0x923f82a4, 2, 3, 4, 5, 6, 7, 0, 1)
	SHA256ROUND0(7, 0xab1c5ed5, 1, 2, 3, 4, 5, 6, 7, 0)
	SHA256ROUND0(8, 0xd807aa98, 0, 1, 2, 3, 4, 5, 6, 7)
	SHA256ROUND0(9, 0x12835b01, 7, 0, 1, 2, 3, 4, 5, 6)
	SHA256ROUND0(10, 0x243185be, 6, 7, 0, 1, 2, 3, 4, 5)