//水印 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() }
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, }) }
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) } } }
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) }
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 }
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) }
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) } }
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) }
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()) } }
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()) } }
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) } }
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) } }
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) }) }
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") }
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]) }
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 }
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) } }) }
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()) } }
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) } }
func newStdBuffers() *stdBuffers { return &stdBuffers{ Stdin: bytes.NewBuffer(nil), Stdout: bytes.NewBuffer(nil), Stderr: bytes.NewBuffer(nil), } }
func TestEncryptData(t *testing.T) { for _, test := range []struct { in []byte expected []byte }{ {[]byte{}, file0}, {[]byte{1}, file1}, {[]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, file16}, } { c, err := newCipher(NameEncryptionStandard, "", "") assert.NoError(t, err) c.cryptoRand = newRandomSource(1E8) // nodge the crypto rand generator // Check encode works buf := bytes.NewBuffer(test.in) encrypted, err := c.EncryptData(buf) assert.NoError(t, err) out, err := ioutil.ReadAll(encrypted) assert.NoError(t, err) assert.Equal(t, test.expected, out) // Check we can decode the data properly too... buf = bytes.NewBuffer(out) decrypted, err := c.DecryptData(ioutil.NopCloser(buf)) assert.NoError(t, err) out, err = ioutil.ReadAll(decrypted) assert.NoError(t, err) assert.Equal(t, test.in, out) } }
func Test030LexingPauseAndResume(t *testing.T) { cv.Convey(`to enable the repl to properly detect the end of a multiline expression (or an expression containing quoted parentheses), the lexer should be able to pause and resume when more input is available.`, t, func() { str := `(defn hello [] "greetings!(((")` str1 := `(defn hel` str2 := `lo [] "greetings!(((")` env := NewGlisp() defer env.parser.Stop() stream := bytes.NewBuffer([]byte(str1)) env.parser.ResetAddNewInput(stream) ex, err := env.parser.ParseTokens() P("\n In lexer_test, after parsing with incomplete input, we should get 0 expressions back.\n") cv.So(len(ex), cv.ShouldEqual, 0) P("\n In lexer_test, after ParseTokens on incomplete fragment, expressions = '%v' and err = '%v'\n", (&SexpArray{Val: ex, Env: env}).SexpString(nil), err) P("\n In lexer_test: calling parser.NewInput() to provide str2='%s'\n", str2) env.parser.NewInput(bytes.NewBuffer([]byte(str2))) P("\n In lexer_test: done with parser.NewInput(), now calling parser.ParseTokens()\n") ex, err = env.parser.ParseTokens() P(` in lexer test: After providing the 2nd half of the input, we returned from env.parser.ParseTokens() with expressions = %v with err = %v `, (&SexpArray{Val: ex, Env: env}).SexpString(nil), err) cv.So(len(ex), cv.ShouldEqual, 1) panicOn(err) P("str=%s\n", str) }) }
func TestDeleteNoObjects(t *testing.T) { f, tf, codec := NewAPIFactory() tf.Printer = &testPrinter{} tf.Client = &client.FakeRESTClient{ Codec: codec, Client: client.HTTPClientFunc(func(req *http.Request) (*http.Response, error) { switch p, m := req.URL.Path, req.Method; { case p == "/ns/test/pods" && m == "GET": return &http.Response{StatusCode: 200, Body: objBody(codec, &api.PodList{})}, nil default: t.Fatalf("unexpected request: %#v\n%#v", req.URL, req) return nil, nil } }), } buf := bytes.NewBuffer([]byte{}) stderr := bytes.NewBuffer([]byte{}) cmd := f.NewCmdDelete(buf) cmd.SetOutput(stderr) cmd.Flags().String("namespace", "test", "") cmd.Run(cmd, []string{"pods"}) if buf.String() != "" { t.Errorf("unexpected output: %s", buf.String()) } if stderr.String() != "No resources found\n" { t.Errorf("unexpected output: %s", stderr.String()) } }
func testRun(t *testing.T, imageName string, commands []string, expectedStdout string, expectedStderr string) { client, err := newTestDockerClient() require.NoError(t, err) err = client.Pull(imageName, PullOptions{}) require.NoError(t, err) containers, err := client.Create( imageName, CreateOptions{ HasCommand: commands != nil, }, ) require.NoError(t, err) require.Equal(t, 1, len(containers)) container := containers[0] err = client.Start( container, StartOptions{ Commands: commands, }, ) require.NoError(t, err) err = client.Wait(container, WaitOptions{}) require.NoError(t, err) stdout := bytes.NewBuffer(nil) stderr := bytes.NewBuffer(nil) err = client.Logs(container, LogsOptions{Stdout: stdout, Stderr: stderr}) require.NoError(t, err) require.Equal(t, expectedStdout, stdout.String()) require.Equal(t, expectedStderr, stderr.String()) err = client.Remove(container, RemoveOptions{}) require.NoError(t, err) }
func TestString(t *testing.T) { s := MakeString([]byte(HARDSQL)) b := bytes.NewBuffer(nil) s.EncodeSql(b) if b.String() != HARDESCAPED { t.Errorf("Expecting %s, received %s", HARDESCAPED, b.String()) } b = bytes.NewBuffer(nil) s.EncodeAscii(b) if b.String() != HARDASCII { t.Errorf("Expecting %s, received %#v", HARDASCII, b.String()) } s = MakeString([]byte("abcd")) // Now, just printable strings. s, err := BuildValue(PRINTABLE) if err != nil { t.Errorf("BuildValue failed on printable: %s", PRINTABLE) } b = bytes.NewBuffer(nil) s.EncodeSql(b) if b.String() != PRINTABLE_ESCAPED { t.Errorf("Expecting %s, received %s", PRINTABLE_ESCAPED, b.String()) } b = bytes.NewBuffer(nil) s.EncodeAscii(b) if b.String() != PRINTABLE_ASCII { t.Errorf("Expecting %s, received %#v", PRINTABLE_ASCII, b.String()) } }
func TestBulkSetAckRead(t *testing.T) { vs := New(&Config{MsgRing: &msgRingPlaceholder{}}) for i := 0; i < len(vs.bulkSetAckState.inBulkSetAckDoneChans); i++ { vs.bulkSetAckState.inMsgChan <- nil } for _, doneChan := range vs.bulkSetAckState.inBulkSetAckDoneChans { <-doneChan } n, err := vs.newInBulkSetAckMsg(bytes.NewBuffer(make([]byte, 100)), 100) if err != nil { t.Fatal(err) } if n != 100 { t.Fatal(n) } <-vs.bulkSetAckState.inMsgChan // Once again, but with an error in the body. n, err = vs.newInBulkSetAckMsg(bytes.NewBuffer(make([]byte, 10)), 100) if err != io.EOF { t.Fatal(err) } if n != 10 { t.Fatal(n) } select { case bsam := <-vs.bulkSetAckState.inMsgChan: t.Fatal(bsam) default: } }
// Body makes the request use obj as the body. Optional. // If obj is a string, try to read a file of that name. // If obj is a []byte, send it directly. // If obj is an io.Reader, use it directly. // If obj is a runtime.Object, marshal it correctly. // Otherwise, set an error. func (r *Request) Body(obj interface{}) *Request { if r.err != nil { return r } switch t := obj.(type) { case string: data, err := ioutil.ReadFile(t) if err != nil { r.err = err return r } r.body = bytes.NewBuffer(data) case []byte: r.body = bytes.NewBuffer(t) case io.Reader: r.body = t case runtime.Object: data, err := r.codec.Encode(t) if err != nil { r.err = err return r } r.body = bytes.NewBuffer(data) default: r.err = fmt.Errorf("unknown type used for body: %+v", obj) } return r }
func (s *ConfigSuite) TestDefaultType(c *gc.C) { assertDefault := func(type_ string, value string, expected interface{}) { config := fmt.Sprintf(`options: {t: {type: %s, default: %s}}`, type_, value) result, err := charm.ReadConfig(bytes.NewBuffer([]byte(config))) c.Assert(err, gc.IsNil) c.Assert(result.Options["t"].Default, gc.Equals, expected) } assertDefault("boolean", "true", true) assertDefault("string", "golden grahams", "golden grahams") assertDefault("string", `""`, "") assertDefault("float", "2.2e11", 2.2e11) assertDefault("int", "99", int64(99)) assertTypeError := func(type_, str, value string) { config := fmt.Sprintf(`options: {t: {type: %s, default: %s}}`, type_, str) _, err := charm.ReadConfig(bytes.NewBuffer([]byte(config))) expected := fmt.Sprintf(`invalid config default: option "t" expected %s, got %s`, type_, value) c.Assert(err, gc.ErrorMatches, expected) } assertTypeError("boolean", "henry", `"henry"`) assertTypeError("string", "2.5", "2.5") assertTypeError("float", "123", "123") assertTypeError("int", "true", "true") }
func saveServices(passwd string, services *Services) { sort.Sort(services) decryptedBuffer := bytes.NewBuffer(nil) err := json.NewEncoder(decryptedBuffer).Encode(services) gobro.CheckErr(err) blockCipher, err := blowfish.NewCipher([]byte(passwd)) gobro.CheckErr(err) iv := make([]byte, 8) _, err = rand.Read(iv) gobro.CheckErr(err) enc := decryptedBuffer.Bytes() cipher.NewCFBEncrypter(blockCipher, iv).XORKeyStream(enc, enc) buff := bytes.NewBuffer(iv) _, err = buff.Write(enc) gobro.CheckErr(err) enc = append(iv, enc...) base64EncodedLen := base64.StdEncoding.EncodedLen(len(enc)) base64Enc := make([]byte, base64EncodedLen) base64.StdEncoding.Encode(base64Enc, enc) err = ioutil.WriteFile(passwdFileName(), base64Enc, os.ModePerm) gobro.CheckErr(err) }
func TestLogTapper(t *testing.T) { c := newBufferLogger() tapped := newLogTapper(c) assertWrite(t, tapped.Stdout(), "First line") r1 := tapped.TapStdout() b1 := bytes.NewBuffer(nil) done1 := make(chan error) go func() { defer close(done1) _, err := io.Copy(b1, r1) if err != nil { done1 <- err } }() assertWrite(t, tapped.Stdout(), "Second line") r2 := tapped.TapStdout() b2 := bytes.NewBuffer(nil) done2 := make(chan error) go func() { defer close(done2) _, err := io.Copy(b2, r2) if err != nil { done2 <- err } }() assertWrite(t, tapped.Stdout(), "Third line") if err := r2.Close(); err != nil { t.Fatal(err) } <-done2 assertWrite(t, tapped.Stdout(), "Fourth line") if err := tapped.Close(); err != nil { t.Fatal(err) } <-done1 expectedAll := []byte(`First line Second line Third line Fourth line `) expected1 := []byte("Second line\nThird line\nFourth line\n") expected2 := []byte("Third line\n") checkBuffer(t, c.stdout, expectedAll) checkBuffer(t, b1, expected1) checkBuffer(t, b2, expected2) }