Initial commit.
This commit is contained in:
@@ -0,0 +1,740 @@
|
||||
package sec
|
||||
|
||||
import (
|
||||
// stdlib
|
||||
"os"
|
||||
"strconv"
|
||||
"testing"
|
||||
|
||||
// other
|
||||
"github.com/stretchr/testify/require"
|
||||
)
|
||||
|
||||
func TestParseString(t *testing.T) {
|
||||
type testStruct struct {
|
||||
StringData string
|
||||
}
|
||||
|
||||
os.Setenv("TESTSTRUCT_STRINGDATA", "test")
|
||||
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
}
|
||||
|
||||
func TestParseBoolean(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData bool
|
||||
}{
|
||||
{"1", true},
|
||||
{"t", true},
|
||||
{"T", true},
|
||||
{"TRUE", true},
|
||||
{"true", true},
|
||||
{"True", true},
|
||||
{"0", false},
|
||||
{"f", false},
|
||||
{"F", false},
|
||||
{"FALSE", false},
|
||||
{"false", false},
|
||||
{"False", false},
|
||||
{"not a boolean", false},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
BoolData bool
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_BOOLDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.BoolData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotBoolError bool
|
||||
_, err2 := strconv.ParseBool(testCase.TestData)
|
||||
if err2 != nil {
|
||||
checkNotBoolError = true
|
||||
}
|
||||
|
||||
if checkNotBoolError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
require.Equal(t, errNotBool, err1)
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_BOOLDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseInt8(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData int8
|
||||
}{
|
||||
{"0", 0},
|
||||
{"1", 1},
|
||||
{"2", 2},
|
||||
{"-128", -128},
|
||||
{"127", 127},
|
||||
{"-129", 0},
|
||||
{"128", 0},
|
||||
{"not an integer", 0},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
IntData int8
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_INTDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.IntData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != int64(testCase.ValidData) {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotInt, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotInt8, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_INTDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseInt16(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData int16
|
||||
}{
|
||||
{"0", 0},
|
||||
{"1", 1},
|
||||
{"2", 2},
|
||||
{"-32768", -32768},
|
||||
{"32767", 32767},
|
||||
{"-32770", 0},
|
||||
{"32770", 0},
|
||||
{"not an integer", 0},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
IntData int16
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_INTDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.IntData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != int64(testCase.ValidData) {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotInt, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotInt16, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_INTDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseInt32(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData int32
|
||||
}{
|
||||
{"0", 0},
|
||||
{"1", 1},
|
||||
{"2", 2},
|
||||
{"-2147483648", -2147483648},
|
||||
{"2147483647", 2147483647},
|
||||
{"-2147483650", 0},
|
||||
{"2147483650", 0},
|
||||
{"not an integer", 0},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
IntData int32
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_INTDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.IntData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != int64(testCase.ValidData) {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotInt, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotInt32, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_INTDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseInt64(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData int64
|
||||
}{
|
||||
{"0", 0},
|
||||
{"1", 1},
|
||||
{"2", 2},
|
||||
{"-9223372036854775808", -9223372036854775808},
|
||||
{"9223372036854775807", 9223372036854775807},
|
||||
{"-9223372036854775810", -9223372036854775808},
|
||||
{"9223372036854775810", 9223372036854775807},
|
||||
{"not an integer", 0},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
IntData int64
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_INTDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.IntData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseInt(testCase.TestData, 10, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != testCase.ValidData {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotInt, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotInt64, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_INTDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseUint8(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData uint8
|
||||
}{
|
||||
{"0", 0},
|
||||
{"1", 1},
|
||||
{"2", 2},
|
||||
{"255", 255},
|
||||
{"256", 0},
|
||||
{"-1", 0},
|
||||
{"not an integer", 0},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
UintData uint8
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_UINTDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.UintData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != uint64(testCase.ValidData) {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotUint, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotUint8, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_UINTDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseUint16(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData uint16
|
||||
}{
|
||||
{"0", 0},
|
||||
{"1", 1},
|
||||
{"2", 2},
|
||||
{"65535", 65535},
|
||||
{"65536", 0},
|
||||
{"-1", 0},
|
||||
{"not an integer", 0},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
UintData uint16
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_UINTDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.UintData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != uint64(testCase.ValidData) {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotUint, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotUint16, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_UINTDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseUint32(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData uint32
|
||||
}{
|
||||
{"0", 0},
|
||||
{"1", 1},
|
||||
{"2", 2},
|
||||
{"4294967295", 4294967295},
|
||||
{"4294967296", 0},
|
||||
{"-1", 0},
|
||||
{"not an integer", 0},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
UintData uint32
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_UINTDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.UintData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != uint64(testCase.ValidData) {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotUint, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotUint32, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_UINTDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseUint64(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData uint64
|
||||
}{
|
||||
{"0", 0},
|
||||
{"1", 1},
|
||||
{"2", 2},
|
||||
{"18446744073709551615", 18446744073709551615},
|
||||
{"18446744073709551616", 18446744073709551615},
|
||||
{"-1", 0},
|
||||
{"not an integer", 0},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
UintData uint64
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_UINTDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.UintData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseUint(testCase.TestData, 10, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != testCase.ValidData {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotUint, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotUint64, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_UINTDATA")
|
||||
}
|
||||
}
|
||||
|
||||
// Next tests should be improved.
|
||||
func TestParseFloat32(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData float32
|
||||
}{
|
||||
{"0.00", 0.00},
|
||||
{"1.00", 1.00},
|
||||
{"2.00", 2.00},
|
||||
{"-1", -1},
|
||||
{"not a float", 0.00},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
FloatData float32
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_FLOATDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.FloatData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseFloat(testCase.TestData, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != float64(testCase.ValidData) {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotFloat, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotFloat32, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_FLOATDATA")
|
||||
}
|
||||
}
|
||||
|
||||
func TestParseFloat64(t *testing.T) {
|
||||
testCases := []struct {
|
||||
TestData string
|
||||
ValidData float64
|
||||
}{
|
||||
{"0.00", 0.00},
|
||||
{"1.00", 1.00},
|
||||
{"2.00", 2.00},
|
||||
{"-1", -1},
|
||||
{"not a float", 0.00},
|
||||
}
|
||||
|
||||
type testStruct struct {
|
||||
FloatData float64
|
||||
}
|
||||
|
||||
for _, testCase := range testCases {
|
||||
t.Logf("Testing: %+v", testCase)
|
||||
os.Setenv("TESTSTRUCT_FLOATDATA", testCase.TestData)
|
||||
|
||||
// If ErrorsAreCritical == false, then we should check only
|
||||
// equality of parsed data and valid data.
|
||||
s := &testStruct{}
|
||||
err := Parse(s, nil)
|
||||
if err != nil {
|
||||
t.Log(err.Error())
|
||||
}
|
||||
require.Nil(t, err)
|
||||
require.Equal(t, testCase.ValidData, s.FloatData)
|
||||
|
||||
// If errors are critical - we should check if test data is within
|
||||
// int8 range and check for error if it isn't.
|
||||
s1 := &testStruct{}
|
||||
err1 := Parse(s1, &Options{ErrorsAreCritical: true})
|
||||
|
||||
var checkNotIntError bool
|
||||
var checkRangeError bool
|
||||
passedData, err2 := strconv.ParseFloat(testCase.TestData, 64)
|
||||
if err2 != nil {
|
||||
checkNotIntError = true
|
||||
}
|
||||
if passedData != testCase.ValidData {
|
||||
checkRangeError = true
|
||||
}
|
||||
|
||||
if checkNotIntError || checkRangeError {
|
||||
if err1 == nil {
|
||||
t.Log("No error returned!")
|
||||
}
|
||||
require.NotNil(t, err1)
|
||||
|
||||
if checkNotIntError {
|
||||
require.Equal(t, errNotFloat, err1)
|
||||
}
|
||||
if checkRangeError {
|
||||
require.Equal(t, errNotFloat64, err1)
|
||||
}
|
||||
}
|
||||
|
||||
os.Unsetenv("TESTSTRUCT_FLOATDATA")
|
||||
}
|
||||
}
|
||||
|
||||
// Float
|
||||
Reference in New Issue
Block a user