package main

type Src1[T any] func() Src1[T]

func (s *Src1[T]) Next() {
	*s = (*s)()
}

type Src2[T any] []func() Src2[T]

func (s Src2[T]) Next() {
	_ = s[0]()
}

type Src3[T comparable] map[T]func() Src3[T]

func (s Src3[T]) Next() {
	var a T
	_ = s[a]()
}

type Src4[T any] chan func() T

func (s Src4[T]) Next() {
	_ = (<-s)()
}

type Src5[T any] func() Src5[T]

	if !reflect.DeepEqual(src2, dest2) {
		t.Errorf("%v and %v are not equal", src2, dest2)
	}

	src3 := []string{"a", "c", "b"}
	dest3 := CopyStrings(src3)

	if !reflect.DeepEqual(src3, dest3) {
		t.Errorf("%v and %v are not equal", src3, dest3)
	}

	src3[0] = "A"
	if reflect.DeepEqual(src3, dest3) {
		t.Errorf("CopyStrings didn't make a copy")
	}
}

func TestSortStrings(t *testing.T) {

            it.from("src1", "src2")
            it.from("src3")
        })
        then:
        collection.from as List == ["src1", "src2", "src3"]
    }

    def "can incrementally set paths using closure"() {
        when:
        collection.withActualValue {
            it.from("src1", "src2")
            it.from("src3")
        }
        then:

	ROUND4(Rb, Rc, Rd, Ra, 13, 21, Rc3)

	MOVM.IA.W (Rtable), [Rc0,Rc1,Rc2,Rc3]
	ROUND4(Ra, Rb, Rc, Rd,  4,	6, Rc0)
	ROUND4(Rd, Ra, Rb, Rc, 11, 10, Rc1)
	ROUND4(Rc, Rd, Ra, Rb,  2, 15, Rc2)
	ROUND4(Rb, Rc, Rd, Ra,  9, 21, Rc3)

	MOVW	dig+0(FP), Rt0
	MOVM.IA (Rt0), [Rc0,Rc1,Rc2,Rc3]

	ADD	Rc0, Ra
	ADD	Rc1, Rb
	ADD	Rc2, Rc
	ADD	Rc3, Rd

	MOVM.IA [Ra,Rb,Rc,Rd], (Rt0)

var langTests = []testCase1[string, string]{
	{"1.2rc3", "1.2"},
	{"1.2.3", "1.2"},
	{"1.2", "1.2"},
	{"1", "1"},
	{"1.999testmod", "1.999"},
}

func TestIsLang(t *testing.T) { test1(t, isLangTests, "IsLang", IsLang) }

var isLangTests = []testCase1[string, bool]{
	{"1.2rc3", false},
	{"1.2.3", false},
	{"1.999testmod", false},
	{"1.22", true},
	{"1.21", true},

var langTests = []testCase1[string, string]{
	{"1.2rc3", "1.2"},
	{"1.2.3", "1.2"},
	{"1.2", "1.2"},
	{"1", "1"},
	{"1.999testmod", "1.999"},
}

func TestIsLang(t *testing.T) { test1(t, isLangTests, "IsLang", IsLang) }

var isLangTests = []testCase1[string, bool]{
	{"1.2rc3", false},
	{"1.2.3", false},
	{"1.999testmod", false},
	{"1.22", true},
	{"1.21", true},

var langTests = []testCase1[string, string]{
	{"bad", ""},
	{"go1.2rc3", "go1.2"},
	{"go1.2.3", "go1.2"},
	{"go1.2", "go1.2"},
	{"go1", "go1"},
	{"go222", "go222.0"},
	{"go1.999testmod", "go1.999"},
}

func TestIsValid(t *testing.T) { test1(t, isValidTests, "IsValid", IsValid) }

var isValidTests = []testCase1[string, bool]{
	{"", false},
	{"1.2.3", false},
	{"go1.2rc3", true},
	{"go1.2.3", true},
	{"go1.999testmod", true},

      while (bb.remaining() >= 16) {
        crc0 = computeForWord(crc0);
        crc1 = computeForWord(crc1);
        crc2 = computeForWord(crc2);
        crc3 = computeForWord(crc3);
        crc0 ^= bb.getInt();
        crc1 ^= bb.getInt();
        crc2 ^= bb.getInt();
        crc3 ^= bb.getInt();
      }
    }

    @Override
    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;

      while (bb.remaining() >= 16) {
        crc0 = computeForWord(crc0);
        crc1 = computeForWord(crc1);
        crc2 = computeForWord(crc2);
        crc3 = computeForWord(crc3);
        crc0 ^= bb.getInt();
        crc1 ^= bb.getInt();
        crc2 ^= bb.getInt();
        crc3 ^= bb.getInt();
      }
    }

    @Override
    protected void processRemaining(ByteBuffer bb) {
      if (finished) {
        return;

	var pad [16]uint64
	pad[FailCount&0x1]++
	rc0 := StructF2S0{F0: ArrayF2S1E1{New_3(float64(-0.4418990509835844))}}
	rc1 := ArrayF2S2E1{StructF2S1{ /* _: "񊶿(z̽|" */ F1: "􂊇񊶿"}}
	rc2 := int16(4162)
	rc3 := float32(-7.667096e+37)
	rc4 := int64(3202175648847048679)
	p1f0c := uint8(57)
	if p1 != p1f0c {
		NoteFailureElem(9, 42, 2, "genChecker42", "parm", 1, 0, false, pad[0])
		return
	}
	_ = uint16(10920)