func TestKnot(t *testing.T) {
p := ast.NewTreeNode(ast.NewAnyName(), ast.NewTreeNode(ast.NewAnyName(), 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)
}
}
func TestRecursiveKnotTurn(t *testing.T) {
p := ast.NewOr(ast.NewTreeNode(ast.NewAnyName(), ast.NewReference("main")), ast.NewTreeNode(ast.NewStringName("Turn"), 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)
}
}
func TestSimplifyContainsFalseTreeNode(t *testing.T) {
input := ast.NewContains(ast.NewTreeNode(ast.NewAnyNameExcept(ast.NewAnyName()), ast.NewZAny()))
expected := ast.NewNot(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 TestSimplifyTreeNodeWithNotZanyChild(t *testing.T) {
input := ast.NewTreeNode(ast.NewAnyName(), ast.NewNot(ast.NewZAny()))
expected := ast.NewNot(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 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 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 TestNotUnreachableArray(t *testing.T) {
p := ast.NewTreeNode(ast.NewAnyNameExcept(ast.NewStringName("NotC")), ast.NewTreeNode(ast.NewStringName("F"),
ast.NewConcat(ast.NewZAny(), ast.NewTreeNode(ast.NewAnyName(),
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 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 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 (this *simplifier) simplify(p *ast.Pattern, top bool) *ast.Pattern {
cRef := func(cp *ast.Pattern) *ast.Pattern {
if top {
return cp
}
return checkRef(this.refs, cp)
}
cachesimp := func(sp *ast.Pattern) *ast.Pattern {
if _, ok := this.cache[sp]; ok {
return sp
}
s := this.simplify(sp, false)
this.cache[s] = struct{}{}
return s
}
simp := func(sp *ast.Pattern) *ast.Pattern {
return this.simplify(sp, false)
}
typ := p.GetValue()
switch v := typ.(type) {
case *ast.Empty:
return p
case *ast.TreeNode:
child := cachesimp(v.GetPattern())
if isNotZany(child) {
return emptyset
}
name := v.GetName()
b := nameexpr.NameToFunc(v.GetName())
if funcs.IsFalse(b) {
return emptyset
}
if funcs.IsTrue(b) {
name = ast.NewAnyName()
}
return cRef(ast.NewTreeNode(name, child))
case *ast.LeafNode:
b, err := compose.NewBool(v.GetExpr())
if err != nil {
//Don't simplify if there is an error to keep this function signature simple.
return p
}
if funcs.IsFalse(b) {
return emptyset
}
return p
case *ast.Concat:
return cRef(simplifyConcat(
simp(v.GetLeftPattern()),
simp(v.GetRightPattern()),
))
case *ast.Or:
return cRef(simplifyOr(this.refs,
simp(v.GetLeftPattern()),
simp(v.GetRightPattern()),
this.record,
))
case *ast.And:
return cRef(simplifyAnd(this.refs,
simp(v.GetLeftPattern()),
simp(v.GetRightPattern()),
this.record,
))
case *ast.ZeroOrMore:
return cRef(simplifyZeroOrMore(simp(v.GetPattern())))
case *ast.Reference:
return p
case *ast.Not:
return cRef(simplifyNot(simp(v.GetPattern())))
case *ast.ZAny:
return p
case *ast.Contains:
return cRef(simplifyContains(simp(v.GetPattern())))
case *ast.Optional:
return simplifyOptional(simp(v.GetPattern()))
case *ast.Interleave:
return cRef(simplifyInterleave(this.refs,
cachesimp(v.GetLeftPattern()),
cachesimp(v.GetRightPattern()),
))
}
panic(fmt.Sprintf("unknown pattern typ %T", typ))
}
