94 lines
4.3 KiB
Go
94 lines
4.3 KiB
Go
//
|
|
// Copyright (C) 2021-2023 IOTech Ltd
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
package transformer
|
|
|
|
import (
|
|
"math"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func Test_validateWriteMaximum(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
value interface{}
|
|
max float64
|
|
expectedErr bool
|
|
}{
|
|
{"valid - uint8 compare succeed", uint8(math.MaxUint8 - 1), float64(math.MaxUint8), false},
|
|
{"invalid - uint8 compare failed", uint8(math.MaxUint8), float64(math.MaxUint8 - 1), true},
|
|
{"valid - uint16 compare succeed", uint16(math.MaxUint16 - 1), float64(math.MaxUint16), false},
|
|
{"invalid - uint16 compare failed", uint16(math.MaxUint16), float64(math.MaxUint16 - 1), true},
|
|
{"valid - uint32 compare succeed", uint32(math.MaxUint32 - 1), float64(math.MaxUint32), false},
|
|
{"invalid - uint32 compare failed", uint32(math.MaxUint32), float64(math.MaxUint32 - 1), true},
|
|
{"valid - uint64 compare succeed", uint64(1000000000), float64(1000000001), false},
|
|
{"invalid - uint64 compare failed", uint64(1000000001), float64(1000000000), true},
|
|
{"valid - int8 compare succeed", int8(math.MaxInt8 - 1), float64(math.MaxInt8), false},
|
|
{"invalid - int8 compare failed", int8(math.MaxInt8), float64(math.MaxInt8 - 1), true},
|
|
{"valid - int16 compare succeed", int16(math.MaxInt16 - 1), float64(math.MaxInt16), false},
|
|
{"invalid - int16 compare failed", int16(math.MaxInt16), float64(math.MaxInt16 - 1), true},
|
|
{"valid - int32 compare succeed", int32(math.MaxInt32 - 1), float64(math.MaxInt32), false},
|
|
{"invalid - int32 compare failed", int32(math.MaxInt32), float64(math.MaxInt32 - 1), true},
|
|
{"valid - int64 compare succeed", int64(1000000000), float64(1000000001), false},
|
|
{"invalid - int64 compare failed", int64(1000000001), float64(1000000000), true},
|
|
{"valid - float32 compare succeed", float32(12345.6789), float64(123456.789), false},
|
|
{"invalid - float32 compare failed", float32(123456.789), float64(12345.6789), true},
|
|
{"valid - float64 compare succeed", float64(12345.6789), float64(123456.789), false},
|
|
{"invalid - float64 compare failed", float64(123456.789), float64(12345.6789), true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := validateWriteMaximum(tt.value, tt.max)
|
|
if !tt.expectedErr {
|
|
assert.NoError(t, err)
|
|
} else {
|
|
assert.Error(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func Test_validateWriteMinimum(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
value interface{}
|
|
min float64
|
|
expectedErr bool
|
|
}{
|
|
{"valid - uint8 compare succeed", uint8(1), float64(0), false},
|
|
{"invalid - uint8 compare failed", uint8(0), float64(1), true},
|
|
{"valid - uint16 compare succeed", uint16(1), float64(0), false},
|
|
{"invalid - uint16 compare failed", uint16(0), float64(1), true},
|
|
{"valid - uint32 compare succeed", uint32(1), float64(0), false},
|
|
{"invalid - uint32 compare failed", uint32(0), float64(1), true},
|
|
{"valid - uint64 compare succeed", uint64(1), float64(0), false},
|
|
{"invalid - uint64 compare failed", uint64(0), float64(1), true},
|
|
{"valid - int8 compare succeed", int8(math.MinInt8 + 1), float64(math.MinInt8), false},
|
|
{"invalid - int8 compare failed", int8(math.MinInt8), float64(math.MinInt8 + 1), true},
|
|
{"valid - int16 compare succeed", int16(math.MinInt16 + 1), float64(math.MinInt16), false},
|
|
{"invalid - int16 compare failed", int16(math.MinInt16), float64(math.MinInt16 + 1), true},
|
|
{"valid - int32 compare succeed", int32(math.MinInt32 + 1), float64(math.MinInt32), false},
|
|
{"invalid - int32 compare failed", int32(math.MinInt32), float64(math.MinInt32 + 1), true},
|
|
{"valid - int64 compare succeed", int64(math.MinInt64 + 1), float64(math.MinInt64), false},
|
|
{"invalid - int64 compare failed", int64(-1000000001), float64(-1000000000), true},
|
|
{"valid - float32 compare succeed", float32(123456.789), float64(12345.6789), false},
|
|
{"invalid - float32 compare failed", float32(12345.6789), float64(123456.789), true},
|
|
{"valid - float64 compare succeed", float64(123456.789), float64(12345.6789), false},
|
|
{"invalid - float64 compare failed", float64(12345.6789), float64(123456.789), true},
|
|
}
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
err := validateWriteMinimum(tt.value, tt.min)
|
|
if !tt.expectedErr {
|
|
assert.NoError(t, err)
|
|
} else {
|
|
assert.Error(t, err)
|
|
}
|
|
})
|
|
}
|
|
}
|