Пример #1
0
func String(s fmt.Stringer) string {
	if reflect.ValueOf(s).IsNil() {
		return ""
	}

	return s.String()
}
Пример #2
0
func TestGraphSupportsDownCasting(t *testing.T) {
	RegisterTestingT(t)

	graph := inject.NewGraph()

	var (
		d fmt.Stringer
	)

	graph.Define(&d, inject.NewProvider(NewD))
	graph.ResolveAll()

	Expect(d).To(Equal(NewD()))
	Expect(d.String()).To(Equal("&ImplD{}"))

	expectedString := `&graph\{
  definitions: \[
    &definition\{
      ptr: \*fmt\.Stringer=0x.*,
      provider: &provider\{
        constructor: func\(\) \*test\.ImplD,
        argPtrs: \[\]
      \},
      value: <\*test\.ImplD Value>
    \}
  \]
\}`
	Expect(graph.String()).To(MatchRegexp(expectedString))
}
Пример #3
0
func TestInterfaces(t *testing.T) {
	db, err := bolt.Open("my4.db", 0600, nil)
	if err != nil {
		t.Error(err.Error())
	}
	defer os.Remove("my4.db")
	defer db.Close()

	s := NewStore(db, []byte("interface"))

	var j fmt.Stringer = &MyType{"First", "Last"}
	s.Put([]byte("test"), &j)

	err = s.ForEach(func(str fmt.Stringer) {
		if str.String() != "First Last" {
			t.Errorf("unexpected string %s", str)
		}
	})
	if err != nil {
		t.Error(err.Error())
	}

	var i fmt.Stringer
	err = s.Get([]byte("test"), &i)
	if err != nil {
		t.Error(err.Error())
	} else {
		if i.String() != "First Last" {
			t.Errorf("unexpected string %s", i)
		}
	}
}
Пример #4
0
// Insert adds a new item to the hash map or, if the key already exists,
// replaces the current item with the new one.
func (pm *ParMap) Insert(item fmt.Stringer) {
	key := item.String()
	shard := pm.getShard(key)
	shard.mutex.Lock()
	shard.index[key] = item
	shard.mutex.Unlock()
}
func testStringMatch(t *testing.T, s fmt.Stringer, expected string) {
	actual := strings.TrimSpace(s.String())
	expected = strings.TrimSpace(expected)
	if actual != expected {
		t.Fatalf("Actual\n\n%s\n\nExpected:\n\n%s", actual, expected)
	}
}
func assert(t *testing.T, o fmt.Stringer, s string) {
	if o.String() != s {
		t.Log("Expected object to be resolved differently as a String:")
		t.Logf("Object: %#v", o)
		t.Logf("Expected: %q", s)
		t.Fatalf("Got: %q", o.String())
	}
}
Пример #7
0
func (v *ASTStringer) AddWithFallback(color string, what fmt.Stringer, fallback string) *ASTStringer {
	if !isNil(what) {
		v.AddStringColored(color, what.String())
	} else {
		v.AddStringColored(color, fallback)
	}
	return v
}
Пример #8
0
func (cLogger *commonLogger) processLogMsg(level LogLevel, message fmt.Stringer, context LogContextInterface) {
	defer func() {
		if err := recover(); err != nil {
			reportInternalError(fmt.Errorf("recovered from panic during message processing: %s", err))
		}
	}()
	if cLogger.config.IsAllowed(level, context) {
		cLogger.config.RootDispatcher.Dispatch(message.String(), level, context, reportInternalError)
	}
}
Пример #9
0
// Lookup finds the first node in the current scope by name.
func (s *Scope) Lookup(token fmt.Stringer) (ssa.Node, error) {
	name := token.String()
	if s.Empty() {
		return nil, fmt.Errorf("can't find a node '%s' in an empty scope stack", name)
	}
	for _, symtab := range s.stack.list {
		if symtab.contains(name) {
			return symtab.get(name)
		}
	}
	return nil, fmt.Errorf("'%s' not yet declared", name)
}
Пример #10
0
func safeString(str fmt.Stringer) (s string, ok bool) {
	defer func() {
		if panicVal := recover(); panicVal != nil {
			if v := reflect.ValueOf(str); v.Kind() == reflect.Ptr && v.IsNil() {
				s, ok = "null", false
			} else {
				panic(panicVal)
			}
		}
	}()
	s, ok = str.String(), true
	return
}
Пример #11
0
func safeString(str fmt.Stringer) (s string) {
	defer func() {
		if panicVal := recover(); panicVal != nil {
			if v := reflect.ValueOf(str); v.Kind() == reflect.Ptr && v.IsNil() {
				s = "NULL"
			} else {
				panic(panicVal)
			}
		}
	}()
	s = str.String()
	return
}
Пример #12
0
// Global sets a node and its name in the global scope.
func (s *Scope) Global(token fmt.Stringer, n ssa.Node) error {
	name := token.String()
	symtab, err := s.stack.bottom()
	if err != nil {
		return err
	}
	if symtab.contains(name) {
		return fmt.Errorf("'%s' already declared globally", name)
	}
	err = symtab.set(name, n)
	if err != nil {
		return err
	}
	return nil
}
Пример #13
0
func (cLogger *commonLogger) processLogMsg(
	level LogLevel,
	message fmt.Stringer,
	context logContextInterface) {

	defer func() {
		if err := recover(); err != nil {
			fmt.Println(err)
		}
	}()

	if cLogger.config.IsAllowed(level, context) {
		cLogger.config.RootDispatcher.Dispatch(message.String(), level, context, reportInternalError)
	}
}
Пример #14
0
// Add adds a name to the topmost scope in the scope stack.
func (s *Scope) Add(token fmt.Stringer, n ssa.Node) error {
	name := token.String()
	if s.Contains(name) {
		return fmt.Errorf("'%s' already declared", name)
	}
	symtab, err := s.stack.peek()
	if err != nil {
		return err
	}
	err = symtab.set(name, n)
	if err != nil {
		return err
	}
	return nil
}
Пример #15
0
func TestNXTStringer(t *testing.T) {
	name, devicePath := "testingbot", "/dev/tty-foobar"
	var n fmt.Stringer
	n = NewNXT(name, devicePath)

	if n == nil {
		t.Errorf("Calling NewNXT should not result in a nil NXT instance.")
		return
	}

	expected, actual := fmt.Sprintf("NXT \"%s\": %s", name, devicePath), n.String()
	if actual != expected {
		t.Errorf("Expected NXT.String to return \"%s\", but got \"%s\" instead", expected, actual)
	}
}
Пример #16
0
func (w *Web) pathDealer(re *regexp.Regexp, str fmt.Stringer) {
	names := re.SubexpNames()
	matches := re.FindStringSubmatch(str.String())

	for key, name := range names {
		if name != "" {
			w.Param.Set(name, matches[key])
		}
	}

	switch str.(type) {
	case pathStr:
		w.pri.curpath += matches[0]
		w.pri.path = w.pri.path[re.FindStringIndex(w.pri.path)[1]:]
	}
}
Пример #17
0
// Trust takes a name token and node that has not yet been defined and "trusts"
// that it will be defined later according to the node type values that were
// implied by the parser.
func (t *TBV) Trust(token fmt.Stringer, node ssa.Node) {
	name := token.String()
	if _, ok := t.table[name]; ok {
		// p.enter()("'" + name + "' is already being trusted.")
	} else {
		t.table[name] = node
	}
}
Пример #18
0
// SendSync sends SYNC message to the writer, tagging it as sent from node,
// described by given source and adding optional description for the given
// SYNC phase taken by extraction it from the original SYNC message, sent
// by node.
func (protocol *syncProtocol) SendSync(
	source fmt.Stringer,
	sync string,
) error {
	data := strings.TrimSpace(
		strings.TrimPrefix(sync, protocol.prefix+" "+syncProtocolSync),
	)

	_, err := io.WriteString(
		protocol.output,
		syncProtocolSync+" "+source.String()+" "+data+"\n",
	)

	if err != nil {
		return protocolSuspendEOF(err)
	}

	return nil
}
Пример #19
0
//AddValue ajoute dans la BD
func (dbManager *DbManager) AddValue(bucketName string, key string, object fmt.Stringer) error {

	err := dbManager.db.Update(func(tx *bolt.Tx) error {
		bucket, err := tx.CreateBucketIfNotExists([]byte(bucketName))
		if err != nil {
			return err
		}

		encoded := object.String()

		return bucket.Put([]byte(key), []byte(encoded))
	})

	if err == nil {
		logger.Print("Ajout de " + key + " dans la bd")
	} else {
		logger.Error("Erreur lors de l'ajout dans la bd", err)
	}

	return nil
}
Пример #20
0
// Verify verifies that the provided token and node match with a corresponding
// pair that were trusted previously.
func (t *TBV) Verify(tok fmt.Stringer, node ssa.Node) (bool, error) {

	name := tok.String()

	// check if the node is present in the TBV table
	if trustNode, ok := t.table[name]; ok {

		if trustNode.Type() != node.Type() {
			return true, errors.New("mismatch types")
		}

		switch trustNode.Type().Token() {
		case token.FUNC:

			trustFuncType := trustNode.Type().(*types.Func)
			funcType := node.Type().(*types.Func)

			if trustFuncType.Value() != nil {
				if trustFuncType.Value() != funcType.Value() {
					return false, errors.New("The function '" + name + "' must return either a type " + trustFuncType.Value().String() + " or " + funcType.Value().String() + ". Not both.")
				}
			}
			if trustFuncType.Arity() != funcType.Arity() {
				return false, errors.New("Number of arguments do not match.")
			}
			trustParam := trustFuncType.Param()
			param := funcType.Param()
			for param != nil {
				if param != trustParam {
					return false, errors.New("Parameter types are off.")
				}
				param = param.Next()
				trustParam = trustParam.Next()
			}
			return true, nil
		}
	}
	return false, nil
}
Пример #21
0
func (self *defaultLogger) output(s Severity, msg fmt.Stringer) {
	if s > self.severity {
		return
	}

	self.mu.Lock()
	defer self.mu.Unlock()

	ctx := newRuntimeContext(s, msg.String(), time.Now())
	final := bytes.NewBufferString(self.formatter.Format(ctx))
	if !bytes.HasSuffix(final.Bytes(), []byte("\n")) {
		final.WriteString("\n")
	}

	if err := self.out.Dispatch(s, final.Bytes()); err != nil {
		fmt.Fprintf(os.Stderr, "Couldn't dispatch msg (%s): %s\n", final, err)
		return
	}

	if s == SeverityFatal {
		fmt.Fprintf(os.Stderr, "Abort with backtrace for debugging purpose:\n%s\n", stack(false))
		os.Exit(255)
	}
}
Пример #22
0
// Contains checks if a token name appears in TBV table.
func (t TBV) Contains(token fmt.Stringer) bool {
	name := token.String()
	_, ok := t.table[name]
	return ok
}
Пример #23
0
func stringer(s fmt.Stringer) string {
	return s.String()
}
Пример #24
0
// Value returns the value associated with this context for key
func (p *testFromSuit) Value(key fmt.Stringer) interface{} {
	return p.vars[key.String()]
}
Пример #25
0
// SetValue saves a value associated with this context for key
func (p *testFromSuit) SetValue(key fmt.Stringer, value interface{}) {
	p.vars[key.String()] = value
}
Пример #26
0
func main() {
	// int, float32, float64, string, bool, byte
	var a int
	a = 11
	var hello string
	hello = "Hello, World!"
	var b byte
	b = 10
	fmt.Println(hello)
	fmt.Printf("Number: %d\n", a)
	fmt.Println("Byte:", b)

	// run-time error
	//n := 0
	//num := 100 / n
	//fmt.Println(num)

	// compile-time error
	//num := 100 / 0
	//fmt.Println(num)

	//name := getName()
	//fmt.Println("Hello", name)

	//name = getName1()
	//fmt.Println("Hello", name)

	for i := 0; i < 10; i++ {
		fmt.Print(i)
		fmt.Print(" ")
	}
	fmt.Println()

	i := 0
	switch i {
	default:
		fmt.Println("Default")
	case 0, 1:
		fmt.Println("Zero or One")
		// The line below is used when we want the code to fall through the case below
		//fallthrough
	case 2:
		fmt.Println("Two")
	}

	// infinite loop
	//for {
	//fmt.Println("Hello")
	//}

	for i := 1; i <= 100; i++ {
		fmt.Print(fizzbuzz(i))
		fmt.Print(" ")
	}
	fmt.Println()

	var nums [5]int
	fmt.Println(nums)

	var x int = 10
	var y int = 20
	x, y = swap(x, y)
	fmt.Println(x, y)
	x, y = y, x
	fmt.Println(x, y)

	//var nums1 []int
	nums1 := []int{}
	nums1 = append(nums1, 1)
	nums1 = append(nums1, 9)
	nums1 = append(nums1, 2, 3)
	fmt.Println(nums1)

	nums2 := [5]int{1, 2, 3, 4, 5}
	var slice []int
	slice = nums2[:3]
	slice[1] = 999
	fmt.Println(nums2)
	fmt.Println(slice)

	nums3 := []int{1, 2, 3, 4, 5}
	var slice1 []int
	slice1 = append(slice1, nums3...)
	fmt.Println(nums3)
	fmt.Println(slice1)

	//m := map[string]string{}
	m := make(map[string]string)
	m["name"] = "Kan"
	m["company"] = "Pronto Marketing"
	fmt.Println(m)

	//m1 := map[string]map[string]string{
	//"p1": map[string]string{
	//"name": "Kan",
	//},
	//}
	m1 := map[string]map[string]string{
		"p1": {
			"name": "Kan",
		},
	}
	fmt.Println(m1)

	arr := [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	fmt.Println(arr)
	fmt.Println(arr[:])
	results := []int{}
	results = even(arr[:])
	fmt.Println(results)
	fmt.Println(arr)

	//var add func(int, int) int = func(a, b int) int {
	var add = func(a, b int) int {
		return a + b
	}
	fmt.Println(add(9, 9))

	fmt.Println(filter(func(n int) bool {
		return n%2 == 0
	}, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
	fmt.Println(filter(isEven, []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))

	num, err := div(100, 0)
	if err != nil {
		fmt.Println("Error:", err)
		//return
	} else {
		fmt.Println(num)
	}

	n := Num(10)
	n.printHello()
	//fmt.Println(n.String())
	//fmt.Println(n)

	// If n does not implement String(), it will have error during the compile time
	var s fmt.Stringer
	s = n
	fmt.Println(s.String())

	var s1 interface{}
	s1 = n

	//ss := s1.(fmt.Stringer)
	//fmt.Println(ss.String())

	// Check if the interface can be converted into Stringer interface
	if ss, ok := s1.(fmt.Stringer); ok {
		fmt.Println(ss.String())
	}

	// The other way to check interface
	// s.(type) can be used only with switch/case
	n2 := NumTest(30)
	var s2 interface{}
	s2 = n2
	switch ss1 := s2.(type) {
	case fmt.Stringer:
		fmt.Println(ss1.String())
	default:
		fmt.Printf("Not fmt.Stringer but is %T\n", s2)
	}

	c := Customer{
		FirstName: "Kan",
		LastName:  "Ouivirach",
		Age:       30,
	}
	fmt.Println(c)
	fmt.Println(c.Name())

	c1 := AnotherCustomer{
		firstName: "Kan",
		lastName:  "Ouivirach",
		age:       30,
	}
	c1.SetFirstName("Pronto")
	fmt.Println(c1.Name())
}
Пример #27
0
// httpPost posts the req using the HTTP client. The call's method is
// appended to the endpoint and set as the URL path. The call's arguments
// are protobuf-serialized and written as the POST body. The content
// type is set to application/x-protobuf.
//
// On success, the response body is unmarshalled into call.Reply.
//
// HTTP response codes which are retryable are retried with backoff in a loop
// using the default retry options. Other errors sending HTTP request are
// retried indefinitely using the same client command ID to avoid reporting
// failure when in fact the command may go through and execute successfully. We
// retry here to eventually get through with the same client command ID and be
// given the cached response.
func httpPost(c postContext, request, response gogoproto.Message, method fmt.Stringer) error {
	// Marshal the args into a request body.
	body, err := gogoproto.Marshal(request)
	if err != nil {
		return err
	}

	sharedClient, err := c.Context.GetHTTPClient()
	if err != nil {
		return err
	}

	// TODO(pmattis): Figure out the right thing to do here. The HTTP client we
	// get back from base.Context has a 3 second timeout. If a client operation
	// takes longer than that it will be retried. If we're not in an explicit
	// transaction the auto-transaction created on the server for the second
	// operation will be different than the still running first operation giving
	// them the potential to stomp on each other.
	client := *sharedClient
	client.Timeout = 60 * time.Second

	url := c.Context.HTTPRequestScheme() + "://" + c.Server + c.Endpoint + method.String()

	var (
		req  *http.Request
		resp *http.Response
		b    []byte
	)

	for r := retry.Start(c.RetryOpts); r.Next(); {
		req, err = http.NewRequest("POST", url, bytes.NewReader(body))
		if err != nil {
			return err
		}
		req.Header.Add(util.ContentTypeHeader, util.ProtoContentType)
		req.Header.Add(util.AcceptHeader, util.ProtoContentType)
		req.Header.Add(util.AcceptEncodingHeader, util.SnappyEncoding)

		resp, err = client.Do(req)
		if err != nil {
			if log.V(1) {
				log.Warning(err)
			}
			continue
		}
		defer resp.Body.Close()

		switch resp.StatusCode {
		case http.StatusOK:
			// We're cool.
		case http.StatusServiceUnavailable, http.StatusGatewayTimeout, StatusTooManyRequests:
			// Retry on service unavailable and request timeout.
			// TODO(spencer): consider respecting the Retry-After header for
			// backoff / retry duration.
			continue
		default:
			// Can't recover from all other errors.
			return errors.New(resp.Status)
		}

		if resp.Header.Get(util.ContentEncodingHeader) == util.SnappyEncoding {
			resp.Body = &snappyReader{body: resp.Body}
		}

		b, err = ioutil.ReadAll(resp.Body)
		if err != nil {
			if log.V(1) {
				log.Warning(err)
			}
			continue
		}
		if err = gogoproto.Unmarshal(b, response); err != nil {
			if log.V(1) {
				log.Warning(err)
			}
			continue
		}

		break
	}
	return err
}
Пример #28
0
func (connection Connection) Send(command fmt.Stringer) {
	connection.writeOut <- command.String()
}
Пример #29
0
// Sign the given item and return a Signature
func (pk PrivateKey) Sign(item fmt.Stringer) (Signature, error) {
	bytes := []byte(item.String())
	return pk.SignBytes(bytes)
}
Пример #30
0
func testMessageParse(t *testing.T, msg fmt.Stringer) {
	res := ParseMessage(msg.String())
	t.Logf("Parsed message is %q", res)
	assert.AssertEquals(t, res[0], msg)
}