From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- libgo/go/crypto/block/xor_test.go | 168 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 168 insertions(+) create mode 100644 libgo/go/crypto/block/xor_test.go (limited to 'libgo/go/crypto/block/xor_test.go') diff --git a/libgo/go/crypto/block/xor_test.go b/libgo/go/crypto/block/xor_test.go new file mode 100644 index 000000000..50f6bb08d --- /dev/null +++ b/libgo/go/crypto/block/xor_test.go @@ -0,0 +1,168 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package block + +import ( + "bytes" + "fmt" + "io" + "testing" + "testing/iotest" +) + +// Simple "pseudo-random" stream for testing. +type incStream struct { + buf []byte + n byte +} + +func newIncStream(blockSize int) *incStream { + x := new(incStream) + x.buf = make([]byte, blockSize) + return x +} + +func (x *incStream) Next() []byte { + x.n++ + for i := range x.buf { + x.buf[i] = x.n + x.n++ + } + return x.buf +} + +func testXorWriter(t *testing.T, maxio int) { + var plain, crypt [256]byte + for i := 0; i < len(plain); i++ { + plain[i] = byte(i) + } + b := new(bytes.Buffer) + for block := 1; block <= 64 && block <= maxio; block *= 2 { + // compute encrypted version + n := byte(0) + for i := 0; i < len(crypt); i++ { + if i%block == 0 { + n++ + } + crypt[i] = plain[i] ^ n + n++ + } + + for frag := 0; frag < 2; frag++ { + test := fmt.Sprintf("block=%d frag=%d maxio=%d", block, frag, maxio) + b.Reset() + r := bytes.NewBuffer(plain[0:]) + s := newIncStream(block) + w := newXorWriter(s, b) + + // copy plain into w in increasingly large chunks: 1, 1, 2, 4, 8, ... + // if frag != 0, move the 1 to the end to cause fragmentation. + if frag == 0 { + _, err := io.Copyn(w, r, 1) + if err != nil { + t.Errorf("%s: first Copyn: %s", test, err) + continue + } + } + for n := 1; n <= len(plain)/2; n *= 2 { + _, err := io.Copyn(w, r, int64(n)) + if err != nil { + t.Errorf("%s: Copyn %d: %s", test, n, err) + } + } + + // check output + crypt := crypt[0 : len(crypt)-frag] + data := b.Bytes() + if len(data) != len(crypt) { + t.Errorf("%s: want %d bytes, got %d", test, len(crypt), len(data)) + continue + } + + if string(data) != string(crypt) { + t.Errorf("%s: want %x got %x", test, data, crypt) + } + } + } +} + + +func TestXorWriter(t *testing.T) { + // Do shorter I/O sizes first; they're easier to debug. + for n := 1; n <= 256 && !t.Failed(); n *= 2 { + testXorWriter(t, n) + } +} + +func testXorReader(t *testing.T, maxio int) { + var readers = []func(io.Reader) io.Reader{ + func(r io.Reader) io.Reader { return r }, + iotest.OneByteReader, + iotest.HalfReader, + } + var plain, crypt [256]byte + for i := 0; i < len(plain); i++ { + plain[i] = byte(255 - i) + } + b := new(bytes.Buffer) + for block := 1; block <= 64 && block <= maxio; block *= 2 { + // compute encrypted version + n := byte(0) + for i := 0; i < len(crypt); i++ { + if i%block == 0 { + n++ + } + crypt[i] = plain[i] ^ n + n++ + } + + for mode := 0; mode < len(readers); mode++ { + for frag := 0; frag < 2; frag++ { + test := fmt.Sprintf("block=%d mode=%d frag=%d maxio=%d", block, mode, frag, maxio) + s := newIncStream(block) + b.Reset() + r := newXorReader(s, readers[mode](bytes.NewBuffer(crypt[0:maxio]))) + + // read from crypt in increasingly large chunks: 1, 1, 2, 4, 8, ... + // if frag == 1, move the 1 to the end to cause fragmentation. + if frag == 0 { + _, err := io.Copyn(b, r, 1) + if err != nil { + t.Errorf("%s: first Copyn: %s", test, err) + continue + } + } + for n := 1; n <= maxio/2; n *= 2 { + _, err := io.Copyn(b, r, int64(n)) + if err != nil { + t.Errorf("%s: Copyn %d: %s", test, n, err) + } + } + + // check output + data := b.Bytes() + crypt := crypt[0 : maxio-frag] + plain := plain[0 : maxio-frag] + if len(data) != len(plain) { + t.Errorf("%s: want %d bytes, got %d", test, len(plain), len(data)) + continue + } + + if string(data) != string(plain) { + t.Errorf("%s: input=%x want %x got %x", test, crypt, plain, data) + } + } + } + } +} + +func TestXorReader(t *testing.T) { + // Do shorter I/O sizes first; they're easier to debug. + for n := 1; n <= 256 && !t.Failed(); n *= 2 { + testXorReader(t, n) + } +} + +// TODO(rsc): Test handling of writes after write errors. -- cgit v1.2.3