generator tests

Makefile

@@ -41,7 +41,7 @@ regenerate: $(SOURCES) $(PARSERS) head
 check: imports build $(PARSERS)
 	go test -test.short -run ^Test
 
-check-full: imports build $(PARSERS)
+checkall: imports build $(PARSERS)
 	go test
 
 .coverprofile: $(SOURCES) imports
@@ -50,10 +50,10 @@ check-full: imports build $(PARSERS)
 cover: .coverprofile
 	go tool cover -func .coverprofile
 
-show-cover: .coverprofile
+showcover: .coverprofile
 	go tool cover -html .coverprofile
 
-publish-coverage: .coverprofile
+publishcoverage: .coverprofile
 	curl -s https://codecov.io/bash -o codecov
 	bash codecov -Zf .coverprofile
 
@@ -67,14 +67,14 @@ fmt: $(SOURCES)
 	@echo fmt
 	@gofmt -w -s $(SOURCES)
 
-check-fmt: $(SOURCES)
+checkfmt: $(SOURCES)
 	@echo check fmt
 	@if [ "$$(gofmt -s -d $(SOURCES))" != "" ]; then false; else true; fi
 
 vet:
 	go vet
 
-precommit: regenerate fmt vet build check-full
+precommit: regenerate fmt vet build checkall
 
 clean:
 	rm -f *.test
@@ -82,7 +82,7 @@ clean:
 	rm -f .coverprofile
 	go clean -i ./...
 
-ci-trigger: deps check-fmt build check-full
+ci-trigger: deps checkfmt build checkall
 ifeq ($(TRAVIS_BRANCH)_$(TRAVIS_PULL_REQUEST), master_false)
-	make publish-coverage
+	make publishcoverage
 endif

chardefine.go

@@ -72,13 +72,7 @@ func (p *charParser) format(_ *registry, f formatFlags) string {
 	return string(s)
 }
 
-func (p *charParser) generate(w io.Writer, done map[string]bool) error {
-	if done[p.name] {
-		return nil
-	}
-
-	done[p.name] = true
-
+func (p *charParser) generate(w io.Writer, _ map[string]bool) error {
 	var err error
 	fprintf := func(f string, args ...interface{}) {
 		if err != nil {
@@ -116,12 +110,7 @@ func (p *charParser) generate(w io.Writer, done map[string]bool) error {
 	return err
 }
 
-func (b *charBuilder) generate(w io.Writer, done map[string]bool) error {
-	if done[b.name] {
-		return nil
-	}
-
-	done[b.name] = true
+func (b *charBuilder) generate(w io.Writer, _ map[string]bool) error {
 	_, err := fmt.Fprintf(w, "var b%d = charBuilder{};", b.id)
 	return err
 }

generate_test.go

@@ -0,0 +1,118 @@
+package treerack
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"strings"
+	"testing"
+)
+
+var errWriteError = errors.New("write failed")
+
+type failingWriter struct {
+	failWhenReceived []string
+	buffer           *bytes.Buffer
+}
+
+func newFailingWriter(failWhenReceived ...string) io.Writer {
+	return &failingWriter{
+		failWhenReceived: failWhenReceived,
+		buffer:           &bytes.Buffer{},
+	}
+}
+
+func (w *failingWriter) Write(p []byte) (int, error) {
+	n, err := w.buffer.Write(p)
+	if err != nil {
+		panic(err)
+	}
+
+	s := w.buffer.String()
+	for i := range w.failWhenReceived {
+		if !strings.Contains(s, w.failWhenReceived[i]) {
+			return n, nil
+		}
+	}
+
+	return n, errWriteError
+}
+
+func TestGenerate(t *testing.T) {
+	s, err := openSyntaxFile("syntax.treerack")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var b bytes.Buffer
+	if err := s.Generate(GeneratorOptions{PackageName: "foo"}, &b); err != nil {
+		t.Error(err)
+	}
+}
+
+func TestGenerateFailingWrite(t *testing.T) {
+	s, err := openSyntaxFile("syntax.treerack")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	t.Run("char parser", func(t *testing.T) {
+		if err := s.Generate(GeneratorOptions{PackageName: "foo"}, newFailingWriter("= charParser")); err == nil {
+			t.Error("failed to fail")
+		}
+	})
+
+	t.Run("char builder", func(t *testing.T) {
+		if err := s.Generate(GeneratorOptions{PackageName: "foo"}, newFailingWriter("= charBuilder")); err == nil {
+			t.Error("failed to fail")
+		}
+	})
+
+	t.Run("sequence parser", func(t *testing.T) {
+		if err := s.Generate(GeneratorOptions{PackageName: "foo"}, newFailingWriter("= sequenceParser")); err == nil {
+			t.Error("failed to fail")
+		}
+	})
+
+	t.Run("sequence builder", func(t *testing.T) {
+		if err := s.Generate(GeneratorOptions{PackageName: "foo"}, newFailingWriter("= sequenceBuilder")); err == nil {
+			t.Error("failed to fail")
+		}
+	})
+
+	t.Run("choice parser", func(t *testing.T) {
+		if err := s.Generate(GeneratorOptions{PackageName: "foo"}, newFailingWriter("= choiceParser")); err == nil {
+			t.Error("failed to fail")
+		}
+	})
+
+	t.Run("choice builder", func(t *testing.T) {
+		if err := s.Generate(GeneratorOptions{PackageName: "foo"}, newFailingWriter("= choiceBuilder")); err == nil {
+			t.Error("failed to fail")
+		}
+	})
+}
+
+func TestGenerateFailOnInit(t *testing.T) {
+	s := &Syntax{}
+	s.Choice("a", None, "b") // undefined b
+	if err := s.Generate(GeneratorOptions{PackageName: "foo"}, &bytes.Buffer{}); err == nil {
+		t.Error("failed to fail")
+	}
+}
+
+func TestGenerateDefaulPackageName(t *testing.T) {
+	s, err := openSyntaxFile("syntax.treerack")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var buf bytes.Buffer
+	if err := s.Generate(GeneratorOptions{}, &buf); err != nil {
+		t.Fatal(err)
+	}
+
+	if !strings.Contains(buf.String(), "\npackage main\n") {
+		t.Error("failed to set default package name")
+	}
+}

parse_test.go

@@ -747,29 +747,3 @@ func TestCharBuildNoop(t *testing.T) {
 		t.Error("char build not noop")
 	}
 }
-
-func TestCharBuilderProps(t *testing.T) {
-	b := &charBuilder{
-		name: "foo",
-		id:   42,
-	}
-
-	if b.nodeName() != "foo" {
-		t.Error("invalid char builder prop")
-	}
-
-	if b.nodeID() != 42 {
-		t.Error("invalid char builder prop")
-	}
-}
-
-func TestCharAddGeneralizationNoEffect(t *testing.T) {
-	(&charParser{}).addGeneralization(42)
-}
-
-func TestSequenceProps(t *testing.T) {
-	d := &sequenceParser{commit: Alias | userDefined}
-	if d.commitType() != Alias|userDefined {
-		t.Error("invalid commit type")
-	}
-}