// PrintMap prints a map - recursing through submaps // concrete types, like map[float64]map[int]float64 // would have to be converted element by element // to map[interface{}]interface{} // the json.indent function might be similar // but I did not bring it to work func PrintMapRecursive(m1 map[interface{}]interface{}, depth int) string { b1 := new(bytes.Buffer) fiveSpaces := " " // html spaces cxIndent := fmt.Sprint(depth * 40) depthStyle := "" if depth == 0 { depthStyle = "margin-top:8px; border-top: 1px solid #aaa;" } else { darkening := 16 - 2*depth bgc := fmt.Sprintf("%x%x%x", darkening, darkening, darkening) depthStyle = "margin:0;padding:0;background-color:#" + bgc + ";" } for k1, m2 := range m1 { b1.WriteString("<div style='" + depthStyle + "margin-left:" + cxIndent + "px;'>\n") b1.WriteString(fmt.Sprint(k1)) //b1.WriteString( "<br>\n" ) switch typedvar := m2.(type) { default: type_unknown := fmt.Sprintf("<br>\n --this type switch does not support type %#v", typedvar) //panic(type_unknown) b1.WriteString(fiveSpaces + fmt.Sprintf("%#v", typedvar) + type_unknown) case string: b1.WriteString(fiveSpaces + typedvar) case int, float64: b1.WriteString(fiveSpaces + fmt.Sprint(typedvar)) case nil: b1.WriteString("nil interface") case map[interface{}]interface{}: b1.WriteString(PrintMapRecursive(typedvar, depth+1)) } b1.WriteString("<br>\n") b1.WriteString("</div>\n") } return b1.String() }
func (entry *Entry) Panic(args ...interface{}) { if entry.Logger.Level >= Panic { msg := entry.log("panic", Panic, fmt.Sprint(args...)) panic(msg) } panic(fmt.Sprint(args...)) }
// DescribeCdnDomainBaseDetail version 2014-11-11 // // required parameters: // name: DomainName, type: string // // optional parameters: // name: OwnerId, type: int64 // name: ResourceOwnerAccount, type: string // name: ResourceOwnerId, type: int64 // name: _method, type: string, optional values: GET|POST // name: _region, type: string // name: _scheme, type: string, optional values: http|https func (api API) DescribeCdnDomainBaseDetail(DomainName string, optional openapi.M) (*DescribeCdnDomainBaseDetailResponse, error) { args := NewParams() args.Query.Set("Action", "DescribeCdnDomainBaseDetail") args.Query.Set("DomainName", DomainName) if v, ok := optional["OwnerId"]; ok { if OwnerId, ok := v.(int64); ok { args.Query.Set("OwnerId", fmt.Sprint(OwnerId)) } else { return nil, errors.New("OwnerId must be int64") } } if v, ok := optional["ResourceOwnerAccount"]; ok { if ResourceOwnerAccount, ok := v.(string); ok { args.Query.Set("ResourceOwnerAccount", ResourceOwnerAccount) } else { return nil, errors.New("ResourceOwnerAccount must be string") } } if v, ok := optional["ResourceOwnerId"]; ok { if ResourceOwnerId, ok := v.(int64); ok { args.Query.Set("ResourceOwnerId", fmt.Sprint(ResourceOwnerId)) } else { return nil, errors.New("ResourceOwnerId must be int64") } } if v, ok := optional["_method"]; ok { if s, ok := v.(string); ok { if !openapi.IsIn(s, "GET|POST") { return nil, errors.New("_method must be GET|POST") } args.Method = s } else { return nil, errors.New("_method must be string") } } if v, ok := optional["_region"]; ok { if s, ok := v.(string); ok { args.Region = s } else { return nil, errors.New("_region must be string") } } if v, ok := optional["_scheme"]; ok { if s, ok := v.(string); ok { if !openapi.IsIn(s, "http|https") { return nil, errors.New("_scheme must be http|https") } args.Scheme = s } else { return nil, errors.New("_scheme must be string") } } result := new(DescribeCdnDomainBaseDetailResponse) if err := api.Service.Do(result, args); err != nil { return nil, err } return result, nil }
func parseGauges(info string) map[string]int64 { gauges_with_values := map[string]int64{ "blocked_clients": 0, "connected_clients": 0, "instantaneous_ops_per_sec": 0, "latest_fork_usec": 0, "mem_fragmentation_ratio": 0, "migrate_cached_sockets": 0, "pubsub_channels": 0, "pubsub_patterns": 0, "uptime_in_seconds": 0, "used_memory": 0, "used_memory_lua": 0, "used_memory_peak": 0, "used_memory_rss": 0, } color.White("-------------------") color.White("GAUGES:") for gauge, _ := range gauges_with_values { r, _ := regexp.Compile(fmt.Sprint(gauge, ":([0-9]*)")) matches := r.FindStringSubmatch(info) if matches == nil { color.Yellow(fmt.Sprint("WARN: ", gauge, "is not displayed in redis info")) } else { value := matches[len(matches)-1] color.Cyan(fmt.Sprint(gauge, ": ", value)) v, _ := strconv.ParseInt(value, 10, 64) gauges_with_values[gauge] = v } } return gauges_with_values }
func TestStatic(t *testing.T) { var ( instances = []string{"foo", "bar", "baz"} endpoints = map[string]endpoint.Endpoint{ "foo": func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil }, "bar": func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil }, "baz": func(context.Context, interface{}) (interface{}, error) { return struct{}{}, nil }, } factory = func(instance string) (endpoint.Endpoint, error) { if e, ok := endpoints[instance]; ok { return e, nil } return nil, fmt.Errorf("%s: not found", instance) } ) p := static.NewPublisher(instances, factory, log.NewNopLogger()) have, err := p.Endpoints() if err != nil { t.Fatal(err) } want := []endpoint.Endpoint{endpoints["foo"], endpoints["bar"], endpoints["baz"]} if fmt.Sprint(want) != fmt.Sprint(have) { t.Fatalf("want %v, have %v", want, have) } }
func InsertWithUID(w http.ResponseWriter, r *http.Request) { w.Header().Set("Cache-Control", "must-revalidate") w.Header().Set("Content-Type", "application/json") var col, doc string if !Require(w, r, "col", &col) { return } if !Require(w, r, "doc", &doc) { return } V3Sync.RLock() defer V3Sync.RUnlock() dbcol := V3DB.Use(col) if dbcol == nil { http.Error(w, fmt.Sprintf("Collection '%s' does not exist.", col), 400) return } var jsonDoc interface{} if err := json.Unmarshal([]byte(doc), &jsonDoc); err != nil { http.Error(w, fmt.Sprintf("'%v' is not valid JSON document.", doc), 400) return } id, uid, err := dbcol.InsertWithUID(jsonDoc) if err != nil { http.Error(w, fmt.Sprint(err), 500) return } resp, err := json.Marshal(map[string]interface{}{"id": id, "uid": uid}) if err != nil { http.Error(w, fmt.Sprint(err), 500) return } w.WriteHeader(201) w.Write(resp) }
func viewInvite(w http.ResponseWriter, r *http.Request) { mail := r.PostFormValue("mail") conf, err := loadConf() if err != nil { log.Fatalln(err) } client := &http.Client{} data := url.Values{ "email": {mail}, "token": {conf.Token}, "set_active": {"true"}, } resp, err := client.Post( "https://"+conf.URL+"/api/users.admin.invite", "application/x-www-form-urlencoded", strings.NewReader(data.Encode()), ) if err != nil { log.Fatalln(err) } body, _ := ioutil.ReadAll(resp.Body) var status map[string]interface{} json.Unmarshal(body, &status) fmt.Println(status["ok"]) statusOk := fmt.Sprint(status["ok"]) if statusOk == "true" { fmt.Fprintf(w, mail+"に招待状を送信しました.") } else { fmt.Fprintf(w, "失敗した。失敗した。失敗した。"+fmt.Sprint(status["error"])) } }
func (m *Map) String() string { s := "Map [" + fmt.Sprint(m.width) + " x " + fmt.Sprint(m.height) + "]\n{" for _, ap := range m.accessPoints { s += ap.String() + ", " } return s + "}" }
func TestUpdateToInvalid(t *testing.T) { ldb := db.OpenMemory() s := db.NewFileSet("test", ldb) localHave := fileList{ protocol.FileInfo{Name: "a", Version: protocol.Vector{Counters: []protocol.Counter{{ID: myID, Value: 1000}}}, Blocks: genBlocks(1)}, protocol.FileInfo{Name: "b", Version: protocol.Vector{Counters: []protocol.Counter{{ID: myID, Value: 1001}}}, Blocks: genBlocks(2)}, protocol.FileInfo{Name: "c", Version: protocol.Vector{Counters: []protocol.Counter{{ID: myID, Value: 1002}}}, Blocks: genBlocks(5), Invalid: true}, protocol.FileInfo{Name: "d", Version: protocol.Vector{Counters: []protocol.Counter{{ID: myID, Value: 1003}}}, Blocks: genBlocks(7)}, } s.Replace(protocol.LocalDeviceID, localHave) have := fileList(haveList(s, protocol.LocalDeviceID)) sort.Sort(have) if fmt.Sprint(have) != fmt.Sprint(localHave) { t.Errorf("Have incorrect before invalidation;\n A: %v !=\n E: %v", have, localHave) } localHave[1] = protocol.FileInfo{Name: "b", Version: protocol.Vector{Counters: []protocol.Counter{{ID: myID, Value: 1001}}}, Invalid: true} s.Update(protocol.LocalDeviceID, localHave[1:2]) have = fileList(haveList(s, protocol.LocalDeviceID)) sort.Sort(have) if fmt.Sprint(have) != fmt.Sprint(localHave) { t.Errorf("Have incorrect after invalidation;\n A: %v !=\n E: %v", have, localHave) } }
func main() { srv := &clonesrv_t{ port: 5556, kvmap: make(map[string]*kvmsg.Kvmsg), } // Set up our clone server sockets srv.snapshot, _ = zmq.NewSocket(zmq.ROUTER) srv.snapshot.Bind(fmt.Sprint("tcp://*:", srv.port)) srv.publisher, _ = zmq.NewSocket(zmq.PUB) srv.publisher.Bind(fmt.Sprint("tcp://*:", srv.port+1)) srv.collector, _ = zmq.NewSocket(zmq.PULL) srv.collector.Bind(fmt.Sprint("tcp://*:", srv.port+2)) // Register our handlers with reactor reactor := zmq.NewReactor() reactor.AddSocket(srv.snapshot, zmq.POLLIN, func(e zmq.State) error { return snapshots(srv) }) reactor.AddSocket(srv.collector, zmq.POLLIN, func(e zmq.State) error { return collector(srv) }) reactor.AddChannelTime(time.Tick(1000*time.Millisecond), 1, func(v interface{}) error { return flush_ttl(srv) }) log.Println(reactor.Run(100 * time.Millisecond)) // precision: .1 seconds }
// zeroConst returns a new "zero" constant of the specified type, // which must not be an array or struct type: the zero values of // aggregates are well-defined but cannot be represented by Const. // func zeroConst(t types.Type) *Const { switch t := t.(type) { case *types.Basic: switch { case t.Info()&types.IsBoolean != 0: return NewConst(exact.MakeBool(false), t) case t.Info()&types.IsNumeric != 0: return NewConst(exact.MakeInt64(0), t) case t.Info()&types.IsString != 0: return NewConst(exact.MakeString(""), t) case t.Kind() == types.UnsafePointer: fallthrough case t.Kind() == types.UntypedNil: return nilConst(t) default: panic(fmt.Sprint("zeroConst for unexpected type:", t)) } case *types.Pointer, *types.Slice, *types.Interface, *types.Chan, *types.Map, *types.Signature: return nilConst(t) case *types.Named: return NewConst(zeroConst(t.Underlying()).Value, t) case *types.Array, *types.Struct, *types.Tuple: panic(fmt.Sprint("zeroConst applied to aggregate:", t)) } panic(fmt.Sprint("zeroConst: unexpected ", t)) }
// Test of aliasing. func init() { type S struct { a, b string } s1 := []string{"foo", "bar"} s2 := s1 // creates an alias s2[0] = "wiz" if x := fmt.Sprint(s1, s2); x != "[wiz bar] [wiz bar]" { panic(x) } pa1 := &[2]string{"foo", "bar"} pa2 := pa1 // creates an alias (*pa2)[0] = "wiz" // * required to workaround typechecker bug if x := fmt.Sprint(*pa1, *pa2); x != "[wiz bar] [wiz bar]" { panic(x) } a1 := [2]string{"foo", "bar"} a2 := a1 // creates a copy a2[0] = "wiz" if x := fmt.Sprint(a1, a2); x != "[foo bar] [wiz bar]" { panic(x) } t1 := S{"foo", "bar"} t2 := t1 // copy t2.a = "wiz" if x := fmt.Sprint(t1, t2); x != "{foo bar} {wiz bar}" { panic(x) } }
func spinner(waitMsg string, position int, channelEnd *ChannelEnd, wg *sync.WaitGroup) { if channelEnd.closed { wg.Done() return } wg.Add(1) chars := []string{".", "-", ".", "-", "-", ".", "-", ".", "-", "-", ".", "-", ".", "-", "-", "."} if position > len(chars)-1 { position = 0 } postfix := "" prefix := "" for counter, str := range chars { if counter < position { postfix = fmt.Sprint(postfix, str) } else { prefix = fmt.Sprint(prefix, str) } } clean() switch runtime.GOOS { case "windows": prefix = "..." postfix = "" } printWait(fmt.Sprintf("%s %s%s", waitMsg, prefix, postfix)) time.Sleep(100 * time.Millisecond) spinner(waitMsg, position+1, channelEnd, wg) wg.Done() }
func (c *help) Run(context *Context, client *Client) error { const deprecatedMsg = "WARNING: %q is deprecated. Showing help for %q instead.\n\n" output := fmt.Sprintf("%s version %s.\n\n", c.manager.name, c.manager.version) if c.manager.wrong { output += fmt.Sprint("ERROR: wrong number of arguments.\n\n") } if len(context.Args) > 0 { if cmd, ok := c.manager.Commands[context.Args[0]]; ok { if deprecated, ok := cmd.(*DeprecatedCommand); ok { fmt.Fprintf(context.Stderr, deprecatedMsg, deprecated.oldName, cmd.Info().Name) } info := cmd.Info() output += fmt.Sprintf("Usage: %s %s\n", c.manager.name, info.Usage) output += fmt.Sprintf("\n%s\n", info.Desc) flags := c.parseFlags(cmd) if flags != "" { output += fmt.Sprintf("\n%s", flags) } if info.MinArgs > 0 { output += fmt.Sprintf("\nMinimum # of arguments: %d", info.MinArgs) } if info.MaxArgs > 0 { output += fmt.Sprintf("\nMaximum # of arguments: %d", info.MaxArgs) } output += fmt.Sprint("\n") } else if topic, ok := c.manager.topics[context.Args[0]]; ok { output += topic } else { return fmt.Errorf("command %q does not exist.", context.Args[0]) } } else { output += fmt.Sprintf("Usage: %s %s\n\nAvailable commands:\n", c.manager.name, c.Info().Usage) var commands []string for name, cmd := range c.manager.Commands { if _, ok := cmd.(*DeprecatedCommand); !ok { commands = append(commands, name) } } sort.Strings(commands) for _, command := range commands { description := c.manager.Commands[command].Info().Desc description = strings.Split(description, "\n")[0] description = strings.Split(description, ".")[0] if len(description) > 2 { description = strings.ToUpper(description[:1]) + description[1:] } output += fmt.Sprintf(" %-20s %s\n", command, description) } output += fmt.Sprintf("\nUse %s help <commandname> to get more information about a command.\n", c.manager.name) if len(c.manager.topics) > 0 { output += fmt.Sprintln("\nAvailable topics:") for topic := range c.manager.topics { output += fmt.Sprintf(" %s\n", topic) } output += fmt.Sprintf("\nUse %s help <topicname> to get more information about a topic.\n", c.manager.name) } } io.WriteString(context.Stdout, output) return nil }
func UpdateByUID(w http.ResponseWriter, r *http.Request) { w.Header().Set("Cache-Control", "must-revalidate") w.Header().Set("Content-Type", "text/json") var col, uid, doc string if !Require(w, r, "col", &col) { return } if !Require(w, r, "uid", &uid) { return } if !Require(w, r, "doc", &doc) { return } V3Sync.RLock() defer V3Sync.RUnlock() dbcol := V3DB.Use(col) if dbcol == nil { http.Error(w, fmt.Sprintf("Collection '%s' does not exist.", col), 400) return } var newDoc interface{} if err := json.Unmarshal([]byte(doc), &newDoc); err != nil { http.Error(w, fmt.Sprintf("'%v' is not valid JSON document.", newDoc), 400) return } newID, err := dbcol.UpdateByUID(uid, newDoc) if err != nil { http.Error(w, fmt.Sprint(err), 500) return } w.Write([]byte(fmt.Sprint(newID))) }
func (this Pair) Up() (Pair, error) { if this.Left.patch { return this, nil } if err := this.Left.ApplyCidr(); err != nil { return this, errors.New(fmt.Sprint("Unable to Left.ApplyCidr, error:", err)) } if err := this.Right.ApplyCidr(); err != nil { return this, errors.New(fmt.Sprint("Unable to Right.ApplyCidr, error:", err)) } if err := this.Left.Up(); err != nil { return this, errors.New(fmt.Sprint("Unable to Left.Up(), error:", err)) } if err := this.Right.Up(); err != nil { return this, errors.New(fmt.Sprint("Unable to Right.Up(), error:", err)) } if err := this.Right.ApplyRoutes(); err != nil { return this, errors.New(fmt.Sprint("Unable to ApplyRoutes(), error:", err)) } this.Left = this.Left.SetState("UP") this.Right = this.Right.SetState("UP") fmt.Println("[Link]", this.Left.NodeName, this.Left.Name, this.Left.Cidr, "<--->", this.Right.NodeName, this.Right.Name, this.Right.Cidr) return this, nil }
func ReassignUID(w http.ResponseWriter, r *http.Request) { w.Header().Set("Cache-Control", "must-revalidate") w.Header().Set("Content-Type", "application/json") var col, id string if !Require(w, r, "col", &col) { return } if !Require(w, r, "id", &id) { return } V3Sync.RLock() defer V3Sync.RUnlock() dbcol := V3DB.Use(col) if dbcol == nil { http.Error(w, fmt.Sprintf("Collection '%s' does not exist.", col), 400) return } docID, err := strconv.Atoi(id) if err != nil { http.Error(w, fmt.Sprintf("Invalid document ID '%v'.", id), 400) return } newID, newUID, err := dbcol.ReassignUID(uint64(docID)) if err != nil { http.Error(w, fmt.Sprint(err), 500) } resp, err := json.Marshal(map[string]interface{}{"id": newID, "uid": newUID}) if err != nil { http.Error(w, fmt.Sprint(err), 500) return } w.WriteHeader(201) w.Write(resp) }
func decodeValue(name string, data *asn1.RawValue, retVal *Variable) (err error) { switch Asn1BER(data.Tag) { // simple values case Integer, OctetString: params, val = "", new(interface{}) // 32 bit application values case Counter32, TimeTicks, Gauge32: params, val = fmt.Sprint("tag:", data.Tag), new(int32) // 64 bit application values case Counter64: params, val = fmt.Sprint("tag:", data.Tag), new(int64) case NoSuchInstance: return fmt.Errorf("No such instance") case NoSuchObject: return fmt.Errorf("No such object") default: return fmt.Errorf("Unable to decode %x - not implemented", data[0]) } _, err = asn1.UnmarshalWithParams(m.Data.FullBytes, &val, fmt.Sprint("tag:", data.Tag)) if err != nil { return } *retVal.Name = name *retVal.Type = Asn1BER(data.Tag) *retVal.Value = val return }
func (self res) resolve(scope map[interface{}]interface{}) (output string) { output = self.value if self.needsResolution { curr := self.resolveValue(scope) OutputSwitch: switch t := curr; t.Kind() { case reflect.String: output = t.String() case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: output = fmt.Sprint(t.Int()) case reflect.Float32, reflect.Float64: output = fmt.Sprint(t.Float()) case reflect.Ptr: if !t.IsNil() { curr = t.Elem() goto OutputSwitch } output = "" case reflect.Interface: curr = t.Elem() goto OutputSwitch default: output = fmt.Sprint(curr) } } return }
// Results func (u *Uchiwa) resultsHandler(w http.ResponseWriter, r *http.Request) { if r.Method != "DELETE" { http.Error(w, "", http.StatusBadRequest) return } resources := strings.Split(r.URL.Path, "/") if len(resources) != 5 { http.Error(w, "", http.StatusBadRequest) return } check := resources[4] client := resources[3] dc := resources[2] token := auth.GetTokenFromContext(r) unauthorized := FilterGetRequest(dc, token) if unauthorized { http.Error(w, fmt.Sprint(""), http.StatusNotFound) return } err := u.DeleteCheckResult(check, client, dc) if err != nil { http.Error(w, fmt.Sprint(err), http.StatusInternalServerError) return } }
func parseCounters(info string) map[string]int64 { counters := map[string]int64{ "evicted_keys": 0, "expired_keys": 0, "keyspace_hits": 0, "keyspace_misses": 0, "rejected_connections": 0, "sync_full": 0, "sync_partial_err": 0, "sync_partial_ok": 0, "total_commands_processed": 0, "total_connections_received": 0, } color.White("-------------------") color.White("COUNTERS:") for counter, _ := range counters { r, _ := regexp.Compile(fmt.Sprint(counter, ":([0-9]*)")) matches := r.FindStringSubmatch(info) if matches == nil { color.Yellow(fmt.Sprint("ERROR: ", counter, "is not displayed in redis info")) } else { value := matches[len(matches)-1] color.Cyan(fmt.Sprint(counter, ": ", value)) v, _ := strconv.ParseInt(value, 10, 64) counters[counter] = v } } return counters }
func startClient(servers []string) (*benchClient, error) { path, err := getBenchClientPath() if err != nil { return nil, err } flags := []string{ "--serviceName", benchServerName, "--requestSize", fmt.Sprint(*requestSize), "--timeout", fmt.Sprint(*timeout), } flags = append(flags, servers...) cmd := exec.Command(path, flags...) cmd.Stderr = os.Stderr stdin, err := cmd.StdinPipe() if err != nil { return nil, err } stdout, err := cmd.StdoutPipe() if err != nil { return nil, err } if err := cmd.Start(); err != nil { return nil, err } bc := &benchClient{cmd: cmd, stdin: stdin, stdout: bufio.NewReader(stdout), errors: make(map[string]int)} return bc, bc.waitForStart() }
func addTestManifest(repo, reference string, content []byte, m *testutil.RequestResponseMap) { *m = append(*m, testutil.RequestResponseMapping{ Request: testutil.Request{ Method: "GET", Route: "/v2/" + repo + "/manifests/" + reference, }, Response: testutil.Response{ StatusCode: http.StatusOK, Body: content, Headers: http.Header(map[string][]string{ "Content-Length": {fmt.Sprint(len(content))}, "Last-Modified": {time.Now().Add(-1 * time.Second).Format(time.ANSIC)}, }), }, }) *m = append(*m, testutil.RequestResponseMapping{ Request: testutil.Request{ Method: "HEAD", Route: "/v2/" + repo + "/manifests/" + reference, }, Response: testutil.Response{ StatusCode: http.StatusOK, Headers: http.Header(map[string][]string{ "Content-Length": {fmt.Sprint(len(content))}, "Last-Modified": {time.Now().Add(-1 * time.Second).Format(time.ANSIC)}, }), }, }) }
func Get(w http.ResponseWriter, r *http.Request) { c := appengine.NewContext(r) categoryName := r.FormValue("category") if categoryName == "" { randomCat, err := getRandomCategory(c) if err != nil { http.Error(w, "Could not get random category"+err.Error(), http.StatusInternalServerError) return } categoryName = randomCat } q := datastore.NewQuery("Fortune").Filter("Category =", categoryName) count, err := q.Count(c) if err != nil { mess := fmt.Sprint("Could not count fortunes matching: %s. Error was: %s", categoryName, err.Error()) http.Error(w, mess, http.StatusInternalServerError) return } if count == 0 { mess := fmt.Sprintf("No fortune matching %s", categoryName) http.Error(w, mess, http.StatusInternalServerError) return } fortunes := make([]Fortune, 0, count) _, err = q.GetAll(c, &fortunes) if err != nil { mess := fmt.Sprint("Could not get fortunes matching: %s. Error was: %s", categoryName, err.Error()) http.Error(w, mess, http.StatusInternalServerError) return } randIndex := rand.Intn(count) fortune := fortunes[randIndex] fmt.Fprintf(w, "%s\n[%s]\n", fortune.Text, fortune.Category) }
func TestFromConfig(t *testing.T) { newString := func(s string) *string { return &s } tests := []struct { in string want interface{} wanterr interface{} }{ {in: "", wanterr: ErrNoAuth}, {in: "slkdjflksdjf", wanterr: `Unknown auth type: "slkdjflksdjf"`}, {in: "none", want: None{}}, {in: "localhost", want: Localhost{}}, {in: "userpass:alice:secret", want: &UserPass{Username: "******", Password: "******", OrLocalhost: false, VivifyPass: nil}}, {in: "userpass:alice:secret:+localhost", want: &UserPass{Username: "******", Password: "******", OrLocalhost: true, VivifyPass: nil}}, {in: "userpass:alice:secret:+localhost:vivify=foo", want: &UserPass{Username: "******", Password: "******", OrLocalhost: true, VivifyPass: newString("foo")}}, {in: "devauth:port3179", want: &DevAuth{Password: "******", VivifyPass: newString("viviport3179")}}, {in: "basic:alice:secret", want: &UserPass{Username: "******", Password: "******", OrLocalhost: false, VivifyPass: nil}}, {in: "basic:alice:secret:+localhost", wanterr: `invalid basic auth syntax. got "alice:secret:+localhost", want "username:password"`}, {in: "basic:alice:secret:+vivify=foo", wanterr: `invalid basic auth syntax. got "alice:secret:+vivify=foo", want "username:password"`}, } for _, tt := range tests { am, err := FromConfig(tt.in) if err != nil || tt.wanterr != nil { if fmt.Sprint(err) != fmt.Sprint(tt.wanterr) { t.Errorf("FromConfig(%q) = error %v; want %v", tt.in, err, tt.wanterr) } continue } if !reflect.DeepEqual(am, tt.want) { t.Errorf("FromConfig(%q) = %#v; want %#v", tt.in, am, tt.want) } } }
// Display sends variable name,value pairs to the debugger. Values are formatted using %#v. // The parameter 'nameValuePairs' must be even sized. func (wp *WatchPoint) Display(nameValuePairs ...interface{}) *WatchPoint { if wp.disabled { return wp } _, file, line, ok := runtime.Caller(wp.offset) cmd := command{ Action: "DISPLAY", Level: levelToStr(wp.watchLevel), } if ok { cmd.addParam("go.file", file) cmd.addParam("go.line", fmt.Sprint(line)) } l := len(nameValuePairs) if l%2 == 0 { for i := 0; i < l; i += 2 { k := nameValuePairs[i] v := nameValuePairs[i+1] cmd.addParam(fmt.Sprint(k), fmt.Sprintf("%#v", v)) } } else { com.ColorLog("[WARN] BW: Missing variable for Display(...) in: %v:%v.\n", file, line) wp.disabled = true return wp } channelExchangeCommands(wp.watchLevel, cmd) return wp }
func (c Test) initData(userId int, fieldGroup FieldGroup, masterData *map[string]interface{}) { dateUtil := DateUtil{} if fieldGroup.FieldDataType == "STRING" { (*masterData)[fieldGroup.Id] = "user" + fmt.Sprint(userId) + "_data_" + fmt.Sprint(rand.Int()) } else if fieldGroup.FieldDataType == "FLOAT" { (*masterData)[fieldGroup.Id] = fmt.Sprint(rand.Float64())[:10] } else if fieldGroup.FieldNumberType == "YEAR" { (*masterData)[fieldGroup.Id] = dateUtil.GetCurrentYyyyMMdd() / (100 * 100) } else if fieldGroup.FieldNumberType == "YEARMONTH" { (*masterData)[fieldGroup.Id] = dateUtil.GetCurrentYyyyMMdd() / 100 } else if fieldGroup.FieldNumberType == "DATE" { (*masterData)[fieldGroup.Id] = dateUtil.GetCurrentYyyyMMdd() } else if fieldGroup.FieldNumberType == "TIME" { (*masterData)[fieldGroup.Id] = 180605 } else if fieldGroup.FieldNumberType == "DATETIME" { (*masterData)[fieldGroup.Id] = dateUtil.GetCurrentYyyyMMddHHmmss() } else { // int if fieldGroup.Id == "billTypeId" { (*masterData)[fieldGroup.Id] = 1 } else if fieldGroup.Id == "billTypeParameterId" { (*masterData)[fieldGroup.Id] = 1 } else if fieldGroup.Id == "currencyTypeId" { (*masterData)[fieldGroup.Id] = 1 } else { (*masterData)[fieldGroup.Id] = rand.Int() } } }
// Run the test cases above. func TestComputeRoute(t *testing.T) { for routeLine, expected := range routeTestCases { method, path, action, found := parseRouteLine(routeLine) if !found { t.Error("Failed to parse route line:", routeLine) continue } actual := NewRoute(method, path, action) eq(t, "Method", actual.Method, expected.Method) eq(t, "Path", actual.Path, expected.Path) eq(t, "Action", actual.Action, expected.Action) eq(t, "pathPattern", fmt.Sprint(actual.pathPattern), fmt.Sprint(expected.pathPattern)) eq(t, "staticDir", actual.staticDir, expected.staticDir) eq(t, "len(args)", len(actual.args), len(expected.args)) for i, arg := range actual.args { if len(expected.args) <= i { break } eq(t, "arg.name", arg.name, expected.args[i].name) eq(t, "arg.constraint", arg.constraint.String(), expected.args[i].constraint.String()) } eq(t, "actionPattern", fmt.Sprint(actual.actionPattern), fmt.Sprint(expected.actionPattern)) if t.Failed() { t.Fatal("Failed on route:", routeLine) } } }
// ModifyCdnService version 2014-11-11 // // required parameters: // name: InternetChargeType, type: string // // optional parameters: // name: OwnerId, type: int64 // name: ResourceOwnerAccount, type: string // name: ResourceOwnerId, type: int64 // name: _method, type: string, optional values: GET|POST // name: _region, type: string // name: _scheme, type: string, optional values: http|https func (api API) ModifyCdnService(InternetChargeType string, optional openapi.M) (*openapi.Response, error) { args := NewParams() args.Query.Set("Action", "ModifyCdnService") args.Query.Set("InternetChargeType", InternetChargeType) if v, ok := optional["OwnerId"]; ok { if OwnerId, ok := v.(int64); ok { args.Query.Set("OwnerId", fmt.Sprint(OwnerId)) } else { return nil, errors.New("OwnerId must be int64") } } if v, ok := optional["ResourceOwnerAccount"]; ok { if ResourceOwnerAccount, ok := v.(string); ok { args.Query.Set("ResourceOwnerAccount", ResourceOwnerAccount) } else { return nil, errors.New("ResourceOwnerAccount must be string") } } if v, ok := optional["ResourceOwnerId"]; ok { if ResourceOwnerId, ok := v.(int64); ok { args.Query.Set("ResourceOwnerId", fmt.Sprint(ResourceOwnerId)) } else { return nil, errors.New("ResourceOwnerId must be int64") } } if v, ok := optional["_method"]; ok { if s, ok := v.(string); ok { if !openapi.IsIn(s, "GET|POST") { return nil, errors.New("_method must be GET|POST") } args.Method = s } else { return nil, errors.New("_method must be string") } } if v, ok := optional["_region"]; ok { if s, ok := v.(string); ok { args.Region = s } else { return nil, errors.New("_region must be string") } } if v, ok := optional["_scheme"]; ok { if s, ok := v.(string); ok { if !openapi.IsIn(s, "http|https") { return nil, errors.New("_scheme must be http|https") } args.Scheme = s } else { return nil, errors.New("_scheme must be string") } } result := new(openapi.Response) if err := api.Service.Do(result, args); err != nil { return nil, err } return result, nil }
func (p *Pattern) String() string { var output string // Output Version & Tempo output += fmt.Sprintln("Saved with HW Version:", p.Version) output += fmt.Sprintln("Tempo:", p.Tempo) // Loop over each track, printing id, name and beats for each one for _, track := range p.Tracks { output += fmt.Sprintf("(%d) %s\t", track.ID, track.Name) // Print the beats by first printing a line each 4 beats, // then printing 'x' for a beat, '-' for a non-beat for k, v := range track.Beats { if k%4 == 0 { output += fmt.Sprint("|") } if v == 1 { output += fmt.Sprint("x") } else { output += fmt.Sprint("-") } } // Add a closing '|' output += fmt.Sprintln("|") } return output }