作者：rlmcpherso
项目：go-fuz
func Fuzz(data []byte) int {
cfg, err := gif.DecodeConfig(bytes.NewReader(data))
if err != nil {
return 0
}
if cfg.Width*cfg.Height > 1e6 {
return 0
}
img, err := gif.Decode(bytes.NewReader(data))
if err != nil {
return 0
}
for c := 1; c <= 256; c += 21 {
var w bytes.Buffer
err = gif.Encode(&w, img, &gif.Options{NumColors: c})
if err != nil {
panic(err)
}
img1, err := gif.Decode(&w)
if err != nil {
panic(err)
}
b0 := img.Bounds()
b1 := img1.Bounds()
if b0.Max.X-b0.Min.X != b1.Max.X-b1.Min.X || b0.Max.Y-b0.Min.Y != b1.Max.Y-b1.Min.Y {
fmt.Printf("img0: %#v\n", img.Bounds())
fmt.Printf("img1: %#v\n", img1.Bounds())
panic("bounds changed")
}
}
return 1
}
作者：starkandwayn
项目：shiel
// FetchUser will go to Cloud Foundry and access basic information about the user.
func (p *Provider) FetchUser(session goth.Session) (goth.User, error) {
s := session.(*Session)
user := goth.User{
AccessToken: s.AccessToken,
Provider: p.Name(),
RefreshToken: s.RefreshToken,
ExpiresAt: s.ExpiresAt,
}
req, err := http.NewRequest("GET", p.UserInfoURL, nil)
if err != nil {
return user, err
}
req.Header.Set("Authorization", "Bearer "+s.AccessToken)
resp, err := p.Client.Do(req)
if err != nil {
if resp != nil {
resp.Body.Close()
}
return user, err
}
defer resp.Body.Close()
bits, err := ioutil.ReadAll(resp.Body)
if err != nil {
return user, err
}
err = json.NewDecoder(bytes.NewReader(bits)).Decode(&user.RawData)
if err != nil {
return user, err
}
err = userFromReader(bytes.NewReader(bits), &user)
return user, err
}
作者：RaulKit
项目：machin
// PutPage writes a range of pages to a page blob or clears the given range.
// In case of 'clear' writes, given chunk is discarded. Ranges must be aligned
// with 512-byte boundaries and chunk must be of size multiplies by 512.
//
// See https://msdn.microsoft.com/en-us/library/ee691975.aspx
func (b BlobStorageClient) PutPage(container, name string, startByte, endByte int64, writeType PageWriteType, chunk []byte, extraHeaders map[string]string) error {
path := fmt.Sprintf("%s/%s", container, name)
uri := b.client.getEndpoint(blobServiceName, path, url.Values{"comp": {"page"}})
headers := b.client.getStandardHeaders()
headers["x-ms-blob-type"] = string(BlobTypePage)
headers["x-ms-page-write"] = string(writeType)
headers["x-ms-range"] = fmt.Sprintf("bytes=%v-%v", startByte, endByte)
for k, v := range extraHeaders {
headers[k] = v
}
var contentLength int64
var data io.Reader
if writeType == PageWriteTypeClear {
contentLength = 0
data = bytes.NewReader([]byte{})
} else {
contentLength = int64(len(chunk))
data = bytes.NewReader(chunk)
}
headers["Content-Length"] = fmt.Sprintf("%v", contentLength)
resp, err := b.client.exec("PUT", uri, headers, data)
if err != nil {
return err
}
defer resp.body.Close()
return checkRespCode(resp.statusCode, []int{http.StatusCreated})
}
作者：deniseschanno
项目：rancher-volum
func (s *TestSuite) TestFuncs(c *C) {
var err error
body := []byte("this is only a test file")
key := "test_file"
key1 := "test_file_1"
key2 := "test_file_2"
err = s.service.PutObject(key1, bytes.NewReader(body))
c.Assert(err, IsNil)
err = s.service.PutObject(key2, bytes.NewReader(body))
c.Assert(err, IsNil)
objs, err := s.service.ListObjects(key)
c.Assert(err, IsNil)
c.Assert(objs, HasLen, 2)
r, err := s.service.GetObject(key1)
c.Assert(err, IsNil)
newBody, err := ioutil.ReadAll(r)
c.Assert(err, IsNil)
c.Assert(newBody, DeepEquals, body)
err = s.service.DeleteObjects([]string{key})
c.Assert(err, IsNil)
objs, err = s.service.ListObjects(key)
c.Assert(err, IsNil)
c.Assert(objs, HasLen, 0)
}
作者：dutchcoder
项目：goam
// This may take a minute or more due to the minimum size accepted S3
// on multipart upload parts.
func (s *ClientTests) TestMultiComplete(c *gocheck.C) {
b := testBucket(s.s3)
err := b.PutBucket(s3.Private)
c.Assert(err, gocheck.IsNil)
multi, err := b.InitMulti("multi", "text/plain", s3.Private)
c.Assert(err, gocheck.IsNil)
c.Assert(multi.UploadId, gocheck.Matches, ".+")
defer multi.Abort()
// Minimum size S3 accepts for all but the last part is 5MB.
data1 := make([]byte, 5*1024*1024)
data2 := []byte("<part 2>")
part1, err := multi.PutPart(1, bytes.NewReader(data1))
c.Assert(err, gocheck.IsNil)
part2, err := multi.PutPart(2, bytes.NewReader(data2))
c.Assert(err, gocheck.IsNil)
// Purposefully reversed. The order requirement must be handled.
err = multi.Complete([]s3.Part{part2, part1})
c.Assert(err, gocheck.IsNil)
data, err := b.Get("multi")
c.Assert(err, gocheck.IsNil)
c.Assert(len(data), gocheck.Equals, len(data1)+len(data2))
for i := range data1 {
if data[i] != data1[i] {
c.Fatalf("uploaded object at byte %d: want %d, got %d", data1[i], data[i])
}
}
c.Assert(string(data[len(data1):]), gocheck.Equals, string(data2))
}
作者：glepore7
项目：siegfrie
func TestTip(t *testing.T) {
expect := "fmt/669"
err := setup()
if err != nil {
t.Error(err)
}
buf := bytes.NewReader([]byte{0x00, 0x4d, 0x52, 0x4d, 0x00})
c, err := s.Identify("test.mrw", buf)
for i := range c {
if i.String() != expect {
t.Errorf("First buffer: expecting %s, got %s", expect, i)
}
}
buf = bytes.NewReader([]byte{0x00, 0x4d, 0x52, 0x4d, 0x00})
c, err = s.Identify("test.mrw", buf)
for i := range c {
if i.String() != expect {
t.Errorf("Second buffer: expecting %s, got %s", expect, i)
}
}
buf = bytes.NewReader([]byte{0x00, 0x4d, 0x52, 0x4d, 0x00})
c, err = s.Identify("test.mrw", buf)
for i := range c {
if i.String() != expect {
t.Errorf("Third buffer: expecting %s, got %s", expect, i)
}
}
}
作者：gitter-badge
项目：botcommentato
func TestUnmarshal(t *testing.T) {
for i, tt := range unmarshalTests {
var scan Scanner
in := []byte(tt.in)
if err := checkValid(in, &scan); err != nil {
if !reflect.DeepEqual(err, tt.err) {
t.Errorf("#%d: checkValid: %#v", i, err)
continue
}
}
if tt.ptr == nil {
continue
}
// v = new(right-type)
v := reflect.New(reflect.TypeOf(tt.ptr).Elem())
dec := NewDecoder(bytes.NewReader(in))
if tt.useNumber {
dec.UseNumber()
}
if err := dec.Decode(v.Interface()); !reflect.DeepEqual(err, tt.err) {
t.Errorf("#%d: %v, want %v", i, err, tt.err)
continue
} else if err != nil {
continue
}
if !reflect.DeepEqual(v.Elem().Interface(), tt.out) {
t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), tt.out)
data, _ := Marshal(v.Elem().Interface())
println(string(data))
data, _ = Marshal(tt.out)
println(string(data))
continue
}
// Check round trip.
if tt.err == nil {
enc, err := Marshal(v.Interface())
if err != nil {
t.Errorf("#%d: error re-marshaling: %v", i, err)
continue
}
vv := reflect.New(reflect.TypeOf(tt.ptr).Elem())
dec = NewDecoder(bytes.NewReader(enc))
if tt.useNumber {
dec.UseNumber()
}
if err := dec.Decode(vv.Interface()); err != nil {
t.Errorf("#%d: error re-unmarshaling %#q: %v", i, enc, err)
continue
}
if !reflect.DeepEqual(v.Elem().Interface(), vv.Elem().Interface()) {
t.Errorf("#%d: mismatch\nhave: %#+v\nwant: %#+v", i, v.Elem().Interface(), vv.Elem().Interface())
t.Errorf(" In: %q", strings.Map(noSpace, string(in)))
t.Errorf("Marshal: %q", strings.Map(noSpace, string(enc)))
continue
}
}
}
}
作者：Gaboos
项目：go-pubsu
func (b *Broadcast) broadcaster(in <-chan msgInfo) {
mx := mux.StandardMux()
for {
mi, ok := <-in
if !ok {
return
}
buf := bytes.Buffer{}
mx.Encoder(&buf).Encode(mi.msg)
bts := buf.Bytes()
b.neighbsmu.RLock()
for conn, _ := range b.neighbsPri {
if mi.sender != conn {
go io.Copy(conn, bytes.NewReader(bts))
}
}
for conn, _ := range b.neighbsSec {
if mi.sender != conn {
go io.Copy(conn, bytes.NewReader(bts))
}
}
b.neighbsmu.RUnlock()
}
}
作者：mm
项目：Si
// TestStorageProof builds a storage proof and checks that it verifies
// correctly.
func TestStorageProof(t *testing.T) {
// generate proof data
numSegments := uint64(7)
data := make([]byte, numSegments*SegmentSize)
rand.Read(data)
rootHash, err := ReaderMerkleRoot(bytes.NewReader(data))
if err != nil {
t.Fatal(err)
}
// create and verify proofs for all indices
for i := uint64(0); i < numSegments; i++ {
baseSegment, hashSet, err := BuildReaderProof(bytes.NewReader(data), i)
if err != nil {
t.Error(err)
continue
}
if !VerifySegment(baseSegment, hashSet, numSegments, i, rootHash) {
t.Error("Proof", i, "did not pass verification")
}
}
// Try an incorrect proof.
baseSegment, hashSet, err := BuildReaderProof(bytes.NewReader(data), 3)
if err != nil {
t.Fatal(err)
}
if VerifySegment(baseSegment, hashSet, numSegments, 4, rootHash) {
t.Error("Verified a bad proof")
}
}
作者：carriercom
项目：interplanetar
func TestSizeSplitterIsDeterministic(t *testing.T) {
if testing.Short() {
t.SkipNow()
}
test := func() {
bufR := randBuf(t, 10000000) // crank this up to satisfy yourself.
bufA := copyBuf(bufR)
bufB := copyBuf(bufR)
chunksA := DefaultSplitter.Split(bytes.NewReader(bufA))
chunksB := DefaultSplitter.Split(bytes.NewReader(bufB))
for n := 0; ; n++ {
a, moreA := <-chunksA
b, moreB := <-chunksB
if !moreA {
if moreB {
t.Fatal("A ended, B didnt.")
}
return
}
if !bytes.Equal(a, b) {
t.Fatalf("chunk %d not equal", n)
}
}
}
for run := 0; run < 1; run++ { // crank this up to satisfy yourself.
test()
}
}
作者：se77e
项目：lilraf
func (log *Log) appendEntries(s *Server, prevIndex int64, logEntries []*LogEntry) {
log.Lock()
defer log.Unlock()
if len(log.entries) == 0 {
log.entries = logEntries
return
}
log.entries = log.entries[:prevIndex-log.startIndex()+1]
// log.entries = append(log.entries[:(index-log.startIndex())+1], logEntries...)
for _, entry := range logEntries {
if entry.GetCommandName() == cOldNewStr {
nodes := []Node{}
if err := gob.NewDecoder(bytes.NewReader(entry.GetCommand())).Decode(&nodes); err != nil {
logger.Println("decode Cold,new config err: ", err.Error())
}
s.config.setState(cOldNew)
s.config.cNewNode = make(nodeMap)
for _, node := range nodes {
s.config.cNewNode[node.id()] = node
}
} else if entry.GetCommandName() == cNewStr {
nodes := []Node{}
if err := gob.NewDecoder(bytes.NewReader(entry.GetCommand())).Decode(&nodes); err != nil {
logger.Println("decode Cnew config err: ", err.Error())
}
s.config.setState(cOld)
s.config.cOldNode = makeNodeMap(nodes...)
s.config.cNewNode = nil
}
log.entries = append(log.entries, entry)
}
}
作者：jaekwo
项目：go-websocke
// NextReader returns the next message received from the peer. The returned
// messageType is one of TextMessage, BinaryMessage or PongMessage. The
// connection automatically handles ping messages received from the peer.
// NextReader returns an error upon receiving a close message from the peer.
//
// There can be at most one open reader on a connection. NextReader discards
// the previous message if the application has not already consumed it.
//
// The NextReader method and the readers returned from the method cannot be
// accessed by more than one goroutine at a time.
func (c *Conn) NextReader() (messageType int, r io.Reader, err error) {
c.readSeq += 1
c.readLength = 0
if c.savedPong != nil {
r := bytes.NewReader(c.savedPong)
c.savedPong = nil
return PongMessage, r, nil
}
for c.readErr == nil {
var opCode int
opCode, c.readErr = c.advanceFrame()
switch opCode {
case TextMessage, BinaryMessage:
return opCode, messageReader{c, c.readSeq}, nil
case PongMessage:
r := bytes.NewReader(c.savedPong)
c.savedPong = nil
return PongMessage, r, nil
case continuationFrame:
// do nothing
}
}
return -1, nil, c.readErr
}
作者：jtbli
项目：deployment-manage
func TestNewTemplateFromArchive(t *testing.T) {
r := bytes.NewReader([]byte{})
if _, err := NewTemplateFromArchive("", r, nil); err == nil {
t.Fatalf("expected error did not occur for empty input: %s", err)
}
r = bytes.NewReader([]byte("test"))
if _, err := NewTemplateFromArchive("", r, nil); err == nil {
t.Fatalf("expected error did not occur for non archive file:%s", err)
}
r = generateArchive(t, invalidFiles)
if _, err := NewTemplateFromArchive(invalidFiles[0].Name, r, nil); err == nil {
t.Fatalf("expected error did not occur for empty file in archive")
}
r = generateArchive(t, validFiles)
if _, err := NewTemplateFromArchive("", r, nil); err == nil {
t.Fatalf("expected error did not occur for missing file in archive")
}
r = generateArchive(t, validFiles)
if _, err := NewTemplateFromArchive(validFiles[1].Name, r, nil); err != nil {
t.Fatalf("cannnot create template from valid archive")
}
}
作者：rlmcpherso
项目：go-fuz
func FuzzAll(data []byte) int {
cfg, err := gif.DecodeConfig(bytes.NewReader(data))
if err != nil {
return 0
}
if cfg.Width*cfg.Height > 1e6 {
return 0
}
img, err := gif.DecodeAll(bytes.NewReader(data))
if err != nil {
return 0
}
w := new(bytes.Buffer)
err = gif.EncodeAll(w, img)
if err != nil {
panic(err)
}
img1, err := gif.DecodeAll(w)
if err != nil {
panic(err)
}
if img.LoopCount == 0 && img1.LoopCount == -1 {
// https://github.com/golang/go/issues/11287
img1.LoopCount = 0
}
// https://github.com/golang/go/issues/11288
img1.Disposal = img.Disposal
if !fuzz.DeepEqual(img, img1) {
fmt.Printf("gif0: %#v\n", img)
fmt.Printf("gif1: %#v\n", img1)
panic("gif changed")
}
return 1
}
作者：ba
项目：juj
func (s *signedSuite) SetUpSuite(c *gc.C) {
var imageData = map[string]string{
"/unsigned/streams/v1/index.json": unsignedIndex,
"/unsigned/streams/v1/image_metadata.json": unsignedProduct,
}
// Set up some signed data from the unsigned data.
// Overwrite the product path to use the sjson suffix.
rawUnsignedIndex := strings.Replace(
unsignedIndex, "streams/v1/image_metadata.json", "streams/v1/image_metadata.sjson", -1)
r := bytes.NewReader([]byte(rawUnsignedIndex))
signedData, err := simplestreams.Encode(
r, sstesting.SignedMetadataPrivateKey, sstesting.PrivateKeyPassphrase)
c.Assert(err, jc.ErrorIsNil)
imageData["/signed/streams/v1/index.sjson"] = string(signedData)
// Replace the image id in the unsigned data with a different one so we can test that the right
// image id is used.
rawUnsignedProduct := strings.Replace(
unsignedProduct, "ami-26745463", "ami-123456", -1)
r = bytes.NewReader([]byte(rawUnsignedProduct))
signedData, err = simplestreams.Encode(
r, sstesting.SignedMetadataPrivateKey, sstesting.PrivateKeyPassphrase)
c.Assert(err, jc.ErrorIsNil)
imageData["/signed/streams/v1/image_metadata.sjson"] = string(signedData)
sstesting.SetRoundTripperFiles(imageData, map[string]int{"test://unauth": http.StatusUnauthorized})
s.origKey = imagemetadata.SetSigningPublicKey(sstesting.SignedMetadataPublicKey)
}
作者：codykriege
项目：jeeve
func (ctx *requestContext) process() {
body, err := ioutil.ReadAll(ctx.req.Body)
if err != nil {
ctx.err(400, err)
return
}
ctx.reqBody = &body
ctx.req.Body = ioutil.NopCloser(bytes.NewReader(*ctx.reqBody))
req, err := ask.NewRequestFromJSON(bytes.NewReader(*ctx.reqBody))
if err != nil {
ctx.err(400, err)
return
}
if !ctx.validateRequestSignature(req) ||
!ctx.validateTimestamp(req) ||
!ctx.validateApplicationID(req) ||
!ctx.validateRequestType(req) {
return
}
ctx.skill.internalHandler(ctx, req)
}
作者：shizh
项目：lanter
func TestVerifyChecksumPatchNegative(t *testing.T) {
t.Parallel()
fName := "TestVerifyChecksumPatchNegative"
defer cleanup(fName)
writeOldFile(fName, t)
checksum, err := ChecksumForBytes(newFile)
if err != nil {
t.Fatalf("Failed to compute checksum: %v", err)
}
patch := new(bytes.Buffer)
anotherFile := []byte{0x77, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66}
err = binarydist.Diff(bytes.NewReader(oldFile), bytes.NewReader(anotherFile), patch)
if err != nil {
t.Fatalf("Failed to create patch: %v", err)
}
up := New().Target(fName).ApplyPatch(PATCHTYPE_BSDIFF).VerifyChecksum(checksum)
err, _ = up.FromStream(bytes.NewReader(patch.Bytes()))
if err == nil {
t.Fatalf("Failed to detect patch to wrong file!")
}
}
作者：calebTomlinso
项目：riak-meso
func decompress() {
log.Info("Decompressing Riak Explorer")
var err error
if err := os.Mkdir("riak_explorer", 0777); err != nil {
log.Fatal("Unable to make rex directory: ", err)
}
asset, err := artifacts.Asset("trusty.tar.gz")
if err != nil {
log.Fatal(err)
}
if err = common.ExtractGZ("riak_explorer", bytes.NewReader(asset)); err != nil {
log.Fatal("Unable to extract trusty root: ", err)
}
asset, err = artifacts.Asset("riak_explorer-bin.tar.gz")
if err != nil {
log.Fatal(err)
}
if err = common.ExtractGZ("riak_explorer", bytes.NewReader(asset)); err != nil {
log.Fatal("Unable to extract rex: ", err)
}
}
作者：AlexisBruemme
项目：juj
func (s *signedSuite) SetUpSuite(c *gc.C) {
s.BaseSuite.SetUpSuite(c)
var imageData = map[string]string{
"/unsigned/streams/v1/index.json": unsignedIndex,
"/unsigned/streams/v1/tools_metadata.json": unsignedProduct,
}
// Set up some signed data from the unsigned data.
// Overwrite the product path to use the sjson suffix.
rawUnsignedIndex := strings.Replace(
unsignedIndex, "streams/v1/tools_metadata.json", "streams/v1/tools_metadata.sjson", -1)
r := bytes.NewReader([]byte(rawUnsignedIndex))
signedData, err := simplestreams.Encode(
r, sstesting.SignedMetadataPrivateKey, sstesting.PrivateKeyPassphrase)
c.Assert(err, jc.ErrorIsNil)
imageData["/signed/streams/v1/index.sjson"] = string(signedData)
// Replace the tools path in the unsigned data with a different one so we can test that the right
// tools path is used.
rawUnsignedProduct := strings.Replace(
unsignedProduct, "juju-1.13.0", "juju-1.13.1", -1)
r = bytes.NewReader([]byte(rawUnsignedProduct))
signedData, err = simplestreams.Encode(
r, sstesting.SignedMetadataPrivateKey, sstesting.PrivateKeyPassphrase)
c.Assert(err, jc.ErrorIsNil)
imageData["/signed/streams/v1/tools_metadata.sjson"] = string(signedData)
sstesting.SetRoundTripperFiles(imageData, map[string]int{"signedtest://unauth": http.StatusUnauthorized})
s.PatchValue(&juju.JujuPublicKey, sstesting.SignedMetadataPublicKey)
}
作者：josharia
项目：go.ss
func TestParsePAXHeader(t *testing.T) {
paxTests := [][3]string{
{"a", "a=name", "10 a=name\n"}, // Test case involving multiple acceptable lengths
{"a", "a=name", "9 a=name\n"}, // Test case involving multiple acceptable length
{"mtime", "mtime=1350244992.023960108", "30 mtime=1350244992.023960108\n"}}
for _, test := range paxTests {
key, expected, raw := test[0], test[1], test[2]
reader := bytes.NewReader([]byte(raw))
headers, err := parsePAX(reader)
if err != nil {
t.Errorf("Couldn't parse correctly formatted headers: %v", err)
continue
}
if strings.EqualFold(headers[key], expected) {
t.Errorf("mtime header incorrectly parsed: got %s, wanted %s", headers[key], expected)
continue
}
trailer := make([]byte, 100)
n, err := reader.Read(trailer)
if err != io.EOF || n != 0 {
t.Error("Buffer wasn't consumed")
}
}
badHeader := bytes.NewReader([]byte("3 somelongkey="))
if _, err := parsePAX(badHeader); err != ErrHeader {
t.Fatal("Unexpected success when parsing bad header")
}
}
