Martino Ferrari
68 lines
1.9 KiB
Go
68 lines
1.9 KiB
Go
package controllogic
|
|
|
|
import (
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestAsNumAsArr(t *testing.T) {
|
|
if n, err := asNum(3.0); err != nil || n != 3 {
|
|
t.Fatalf("asNum(3)=%v,%v", n, err)
|
|
}
|
|
if _, err := asNum([]Value{1.0}); err == nil {
|
|
t.Fatal("asNum(array) should error")
|
|
}
|
|
if a, err := asArr([]Value{1.0, 2.0}); err != nil || len(a) != 2 {
|
|
t.Fatalf("asArr=%v,%v", a, err)
|
|
}
|
|
if _, err := asArr(3.0); err == nil {
|
|
t.Fatal("asArr(number) should error")
|
|
}
|
|
}
|
|
|
|
func TestIdxResolve(t *testing.T) {
|
|
if k, err := idxResolve(-1, 3); err != nil || k != 2 {
|
|
t.Fatalf("idx(-1,3)=%v,%v", k, err)
|
|
}
|
|
if _, err := idxResolve(3, 3); err == nil {
|
|
t.Fatal("idx(3,3) should be out of range")
|
|
}
|
|
}
|
|
|
|
func TestNormalizeValue(t *testing.T) {
|
|
got := normalizeValue([]interface{}{1.0, true, []interface{}{2.0}})
|
|
want := []Value{1.0, 1.0, []Value{2.0}}
|
|
if !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("normalize=%#v want %#v", got, want)
|
|
}
|
|
if normalizeValue(5) != Value(5.0) {
|
|
t.Fatalf("normalize(int) = %#v", normalizeValue(5))
|
|
}
|
|
}
|
|
|
|
func TestParseInitialArray(t *testing.T) {
|
|
fixed := parseInitialArray(StateVar{Type: "array", Sizing: "fixed", Capacity: 3, Initial: "[1,2]"})
|
|
if !reflect.DeepEqual(fixed, []Value{1.0, 2.0, 0.0}) {
|
|
t.Fatalf("fixed init = %#v", fixed)
|
|
}
|
|
dyn := parseInitialArray(StateVar{Type: "array", Sizing: "dynamic", Initial: "[5,6,7]"})
|
|
if !reflect.DeepEqual(dyn, []Value{5.0, 6.0, 7.0}) {
|
|
t.Fatalf("dynamic init = %#v", dyn)
|
|
}
|
|
empty := parseInitialArray(StateVar{Type: "array", Sizing: "dynamic", Initial: ""})
|
|
if len(empty) != 0 {
|
|
t.Fatalf("empty init = %#v", empty)
|
|
}
|
|
}
|
|
|
|
func TestApplySizing(t *testing.T) {
|
|
capped := applySizing([]Value{1.0, 2.0, 3.0, 4.0}, StateVar{Sizing: "capped", Capacity: 2})
|
|
if !reflect.DeepEqual(capped, []Value{3.0, 4.0}) {
|
|
t.Fatalf("capped = %#v", capped)
|
|
}
|
|
fixed := applySizing([]Value{1.0}, StateVar{Sizing: "fixed", Capacity: 3})
|
|
if !reflect.DeepEqual(fixed, []Value{1.0, 0.0, 0.0}) {
|
|
t.Fatalf("fixed = %#v", fixed)
|
|
}
|
|
}
|