Golang quick.CheckEqual函數代碼示例

func TestMarshalUnmarshalArbitrary(t *testing.T) {
	f := func(arb Arbitrary) interface{} { a, _ := standardize(arb.Value); return a }
	g := func(arb Arbitrary) interface{} {
		data, err := Marshal(arb.Value, XMLFormat)
		if err != nil {
			t.Error(err)
			return nil
		}
		var result interface{}
		format, err := Unmarshal(data, &result)
		if err != nil {
			t.Error(err)
			return nil
		}
		if format != XMLFormat {
			t.Error(err)
			return nil
		}
		a, _ := standardize(result)
		return a
	}
	if err := quick.CheckEqual(f, g, nil); err != nil {
		out1 := err.(*quick.CheckEqualError).Out1[0]
		out2 := err.(*quick.CheckEqualError).Out2[0]
		findDifferences(t, out1, out2)
		t.Error(err)
	}
}

func TestXXD(t *testing.T) {
	if *xxdFile == "" {
		t.Skip("-xxdFile argument not given")
	}
	data, err := ioutil.ReadFile(*xxdFile)
	if err != nil {
		t.Fatal(err)
	}
	test := func(fn func(r io.Reader, w io.Writer, s string) error) func(n uint64) []string {
		return func(n uint64) []string {
			size := n % uint64(len(data))
			fmt.Printf("%d\n", size)
			var out bytes.Buffer
			if err := fn(&pathologicalReader{data[0:size]}, &out, ""); err != nil {
				return []string{err.Error()}
			}
			return strings.Split(out.String(), "\n")
		}
	}
	if err := quick.CheckEqual(test(xxd), test(xxdNative), nil); err != nil {
		cErr := err.(*quick.CheckEqualError)
		size := cErr.In[0].(uint64) % uint64(len(data))
		for i := range cErr.Out1[0].([]string) {
			got := cErr.Out1[0].([]string)[i]
			want := cErr.Out2[0].([]string)[i]
			if got != want {
				t.Errorf("size: %d\n\ngot : %s\nwant: %s\n", size, got, want)
				break
			}
		}
	}
}

func TestQuickPythonEncodeBits(t *testing.T) {
	if !*python {
		t.Skip("Skipping, use -python to enable")
	}
	us := func(orig []byte, partial uint) (string, error) {
		bits := calcBits(orig, partial)
		encoded := zbase32.EncodeBitsToString(orig, bits)
		return encoded, nil
	}
	them := func(orig []byte, partial uint) (string, error) {
		// the python library raises IndexError on zero-length input
		if len(orig) == 0 {
			return "", nil
		}
		bits := calcBits(orig, partial)
		cmd := exec.Command("python", "-c", `
import sys, zbase32
orig = sys.stdin.read()
bits = int(sys.argv[1])
sys.stdout.write(zbase32.b2a_l(orig, bits))
`,
			strconv.Itoa(bits),
		)
		cmd.Stdin = bytes.NewReader(orig)
		cmd.Stderr = os.Stderr
		output, err := cmd.Output()
		if err != nil {
			return "", fmt.Errorf("cannot run python: %v", err)
		}
		return string(output), nil
	}
	if err := quick.CheckEqual(us, them, nil); err != nil {
		t.Fatal(err)
	}
}

func TestCompareRead(t *testing.T) {
	r := NewRandReader(42)
	buf := make([]byte, 10*1024*1024)
	r.Read(buf)

	blob := emptyBlob(t, &mock.InMemory{})
	blob.WriteAt(buf, 0)

	got := func(p []byte, off int64) (int, error) {
		if off < 0 {
			off = -off
		}
		return blob.ReadAt(p, off)
	}
	rat := bytes.NewReader(buf)
	exp := func(p []byte, off int64) (int, error) {
		if off < 0 {
			off = -off
		}
		return rat.ReadAt(p, off)
	}

	config := quick.Config{
		MaxCountScale: 100.0,
	}
	if err := quick.CheckEqual(got, exp, &config); err != nil {
		t.Error(err)
	}
}

func TestPackageMethods(t *T) {
	pkg := func(a, b, c, d, e, f string) string {
		buf := setupLogger()
		defer resetLogger()

		Println(a, b, c, d, e, f)
		Print(a, b, c, d, e, f)
		Printf(a, b, c, d, e, f)
		return buf.String()
	}

	dft := func(a, b, c, d, e, f string) string {
		buf := setupLogger()
		defer resetLogger()

		Default.Println(a, b, c, d, e, f)
		Default.Print(a, b, c, d, e, f)
		Default.Printf(a, b, c, d, e, f)
		return buf.String()
	}

	if err := quick.CheckEqual(pkg, dft, nil); err != nil {
		t.Error(err)
	}
}

func TestQuickPythonDecodeBytes(t *testing.T) {
	if !*python {
		t.Skip("Skipping, use -python to enable")
	}
	us := func(orig []byte) ([]byte, error) {
		encoded := zbase32.EncodeToString(orig)
		return zbase32.DecodeString(encoded)
	}
	them := func(orig []byte) ([]byte, error) {
		// the python library raises IndexError on zero-length input
		if len(orig) == 0 {
			return []byte{}, nil
		}
		encoded := zbase32.EncodeToString(orig)

		cmd := exec.Command("python", "-c", `
import sys, zbase32
enc = sys.stdin.read()
sys.stdout.write(zbase32.a2b(enc))
`)
		cmd.Stdin = strings.NewReader(encoded)
		cmd.Stderr = os.Stderr
		output, err := cmd.Output()
		if err != nil {
			return nil, fmt.Errorf("cannot run python: %v", err)
		}
		return output, nil
	}
	if err := quick.CheckEqual(us, them, nil); err != nil {
		t.Fatal(err)
	}
}

func TestSumBytes(t *testing.T) {
	config := &quick.Config{MaxCount: 1 << 10}
	fast := func(x TestSlice) uint64 { return FastSumUint8(x) }
	slow := func(x TestSlice) uint64 { return SumUint8(x) }
	if err := quick.CheckEqual(fast, slow, config); err != nil {
		t.Error(err)
	}
}

func TestNodeID_logdist(t *testing.T) {
	logdistBig := func(a, b common.Hash) int {
		abig, bbig := new(big.Int).SetBytes(a[:]), new(big.Int).SetBytes(b[:])
		return new(big.Int).Xor(abig, bbig).BitLen()
	}
	if err := quick.CheckEqual(logdist, logdistBig, quickcfg()); err != nil {
		t.Error(err)
	}
}

func TestForward(t *testing.T) {
	if err := quick.CheckEqual(func(a, b []byte) ([]byte, error) {
		diff := Diff(a, b, 0)
		return Forward(a, diff)
	}, func(a, b []byte) ([]byte, error) {
		return b, nil
	}, nil); err != nil {
		t.Error(err)
	}
}

func TestReverse(t *testing.T) {
	if err := quick.CheckEqual(func(a, b []byte) ([]byte, error) {
		diff := Diff(a, b, 0)
		return Reverse(b, diff)
	}, func(a, b []byte) ([]byte, error) {
		return a, nil
	}, nil); err != nil {
		t.Error(err)
	}
}

func TestClientSeek(t *testing.T) {
	sftp, cmd := testClient(t, READONLY, NO_DELAY)
	defer cmd.Wait()
	defer sftp.Close()

	fOS, err := ioutil.TempFile("", "seek-test")
	if err != nil {
		t.Fatal(err)
	}
	defer fOS.Close()

	fSFTP, err := sftp.Open(fOS.Name())
	if err != nil {
		t.Fatal(err)
	}
	defer fSFTP.Close()

	writeN(t, fOS, seekBytes)

	if err := quick.CheckEqual(
		func(s seek) (string, int64) { s.set(t, fOS); return readHash(t, fOS) },
		func(s seek) (string, int64) { s.set(t, fSFTP); return readHash(t, fSFTP) },
		nil,
	); err != nil {
		t.Errorf("Seek: expected equal absolute seeks: %v", err)
	}

	if err := quick.CheckEqual(
		func(s seek) (string, int64) { s.current(t, fOS); return readHash(t, fOS) },
		func(s seek) (string, int64) { s.current(t, fSFTP); return readHash(t, fSFTP) },
		nil,
	); err != nil {
		t.Errorf("Seek: expected equal seeks from middle: %v", err)
	}

	if err := quick.CheckEqual(
		func(s seek) (string, int64) { s.end(t, fOS); return readHash(t, fOS) },
		func(s seek) (string, int64) { s.end(t, fSFTP); return readHash(t, fSFTP) },
		nil,
	); err != nil {
		t.Errorf("Seek: expected equal seeks from end: %v", err)
	}
}

func TestNodeID_distcmp(t *testing.T) {
	distcmpBig := func(target, a, b common.Hash) int {
		tbig := new(big.Int).SetBytes(target[:])
		abig := new(big.Int).SetBytes(a[:])
		bbig := new(big.Int).SetBytes(b[:])
		return new(big.Int).Xor(tbig, abig).Cmp(new(big.Int).Xor(tbig, bbig))
	}
	if err := quick.CheckEqual(distcmp, distcmpBig, quickcfg()); err != nil {
		t.Error(err)
	}
}

func TestConstantTimeByteEq(t *testing.T) {
	for i, test := range testConstandTimeByteEqData {
		if r := ConstantTimeByteEq(test.a, test.b); r != test.out {
			t.Errorf("#%d bad result (got %x, want %x)", i, r, test.out)
		}
	}
	err := quick.CheckEqual(ConstantTimeByteEq, byteEq, nil)
	if err != nil {
		t.Error(err)
	}
}

func TestNewEscaper(t *testing.T) {
	of := func(in chars) string {
		return oldunescape(string(in))
	}
	nf := func(in chars) string {
		return unescape(string(in))
	}
	if err := quick.CheckEqual(of, nf, nil); err != nil {
		t.Errorf("quickcheck failure: %v", err)
	}
}

func TestCFNumber_Float64(t *testing.T) {
	f := func(f float64) float64 { return f }
	g := func(f float64) float64 {
		cfNum := convertFloat64ToCFNumber(f)
		if cfNum == nil {
			t.Fatal("CFNumberRef is NULL (%#v)", f)
		}
		defer cfRelease(cfTypeRef(cfNum))
		return convertCFNumberToFloat64(cfNum)
	}
	if err := quick.CheckEqual(f, g, nil); err != nil {
		t.Error(err)
	}
}