:HA#100:E	X(.?){0,}Y	X1234567Y	(0,9)(7,8)
:HA#101:E	X(.?){1,}Y	X1234567Y	(0,9)(7,8)
:HA#102:E	X(.?){2,}Y	X1234567Y	(0,9)(7,8)
:HA#103:E	X(.?){3,}Y	X1234567Y	(0,9)(7,8)
:HA#104:E	X(.?){4,}Y	X1234567Y	(0,9)(7,8)
:HA#105:E	X(.?){5,}Y	X1234567Y	(0,9)(7,8)
:HA#106:E	X(.?){6,}Y	X1234567Y	(0,9)(7,8)
:HA#107:E	X(.?){7,}Y	X1234567Y	(0,9)(7,8)
:HA#108:E	X(.?){8,}Y	X1234567Y	(0,9)(8,8)
#:HA#110:E	X(.?){0,8}Y	X1234567Y	(0,9)(7,8)

        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"

	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)
	SHA256ROUND0(11, 0x550c7dc3, 5, 6, 7, 0, 1, 2, 3, 4)
	SHA256ROUND0(12, 0x72be5d74, 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)
	SHA256ROUND0(11, 0x550c7dc3, 5, 6, 7, 0, 1, 2, 3, 4)
	SHA256ROUND0(12, 0x72be5d74, 4, 5, 6, 7, 0, 1, 2, 3)

	// decimals
	assert(1_234 == 1234)
	assert(1_234_567 == 1234567)

	// hexadecimals
	assert(0X_0 == 0)
	assert(0X_1234 == 0x1234)
	assert(0X_CAFE_f00d == 0xcafef00d)

	// octals
	assert(0o0 == 0)
	assert(0o1234 == 01234)
	assert(0o01234567 == 01234567)

	assert(0O0 == 0)
	assert(0O1234 == 01234)
	assert(0O01234567 == 01234567)

	assert(0o_0 == 0)
	assert(0o_1234 == 01234)

	expect(t, a, []int{1})
	a = appendThree_ssa(a, 2, 3, 4)
	expect(t, a, []int{1, 2, 3, 4})
	a = appendThree_ssa(a, 5, 6, 7)
	expect(t, a, []int{1, 2, 3, 4, 5, 6, 7})
	if &a[0] != &store[0] {
		t.Errorf("unnecessary grow")
	}
	a = appendOne_ssa(a, 8)
	expect(t, a, []int{1, 2, 3, 4, 5, 6, 7, 8})
	if &a[0] == &store[0] {
		t.Errorf("didn't grow")
	}
}

func TestAppend(t *testing.T) {
	testAppend(t)

	"k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
)

func activeTestPods() []*v1.Pod {
	return []*v1.Pod{
		{
			ObjectMeta: metav1.ObjectMeta{
				UID:       "12345678",
				Name:      "guaranteed-pod",
				Namespace: "test",
			},
			Spec: v1.PodSpec{
				Containers: []v1.Container{
					{
						Name:  "foo",
						Image: "busybox",

			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:

 * @author Colin Decker
 */
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});