func xmlToSocketLogWriter(filename string, props []xmlProperty, enabled bool) (SocketLogWriter, bool) { endpoint := "" protocol := "udp" for _, prop := range props { switch prop.Name { case "endpoint": endpoint = strings.Trim(prop.Value, " \r\n") case "protocol": protocol = strings.Trim(prop.Value, " \r\n") default: fmt.Fprintf(os.Stderr, "LoadConfiguration: Warning: Unknown property \"%s\" for file filter in %s\n", prop.Name, filename) } } if len(endpoint) == 0 { fmt.Fprintf(os.Stderr, "LoadConfiguration: Error: Required property \"%s\" for file filter missing in %s\n", "endpoint", filename) return nil, false } if !enabled { return nil, true } return NewSocketLogWriter(protocol, endpoint), true }
// identityConfig initializes a new identity. func identityConfig(out io.Writer, nbits int) (Identity, error) { // TODO guard higher up ident := Identity{} if nbits < 1024 { return ident, errors.New("Bitsize less than 1024 is considered unsafe.") } fmt.Fprintf(out, "generating %v-bit RSA keypair...", nbits) sk, pk, err := ci.GenerateKeyPair(ci.RSA, nbits) if err != nil { return ident, err } fmt.Fprintf(out, "done\n") // currently storing key unencrypted. in the future we need to encrypt it. // TODO(security) skbytes, err := sk.Bytes() if err != nil { return ident, err } ident.PrivKey = base64.StdEncoding.EncodeToString(skbytes) id, err := peer.IDFromPublicKey(pk) if err != nil { return ident, err } ident.PeerID = id.Pretty() fmt.Fprintf(out, "peer identity: %s\n", ident.PeerID) return ident, nil }
func (p *Addr) printText(w io.Writer, codeblockEnd int) { switch p.Type { case None: case Reg, Xmm: name := p.Value.(Register).String() io.WriteString(w, name) case Ind: name := p.Value.(Register).String() if p.Disp != 0 { fmt.Fprintf(w, "%x+(%s)", p.Disp, name) } else { fmt.Fprintf(w, "(%s)", name) } case Rel8, Rel16, Rel32: if codeblockEnd != 0 { // We know where we are, print the absolute jump point. blk := int64(codeblockEnd) + p.valueInt64() fmt.Fprintf(w, "%s:(%06x)", p.Name, blk) } else { fmt.Fprintf(w, "%s:(%x)", p.Name, p.Value) } case Imm8, Imm16, Imm32, Imm64: fmt.Fprintf(w, "0x%x", p.Value) case Label: fmt.Fprint(w, p.Name) default: panic(fmt.Sprintf("unknown addr type: %v", p.Type)) } }
func check_fatal(err error) { if err != nil { fmt.Fprintf(os.Stderr, "**** KURWA!!! ****\n") fmt.Fprintf(os.Stderr, "Error encountered was of FATAL. Is of wrong. Gib correct config pl0x.\n") panic(err) } }
func postscript(out *bytes.Buffer, name string) { fmt.Fprintf(out, "__start_%s()\n", name) fmt.Fprintf(out, `{ local cur prev words cword split _init_completion -s || return local completions_func local c=0 local flags=() local two_word_flags=() local flags_with_completion=() local flags_completion=() local commands=("%s") local must_have_one_flag=() local must_have_one_noun=() local last_command local nouns=() __handle_word } `, name) fmt.Fprintf(out, "complete -F __start_%s %s\n", name, name) fmt.Fprintf(out, "# ex: ts=4 sw=4 et filetype=sh\n") }
func (f *FingerClient) Execute() error { f.finger.Start() defer f.finger.Stop() resp := new(Response) Logger.Debugf("Executing finger %s", f.Path) methodName := "Finger.Execute" if f.args.Flags.Help { methodName = "Finger.Help" } if err := f.finger.Call(methodName, f.args, &resp); err != nil { Logger.Debugf(resp.SprintLog()) return err } stdout := resp.SprintStdout() stderr := resp.SprintStderr() fingerLog := resp.SprintLog() if stdout != "" { fmt.Println(stdout) } if stderr != "" { fmt.Fprintf(os.Stderr, stderr+"\n") } if fingerLog != "" { fmt.Fprintf(os.Stderr, fingerLog+"\n") } return nil }
func urlShortenerMain(client *http.Client, argv []string) { if len(argv) != 1 { fmt.Fprintf(os.Stderr, "Usage: urlshortener http://goo.gl/xxxxx (to look up details)\n") fmt.Fprintf(os.Stderr, " urlshortener http://example.com/long (to shorten)\n") return } svc, _ := urlshortener.New(client) urlstr := argv[0] // short -> long if strings.HasPrefix(urlstr, "http://goo.gl/") || strings.HasPrefix(urlstr, "https://goo.gl/") { url, err := svc.Url.Get(urlstr).Do() if err != nil { log.Fatalf("URL Get: %v", err) } fmt.Printf("Lookup of %s: %s\n", urlstr, url.LongUrl) return } // long -> short url, err := svc.Url.Insert(&urlshortener.Url{ Kind: "urlshortener#url", // Not really needed LongUrl: urlstr, }).Do() if err != nil { log.Fatalf("URL Insert: %v", err) } fmt.Printf("Shortened %s => %s\n", urlstr, url.Id) }
// describeObjects prints out information about the objects of a template func (d *TemplateDescriber) describeObjects(objects []runtime.Object, out *tabwriter.Writer) { formatString(out, "Objects", " ") indent := " " for _, obj := range objects { if d.ObjectDescriber != nil { output, err := d.DescribeObject(obj) if err != nil { fmt.Fprintf(out, "error: %v\n", err) continue } fmt.Fprint(out, output) fmt.Fprint(out, "\n") continue } _, kind, _ := d.ObjectTyper.ObjectVersionAndKind(obj) meta := kapi.ObjectMeta{} meta.Name, _ = d.MetadataAccessor.Name(obj) fmt.Fprintf(out, fmt.Sprintf("%s%s\t%s\n", indent, kind, meta.Name)) //meta.Annotations, _ = d.MetadataAccessor.Annotations(obj) //meta.Labels, _ = d.MetadataAccessor.Labels(obj) /*if len(meta.Labels) > 0 { formatString(out, indent+"Labels", formatLabels(meta.Labels)) } formatAnnotations(out, meta, indent)*/ } }
//line fitted_type.got:17 func drawFittedTableQLetters(rSeq, qSeq alphabet.QLetters, index alphabet.Index, table []int, a [][]int) { tw := tabwriter.NewWriter(os.Stdout, 0, 0, 0, ' ', tabwriter.AlignRight|tabwriter.Debug) fmt.Printf("rSeq: %s\n", rSeq) fmt.Printf("qSeq: %s\n", qSeq) fmt.Fprint(tw, "\tqSeq\t") for _, l := range qSeq { fmt.Fprintf(tw, "%c\t", l) } fmt.Fprintln(tw) r, c := rSeq.Len()+1, qSeq.Len()+1 fmt.Fprint(tw, "rSeq\t") for i := 0; i < r; i++ { if i != 0 { fmt.Fprintf(tw, "%c\t", rSeq[i-1].L) } for j := 0; j < c; j++ { p := pointerFittedQLetters(rSeq, qSeq, i, j, table, index, a, c) if p != "" { fmt.Fprintf(tw, "%s % 3v\t", p, table[i*c+j]) } else { fmt.Fprintf(tw, "%v\t", table[i*c+j]) } } fmt.Fprintln(tw) } tw.Flush() }
// Single mode writes a single condensed line. Used for debugging comparison with tester/tester. func (p *props) writeSingle(w io.Writer) { fmt.Fprintf(w, `"0","0","1","%d","0","%s",`, p.ftype, escape(p.fname)) fmt.Fprintf(w, `"%x","%x",`, p.ident, p.dident) fmt.Fprintf(w, `"%s","%s","%s",`, p.ext, p.mime, escape(p.bname)) fmt.Fprintf(w, `"%x",`, p.chash) fmt.Fprintf(w, "\"%d\",\"%d\",\"%d\"\n", p.size, p.isize.X, p.isize.Y) }
func (c *AppRemove) Run(context *cmd.Context, client cmd.Doer) error { appName, err := c.Guess() if err != nil { return err } var answer string if !*tsuru.AssumeYes { fmt.Fprintf(context.Stdout, `Are you sure you want to remove app "%s"? (y/n) `, appName) fmt.Fscanf(context.Stdin, "%s", &answer) if answer != "y" { fmt.Fprintln(context.Stdout, "Abort.") return nil } } url := cmd.GetUrl(fmt.Sprintf("/apps/%s", appName)) request, err := http.NewRequest("DELETE", url, nil) if err != nil { return err } _, err = client.Do(request) if err != nil { return err } fmt.Fprintf(context.Stdout, `App "%s" successfully removed!`+"\n", appName) return nil }
func (c *AppCreate) Run(context *cmd.Context, client cmd.Doer) error { appName := context.Args[0] framework := context.Args[1] b := bytes.NewBufferString(fmt.Sprintf(`{"name":"%s", "framework":"%s"}`, appName, framework)) request, err := http.NewRequest("POST", cmd.GetUrl("/apps"), b) request.Header.Set("Content-Type", "application/json") if err != nil { return err } response, err := client.Do(request) if err != nil { return err } defer response.Body.Close() result, err := ioutil.ReadAll(response.Body) if err != nil { return err } out := make(map[string]string) err = json.Unmarshal(result, &out) if err != nil { return err } fmt.Fprintf(context.Stdout, `App "%s" is being created!`+"\n", appName) fmt.Fprint(context.Stdout, "Check its status with app-list.\n") fmt.Fprintf(context.Stdout, `Your repository for "%s" project is "%s"`+"\n", appName, out["repository_url"]) return nil }
// Load loads the source into the config defined by struct s func (f *FlagLoader) Load(s interface{}) error { strct := structs.New(s) structName := strct.Name() flagSet := flag.NewFlagSet(structName, flag.ExitOnError) f.flagSet = flagSet for _, field := range strct.Fields() { f.processField(field.Name(), field) } flagSet.Usage = func() { fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0]) flagSet.PrintDefaults() fmt.Fprintf(os.Stderr, "\nGenerated environment variables:\n") e := &EnvironmentLoader{ Prefix: f.EnvPrefix, CamelCase: f.CamelCase, } e.PrintEnvs(s) fmt.Println("") } args := os.Args[1:] if f.Args != nil { args = f.Args } return flagSet.Parse(args) }
// mkzcgo writes zcgo.go for the go/build package: // // package build // var cgoEnabled = map[string]bool{} // // It is invoked to write go/build/zcgo.go. func mkzcgo(dir, file string) { // sort for deterministic zcgo.go file var list []string for plat, hasCgo := range cgoEnabled { if hasCgo { list = append(list, plat) } } sort.Strings(list) var buf bytes.Buffer fmt.Fprintf(&buf, "// auto generated by go tool dist\n"+ "\n"+ "package build\n"+ "\n"+ "var cgoEnabled = map[string]bool{\n") for _, plat := range list { fmt.Fprintf(&buf, "\t%q: true,\n", plat) } fmt.Fprintf(&buf, "}") writefile(buf.String(), file, writeSkipSame) }
// Create a new DNS info provider. func ExampleNewDNSInfoProvider() { // create a DNS client credentials := APICredentials{"*****@*****.**", "ApItOken"} dnsClient, clientError := NewDNSClient(credentials) if clientError != nil { fmt.Fprintf(os.Stderr, "Unable to create DNS client: %s", clientError.Error()) os.Exit(1) } // create a new DNS info provider instance dnsInfoProvider := NewDNSInfoProvider(dnsClient) // get all domain names domainNames, domainNamesError := dnsInfoProvider.GetDomainNames() if domainNamesError != nil { fmt.Fprintf(os.Stderr, "Unable to fetch domain names: %s", domainNamesError.Error()) os.Exit(1) } // print a list all domain names for _, domainName := range domainNames { fmt.Fprintf(os.Stdout, "%s\n", domainName) } }
func verifyCertWithSystem(block *pem.Block, add func(*Certificate)) { data := pem.EncodeToMemory(block) var cmd *exec.Cmd if needsTmpFiles() { f, err := ioutil.TempFile("", "cert") if err != nil { fmt.Fprintf(os.Stderr, "can't create temporary file for cert: %v", err) return } defer os.Remove(f.Name()) if _, err := f.Write(data); err != nil { fmt.Fprintf(os.Stderr, "can't write temporary file for cert: %v", err) return } if err := f.Close(); err != nil { fmt.Fprintf(os.Stderr, "can't write temporary file for cert: %v", err) return } cmd = exec.Command("/usr/bin/security", "verify-cert", "-c", f.Name(), "-l") } else { cmd = exec.Command("/usr/bin/security", "verify-cert", "-c", "/dev/stdin", "-l") cmd.Stdin = bytes.NewReader(data) } if cmd.Run() == nil { // Non-zero exit means untrusted cert, err := ParseCertificate(block.Bytes) if err != nil { return } add(cert) } }
func write(buf *bytes.Buffer, e Expr) { switch e := e.(type) { case literal: fmt.Fprintf(buf, "%g", e) case Var: fmt.Fprintf(buf, "%s", e) case unary: fmt.Fprintf(buf, "(%c", e.op) write(buf, e.x) buf.WriteByte(')') case binary: buf.WriteByte('(') write(buf, e.x) fmt.Fprintf(buf, " %c ", e.op) write(buf, e.y) buf.WriteByte(')') case call: fmt.Fprintf(buf, "%s(", e.fn) for i, arg := range e.args { if i > 0 { buf.WriteString(", ") } write(buf, arg) } buf.WriteByte(')') default: panic(fmt.Sprintf("unknown Expr: %T", e)) } }
// Print command line help and exit application func usage() { fmt.Fprintf(os.Stderr, "Usage: domainerator [flags] [prefixes wordlist] [suffixes wordlist] [output file]\n") fmt.Fprintf(os.Stderr, "\nFlags:\n") flag.PrintDefaults() os.Exit(1) }
func writeListOfPins(w io.Writer, name string, pinNames []string) { fmt.Fprintf(w, "static const char* const %s[] = {\n", name) for _, pinName := range pinNames { fmt.Fprintf(w, " kSPKIHash_%s,\n", pinName) } fmt.Fprintf(w, " NULL,\n};\n") }
// buildBenchmark builds the benchmark binary. func (b *Builder) buildBenchmark(workpath string, update bool) (benchBin, log string, err error) { goroot := filepath.Join(workpath, "go") gobin := filepath.Join(goroot, "bin", "go") + exeExt gopath := filepath.Join(*buildroot, "gopath") env := append([]string{ "GOROOT=" + goroot, "GOPATH=" + gopath}, b.envv()...) // First, download without installing. args := []string{"get", "-d"} if update { args = append(args, "-u") } args = append(args, *benchPath) var buildlog bytes.Buffer runOpts := []runOpt{runTimeout(*buildTimeout), runEnv(env), allOutput(&buildlog), runDir(workpath)} err = run(exec.Command(gobin, args...), runOpts...) if err != nil { fmt.Fprintf(&buildlog, "go get -d %s failed: %s", *benchPath, err) return "", buildlog.String(), err } // Then, build into workpath. benchBin = filepath.Join(workpath, "benchbin") + exeExt args = []string{"build", "-o", benchBin, *benchPath} buildlog.Reset() err = run(exec.Command(gobin, args...), runOpts...) if err != nil { fmt.Fprintf(&buildlog, "go build %s failed: %s", *benchPath, err) return "", buildlog.String(), err } return benchBin, "", nil }
// writeOutput creates stubs for a specific source file to be compiled by 6g // (The comments here say 6g and 6c but the code applies to the 8 and 5 tools too.) func (p *Package) writeOutput(f *File, srcfile string) { base := srcfile if strings.HasSuffix(base, ".go") { base = base[0 : len(base)-3] } base = strings.Map(slashToUnderscore, base) fgo1 := creat("_obj/" + base + ".cgo1.go") fgcc := creat("_obj/" + base + ".cgo2.c") p.GoFiles = append(p.GoFiles, base+".cgo1.go") p.GccFiles = append(p.GccFiles, base+".cgo2.c") // Write Go output: Go input with rewrites of C.xxx to _C_xxx. fmt.Fprintf(fgo1, "// Created by cgo - DO NOT EDIT\n\n") fmt.Fprintf(fgo1, "//line %s:1\n", srcfile) printer.Fprint(fgo1, fset, f.AST) // While we process the vars and funcs, also write 6c and gcc output. // Gcc output starts with the preamble. fmt.Fprintf(fgcc, "%s\n", f.Preamble) fmt.Fprintf(fgcc, "%s\n", gccProlog) for _, n := range f.Name { if n.FuncType != nil { p.writeOutputFunc(fgcc, n) } } fgo1.Close() fgcc.Close() }
func printHelpCommand(preamble interface{}) { if preamble != nil { fmt.Fprintf(os.Stdout, "%s\n%s\n", preamble, HELP_MESSAGE) } else { fmt.Fprintf(os.Stdout, "%s\n", HELP_MESSAGE) } }
// WriteGPX writes samples to w in GPX format. func WriteGPX(w io.Writer, samples []Sample) error { if _, err := fmt.Fprintf(w, ""+ "<gpx version=\"1.1\" creator=\"https://github.com/twpayne/go-doarama\">"+ "<trk>"+ "<trkseg>"); err != nil { return err } for _, s := range samples { if _, err := fmt.Fprintf(w, ""+ "<trkpt lat=\"%f\" lon=\"%f\">"+ "<ele>%f</ele>"+ "<time>%s</time>"+ "</trkpt>", s.Coords.Latitude, s.Coords.Longitude, s.Coords.Altitude, s.Time.Time().Format("2006-01-02T15:04:05Z")); err != nil { return err } } if _, err := fmt.Fprintf(w, ""+ "</trkseg>"+ "</trk>"+ "</gpx>"); err != nil { return err } return nil }
func (f *FlagSet) AddFlag(flag *Flag) { _, alreadythere := f.formal[flag.Name] if alreadythere { msg := fmt.Sprintf("%s flag redefined: %s", f.name, flag.Name) fmt.Fprintln(f.out(), msg) panic(msg) // Happens only if flags are declared with identical names } if f.formal == nil { f.formal = make(map[string]*Flag) } f.formal[flag.Name] = flag if len(flag.Shorthand) == 0 { return } if len(flag.Shorthand) > 1 { fmt.Fprintf(f.out(), "%s shorthand more than ASCII character: %s\n", f.name, flag.Shorthand) panic("shorthand is more than one character") } if f.shorthands == nil { f.shorthands = make(map[byte]*Flag) } c := flag.Shorthand[0] old, alreadythere := f.shorthands[c] if alreadythere { fmt.Fprintf(f.out(), "%s shorthand reused: %q for %s already used for %s\n", f.name, c, flag.Name, old.Name) panic("shorthand redefinition") } f.shorthands[c] = flag }
func writeRequiredNoun(cmd *Command, out *bytes.Buffer) { fmt.Fprintf(out, " must_have_one_noun=()\n") sort.Sort(sort.StringSlice(cmd.ValidArgs)) for _, value := range cmd.ValidArgs { fmt.Fprintf(out, " must_have_one_noun+=(%q)\n", value) } }
func createHelpCommand(com *Comandante, w io.Writer) *Command { action := func() error { // The first parameter passed to the help command should be the // command for requested documentation. if len(os.Args) < 3 { com.printDefaultHelp(w) } else { cmdName := os.Args[2] cmd := com.getCommand(cmdName) if cmd != nil && cmdName != "help" { fmt.Fprintf(w, "%s %s\n%s", com.binaryName, cmdName, cmd.Documentation) if cmd.FlagInit != nil { cmd.FlagInit(&cmd.flagSet) fmt.Fprintf(w, "\noptions\n") cmd.flagSet.SetOutput(w) cmd.flagSet.PrintDefaults() } } else { com.printDefaultHelp(w) } } return nil } cmd := NewCommand("help", "get more information about a command", action) return cmd }
// This example displays the results of Dec.Round with each of the Rounders. // func ExampleRounder() { var vals = []struct { x string s inf.Scale }{ {"-0.18", 1}, {"-0.15", 1}, {"-0.12", 1}, {"-0.10", 1}, {"-0.08", 1}, {"-0.05", 1}, {"-0.02", 1}, {"0.00", 1}, {"0.02", 1}, {"0.05", 1}, {"0.08", 1}, {"0.10", 1}, {"0.12", 1}, {"0.15", 1}, {"0.18", 1}, } var rounders = []struct { name string rounder inf.Rounder }{ {"RoundDown", inf.RoundDown}, {"RoundUp", inf.RoundUp}, {"RoundCeil", inf.RoundCeil}, {"RoundFloor", inf.RoundFloor}, {"RoundHalfDown", inf.RoundHalfDown}, {"RoundHalfUp", inf.RoundHalfUp}, {"RoundHalfEven", inf.RoundHalfEven}, {"RoundExact", inf.RoundExact}, } fmt.Println("The results of new(inf.Dec).Round(x, s, inf.RoundXXX):\n") w := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', tabwriter.AlignRight) fmt.Fprint(w, "x\ts\t|\t") for _, r := range rounders { fmt.Fprintf(w, "%s\t", r.name[5:]) } fmt.Fprintln(w) for _, v := range vals { fmt.Fprintf(w, "%s\t%d\t|\t", v.x, v.s) for _, r := range rounders { x, _ := new(inf.Dec).SetString(v.x) z := new(inf.Dec).Round(x, v.s, r.rounder) fmt.Fprintf(w, "%d\t", z) } fmt.Fprintln(w) } w.Flush() // Output: // The results of new(inf.Dec).Round(x, s, inf.RoundXXX): // // x s | Down Up Ceil Floor HalfDown HalfUp HalfEven Exact // -0.18 1 | -0.1 -0.2 -0.1 -0.2 -0.2 -0.2 -0.2 <nil> // -0.15 1 | -0.1 -0.2 -0.1 -0.2 -0.1 -0.2 -0.2 <nil> // -0.12 1 | -0.1 -0.2 -0.1 -0.2 -0.1 -0.1 -0.1 <nil> // -0.10 1 | -0.1 -0.1 -0.1 -0.1 -0.1 -0.1 -0.1 -0.1 // -0.08 1 | 0.0 -0.1 0.0 -0.1 -0.1 -0.1 -0.1 <nil> // -0.05 1 | 0.0 -0.1 0.0 -0.1 0.0 -0.1 0.0 <nil> // -0.02 1 | 0.0 -0.1 0.0 -0.1 0.0 0.0 0.0 <nil> // 0.00 1 | 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 // 0.02 1 | 0.0 0.1 0.1 0.0 0.0 0.0 0.0 <nil> // 0.05 1 | 0.0 0.1 0.1 0.0 0.0 0.1 0.0 <nil> // 0.08 1 | 0.0 0.1 0.1 0.0 0.1 0.1 0.1 <nil> // 0.10 1 | 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 // 0.12 1 | 0.1 0.2 0.2 0.1 0.1 0.1 0.1 <nil> // 0.15 1 | 0.1 0.2 0.2 0.1 0.1 0.2 0.2 <nil> // 0.18 1 | 0.1 0.2 0.2 0.1 0.2 0.2 0.2 <nil> }
func runLsRanges(cmd *cobra.Command, args []string) { if len(args) > 1 { mustUsage(cmd) return } var startKey proto.Key if len(args) >= 1 { startKey = keys.RangeMetaKey(proto.Key(args[0])) } else { startKey = keys.Meta2Prefix } kvDB, stopper := makeDBClient() defer stopper.Stop() rows, err := kvDB.Scan(startKey, keys.Meta2Prefix.PrefixEnd(), maxResults) if err != nil { fmt.Fprintf(os.Stderr, "scan failed: %s\n", err) osExit(1) return } for _, row := range rows { desc := &proto.RangeDescriptor{} if err := row.ValueProto(desc); err != nil { fmt.Fprintf(os.Stderr, "%s: unable to unmarshal range descriptor\n", row.Key) continue } fmt.Printf("%s-%s [%d]\n", desc.StartKey, desc.EndKey, desc.RangeID) for i, replica := range desc.Replicas { fmt.Printf("\t%d: node-id=%d store-id=%d\n", i, replica.NodeID, replica.StoreID) } } fmt.Printf("%d result(s)\n", len(rows)) }
// HandleListObjectsInfoSuccessfully creates an HTTP handler at `/testContainer` on the test handler mux that // responds with a `List` response when full info is requested. func HandleListObjectsInfoSuccessfully(t *testing.T) { th.Mux.HandleFunc("/testContainer", func(w http.ResponseWriter, r *http.Request) { th.TestMethod(t, r, "GET") th.TestHeader(t, r, "X-Auth-Token", fake.TokenID) th.TestHeader(t, r, "Accept", "application/json") w.Header().Set("Content-Type", "application/json") r.ParseForm() marker := r.Form.Get("marker") switch marker { case "": fmt.Fprintf(w, `[ { "hash": "451e372e48e0f6b1114fa0724aa79fa1", "last_modified": "2009-11-10 23:00:00 +0000 UTC", "bytes": 14, "name": "goodbye", "content_type": "application/octet-stream" }, { "hash": "451e372e48e0f6b1114fa0724aa79fa1", "last_modified": "2009-11-10 23:00:00 +0000 UTC", "bytes": 14, "name": "hello", "content_type": "application/octet-stream" } ]`) case "hello": fmt.Fprintf(w, `[]`) default: t.Fatalf("Unexpected marker: [%s]", marker) } }) }
func testExpr(b *bufio.Writer, expr string) { if *pass == 0 { fmt.Fprintf(b, "\ttest(func(){use(%s)}, %q)\n", expr, expr) } else { fmt.Fprintf(b, "\tuse(%s) // ERROR \"index|overflow\"\n", expr) } }