String    | 'hello'
        File      | TEST_FILE
    }

    def "can zip two providers"() {
        def big = withValues("big")
        def black = withValues("black")
        def cat = withValues("cat")

        when:
        def zipped = providerFactory.zip(
                providerFactory.zip(big, black) { s1, s2 -> "$s1 $s2" } ,
                cat) { s1, s2 -> "${s1.capitalize()} ${s2}"}

        then:

func (intVal) implementsValue()     {}
func (floatVal) implementsValue()   {}
func (complexVal) implementsValue() {}

func newInt() *big.Int     { return new(big.Int) }
func newRat() *big.Rat     { return new(big.Rat) }
func newFloat() *big.Float { return new(big.Float).SetPrec(prec) }

func i64toi(x int64Val) intVal   { return intVal{newInt().SetInt64(int64(x))} }

)

import "math" /* ERROR "imported and not used" */
import m /* ERROR "imported as m and not used" */ "math"
import _ "math"

import (
	"math/big" /* ERROR "imported and not used" */
	b /* ERROR "imported as b and not used" */ "math/big"
	_ "math/big"
)

import "fmt"
import f1 "fmt"
import f2 "fmt"

// reflect.flag must not be visible in this package
type flag int

  }

  public void testLimit_mark() throws Exception {
    byte[] big = newPreFilledByteArray(5);
    InputStream bin = new ByteArrayInputStream(big);
    InputStream lin = ByteStreams.limit(bin, 2);

    int read = lin.read();
    assertEquals(big[0], read);
    lin.mark(2);

    read = lin.read();
    assertEquals(big[1], read);
    read = lin.read();
    assertEquals(-1, read);

					}
					x = int(big)

				case reflect.Uint:
					if m.Name == "Uint" {
						continue
					}
					big := uint64s[repeat%len(uint64s)]
					if uint64(uint(big)) != big {
						r.Uint64N(big) // what would happen on 64-bit machine, to keep stream in sync
						if *update {
							t.Fatalf("must run -update on 64-bit machine")
						}
						p++
						continue
					}
					x = uint(big)

				case reflect.Int32:

}

// Archive represents an open AIX big archive.
type Archive struct {
	ArchiveHeader
	Members []*Member

	closer io.Closer
}

// ArchiveHeader holds information about a big archive file header
type ArchiveHeader struct {
	magic string
}

// Member represents a member of an AIX big archive.
type Member struct {
	MemberHeader
	sr *io.SectionReader
}

		got    infDecAmount
		expect string
	}{
		{bigDec(big.NewInt(1), 0), "1"},
		{bigDec(big.NewInt(1), 1), "10"},
		{bigDec(big.NewInt(5), 2), "500"},
		{bigDec(big.NewInt(8), 3), "8000"},
		{bigDec(big.NewInt(2), 0), "2"},
		{bigDec(big.NewInt(1), -1), "0.1"},
		{bigDec(big.NewInt(3), -2), "0.03"},
		{bigDec(big.NewInt(4), -3), "0.004"},
		{bigDec(big.NewInt(0).Add(bigMostPositive, big.NewInt(1)), 0), "9223372036854775808"},

	}
	*out = uint8(v[0])
	return true
}

// ReadUint16 decodes a big-endian, 16-bit value into out and advances over it.
// It reports whether the read was successful.
func (s *String) ReadUint16(out *uint16) bool {
	v := s.read(2)
	if v == nil {
		return false
	}
	*out = uint16(v[0])<<8 | uint16(v[1])
	return true
}

// ReadUint24 decodes a big-endian, 24-bit value into out and advances over it.

	} else if out != nil {
		t.Errorf("SetCanonicalBytes did not return nil with an error")
	}
}

func TestScalarSetUniformBytes(t *testing.T) {
	mod, _ := new(big.Int).SetString("27742317777372353535851937790883648493", 10)
	mod.Add(mod, new(big.Int).Lsh(big.NewInt(1), 252))
	f := func(in [64]byte, sc Scalar) bool {
		sc.SetUniformBytes(in[:])
		repr := sc.Bytes()
		if !isReduced(repr) {
			return false
		}

		},
		{
			name:         "service cidr is too big",
			expectErrors: true,
			options:      makeOptionsWithCIDRs("10.0.0.0/8", ""),
		},
		{
			name:         "service cidr IPv4 is too big but gate enbled",
			expectErrors: false,
			options:      makeOptionsWithCIDRs("10.0.0.0/8", ""),
			gate:         true,
		},
		{
			name:         "service cidr IPv6 is too big but gate enbled",
			expectErrors: false,