Merge branch 'master' into key-each

# Conflicts:
#	parser_test.go

parser_test.go

@@ -653,3 +653,164 @@ func TestEachKey(t *testing.T) {
 		t.Errorf("Should find 3 keys: %d", keysFound)
 	}
 }
+
+type ParseTest struct {
+	in     string
+	intype ValueType
+	out    interface{}
+	isErr  bool
+}
+
+var parseBoolTests = []ParseTest{
+	ParseTest{
+		in:     "true",
+		intype: Boolean,
+		out:    true,
+	},
+	ParseTest{
+		in:     "false",
+		intype: Boolean,
+		out:    false,
+	},
+	ParseTest{
+		in:     "foo",
+		intype: Boolean,
+		isErr:  true,
+	},
+	ParseTest{
+		in:     "trux",
+		intype: Boolean,
+		isErr:  true,
+	},
+	ParseTest{
+		in:     "truex",
+		intype: Boolean,
+		isErr:  true,
+	},
+	ParseTest{
+		in:     "",
+		intype: Boolean,
+		isErr:  true,
+	},
+}
+
+var parseFloatTest = []ParseTest{
+	ParseTest{
+		in:     "0",
+		intype: Number,
+		out:    float64(0),
+	},
+	ParseTest{
+		in:     "0.0",
+		intype: Number,
+		out:    float64(0.0),
+	},
+	ParseTest{
+		in:     "1",
+		intype: Number,
+		out:    float64(1),
+	},
+	ParseTest{
+		in:     "1.234",
+		intype: Number,
+		out:    float64(1.234),
+	},
+	ParseTest{
+		in:     "1.234e5",
+		intype: Number,
+		out:    float64(1.234e5),
+	},
+	ParseTest{
+		in:     "-1.234e5",
+		intype: Number,
+		out:    float64(-1.234e5),
+	},
+	ParseTest{
+		in:     "+1.234e5", // Note: + sign not allowed under RFC7159, but our parser accepts it since it uses strconv.ParseFloat
+		intype: Number,
+		out:    float64(1.234e5),
+	},
+	ParseTest{
+		in:     "1.2.3",
+		intype: Number,
+		isErr:  true,
+	},
+	ParseTest{
+		in:     "1..1",
+		intype: Number,
+		isErr:  true,
+	},
+	ParseTest{
+		in:     "1a",
+		intype: Number,
+		isErr:  true,
+	},
+	ParseTest{
+		in:     "",
+		intype: Number,
+		isErr:  true,
+	},
+}
+
+// parseTestCheckNoError checks the error return from Parse*() against the test case expectations.
+// Returns true the test should proceed to checking the actual data returned from Parse*(), or false if the test is finished.
+func parseTestCheckNoError(t *testing.T, testKind string, test ParseTest, value interface{}, err error) bool {
+	if isErr := (err != nil); test.isErr != isErr {
+		// If the call didn't match the error expectation, fail
+		t.Errorf("%s test '%s' isErr mismatch: expected %t, obtained %t (err %v). Obtained value: %v", testKind, test.in, test.isErr, isErr, err, value)
+		return false
+	} else if isErr {
+		// Else, if there was an error, don't fail and don't check isFound or the value
+		return false
+	} else {
+		// Else, there was no error and a value was found, so check the value
+		return true
+	}
+}
+
+func runParseTests(t *testing.T, testKind string, tests []ParseTest, runner func(ParseTest) (interface{}, error), resultChecker func(ParseTest, interface{}) (bool, interface{})) {
+	for _, test := range tests {
+		value, err := runner(test)
+
+		if parseTestCheckNoError(t, testKind, test, value, err) {
+			if test.out == nil {
+				t.Errorf("MALFORMED TEST: %v", test)
+				continue
+			}
+
+			if ok, expected := resultChecker(test, value); !ok {
+				if expectedBytes, ok := expected.([]byte); ok {
+					expected = string(expectedBytes)
+				}
+				if valueBytes, ok := value.([]byte); ok {
+					value = string(valueBytes)
+				}
+				t.Errorf("%s test '%s' expected to return value %v, but did returned %v instead", testKind, test.in, expected, value)
+			}
+		}
+	}
+}
+
+func TestParseBoolean(t *testing.T) {
+	runParseTests(t, "ParseBoolean()", parseBoolTests,
+		func(test ParseTest) (value interface{}, err error) {
+			return ParseBoolean([]byte(test.in))
+		},
+		func(test ParseTest, obtained interface{}) (bool, interface{}) {
+			expected := test.out.(bool)
+			return obtained.(bool) == expected, expected
+		},
+	)
+}
+
+func TestParseFloat(t *testing.T) {
+	runParseTests(t, "ParseFloat()", parseFloatTest,
+		func(test ParseTest) (value interface{}, err error) {
+			return ParseFloat([]byte(test.in))
+		},
+		func(test ParseTest, obtained interface{}) (bool, interface{}) {
+			expected := test.out.(float64)
+			return obtained.(float64) == expected, expected
+		},
+	)
+}