コード例 #1
0
ファイル: keyparam_test.go プロジェクト: jgluck/bazil
func TestKeyParamFlagSetInvalid(t *testing.T) {
	var kp flagx.KeyParam
	v := flag.Value(&kp)
	var hexKey = cas.Invalid.String()
	err := v.Set(hexKey)
	if err == nil {
		t.Fatalf("expected an error from Set: %v", err)
	}
	if g, e := err.Error(), "bad key format"; g != e {
		t.Errorf("bad string value: %v", g)
	}
}
コード例 #2
0
ファイル: keyparam_test.go プロジェクト: jgluck/bazil
func TestKeyParamFlagSetOk(t *testing.T) {
	var kp flagx.KeyParam
	v := flag.Value(&kp)
	const hexKey = "095920158295e252b3cb4728713a987875d210eca00d5b69e89e1d2e2e473153ec3de87ada31787b0d5080cdb0f7dcf15ea1f03cec5fef76df027bcc7d57b337"
	err := v.Set(hexKey)
	if err != nil {
		t.Fatalf("unexpected error from Set: %v", err)
	}
	if g, e := v.String(), hexKey; g != e {
		t.Errorf("bad string value: %v", g)
	}
}
コード例 #3
0
ファイル: keyparam_test.go プロジェクト: jgluck/bazil
func TestKeyParamFlagSetNotHex(t *testing.T) {
	var kp flagx.KeyParam
	v := flag.Value(&kp)
	const hexKey = "i am not even hex!"
	err := v.Set(hexKey)
	if err == nil {
		t.Fatalf("expected an error from Set: %v", err)
	}
	if _, ok := err.(hex.InvalidByteError); !ok {
		t.Fatalf("bad error type Set: %T: %v", err, err)
	}
	if g, e := err.Error(), "encoding/hex: invalid byte: U+0069 'i'"; g != e {
		t.Errorf("bad string value: %v", g)
	}
}
コード例 #4
0
ファイル: keyparam_test.go プロジェクト: jgluck/bazil
func TestKeyParamFlagSetTooShort(t *testing.T) {
	var kp flagx.KeyParam
	v := flag.Value(&kp)
	const hexKey = "ff"
	err := v.Set(hexKey)
	if err == nil {
		t.Fatalf("expected an error from Set: %v", err)
	}
	err2, ok := err.(*cas.BadKeySizeError)
	if !ok {
		t.Fatalf("bad error type Set: %T: %v", err, err)
	}
	if g, e := string(err2.Key), "\xFF"; g != e {
		t.Errorf("bad error detail: %x", g)
	}
	if g, e := err2.Error(), "Key is bad length 1: ff"; g != e {
		t.Errorf("bad string value: %v", g)
	}
}
コード例 #5
0
ファイル: debug.go プロジェクト: carriercomm/interplanetary
package fstestutil

import (
	"flag"
	"log"
	"strconv"

	"github.com/maybebtc/interplanetary/Godeps/_workspace/src/bazil.org/fuse"
)

type flagDebug bool

var debug flagDebug

var _ = flag.Value(&debug)

func (f *flagDebug) IsBoolFlag() bool {
	return true
}

func nop(msg interface{}) {}

func (f *flagDebug) Set(s string) error {
	v, err := strconv.ParseBool(s)
	if err != nil {
		return err
	}
	*f = flagDebug(v)
	if v {
		fuse.Debug = logMsg
	} else {
コード例 #6
0
ファイル: regexpflag.go プロジェクト: nicksnyder/pdscviz
package main

import (
	"flag"
	"regexp"
)

type RegexpValue struct {
	regexp *regexp.Regexp
}

func (rv *RegexpValue) Set(s string) error {
	var err error
	rv.regexp, err = regexp.Compile(s)
	return err
}

func (rv *RegexpValue) String() string {
	if rv.regexp == nil {
		return ""
	}
	return rv.regexp.String()
}

var _ = flag.Value(&RegexpValue{})
コード例 #7
0
ファイル: stringmapflag.go プロジェクト: shishkander/luci-go
// map[string]string {"foo": "bar", "baz": ""}
package stringmapflag

import (
	"flag"
	"fmt"
	"sort"
	"strings"
)

// Value is a flag.Value implementation that stores arbitrary "key[=value]"
// command-line flags as a string map.
type Value map[string]string

// Assert that Value conforms to the "flag.Value" interface.
var _ = flag.Value(new(Value))

func (v *Value) String() string {
	if len(*v) == 0 {
		return ""
	}

	keys := make([]string, 0, len(*v))
	for k := range *v {
		keys = append(keys, k)
	}
	sort.Strings(keys)

	for idx, k := range keys {
		if value := (*v)[k]; value != "" {
			keys[idx] = fmt.Sprintf("%s=%s", k, value)
コード例 #8
0
ファイル: abspath.go プロジェクト: jgluck/bazil
package flagx

import (
	"errors"
	"flag"
	"path/filepath"
)

// AbsPath returns a flag.Value that wraps the given string and sets
// it to an absolute path.
type AbsPath string

var _ = flag.Value(new(AbsPath))

func (a AbsPath) String() string {
	return string(a)
}

var EmptyPathError = errors.New("empty path not allowed")

func (a *AbsPath) Set(value string) error {
	if value == "" {
		return EmptyPathError
	}
	path, err := filepath.Abs(value)
	if err != nil {
		return err
	}
	*a = AbsPath(path)
	return nil
}