|
|
|
@ -20,59 +20,59 @@ import (
|
|
|
|
|
|
|
|
|
|
func TestRekursivEvalLiteral(test *testing.T) { |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var I []string |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("A0") |
|
|
|
|
tree = schema.ParseExpr("A0") |
|
|
|
|
I = []string{"A0"} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 1) |
|
|
|
|
tree, _ = schema.ParseExpr("A0") |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 1) |
|
|
|
|
tree = schema.ParseExpr("A0") |
|
|
|
|
I = []string{} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 0) |
|
|
|
|
tree, _ = schema.ParseExpr("! A0") |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 0) |
|
|
|
|
tree = schema.ParseExpr("! A0") |
|
|
|
|
I = []string{"A0"} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 0) |
|
|
|
|
tree, _ = schema.ParseExpr("! A0") |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 0) |
|
|
|
|
tree = schema.ParseExpr("! A0") |
|
|
|
|
I = []string{} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 1) |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 1) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivEvalComplex1(test *testing.T) { |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var I []string |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || A2 ))") |
|
|
|
|
tree = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || A2 ))") |
|
|
|
|
I = []string{"A0", "A2"} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 1) |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 1) |
|
|
|
|
I = []string{"A0", "A3"} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 1) |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 1) |
|
|
|
|
I = []string{"A0"} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 0) |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 0) |
|
|
|
|
I = []string{"A4", "A8"} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 1) |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 1) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivEvalComplex2(test *testing.T) { |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var I []string |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || ! A2 ))") |
|
|
|
|
tree = schema.ParseExpr("( ! A0 || (( A0 && A3 ) || ! A2 ))") |
|
|
|
|
I = []string{"A0", "A2"} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 0) |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 0) |
|
|
|
|
I = []string{"A0", "A3"} |
|
|
|
|
val = rekursion.RekursivEval(tree, I) |
|
|
|
|
assert.Equal(val, 1) |
|
|
|
|
go rekursion.RekursivEval(ch, tree, I) |
|
|
|
|
assert.Equal(<-ch, 1) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------- * |
|
|
|
@ -82,10 +82,12 @@ func TestRekursivEvalComplex2(test *testing.T) {
|
|
|
|
|
func TestRekursivAtomsNoduplicates(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan []string) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val []string |
|
|
|
|
tree, _ = schema.ParseExpr("( A4 && ( A4 || A4 ))") |
|
|
|
|
val = rekursion.RekursivAtoms(tree) |
|
|
|
|
tree = schema.ParseExpr("( A4 && ( A4 || A4 ))") |
|
|
|
|
go rekursion.RekursivAtoms(ch, tree) |
|
|
|
|
val = <-ch |
|
|
|
|
var n int = len(utils.FilterStrings(&val, func(x string) bool { return x == "A4" })) |
|
|
|
|
assert.Equal(n, 1, "Atome dürfen nicht mehrfach vorkommen!") |
|
|
|
|
} |
|
|
|
@ -94,10 +96,12 @@ func TestRekursivAtomsNononatoms(test *testing.T) {
|
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
test.Skip("Syntax for generic expressions in ANTLR4 g4 needs to be implemented.") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan []string) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val []string |
|
|
|
|
tree, _ = schema.ParseExpr("( {F} || A3 )") |
|
|
|
|
val = rekursion.RekursivAtoms(tree) |
|
|
|
|
tree = schema.ParseExpr("( {F} || A3 )") |
|
|
|
|
go rekursion.RekursivAtoms(ch, tree) |
|
|
|
|
val = <-ch |
|
|
|
|
utils.SortStrings(&val) |
|
|
|
|
assert.NotContains(val, "F", "Nichtatomare Formeln dürfen nicht vorkommen!") |
|
|
|
|
} |
|
|
|
@ -105,10 +109,12 @@ func TestRekursivAtomsNononatoms(test *testing.T) {
|
|
|
|
|
func TestRekursivAtomsCalc1(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan []string) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val []string |
|
|
|
|
tree, _ = schema.ParseExpr("A0") |
|
|
|
|
val = rekursion.RekursivAtoms(tree) |
|
|
|
|
tree = schema.ParseExpr("A0") |
|
|
|
|
go rekursion.RekursivAtoms(ch, tree) |
|
|
|
|
val = <-ch |
|
|
|
|
utils.SortStrings(&val) |
|
|
|
|
assert.Equal(val, []string{"A0"}) |
|
|
|
|
} |
|
|
|
@ -116,10 +122,12 @@ func TestRekursivAtomsCalc1(test *testing.T) {
|
|
|
|
|
func TestRekursivAtomsCalc2(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan []string) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val []string |
|
|
|
|
tree, _ = schema.ParseExpr("((( ! A8 && A3 ) || A4 ) && A0 )") |
|
|
|
|
val = rekursion.RekursivAtoms(tree) |
|
|
|
|
tree = schema.ParseExpr("((( ! A8 && A3 ) || A4 ) && A0 )") |
|
|
|
|
go rekursion.RekursivAtoms(ch, tree) |
|
|
|
|
val = <-ch |
|
|
|
|
utils.SortStrings(&val) |
|
|
|
|
assert.Equal(val, []string{"A0", "A3", "A4", "A8"}) |
|
|
|
|
} |
|
|
|
@ -131,51 +139,51 @@ func TestRekursivAtomsCalc2(test *testing.T) {
|
|
|
|
|
func TestRekursivDepthCalc1(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("A0") |
|
|
|
|
val = rekursion.RekursivDepth(tree) |
|
|
|
|
assert.Equal(val, 0) |
|
|
|
|
tree = schema.ParseExpr("A0") |
|
|
|
|
go rekursion.RekursivDepth(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 0) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivDepthCalc2(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("!! A8") |
|
|
|
|
val = rekursion.RekursivDepth(tree) |
|
|
|
|
assert.Equal(val, 2) |
|
|
|
|
tree = schema.ParseExpr("!! A8") |
|
|
|
|
go rekursion.RekursivDepth(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 2) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivDepthCalc3(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("( ! A0 && A3 )") |
|
|
|
|
val = rekursion.RekursivDepth(tree) |
|
|
|
|
assert.Equal(val, 2) |
|
|
|
|
tree = schema.ParseExpr("( ! A0 && A3 )") |
|
|
|
|
go rekursion.RekursivDepth(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 2) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivDepthCalc4(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
val = rekursion.RekursivDepth(tree) |
|
|
|
|
assert.Equal(val, 4) |
|
|
|
|
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
go rekursion.RekursivDepth(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 4) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivDepthCalc5(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
val = rekursion.RekursivDepth(tree) |
|
|
|
|
assert.Equal(val, 5) |
|
|
|
|
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
go rekursion.RekursivDepth(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 5) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------- * |
|
|
|
@ -185,51 +193,51 @@ func TestRekursivDepthCalc5(test *testing.T) {
|
|
|
|
|
func TestRekursivLengthCalc1(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("A0") |
|
|
|
|
val = rekursion.RekursivLength(tree) |
|
|
|
|
assert.Equal(val, 1) |
|
|
|
|
tree = schema.ParseExpr("A0") |
|
|
|
|
go rekursion.RekursivLength(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 1) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivLengthCalc2(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("!! A8") |
|
|
|
|
val = rekursion.RekursivLength(tree) |
|
|
|
|
assert.Equal(val, 3) |
|
|
|
|
tree = schema.ParseExpr("!! A8") |
|
|
|
|
go rekursion.RekursivLength(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 3) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivLengthCalc3(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("( ! A0 && A3 )") |
|
|
|
|
val = rekursion.RekursivLength(tree) |
|
|
|
|
assert.Equal(val, 4) |
|
|
|
|
tree = schema.ParseExpr("( ! A0 && A3 )") |
|
|
|
|
go rekursion.RekursivLength(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 4) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivLengthCalc4(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
val = rekursion.RekursivLength(tree) |
|
|
|
|
assert.Equal(val, 8) |
|
|
|
|
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
go rekursion.RekursivLength(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 8) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivLengthCalc5(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
val = rekursion.RekursivLength(tree) |
|
|
|
|
assert.Equal(val, 9) |
|
|
|
|
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
go rekursion.RekursivLength(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 9) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
/* ---------------------------------------------------------------- * |
|
|
|
@ -239,49 +247,49 @@ func TestRekursivLengthCalc5(test *testing.T) {
|
|
|
|
|
func TestRekursivParenthesesCalc1(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("A0") |
|
|
|
|
val = rekursion.RekursivParentheses(tree) |
|
|
|
|
assert.Equal(val, 0) |
|
|
|
|
tree = schema.ParseExpr("A0") |
|
|
|
|
go rekursion.RekursivParentheses(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 0) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivParenthesesCalc2(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("!! A8") |
|
|
|
|
val = rekursion.RekursivParentheses(tree) |
|
|
|
|
assert.Equal(val, 0) |
|
|
|
|
tree = schema.ParseExpr("!! A8") |
|
|
|
|
go rekursion.RekursivParentheses(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 0) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivParenthesesCalc3(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("( ! A0 && A3 )") |
|
|
|
|
val = rekursion.RekursivParentheses(tree) |
|
|
|
|
assert.Equal(val, 2) |
|
|
|
|
tree = schema.ParseExpr("( ! A0 && A3 )") |
|
|
|
|
go rekursion.RekursivParentheses(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 2) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivParenthesesCalc4(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
val = rekursion.RekursivParentheses(tree) |
|
|
|
|
assert.Equal(val, 6) |
|
|
|
|
tree = schema.ParseExpr("((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
go rekursion.RekursivParentheses(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 6) |
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
func TestRekursivParenthesesCalc5(test *testing.T) { |
|
|
|
|
test.Skip("Methode noch nicht implementiert") |
|
|
|
|
var assert = assert.New(test) |
|
|
|
|
var ch = make(chan int) |
|
|
|
|
var tree syntaxbaum.SyntaxBaum |
|
|
|
|
var val int |
|
|
|
|
tree, _ = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
val = rekursion.RekursivParentheses(tree) |
|
|
|
|
assert.Equal(val, 6) |
|
|
|
|
tree = schema.ParseExpr("! ((( ! A0 && A3 ) || A4 ) && A8 )") |
|
|
|
|
go rekursion.RekursivParentheses(ch, tree) |
|
|
|
|
assert.Equal(<-ch, 6) |
|
|
|
|
} |
|
|
|
|