作者：jaegerpicke
项目：docke
func postContainerExecCreate(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if err := parseForm(r); err != nil {
return nil
}
var (
name = vars["name"]
job = eng.Job("execCreate", name)
stdoutBuffer = bytes.NewBuffer(nil)
outWarnings []string
warnings = bytes.NewBuffer(nil)
)
if err := job.DecodeEnv(r.Body); err != nil {
return err
}
job.Stdout.Add(stdoutBuffer)
// Read warnings from stderr
job.Stderr.Add(warnings)
// Register an instance of Exec in container.
if err := job.Run(); err != nil {
fmt.Fprintf(os.Stderr, "Error setting up exec command in container %s: %s\n", name, err)
return err
}
// Parse warnings from stderr
scanner := bufio.NewScanner(warnings)
for scanner.Scan() {
outWarnings = append(outWarnings, scanner.Text())
}
return writeJSON(w, http.StatusCreated, &types.ContainerExecCreateResponse{
ID: engine.Tail(stdoutBuffer, 1),
Warnings: outWarnings,
})
}
作者：elvizla
项目：MGBlo
//水印
func waterMark(picBytes []byte) []byte {
// 打开水印图并解码
img, fileType, _ := image.Decode(bytes.NewBuffer(picBytes))
//读取水印图片
watermark, _ := png.Decode(bytes.NewBuffer(wm))
//原始图界限
origin_size := img.Bounds()
//创建新图层
canvas := image.NewNRGBA(origin_size)
//贴原始图
draw.Draw(canvas, origin_size, img, image.ZP, draw.Src)
//贴水印图
draw.Draw(canvas, watermark.Bounds().Add(image.Pt(origin_size.Dx()-watermark.Bounds().Dx(), origin_size.Dy()-watermark.Bounds().Dy()-4)), watermark, image.ZP, draw.Over)
//生成新图片
buff := bytes.NewBuffer([]byte{})
switch fileType {
case "jpeg":
jpeg.Encode(buff, canvas, &jpeg.Options{95})
default:
png.Encode(buff, canvas)
}
return buff.Bytes()
}
作者：pse
项目：ato
func (self *Task) Render() {
for _, config := range self.Config.Templates {
log.Printf("Render: %s", config.Dst)
f, err := ioutil.ReadFile(self.Controller.Atom.Config.TmplDir + "/" + config.Src)
if err != nil {
log.Printf("Error:: Read - %s", err)
continue
}
var output *bytes.Buffer
if self.Controller.Atom.Config.Verbose {
output = bytes.NewBuffer(nil)
}
src := bytes.NewBuffer(f)
tmpl, err := template.New("").Funcs(self.Config.Store.FuncMap).Parse(src.String())
if err != nil {
log.Printf("Error:: Render - %s", err)
continue
}
vars := map[string]interface{}{"cli": self.Controller.Atom.CLI}
if self.Controller.Atom.Config.Verbose {
if err := tmpl.Execute(output, vars); err != nil {
log.Printf("Error:: Write - %s", err)
}
fmt.Print(output.String())
}
dst, err := os.Create(config.Dst)
if err != nil {
log.Printf("Error:: Open - %s", err)
continue
}
if err := tmpl.Execute(dst, vars); err != nil {
log.Printf("Error:: Write - %s", err)
}
}
}
作者：nc
项目：rclon
func TestDecrypterClose(t *testing.T) {
c, err := newCipher(NameEncryptionStandard, "", "")
assert.NoError(t, err)
cd := newCloseDetector(bytes.NewBuffer(file16))
fh, err := c.newDecrypter(cd)
assert.NoError(t, err)
assert.Equal(t, 0, cd.closed)
// close before reading
assert.Equal(t, nil, fh.err)
err = fh.Close()
assert.Equal(t, ErrorFileClosed, fh.err)
assert.Equal(t, 1, cd.closed)
// double close
err = fh.Close()
assert.Error(t, err, ErrorFileClosed.Error())
assert.Equal(t, 1, cd.closed)
// try again reading the file this time
cd = newCloseDetector(bytes.NewBuffer(file1))
fh, err = c.newDecrypter(cd)
assert.NoError(t, err)
assert.Equal(t, 0, cd.closed)
// close after reading
out, err := ioutil.ReadAll(fh)
assert.NoError(t, err)
assert.Equal(t, []byte{1}, out)
assert.Equal(t, io.EOF, fh.err)
err = fh.Close()
assert.Equal(t, ErrorFileClosed, fh.err)
assert.Equal(t, 1, cd.closed)
}
作者：howbazaa
项目：juj
func (s *archiveDataSuite) SetUpTest(c *gc.C) {
s.IsolationSuite.SetUpTest(c)
meta, err := backups.NewMetadataJSONReader(bytes.NewBufferString(`{` +
`"ID":"20140909-115934.asdf-zxcv-qwe",` +
`"Checksum":"123af2cef",` +
`"ChecksumFormat":"SHA-1, base64 encoded",` +
`"Size":10,` +
`"Stored":"0001-01-01T00:00:00Z",` +
`"Started":"2014-09-09T11:59:34Z",` +
`"Finished":"2014-09-09T12:00:34Z",` +
`"Notes":"",` +
`"Environment":"asdf-zxcv-qwe",` +
`"Machine":"0",` +
`"Hostname":"myhost",` +
`"Version":"1.21-alpha3"` +
`}` + "\n"))
c.Assert(err, jc.ErrorIsNil)
archiveFile := s.newArchiveFile(c, meta)
compressed, err := ioutil.ReadAll(archiveFile)
c.Assert(err, jc.ErrorIsNil)
gzr, err := gzip.NewReader(bytes.NewBuffer(compressed))
c.Assert(err, jc.ErrorIsNil)
data, err := ioutil.ReadAll(gzr)
c.Assert(err, jc.ErrorIsNil)
s.archiveFile = bytes.NewBuffer(compressed)
s.data = data
s.meta = meta
}
作者：houb
项目：docke
func postContainersCreate(eng *engine.Engine, version version.Version, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
if err := parseForm(r); err != nil {
return nil
}
var (
out engine.Env
job = eng.Job("create", r.Form.Get("name"))
outWarnings []string
stdoutBuffer = bytes.NewBuffer(nil)
warnings = bytes.NewBuffer(nil)
)
if err := job.DecodeEnv(r.Body); err != nil {
return err
}
// Read container ID from the first line of stdout
job.Stdout.Add(stdoutBuffer)
// Read warnings from stderr
job.Stderr.Add(warnings)
if err := job.Run(); err != nil {
return err
}
// Parse warnings from stderr
scanner := bufio.NewScanner(warnings)
for scanner.Scan() {
outWarnings = append(outWarnings, scanner.Text())
}
out.Set("Id", engine.Tail(stdoutBuffer, 1))
out.SetList("Warnings", outWarnings)
return writeJSON(w, http.StatusCreated, out)
}
作者：ds2de
项目：gc
func TestTeeReader(t *testing.T) {
src := []byte("hello, world")
dst := make([]byte, len(src))
rb := bytes.NewBuffer(src)
wb := new(bytes.Buffer)
r := TeeReader(rb, wb)
if n, err := ReadFull(r, dst); err != nil || n != len(src) {
t.Fatalf("ReadFull(r, dst) = %d, %v; want %d, nil", n, err, len(src))
}
if !bytes.Equal(dst, src) {
t.Errorf("bytes read = %q want %q", dst, src)
}
if !bytes.Equal(wb.Bytes(), src) {
t.Errorf("bytes written = %q want %q", wb.Bytes(), src)
}
if n, err := r.Read(dst); n != 0 || err != EOF {
t.Errorf("r.Read at EOF = %d, %v want 0, EOF", n, err)
}
rb = bytes.NewBuffer(src)
pr, pw := Pipe()
pr.Close()
r = TeeReader(rb, pw)
if n, err := ReadFull(r, dst); n != 0 || err != ErrClosedPipe {
t.Errorf("closed tee: ReadFull(r, dst) = %d, %v; want 0, EPIPE", n, err)
}
}
作者：andrewmlev
项目：agent_crittercis
func (c *CrittercismAPIClient) RawRequest(method, path string, params *CrittercismAPIParams, handler CrittercismAPIClientResponseHandler) {
// Construct REST Request
url := fmt.Sprintf("%s/%s", crittercismAPIURL, path)
var buffer *bytes.Buffer
if params != nil {
p, err := json.Marshal(map[string]interface{}{"params": params})
if err != nil {
handler(nil, err)
return
}
buffer = bytes.NewBuffer(p)
} else {
buffer = bytes.NewBuffer([]byte{})
}
client := &http.Client{}
req, _ := http.NewRequest(method, url, buffer)
req.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.accessToken))
req.Header.Set("Content-Type", "application/json")
// Make Request
resp, err := client.Do(req)
handler(resp, err)
}
作者：fejt
项目：kubernete
func TestDeleteDirectory(t *testing.T) {
_, _, rc := testData()
f, tf, codec, _ := cmdtesting.NewAPIFactory()
tf.Printer = &testPrinter{}
tf.Client = &fake.RESTClient{
NegotiatedSerializer: unstructuredSerializer,
Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
switch p, m := req.URL.Path, req.Method; {
case strings.HasPrefix(p, "/namespaces/test/replicationcontrollers/") && m == "DELETE":
return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
default:
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
return nil, nil
}
}),
}
tf.Namespace = "test"
buf, errBuf := bytes.NewBuffer([]byte{}), bytes.NewBuffer([]byte{})
cmd := NewCmdDelete(f, buf, errBuf)
cmd.Flags().Set("filename", "../../../examples/guestbook/legacy")
cmd.Flags().Set("cascade", "false")
cmd.Flags().Set("output", "name")
cmd.Run(cmd, []string{})
if buf.String() != "replicationcontroller/frontend\nreplicationcontroller/redis-master\nreplicationcontroller/redis-slave\n" {
t.Errorf("unexpected output: %s", buf.String())
}
}
作者：fejt
项目：kubernete
func TestDeleteObjectIgnoreNotFound(t *testing.T) {
f, tf, _, _ := cmdtesting.NewAPIFactory()
tf.Printer = &testPrinter{}
tf.Client = &fake.RESTClient{
NegotiatedSerializer: unstructuredSerializer,
Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
switch p, m := req.URL.Path, req.Method; {
case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "DELETE":
return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: stringBody("")}, nil
default:
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
return nil, nil
}
}),
}
tf.Namespace = "test"
buf, errBuf := bytes.NewBuffer([]byte{}), bytes.NewBuffer([]byte{})
cmd := NewCmdDelete(f, buf, errBuf)
cmd.Flags().Set("filename", "../../../examples/guestbook/legacy/redis-master-controller.yaml")
cmd.Flags().Set("cascade", "false")
cmd.Flags().Set("ignore-not-found", "true")
cmd.Flags().Set("output", "name")
cmd.Run(cmd, []string{})
if buf.String() != "" {
t.Errorf("unexpected output: %s", buf.String())
}
}
作者：fejt
项目：kubernete
func TestDeleteObjectNotFound(t *testing.T) {
f, tf, _, _ := cmdtesting.NewAPIFactory()
tf.Printer = &testPrinter{}
tf.Client = &fake.RESTClient{
NegotiatedSerializer: unstructuredSerializer,
Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
switch p, m := req.URL.Path, req.Method; {
case p == "/namespaces/test/replicationcontrollers/redis-master" && m == "DELETE":
return &http.Response{StatusCode: 404, Header: defaultHeader(), Body: stringBody("")}, nil
default:
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
return nil, nil
}
}),
}
tf.Namespace = "test"
buf, errBuf := bytes.NewBuffer([]byte{}), bytes.NewBuffer([]byte{})
cmd := NewCmdDelete(f, buf, errBuf)
options := &resource.FilenameOptions{}
options.Filenames = []string{"../../../examples/guestbook/legacy/redis-master-controller.yaml"}
cmd.Flags().Set("cascade", "false")
cmd.Flags().Set("output", "name")
err := RunDelete(f, buf, errBuf, cmd, []string{}, options)
if err == nil || !errors.IsNotFound(err) {
t.Errorf("unexpected error: expected NotFound, got %v", err)
}
}
作者：Sunmond
项目：gc
func TestBufAPI(t *testing.T) {
s := "0<a>1</a>2<b>3<a>4<a>5</a>6</b>7</a>8<a/>9"
z := NewTokenizer(bytes.NewBuffer([]byte(s)))
result := bytes.NewBuffer(nil)
depth := 0
loop:
for {
tt := z.Next()
switch tt {
case ErrorToken:
if z.Error() != os.EOF {
t.Error(z.Error())
}
break loop
case TextToken:
if depth > 0 {
result.Write(z.Text())
}
case StartTagToken, EndTagToken:
tn, _ := z.TagName()
if len(tn) == 1 && tn[0] == 'a' {
if tt == StartTagToken {
depth++
} else {
depth--
}
}
}
}
u := "14567"
v := string(result.Bytes())
if u != v {
t.Errorf("TestBufAPI: want %q got %q", u, v)
}
}
作者：escriban
项目：cli
func TestOutput(t *testing.T) {
Convey("Default output rendering", t, func() {
b := bytes.NewBuffer(nil)
o := NewMonochromeOutput(b)
o.Printf("With <headline>formatted<reset> input")
So(b.String(), ShouldEqual, "With formatted input")
})
Convey("Fancy output rendering", t, func() {
b := bytes.NewBuffer(nil)
o := NewColorOutput(b)
o.Printf("With <headline>formatted<reset> input")
So(b.String(), ShouldEqual, "With \033[4;1mformatted\033[0m input")
})
Convey("Custom output rendering", t, func() {
b := bytes.NewBuffer(nil)
o := NewOutput(b, &testCustomFormatter{})
o.Printf("With <headline>formatted<reset> input")
So(b.String(), ShouldEqual, "WITH <HEADLINE>FORMATTED<RESET> INPUT")
})
Convey("Switching formatter later on", t, func() {
b := bytes.NewBuffer(nil)
o := NewMonochromeOutput(b)
o.SetFormatter(&testCustomFormatter{})
o.Printf("With <headline>formatted<reset> input")
So(b.String(), ShouldEqual, "WITH <HEADLINE>FORMATTED<RESET> INPUT")
})
Convey("Multi-line rendering", t, func() {
b := bytes.NewBuffer(nil)
o := NewColorOutput(b)
o.Printf("With <headline>formatted\nfoo\nbar\nbaz<reset> input")
s := o.Sprintf("With <headline>formatted\nfoo\nbar\nbaz<reset> input")
So(b.String(), ShouldEqual, "With \033[4;1mformatted\nfoo\nbar\nbaz\033[0m input")
So(b.String(), ShouldEqual, s)
})
}
作者：piotrkowalczu
项目：sklo
func TestMultiLogger_Log(t *testing.T) {
b1 := bytes.NewBuffer(nil)
b2 := bytes.NewBuffer(nil)
l1 := log.NewJSONLogger(b1)
l2 := log.NewJSONLogger(b2)
l := sklog.NewMultiLogger(l1, l2)
sklog.Debug(l, "debug message")
sklog.Info(l, "info message")
sklog.Error(l, errors.New("sklog_test: example error message"))
assert.Equal(t, b1.String(), b2.String())
b1.Reset()
b2.Reset()
l1 = &faultyLogger{}
l2 = log.NewJSONLogger(b2)
l = sklog.NewMultiLogger(l1, l2)
sklog.Debug(l, "debug message")
sklog.Info(l, "info message")
sklog.Error(l, errors.New("sklog_test: example error message"))
assert.Contains(t, b2.String(), "debug message")
assert.Contains(t, b2.String(), "msg")
assert.Contains(t, b2.String(), "info message")
assert.Contains(t, b2.String(), "info")
assert.Contains(t, b2.String(), "debug")
assert.Contains(t, b2.String(), "sklog_test: example error message")
}
作者：harveymonste
项目：ogonor
func TestReadBytes(t *testing.T) {
var bs []byte
// data[0:4] gets interpreted as a big-endian int (=4) which specifies the number of bytes to be read
// bytes data are then data[1:5], since int32(data[0:4])==4)
data := []byte{0, 0, 0, 4, 1, 2, 3, 4}
rdr := bytes.NewBuffer(data)
bs, err = ReadBytes(rdr)
ok(t, err)
equals(t, 4, len(bs))
equals(t, byte(1), bs[0])
equals(t, byte(2), bs[1])
equals(t, byte(3), bs[2])
equals(t, byte(4), bs[3])
// ensure more than 4 entries are not read
data = []byte{0, 0, 0, 4, 1, 2, 3, 4, 5, 6}
rdr = bytes.NewBuffer(data)
bs, err = ReadBytes(rdr)
ok(t, err)
equals(t, 4, len(bs))
equals(t, byte(1), bs[0])
equals(t, byte(2), bs[1])
equals(t, byte(3), bs[2])
equals(t, byte(4), bs[3])
}
作者：hanshen
项目：influxd
func (self *Shard) deleteRangeOfSeriesCommon(database, series string, startTimeBytes, endTimeBytes []byte) error {
columns := self.getColumnNamesForSeries(database, series)
fields, err := self.getFieldsForSeries(database, series, columns)
if err != nil {
// because a db is distributed across the cluster, it's possible we don't have the series indexed here. ignore
switch err := err.(type) {
case FieldLookupError:
return nil
default:
return err
}
}
startKey := bytes.NewBuffer(nil)
endKey := bytes.NewBuffer(nil)
for _, field := range fields {
startKey.Reset()
startKey.Write(field.Id)
startKey.Write(startTimeBytes)
startKey.Write([]byte{0, 0, 0, 0, 0, 0, 0, 0})
endKey.Reset()
endKey.Write(field.Id)
endKey.Write(endTimeBytes)
endKey.Write([]byte{0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff})
err := self.db.Del(startKey.Bytes(), endKey.Bytes())
if err != nil {
return err
}
}
return nil
}
作者：pulc
项目：vault-monke
func TestSnapshot_BadMethods(t *testing.T) {
httpTest(t, func(srv *HTTPServer) {
body := bytes.NewBuffer(nil)
req, err := http.NewRequest("POST", "/v1/snapshot", body)
if err != nil {
t.Fatalf("err: %v", err)
}
resp := httptest.NewRecorder()
_, err = srv.Snapshot(resp, req)
if err != nil {
t.Fatalf("err: %v", err)
}
if resp.Code != 405 {
t.Fatalf("bad code: %d", resp.Code)
}
})
httpTest(t, func(srv *HTTPServer) {
body := bytes.NewBuffer(nil)
req, err := http.NewRequest("DELETE", "/v1/snapshot", body)
if err != nil {
t.Fatalf("err: %v", err)
}
resp := httptest.NewRecorder()
_, err = srv.Snapshot(resp, req)
if err != nil {
t.Fatalf("err: %v", err)
}
if resp.Code != 405 {
t.Fatalf("bad code: %d", resp.Code)
}
})
}
作者：fejt
项目：kubernete
func TestDeleteNamedObject(t *testing.T) {
_, _, rc := testData()
f, tf, codec, _ := cmdtesting.NewAPIFactory()
tf.Printer = &testPrinter{}
tf.Client = &fake.RESTClient{
NegotiatedSerializer: unstructuredSerializer,
Client: fake.CreateHTTPClient(func(req *http.Request) (*http.Response, error) {
switch p, m := req.URL.Path, req.Method; {
case p == "/namespaces/test/replicationcontrollers/redis-master-controller" && m == "DELETE":
return &http.Response{StatusCode: 200, Header: defaultHeader(), Body: objBody(codec, &rc.Items[0])}, nil
default:
// Ensures no GET is performed when deleting by name
t.Fatalf("unexpected request: %#v\n%#v", req.URL, req)
return nil, nil
}
}),
}
tf.Namespace = "test"
buf, errBuf := bytes.NewBuffer([]byte{}), bytes.NewBuffer([]byte{})
cmd := NewCmdDelete(f, buf, errBuf)
cmd.Flags().Set("namespace", "test")
cmd.Flags().Set("cascade", "false")
cmd.Flags().Set("output", "name")
cmd.Run(cmd, []string{"replicationcontrollers", "redis-master-controller"})
if buf.String() != "replicationcontroller/redis-master-controller\n" {
t.Errorf("unexpected output: %s", buf.String())
}
}
作者：ageli
项目：et
func BenchmarkDecodeStruct(b *testing.B) {
type s1 struct {
Atom types.Atom
priv0 int
Uint8 uint8
Uint16 uint16
Uint32 uint32
priv1 string
Byte byte
Int int
priv2 *s1
List []s1
Binary []byte
}
data := []byte{
131, 104, 8, 100, 0, 12, 116, 104, 105, 115, 32, 105, 115, 32, 97, 116, 111,
109, 97, 255, 98, 0, 0, 255, 255, 110, 4, 0, 255, 255, 255, 255, 97, 128, 98,
255, 255, 253, 102, 106, 107, 0, 5, 1, 2, 3, 4, 5,
}
in := bytes.NewBuffer(data)
var v s1
err := Decode(in, &v)
if err != nil {
b.Fatal(err)
} else if l := in.Len(); l != 0 {
b.Fatalf("buffer len %d", l)
}
for i := 0; i < b.N; i++ {
in = bytes.NewBuffer(data)
err = Decode(in, &v)
}
}
作者：rrat
项目：origi
func newStdBuffers() *stdBuffers {
return &stdBuffers{
Stdin: bytes.NewBuffer(nil),
Stdout: bytes.NewBuffer(nil),
Stderr: bytes.NewBuffer(nil),
}
}
