X-Git-Url: http://git.osdn.net/view?p=bytom%2Fvapor.git;a=blobdiff_plain;f=vendor%2Fgithub.com%2Fbtcsuite%2Fbtcd%2Fbtcjson%2Fhelp_test.go;fp=vendor%2Fgithub.com%2Fbtcsuite%2Fbtcd%2Fbtcjson%2Fhelp_test.go;h=0000000000000000000000000000000000000000;hp=265e0c2c60a0288d73add32ad1589920e06ef28c;hb=d09b7a78d44dc259725902b8141cdba0d716b121;hpb=ee01d543fdfe1fd0a4d548965c66f7923ea7b062

diff --git a/vendor/github.com/btcsuite/btcd/btcjson/help_test.go b/vendor/github.com/btcsuite/btcd/btcjson/help_test.go
deleted file mode 100644
index 265e0c2c..00000000
--- a/vendor/github.com/btcsuite/btcd/btcjson/help_test.go
+++ /dev/null
@@ -1,737 +0,0 @@
-// Copyright (c) 2014 The btcsuite developers
-// Use of this source code is governed by an ISC
-// license that can be found in the LICENSE file.
-
-package btcjson_test
-
-import (
-	"reflect"
-	"testing"
-
-	"github.com/btcsuite/btcd/btcjson"
-)
-
-// TestHelpReflectInternals ensures the various help functions which deal with
-// reflect types work as expected for various Go types.
-func TestHelpReflectInternals(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		reflectType reflect.Type
-		indentLevel int
-		key         string
-		examples    []string
-		isComplex   bool
-		help        string
-		isInvalid   bool
-	}{
-		{
-			name:        "int",
-			reflectType: reflect.TypeOf(int(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "*int",
-			reflectType: reflect.TypeOf((*int)(nil)),
-			key:         "json-type-value",
-			examples:    []string{"n"},
-			help:        "n (json-type-value) fdk",
-			isInvalid:   true,
-		},
-		{
-			name:        "int8",
-			reflectType: reflect.TypeOf(int8(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "int16",
-			reflectType: reflect.TypeOf(int16(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "int32",
-			reflectType: reflect.TypeOf(int32(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "int64",
-			reflectType: reflect.TypeOf(int64(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "uint",
-			reflectType: reflect.TypeOf(uint(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "uint8",
-			reflectType: reflect.TypeOf(uint8(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "uint16",
-			reflectType: reflect.TypeOf(uint16(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "uint32",
-			reflectType: reflect.TypeOf(uint32(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "uint64",
-			reflectType: reflect.TypeOf(uint64(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n"},
-			help:        "n (json-type-numeric) fdk",
-		},
-		{
-			name:        "float32",
-			reflectType: reflect.TypeOf(float32(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n.nnn"},
-			help:        "n.nnn (json-type-numeric) fdk",
-		},
-		{
-			name:        "float64",
-			reflectType: reflect.TypeOf(float64(0)),
-			key:         "json-type-numeric",
-			examples:    []string{"n.nnn"},
-			help:        "n.nnn (json-type-numeric) fdk",
-		},
-		{
-			name:        "string",
-			reflectType: reflect.TypeOf(""),
-			key:         "json-type-string",
-			examples:    []string{`"json-example-string"`},
-			help:        "\"json-example-string\" (json-type-string) fdk",
-		},
-		{
-			name:        "bool",
-			reflectType: reflect.TypeOf(true),
-			key:         "json-type-bool",
-			examples:    []string{"json-example-bool"},
-			help:        "json-example-bool (json-type-bool) fdk",
-		},
-		{
-			name:        "array of int",
-			reflectType: reflect.TypeOf([1]int{0}),
-			key:         "json-type-arrayjson-type-numeric",
-			examples:    []string{"[n,...]"},
-			help:        "[n,...] (json-type-arrayjson-type-numeric) fdk",
-		},
-		{
-			name:        "slice of int",
-			reflectType: reflect.TypeOf([]int{0}),
-			key:         "json-type-arrayjson-type-numeric",
-			examples:    []string{"[n,...]"},
-			help:        "[n,...] (json-type-arrayjson-type-numeric) fdk",
-		},
-		{
-			name:        "struct",
-			reflectType: reflect.TypeOf(struct{}{}),
-			key:         "json-type-object",
-			examples:    []string{"{", "}\t\t"},
-			isComplex:   true,
-			help:        "{\n} ",
-		},
-		{
-			name:        "struct indent level 1",
-			reflectType: reflect.TypeOf(struct{ field int }{}),
-			indentLevel: 1,
-			key:         "json-type-object",
-			examples: []string{
-				"  \"field\": n,\t(json-type-numeric)\t-field",
-				" },\t\t",
-			},
-			help: "{\n" +
-				" \"field\": n, (json-type-numeric) -field\n" +
-				"}            ",
-			isComplex: true,
-		},
-		{
-			name: "array of struct indent level 0",
-			reflectType: func() reflect.Type {
-				type s struct {
-					field int
-				}
-				return reflect.TypeOf([]s{})
-			}(),
-			key: "json-type-arrayjson-type-object",
-			examples: []string{
-				"[{",
-				" \"field\": n,\t(json-type-numeric)\ts-field",
-				"},...]",
-			},
-			help: "[{\n" +
-				" \"field\": n, (json-type-numeric) s-field\n" +
-				"},...]",
-			isComplex: true,
-		},
-		{
-			name: "array of struct indent level 1",
-			reflectType: func() reflect.Type {
-				type s struct {
-					field int
-				}
-				return reflect.TypeOf([]s{})
-			}(),
-			indentLevel: 1,
-			key:         "json-type-arrayjson-type-object",
-			examples: []string{
-				"  \"field\": n,\t(json-type-numeric)\ts-field",
-				" },...],\t\t",
-			},
-			help: "[{\n" +
-				" \"field\": n, (json-type-numeric) s-field\n" +
-				"},...]",
-			isComplex: true,
-		},
-		{
-			name:        "map",
-			reflectType: reflect.TypeOf(map[string]string{}),
-			key:         "json-type-object",
-			examples: []string{"{",
-				" \"fdk--key\": fdk--value, (json-type-object) fdk--desc",
-				" ...", "}",
-			},
-			help: "{\n" +
-				" \"fdk--key\": fdk--value, (json-type-object) fdk--desc\n" +
-				" ...\n" +
-				"}",
-			isComplex: true,
-		},
-		{
-			name:        "complex",
-			reflectType: reflect.TypeOf(complex64(0)),
-			key:         "json-type-value",
-			examples:    []string{"json-example-unknown"},
-			help:        "json-example-unknown (json-type-value) fdk",
-			isInvalid:   true,
-		},
-	}
-
-	xT := func(key string) string {
-		return key
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		// Ensure the description key is the expected value.
-		key := btcjson.TstReflectTypeToJSONType(xT, test.reflectType)
-		if key != test.key {
-			t.Errorf("Test #%d (%s) unexpected key - got: %v, "+
-				"want: %v", i, test.name, key, test.key)
-			continue
-		}
-
-		// Ensure the generated example is as expected.
-		examples, isComplex := btcjson.TstReflectTypeToJSONExample(xT,
-			test.reflectType, test.indentLevel, "fdk")
-		if isComplex != test.isComplex {
-			t.Errorf("Test #%d (%s) unexpected isComplex - got: %v, "+
-				"want: %v", i, test.name, isComplex,
-				test.isComplex)
-			continue
-		}
-		if len(examples) != len(test.examples) {
-			t.Errorf("Test #%d (%s) unexpected result length - "+
-				"got: %v, want: %v", i, test.name, len(examples),
-				len(test.examples))
-			continue
-		}
-		for j, example := range examples {
-			if example != test.examples[j] {
-				t.Errorf("Test #%d (%s) example #%d unexpected "+
-					"example - got: %v, want: %v", i,
-					test.name, j, example, test.examples[j])
-				continue
-			}
-		}
-
-		// Ensure the generated result type help is as expected.
-		helpText := btcjson.TstResultTypeHelp(xT, test.reflectType, "fdk")
-		if helpText != test.help {
-			t.Errorf("Test #%d (%s) unexpected result help - "+
-				"got: %v, want: %v", i, test.name, helpText,
-				test.help)
-			continue
-		}
-
-		isValid := btcjson.TstIsValidResultType(test.reflectType.Kind())
-		if isValid != !test.isInvalid {
-			t.Errorf("Test #%d (%s) unexpected result type validity "+
-				"- got: %v", i, test.name, isValid)
-			continue
-		}
-	}
-}
-
-// TestResultStructHelp ensures the expected help text format is returned for
-// various Go struct types.
-func TestResultStructHelp(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		reflectType reflect.Type
-		expected    []string
-	}{
-		{
-			name: "empty struct",
-			reflectType: func() reflect.Type {
-				type s struct{}
-				return reflect.TypeOf(s{})
-			}(),
-			expected: nil,
-		},
-		{
-			name: "struct with primitive field",
-			reflectType: func() reflect.Type {
-				type s struct {
-					field int
-				}
-				return reflect.TypeOf(s{})
-			}(),
-			expected: []string{
-				"\"field\": n,\t(json-type-numeric)\ts-field",
-			},
-		},
-		{
-			name: "struct with primitive field and json tag",
-			reflectType: func() reflect.Type {
-				type s struct {
-					Field int `json:"f"`
-				}
-				return reflect.TypeOf(s{})
-			}(),
-			expected: []string{
-				"\"f\": n,\t(json-type-numeric)\ts-f",
-			},
-		},
-		{
-			name: "struct with array of primitive field",
-			reflectType: func() reflect.Type {
-				type s struct {
-					field []int
-				}
-				return reflect.TypeOf(s{})
-			}(),
-			expected: []string{
-				"\"field\": [n,...],\t(json-type-arrayjson-type-numeric)\ts-field",
-			},
-		},
-		{
-			name: "struct with sub-struct field",
-			reflectType: func() reflect.Type {
-				type s2 struct {
-					subField int
-				}
-				type s struct {
-					field s2
-				}
-				return reflect.TypeOf(s{})
-			}(),
-			expected: []string{
-				"\"field\": {\t(json-type-object)\ts-field",
-				"{",
-				" \"subfield\": n,\t(json-type-numeric)\ts2-subfield",
-				"}\t\t",
-			},
-		},
-		{
-			name: "struct with sub-struct field pointer",
-			reflectType: func() reflect.Type {
-				type s2 struct {
-					subField int
-				}
-				type s struct {
-					field *s2
-				}
-				return reflect.TypeOf(s{})
-			}(),
-			expected: []string{
-				"\"field\": {\t(json-type-object)\ts-field",
-				"{",
-				" \"subfield\": n,\t(json-type-numeric)\ts2-subfield",
-				"}\t\t",
-			},
-		},
-		{
-			name: "struct with array of structs field",
-			reflectType: func() reflect.Type {
-				type s2 struct {
-					subField int
-				}
-				type s struct {
-					field []s2
-				}
-				return reflect.TypeOf(s{})
-			}(),
-			expected: []string{
-				"\"field\": [{\t(json-type-arrayjson-type-object)\ts-field",
-				"[{",
-				" \"subfield\": n,\t(json-type-numeric)\ts2-subfield",
-				"},...]",
-			},
-		},
-	}
-
-	xT := func(key string) string {
-		return key
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		results := btcjson.TstResultStructHelp(xT, test.reflectType, 0)
-		if len(results) != len(test.expected) {
-			t.Errorf("Test #%d (%s) unexpected result length - "+
-				"got: %v, want: %v", i, test.name, len(results),
-				len(test.expected))
-			continue
-		}
-		for j, result := range results {
-			if result != test.expected[j] {
-				t.Errorf("Test #%d (%s) result #%d unexpected "+
-					"result - got: %v, want: %v", i,
-					test.name, j, result, test.expected[j])
-				continue
-			}
-		}
-	}
-}
-
-// TestHelpArgInternals ensures the various help functions which deal with
-// arguments work as expected for various argument types.
-func TestHelpArgInternals(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		method      string
-		reflectType reflect.Type
-		defaults    map[int]reflect.Value
-		help        string
-	}{
-		{
-			name:   "command with no args",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct{}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			defaults: nil,
-			help:     "",
-		},
-		{
-			name:   "command with one required arg",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct {
-					Field int
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			defaults: nil,
-			help:     "1. field (json-type-numeric, help-required) test-field\n",
-		},
-		{
-			name:   "command with one optional arg, no default",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct {
-					Optional *int
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			defaults: nil,
-			help:     "1. optional (json-type-numeric, help-optional) test-optional\n",
-		},
-		{
-			name:   "command with one optional arg with default",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct {
-					Optional *string
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			defaults: func() map[int]reflect.Value {
-				defVal := "test"
-				return map[int]reflect.Value{
-					0: reflect.ValueOf(&defVal),
-				}
-			}(),
-			help: "1. optional (json-type-string, help-optional, help-default=\"test\") test-optional\n",
-		},
-		{
-			name:   "command with struct field",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s2 struct {
-					F int8
-				}
-				type s struct {
-					Field s2
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			defaults: nil,
-			help: "1. field (json-type-object, help-required) test-field\n" +
-				"{\n" +
-				" \"f\": n, (json-type-numeric) s2-f\n" +
-				"}        \n",
-		},
-		{
-			name:   "command with map field",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct {
-					Field map[string]float64
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			defaults: nil,
-			help: "1. field (json-type-object, help-required) test-field\n" +
-				"{\n" +
-				" \"test-field--key\": test-field--value, (json-type-object) test-field--desc\n" +
-				" ...\n" +
-				"}\n",
-		},
-		{
-			name:   "command with slice of primitives field",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct {
-					Field []int64
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			defaults: nil,
-			help:     "1. field (json-type-arrayjson-type-numeric, help-required) test-field\n",
-		},
-		{
-			name:   "command with slice of structs field",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s2 struct {
-					F int64
-				}
-				type s struct {
-					Field []s2
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			defaults: nil,
-			help: "1. field (json-type-arrayjson-type-object, help-required) test-field\n" +
-				"[{\n" +
-				" \"f\": n, (json-type-numeric) s2-f\n" +
-				"},...]\n",
-		},
-	}
-
-	xT := func(key string) string {
-		return key
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		help := btcjson.TstArgHelp(xT, test.reflectType, test.defaults,
-			test.method)
-		if help != test.help {
-			t.Errorf("Test #%d (%s) unexpected help - got:\n%v\n"+
-				"want:\n%v", i, test.name, help, test.help)
-			continue
-		}
-	}
-}
-
-// TestMethodHelp ensures the method help function works as expected for various
-// command structs.
-func TestMethodHelp(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		method      string
-		reflectType reflect.Type
-		defaults    map[int]reflect.Value
-		resultTypes []interface{}
-		help        string
-	}{
-		{
-			name:   "command with no args or results",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct{}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			help: "test\n\ntest--synopsis\n\n" +
-				"help-arguments:\nhelp-arguments-none\n\n" +
-				"help-result:\nhelp-result-nothing\n",
-		},
-		{
-			name:   "command with no args and one primitive result",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct{}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			resultTypes: []interface{}{(*int64)(nil)},
-			help: "test\n\ntest--synopsis\n\n" +
-				"help-arguments:\nhelp-arguments-none\n\n" +
-				"help-result:\nn (json-type-numeric) test--result0\n",
-		},
-		{
-			name:   "command with no args and two results",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct{}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			resultTypes: []interface{}{(*int64)(nil), nil},
-			help: "test\n\ntest--synopsis\n\n" +
-				"help-arguments:\nhelp-arguments-none\n\n" +
-				"help-result (test--condition0):\nn (json-type-numeric) test--result0\n\n" +
-				"help-result (test--condition1):\nhelp-result-nothing\n",
-		},
-		{
-			name:   "command with primitive arg and no results",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct {
-					Field bool
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			help: "test field\n\ntest--synopsis\n\n" +
-				"help-arguments:\n1. field (json-type-bool, help-required) test-field\n\n" +
-				"help-result:\nhelp-result-nothing\n",
-		},
-		{
-			name:   "command with primitive optional and no results",
-			method: "test",
-			reflectType: func() reflect.Type {
-				type s struct {
-					Field *bool
-				}
-				return reflect.TypeOf((*s)(nil))
-			}(),
-			help: "test (field)\n\ntest--synopsis\n\n" +
-				"help-arguments:\n1. field (json-type-bool, help-optional) test-field\n\n" +
-				"help-result:\nhelp-result-nothing\n",
-		},
-	}
-
-	xT := func(key string) string {
-		return key
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		help := btcjson.TestMethodHelp(xT, test.reflectType,
-			test.defaults, test.method, test.resultTypes)
-		if help != test.help {
-			t.Errorf("Test #%d (%s) unexpected help - got:\n%v\n"+
-				"want:\n%v", i, test.name, help, test.help)
-			continue
-		}
-	}
-}
-
-// TestGenerateHelpErrors ensures the GenerateHelp function returns the expected
-// errors.
-func TestGenerateHelpErrors(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name        string
-		method      string
-		resultTypes []interface{}
-		err         btcjson.Error
-	}{
-		{
-			name:   "unregistered command",
-			method: "boguscommand",
-			err:    btcjson.Error{ErrorCode: btcjson.ErrUnregisteredMethod},
-		},
-		{
-			name:        "non-pointer result type",
-			method:      "help",
-			resultTypes: []interface{}{0},
-			err:         btcjson.Error{ErrorCode: btcjson.ErrInvalidType},
-		},
-		{
-			name:        "invalid result type",
-			method:      "help",
-			resultTypes: []interface{}{(*complex64)(nil)},
-			err:         btcjson.Error{ErrorCode: btcjson.ErrInvalidType},
-		},
-		{
-			name:        "missing description",
-			method:      "help",
-			resultTypes: []interface{}{(*string)(nil), nil},
-			err:         btcjson.Error{ErrorCode: btcjson.ErrMissingDescription},
-		},
-	}
-
-	t.Logf("Running %d tests", len(tests))
-	for i, test := range tests {
-		_, err := btcjson.GenerateHelp(test.method, nil,
-			test.resultTypes...)
-		if reflect.TypeOf(err) != reflect.TypeOf(test.err) {
-			t.Errorf("Test #%d (%s) wrong error - got %T (%[2]v), "+
-				"want %T", i, test.name, err, test.err)
-			continue
-		}
-		gotErrorCode := err.(btcjson.Error).ErrorCode
-		if gotErrorCode != test.err.ErrorCode {
-			t.Errorf("Test #%d (%s) mismatched error code - got "+
-				"%v (%v), want %v", i, test.name, gotErrorCode,
-				err, test.err.ErrorCode)
-			continue
-		}
-	}
-}
-
-// TestGenerateHelp performs a very basic test to ensure GenerateHelp is working
-// as expected.  The internal are testd much more thoroughly in other tests, so
-// there is no need to add more tests here.
-func TestGenerateHelp(t *testing.T) {
-	t.Parallel()
-
-	descs := map[string]string{
-		"help--synopsis": "test",
-		"help-command":   "test",
-	}
-	help, err := btcjson.GenerateHelp("help", descs)
-	if err != nil {
-		t.Fatalf("GenerateHelp: unexpected error: %v", err)
-	}
-	wantHelp := "help (\"command\")\n\n" +
-		"test\n\nArguments:\n1. command (string, optional) test\n\n" +
-		"Result:\nNothing\n"
-	if help != wantHelp {
-		t.Fatalf("GenerateHelp: unexpected help - got\n%v\nwant\n%v",
-			help, wantHelp)
-	}
-}