func TestSimplifyTree(t *testing.T) {
left := ast.NewTreeNode(ast.NewStringName("A"),
ast.NewTreeNode(ast.NewStringName("B"), ast.NewContains(
ast.NewTreeNode(ast.NewStringName("C"), ast.NewZAny()),
)),
)
right := ast.NewTreeNode(ast.NewStringName("A"),
ast.NewTreeNode(ast.NewStringName("B"), ast.NewContains(
ast.NewTreeNode(ast.NewStringName("D"), ast.NewZAny()),
)),
)
input := ast.NewAnd(left, right)
expected := ast.NewTreeNode(ast.NewStringName("A"),
ast.NewTreeNode(ast.NewStringName("B"), ast.NewAnd(
ast.NewContains(
ast.NewTreeNode(ast.NewStringName("C"), ast.NewZAny()),
),
ast.NewContains(
ast.NewTreeNode(ast.NewStringName("D"), ast.NewZAny()),
),
)),
)
output := NewSimplifier(input.Grammar()).Simplify(input)
t.Logf("%v", output)
if !expected.Equal(output) {
t.Fatalf("expected %v, but got %v", expected, output)
}
}
func TestUnreachable(t *testing.T) {
p := ast.NewTreeNode(ast.NewStringName("NotC"), ast.NewTreeNode(ast.NewStringName("C"), ast.NewTreeNode(ast.NewStringName("A"), ast.NewZAny())))
g := p.Grammar()
gkey, err := FieldNamesToNumbers("debug", "Debug", debug.DebugDescription(), g)
if err == nil {
t.Fatalf("Expected: Unknown Field Error: Name: NotC, Msg: Debug, but got %v", gkey)
}
}
func TestKeyAnyName(t *testing.T) {
p := ast.NewOr(
ast.NewTreeNode(ast.NewNameChoice(ast.NewAnyName(), ast.NewStringName("C")), ast.NewZAny()),
ast.NewTreeNode(ast.NewStringName("B"), ast.NewZAny()),
)
g := p.Grammar()
gkey, err := FieldNamesToNumbers("debug", "Debug", debug.DebugDescription(), g)
if err == nil {
t.Fatalf("Expected: Any Field Not Supported: Name: _, but got %v", gkey)
}
}
func TestAnyIndex(t *testing.T) {
p := ast.NewTreeNode(ast.NewStringName("KeyValue"), ast.NewTreeNode(ast.NewAnyName(), ast.NewConcat(
ast.NewTreeNode(ast.NewStringName("Key"), ast.NewZAny()),
ast.NewTreeNode(ast.NewStringName("Value"), ast.NewZAny()),
)))
gkey, err := FieldNamesToNumbers("protonum", "ProtoNum", ProtonumDescription(), p.Grammar())
if err != nil {
t.Fatal(err)
}
t.Logf("%v", gkey)
check(t, gkey)
}
func TestKeyRecursive(t *testing.T) {
p := ast.NewOr(
ast.NewTreeNode(ast.NewStringName("C"), ast.NewReference("main")),
ast.NewTreeNode(ast.NewStringName("A"), ast.NewZAny()),
)
g := p.Grammar()
gkey, err := FieldNamesToNumbers("debug", "Debug", debug.DebugDescription(), g)
if err != nil {
t.Fatal(err)
}
t.Logf("%v", gkey)
check(t, gkey)
}
func TestKeyTree(t *testing.T) {
p := ast.NewTreeNode(ast.NewStringName("C"), ast.NewTreeNode(ast.NewStringName("A"), ast.NewZAny()))
g := p.Grammar()
gkey, err := FieldNamesToNumbers("debug", "Debug", debug.DebugDescription(), g)
if err != nil {
t.Fatal(err)
}
t.Logf("%v", gkey)
if gkey.GetTopPattern().GetTreeNode().GetName().GetName().GetUintValue() != 3 {
t.Fatalf("expected field 3, but got %v", gkey)
}
if gkey.GetTopPattern().GetTreeNode().GetPattern().GetTreeNode().GetName().GetName().GetUintValue() != 1 {
t.Fatalf("expected field 1, but got %v", gkey)
}
check(t, gkey)
}
func TestTopsyTurvy(t *testing.T) {
p := ast.NewTreeNode(ast.NewAnyName(), ast.NewTreeNode(ast.NewStringName("A"), ast.NewZAny()))
gkey, err := FieldNamesToNumbers("protonum", "TopsyTurvy", ProtonumDescription(), p.Grammar())
if err == nil {
t.Fatalf("Expected: Any Field Not Supported: Name: _, but got %v", gkey)
}
}
func TestNotUnreachable(t *testing.T) {
p := ast.NewTreeNode(ast.NewAnyNameExcept(ast.NewStringName("NotC")), ast.NewTreeNode(ast.NewStringName("C"), ast.NewTreeNode(ast.NewStringName("A"), ast.NewZAny())))
g := p.Grammar()
gkey, err := FieldNamesToNumbers("debug", "Debug", debug.DebugDescription(), g)
if err == nil {
t.Fatalf("Expected: AnyNameExcept Not Supported Error: Name: !(NotC), but got %v", gkey)
}
}
func TestKeyLeftRecursive(t *testing.T) {
p := ast.NewOr(
ast.NewReference("a"),
ast.NewTreeNode(ast.NewStringName("C"), ast.NewReference("main")),
ast.NewTreeNode(ast.NewStringName("A"), ast.NewZAny()),
)
g := p.Grammar().AddRef("a", ast.NewReference("main"))
gkey, err := FieldNamesToNumbers("debug", "Debug", debug.DebugDescription(), g)
if err != nil {
t.Fatal(err)
}
t.Logf("%v", gkey)
if gkey.GetTopPattern().GetOr().GetRightPattern().GetOr().GetLeftPattern().GetTreeNode().GetName().GetName().GetUintValue() != 3 {
t.Fatalf("expected field 3, but got %v", gkey)
}
check(t, gkey)
}
func TestSimplifyRecordLeaf2(t *testing.T) {
input := ast.NewAnd(
ast.NewContains(ast.NewTreeNode(ast.NewStringName("A"), ast.NewContains(ast.NewTreeNode(ast.NewStringName("B"), combinator.Value(funcs.Contains(funcs.StringVar(), funcs.StringConst("a"))))))),
ast.NewContains(ast.NewTreeNode(ast.NewStringName("A"), ast.NewContains(ast.NewTreeNode(ast.NewStringName("B"), combinator.Value(funcs.Contains(funcs.StringVar(), funcs.StringConst("b"))))))),
)
t.Logf("input: %v", input)
expected := ast.NewContains(ast.NewTreeNode(ast.NewStringName("A"), ast.NewContains(ast.NewTreeNode(ast.NewStringName("B"), combinator.Value(funcs.And(
funcs.Contains(funcs.StringVar(), funcs.StringConst("a")),
funcs.Contains(funcs.StringVar(), funcs.StringConst("b")),
))))))
output := NewSimplifier(input.Grammar()).OptimizeForRecord().Simplify(input)
expected.Format()
output.Format()
t.Logf("%v", output)
if !expected.Equal(output) {
t.Fatalf("expected %v, but got %v", expected, output)
}
}
func exprToName(e *ast.Expr) *ast.NameExpr {
if e.GetBuiltIn() != nil {
if e.GetBuiltIn().GetSymbol().String() == "==" {
if e.GetBuiltIn().GetExpr().GetTerminal() != nil {
t := e.GetBuiltIn().GetExpr().GetTerminal()
if t.DoubleValue != nil {
return ast.NewDoubleName(t.GetDoubleValue())
}
if t.IntValue != nil {
return ast.NewIntName(t.GetIntValue())
}
if t.UintValue != nil {
return ast.NewUintName(t.GetUintValue())
}
if t.BoolValue != nil {
return ast.NewBoolName(t.GetBoolValue())
}
if t.StringValue != nil {
return ast.NewStringName(t.GetStringValue())
}
if t.BytesValue != nil {
return ast.NewBytesName(t.GetBytesValue())
}
} else {
panic("todo")
}
} else {
panic("todo")
}
}
if e.GetFunction() != nil {
if e.GetFunction().GetName() == "not" {
return ast.NewAnyNameExcept(exprToName(e.GetFunction().GetParams()[0]))
}
if e.GetFunction().GetName() == "or" {
return ast.NewNameChoice(
exprToName(e.GetFunction().GetParams()[0]),
exprToName(e.GetFunction().GetParams()[1]),
)
}
panic("todo")
}
if e.GetTerminal() != nil {
if e.GetTerminal().BoolValue != nil {
if e.GetTerminal().GetBoolValue() {
return ast.NewAnyName()
} else {
panic("todo")
}
} else {
panic("todo")
}
}
panic("todo")
}
func TestRepeatedMessageWithNoFieldsOfTypeMessage(t *testing.T) {
p := ast.NewConcat(
ast.NewZAny(),
ast.NewTreeNode(ast.NewStringName("KeyValue"),
ast.NewTreeNode(ast.NewAnyName(),
ast.NewConcat(
ast.NewTreeNode(ast.NewStringName("Key"), ast.NewZAny()),
ast.NewTreeNode(ast.NewStringName("Value"), ast.NewZAny()),
),
),
),
ast.NewZAny(),
)
g := p.Grammar()
gkey, err := FieldNamesToNumbers("protonum", "ProtoNum", ProtonumDescription(), g)
if err != nil {
t.Fatal(err)
}
t.Logf("%v", gkey)
check(t, gkey)
}
func TestKeyAnyArrayIndex(t *testing.T) {
p := ast.NewConcat(
ast.NewZAny(),
ast.NewTreeNode(ast.NewStringName("E"),
ast.NewTreeNode(ast.NewAnyName(),
ast.NewConcat(
ast.NewTreeNode(ast.NewStringName("A"), ast.NewZAny()),
ast.NewTreeNode(ast.NewStringName("B"), ast.NewZAny()),
),
),
),
ast.NewZAny(),
)
g := p.Grammar()
gkey, err := FieldNamesToNumbers("debug", "Debug", debug.DebugDescription(), g)
if err != nil {
t.Fatal(err)
}
t.Logf("%v", gkey)
check(t, gkey)
}
func newT(s string) *ast.Pattern {
return ast.NewTreeNode(ast.NewStringName(s), ast.NewEmpty())
}
func TestRecursiveKnotElbow(t *testing.T) {
p := ast.NewOr(ast.NewTreeNode(ast.NewAnyName(), ast.NewReference("main")), ast.NewTreeNode(ast.NewStringName("Elbow"), ast.NewZAny()))
gkey, err := FieldNamesToNumbers("protonum", "Knot", ProtonumDescription(), p.Grammar())
if err == nil {
t.Fatalf("Expected: Any Field Not Supported: Name: _, but got %v", gkey)
}
}
