tests: improve code coverage

Author: pandatix

dag.go

@@ -1,6 +1,9 @@
 package goabnf
 
-import "strings"
+import (
+	"fmt"
+	"strings"
+)
 
 type node struct {
 	Rulename       string
@@ -66,6 +69,18 @@ func appendDeps(deps []string, ndeps ...string) []string {
 	return deps
 }
 
+// Mermaid returns a flowchart of the dependency graph.
+func (dg Depgraph) Mermaid() string {
+	out := "flowchart TD\n"
+	for _, node := range dg {
+		for _, dep := range node.Dependencies {
+			out += fmt.Sprintf("\t%s --> %s\n", node.Rulename, dep)
+		}
+		out += "\n"
+	}
+	return out
+}
+
 // IsDag find Strongly Connected Components using Tarjan's algorithm
 // and returns whether it contains cycle or not.
 // Could be improved by Nuutila's or Pearce's algorithms, or replaced
@@ -247,7 +262,8 @@ func (c *cycle) strongconnect(v *node) {
 	for _, dep := range v.Dependencies {
 		w, ok := c.dg[dep]
 		if !ok {
-			// core rules
+			// core rules, as we know they won't have a cycle thus
+			// no SCC, we don't need to recurse.
 			continue
 		}
 		if w.index == 0 {

dag_test.go

@@ -44,6 +44,14 @@ func Test_U_IsDAG(t *testing.T) {
 			if !assert.Nil(err) {
 				t.FailNow()
 			}
+			// Side checks that this dependency graph does not produce an
+			// empty dependency graph. It should not be, at any time,
+			// as only the diagram header is a non-empty content.
+			mrmd := g.DependencyGraph().Mermaid()
+			assert.NotEmpty(mrmd)
+			// Do the same with the pretty print.
+			ptp := g.PrettyPrint()
+			assert.NotEmpty(ptp)
 
 			isDag := g.IsDAG()
 			assert.Equal(tt.ExpectedIsDag, isDag)

grammar_fuzz_test.go

@@ -43,10 +43,10 @@ func FuzzParseABNF_Generate(f *testing.F) {
 				t.Fatalf("For input %s, got error %s", input, err)
 			}
 			return
-		} else {
-			if g == nil {
-				t.Fatal("Expected a path when no error")
-			}
+		}
+		if g == nil {
+			t.Fatal("Expected a grammar when no error")
+			return
 		}
 	})
 }

grammar_test.go

@@ -157,10 +157,8 @@ func Test_U_ParseABNF(t *testing.T) {
 			assert.NotEmpty(tt.Input)
 			_, err := goabnf.ParseABNF(tt.Input, goabnf.WithValidation(tt.Validate))
 
-			if tt.ExpectErr {
-				assert.NotNil(err)
-			} else {
-				assert.Nil(err)
+			if (err != nil) != tt.ExpectErr {
+				t.Fatalf("Expected err: %t ; got: %s", tt.ExpectErr, err)
 			}
 		})
 	}

mermaid.go

@@ -18,6 +18,26 @@ var testsRegex = map[string]struct {
 		Rulename:  "alpha",
 		ExpectErr: false,
 	},
+	"cycle": {
+		Grammar:   mustGrammar(string(cycleAbnf)),
+		Rulename:  "a",
+		ExpectErr: true,
+	},
+	"void": {
+		Grammar:   mustGrammar(string(voidAbnf)),
+		Rulename:  "",
+		ExpectErr: true,
+	},
+	"nocycle": {
+		Grammar:   mustGrammar(string(nocycleAbnf)),
+		Rulename:  "a",
+		ExpectErr: false,
+	},
+	"group-option": {
+		Grammar:   mustGrammar("a = 1*(*[\"b.\"] *3%x61.7a)\r\n"),
+		Rulename:  "a",
+		ExpectErr: false,
+	},
 }
 
 func Test_U_Regex(t *testing.T) {