115 lines
3.3 KiB
Go
115 lines
3.3 KiB
Go
package core
|
|
|
|
import "testing"
|
|
|
|
func CompareValues(t *testing.T, got Value, want Value) {
|
|
if got == nil || want == nil {
|
|
t.Fatalf("a value is nil: got %v; want %v", got, want)
|
|
}
|
|
|
|
if got.Type() != want.Type() {
|
|
t.Fatalf("type mismatch: got %v want %v", got.Type(), want.Type())
|
|
}
|
|
|
|
switch got.Type() {
|
|
case NilValueType:
|
|
t.Logf("Both are nil")
|
|
return
|
|
case BoolValueType:
|
|
if got.(*BoolValue).Boolean != want.(*BoolValue).Boolean {
|
|
t.Errorf("bool value mismatch: got %v, want %v", got.(*BoolValue), want.(*BoolValue))
|
|
} else {
|
|
t.Logf("Both are same boolean (%s)", want.(*BoolValue).String())
|
|
}
|
|
case FloatValueType:
|
|
if got.(*FloatValue).Number != want.(*FloatValue).Number {
|
|
t.Errorf("number value mismatch: got %v, want %v", got.(*FloatValue), want.(*FloatValue))
|
|
} else {
|
|
t.Logf("Both are same number (%s)", got.(*FloatValue).String())
|
|
}
|
|
case IntegerValueType:
|
|
if got.(*IntegerValue).Number.String() != want.(*IntegerValue).Number.String() {
|
|
t.Errorf("number value mismatch: got %v, want %v", got.(*IntegerValue), want.(*IntegerValue))
|
|
} else {
|
|
t.Logf("Both are same number (%s)", got.(*IntegerValue).String())
|
|
}
|
|
case StringValueType:
|
|
if got.(*StringValue).Text != want.(*StringValue).Text {
|
|
t.Errorf("string value mismatch: got %s, want %s", got.(*StringValue), want.(*StringValue))
|
|
} else {
|
|
t.Logf("Both are same string (%s)", got.(*StringValue).String())
|
|
}
|
|
case FunctionValueType:
|
|
n := got.(*FunctionValue)
|
|
m := want.(*FunctionValue)
|
|
|
|
if n.Name != m.Name {
|
|
t.Errorf("function name mismatch: got %v, want %v", n.Name, m.Name)
|
|
}
|
|
|
|
if len(n.Params) != len(m.Params) {
|
|
t.Errorf("function params length mismatch: got %v, want %v", len(m.Params), len(n.Params))
|
|
}
|
|
|
|
for i, v := range n.Params {
|
|
if v != m.Params[i] {
|
|
t.Errorf("function params mismatch: got %v, want %v", v, m.Params[i])
|
|
}
|
|
}
|
|
|
|
CompareChunks(t, n.Chunk, m.Chunk)
|
|
case BuiltinFunctionValueType:
|
|
n := got.(*BuiltinFunctionValue)
|
|
m := want.(*BuiltinFunctionValue)
|
|
|
|
if n.Name != m.Name {
|
|
t.Errorf("builtin function name mismatch: got %v, want %v", n.Name, m.Name)
|
|
}
|
|
|
|
if !n.Signature.Contains(m.Signature) {
|
|
t.Errorf("builtin function parameter count mismatch: got %v, want %v", n, m)
|
|
}
|
|
|
|
case ListValueType:
|
|
n := got.(*ListValue)
|
|
m := want.(*ListValue)
|
|
|
|
if len(n.Items) != len(m.Items) {
|
|
t.Fatalf("list items length mismatch: got %d, want %d", len(n.Items), len(m.Items))
|
|
}
|
|
|
|
for i, v := range n.Items {
|
|
t.Logf("comparing list items #%d: got %s, want %s", i, v, m.Items[i])
|
|
CompareValues(t, v, m.Items[i])
|
|
}
|
|
|
|
case ObjectValueType:
|
|
n := got.(*ObjectValue)
|
|
m := want.(*ObjectValue)
|
|
|
|
if len(n.Members) != len(m.Members) {
|
|
t.Fatalf("object members count mismatch: got %d, want %d", len(n.Members), len(m.Members))
|
|
}
|
|
|
|
for k, v := range n.Members {
|
|
t.Logf("comparing object member %s: got %s, want %s", k, v, m.Members[k])
|
|
CompareValues(t, v, m.Members[k])
|
|
}
|
|
|
|
case TupleValueType:
|
|
n := got.(*TupleValue)
|
|
m := want.(*TupleValue)
|
|
|
|
if len(n.Items) != len(m.Items) {
|
|
t.Fatalf("tuple item count mismatch: got %d items, want %d items", len(n.Items), len(m.Items))
|
|
}
|
|
|
|
for i, v := range n.Items {
|
|
t.Logf("comparing tuple item #%d", i)
|
|
CompareValues(t, v, m.Items[i])
|
|
}
|
|
|
|
default:
|
|
panic("unimplemented comparison")
|
|
}
|
|
}
|