From 54d3d47daf9190275bbdaf8703b84969a4593451 Mon Sep 17 00:00:00 2001
From: Corey Hulen <corey@hulen.com>
Date: Fri, 24 Mar 2017 23:31:34 -0700
Subject: PLT-6076 Adding viper libs for config file changes (#5871)

* Adding viper libs for config file changes

* Removing the old fsnotify lib

* updating some missing libs
---
 .../magiconair/properties/decode_test.go           | 299 +++++++++++++++++++++
 1 file changed, 299 insertions(+)
 create mode 100644 vendor/github.com/magiconair/properties/decode_test.go

(limited to 'vendor/github.com/magiconair/properties/decode_test.go')

diff --git a/vendor/github.com/magiconair/properties/decode_test.go b/vendor/github.com/magiconair/properties/decode_test.go
new file mode 100644
index 000000000..c82931482
--- /dev/null
+++ b/vendor/github.com/magiconair/properties/decode_test.go
@@ -0,0 +1,299 @@
+// Copyright 2017 Frank Schroeder. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package properties
+
+import (
+	"reflect"
+	"testing"
+	"time"
+)
+
+func TestDecodeValues(t *testing.T) {
+	type S struct {
+		S   string
+		BT  bool
+		BF  bool
+		I   int
+		I8  int8
+		I16 int16
+		I32 int32
+		I64 int64
+		U   uint
+		U8  uint8
+		U16 uint16
+		U32 uint32
+		U64 uint64
+		F32 float32
+		F64 float64
+		D   time.Duration
+		TM  time.Time
+	}
+	in := `
+	S=abc
+	BT=true
+	BF=false
+	I=-1
+	I8=-8
+	I16=-16
+	I32=-32
+	I64=-64
+	U=1
+	U8=8
+	U16=16
+	U32=32
+	U64=64
+	F32=3.2
+	F64=6.4
+	D=5s
+	TM=2015-01-02T12:34:56Z
+	`
+	out := &S{
+		S:   "abc",
+		BT:  true,
+		BF:  false,
+		I:   -1,
+		I8:  -8,
+		I16: -16,
+		I32: -32,
+		I64: -64,
+		U:   1,
+		U8:  8,
+		U16: 16,
+		U32: 32,
+		U64: 64,
+		F32: 3.2,
+		F64: 6.4,
+		D:   5 * time.Second,
+		TM:  tm(t, time.RFC3339, "2015-01-02T12:34:56Z"),
+	}
+	testDecode(t, in, &S{}, out)
+}
+
+func TestDecodeValueDefaults(t *testing.T) {
+	type S struct {
+		S   string        `properties:",default=abc"`
+		BT  bool          `properties:",default=true"`
+		BF  bool          `properties:",default=false"`
+		I   int           `properties:",default=-1"`
+		I8  int8          `properties:",default=-8"`
+		I16 int16         `properties:",default=-16"`
+		I32 int32         `properties:",default=-32"`
+		I64 int64         `properties:",default=-64"`
+		U   uint          `properties:",default=1"`
+		U8  uint8         `properties:",default=8"`
+		U16 uint16        `properties:",default=16"`
+		U32 uint32        `properties:",default=32"`
+		U64 uint64        `properties:",default=64"`
+		F32 float32       `properties:",default=3.2"`
+		F64 float64       `properties:",default=6.4"`
+		D   time.Duration `properties:",default=5s"`
+		TM  time.Time     `properties:",default=2015-01-02T12:34:56Z"`
+	}
+	out := &S{
+		S:   "abc",
+		BT:  true,
+		BF:  false,
+		I:   -1,
+		I8:  -8,
+		I16: -16,
+		I32: -32,
+		I64: -64,
+		U:   1,
+		U8:  8,
+		U16: 16,
+		U32: 32,
+		U64: 64,
+		F32: 3.2,
+		F64: 6.4,
+		D:   5 * time.Second,
+		TM:  tm(t, time.RFC3339, "2015-01-02T12:34:56Z"),
+	}
+	testDecode(t, "", &S{}, out)
+}
+
+func TestDecodeArrays(t *testing.T) {
+	type S struct {
+		S   []string
+		B   []bool
+		I   []int
+		I8  []int8
+		I16 []int16
+		I32 []int32
+		I64 []int64
+		U   []uint
+		U8  []uint8
+		U16 []uint16
+		U32 []uint32
+		U64 []uint64
+		F32 []float32
+		F64 []float64
+		D   []time.Duration
+		TM  []time.Time
+	}
+	in := `
+	S=a;b
+	B=true;false
+	I=-1;-2
+	I8=-8;-9
+	I16=-16;-17
+	I32=-32;-33
+	I64=-64;-65
+	U=1;2
+	U8=8;9
+	U16=16;17
+	U32=32;33
+	U64=64;65
+	F32=3.2;3.3
+	F64=6.4;6.5
+	D=4s;5s
+	TM=2015-01-01T00:00:00Z;2016-01-01T00:00:00Z
+	`
+	out := &S{
+		S:   []string{"a", "b"},
+		B:   []bool{true, false},
+		I:   []int{-1, -2},
+		I8:  []int8{-8, -9},
+		I16: []int16{-16, -17},
+		I32: []int32{-32, -33},
+		I64: []int64{-64, -65},
+		U:   []uint{1, 2},
+		U8:  []uint8{8, 9},
+		U16: []uint16{16, 17},
+		U32: []uint32{32, 33},
+		U64: []uint64{64, 65},
+		F32: []float32{3.2, 3.3},
+		F64: []float64{6.4, 6.5},
+		D:   []time.Duration{4 * time.Second, 5 * time.Second},
+		TM:  []time.Time{tm(t, time.RFC3339, "2015-01-01T00:00:00Z"), tm(t, time.RFC3339, "2016-01-01T00:00:00Z")},
+	}
+	testDecode(t, in, &S{}, out)
+}
+
+func TestDecodeArrayDefaults(t *testing.T) {
+	type S struct {
+		S   []string        `properties:",default=a;b"`
+		B   []bool          `properties:",default=true;false"`
+		I   []int           `properties:",default=-1;-2"`
+		I8  []int8          `properties:",default=-8;-9"`
+		I16 []int16         `properties:",default=-16;-17"`
+		I32 []int32         `properties:",default=-32;-33"`
+		I64 []int64         `properties:",default=-64;-65"`
+		U   []uint          `properties:",default=1;2"`
+		U8  []uint8         `properties:",default=8;9"`
+		U16 []uint16        `properties:",default=16;17"`
+		U32 []uint32        `properties:",default=32;33"`
+		U64 []uint64        `properties:",default=64;65"`
+		F32 []float32       `properties:",default=3.2;3.3"`
+		F64 []float64       `properties:",default=6.4;6.5"`
+		D   []time.Duration `properties:",default=4s;5s"`
+		TM  []time.Time     `properties:",default=2015-01-01T00:00:00Z;2016-01-01T00:00:00Z"`
+	}
+	out := &S{
+		S:   []string{"a", "b"},
+		B:   []bool{true, false},
+		I:   []int{-1, -2},
+		I8:  []int8{-8, -9},
+		I16: []int16{-16, -17},
+		I32: []int32{-32, -33},
+		I64: []int64{-64, -65},
+		U:   []uint{1, 2},
+		U8:  []uint8{8, 9},
+		U16: []uint16{16, 17},
+		U32: []uint32{32, 33},
+		U64: []uint64{64, 65},
+		F32: []float32{3.2, 3.3},
+		F64: []float64{6.4, 6.5},
+		D:   []time.Duration{4 * time.Second, 5 * time.Second},
+		TM:  []time.Time{tm(t, time.RFC3339, "2015-01-01T00:00:00Z"), tm(t, time.RFC3339, "2016-01-01T00:00:00Z")},
+	}
+	testDecode(t, "", &S{}, out)
+}
+
+func TestDecodeSkipUndef(t *testing.T) {
+	type S struct {
+		X     string `properties:"-"`
+		Undef string `properties:",default=some value"`
+	}
+	in := `X=ignore`
+	out := &S{"", "some value"}
+	testDecode(t, in, &S{}, out)
+}
+
+func TestDecodeStruct(t *testing.T) {
+	type A struct {
+		S string
+		T string `properties:"t"`
+		U string `properties:"u,default=uuu"`
+	}
+	type S struct {
+		A A
+		B A `properties:"b"`
+	}
+	in := `
+	A.S=sss
+	A.t=ttt
+	b.S=SSS
+	b.t=TTT
+	`
+	out := &S{
+		A{S: "sss", T: "ttt", U: "uuu"},
+		A{S: "SSS", T: "TTT", U: "uuu"},
+	}
+	testDecode(t, in, &S{}, out)
+}
+
+func TestDecodeMap(t *testing.T) {
+	type S struct {
+		A string `properties:"a"`
+	}
+	type X struct {
+		A map[string]string
+		B map[string][]string
+		C map[string]map[string]string
+		D map[string]S
+		E map[string]int
+		F map[string]int `properties:"-"`
+	}
+	in := `
+	A.foo=bar
+	A.bar=bang
+	B.foo=a;b;c
+	B.bar=1;2;3
+	C.foo.one=1
+	C.foo.two=2
+	C.bar.three=3
+	C.bar.four=4
+	D.foo.a=bar
+	`
+	out := &X{
+		A: map[string]string{"foo": "bar", "bar": "bang"},
+		B: map[string][]string{"foo": []string{"a", "b", "c"}, "bar": []string{"1", "2", "3"}},
+		C: map[string]map[string]string{"foo": map[string]string{"one": "1", "two": "2"}, "bar": map[string]string{"three": "3", "four": "4"}},
+		D: map[string]S{"foo": S{"bar"}},
+		E: map[string]int{},
+	}
+	testDecode(t, in, &X{}, out)
+}
+
+func testDecode(t *testing.T, in string, v, out interface{}) {
+	p, err := parse(in)
+	if err != nil {
+		t.Fatalf("got %v want nil", err)
+	}
+	if err := p.Decode(v); err != nil {
+		t.Fatalf("got %v want nil", err)
+	}
+	if got, want := v, out; !reflect.DeepEqual(got, want) {
+		t.Fatalf("\ngot  %+v\nwant %+v", got, want)
+	}
+}
+
+func tm(t *testing.T, layout, s string) time.Time {
+	tm, err := time.Parse(layout, s)
+	if err != nil {
+		t.Fatalf("got %v want nil", err)
+	}
+	return tm
+}
-- 
cgit v1.2.3-1-g7c22