BugFix in axisDescr.go and added some unit tests.

conversionSet was never true and thus maxAxisPoints could never be parsed.
This was corrected and several unit tests were added.

Author: asap2Go

a2l/a2l_test.go

@@ -13,7 +13,7 @@ import (
 
 func TestParseFromFile(t *testing.T) {
 	configureLogger()
-	zerolog.SetGlobalLevel(zerolog.InfoLevel)
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
 	a2lPath := "testing/ASAP2_Demo_V171_allKeywords.a2l"
 	startTime := time.Now()
 	a, err := ParseFromFile(a2lPath)
@@ -28,31 +28,27 @@ func TestParseFromFile(t *testing.T) {
 
 func TestMapify(t *testing.T) {
 	configureLogger()
-	zerolog.SetGlobalLevel(zerolog.InfoLevel)
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
 	a2lPath := "testing/ASAP2_Demo_V171_allKeywords.a2l"
 	a, err := ParseFromFile(a2lPath)
 	if err != nil {
 		t.Fatalf("failed parsing with error: %s.", err)
 	}
 	startTime := time.Now()
-	hm, err := a.toHashMap()
+	_, err = a.toHashMap()
 	if err != nil {
 		t.Fatalf("failed to convert a2l struct into hashmap %s.", err)
 	}
 	endTime := time.Now()
 	elapsed := endTime.Sub(startTime)
-	_, err = fmt.Println(hm)
-	if err != nil {
-		log.Err(err).Msg("failed to print hashmap")
-		t.Fatalf("failed to print a2l struct hashmap %s.", err)
-	}
+
 	log.Info().Str("project name", a.Project.Name).Msg("finished parsing:")
 	log.Info().Msg("time for parsing a2l test file: " + fmt.Sprint(elapsed.Milliseconds()) + "[ms]")
 }
 
 func FuzzParseA2L(f *testing.F) {
 	configureLogger()
-	zerolog.SetGlobalLevel(zerolog.WarnLevel)
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
 	a2lPath := "testing/ASAP2_Demo_V171_allKeywords.a2l"
 	text, _ := readFileToString(a2lPath)
 	f.Add(text)
@@ -94,7 +90,7 @@ func FuzzParseA2L(f *testing.F) {
 
 func BenchmarkParseFromFile(b *testing.B) {
 	configureLogger()
-	zerolog.SetGlobalLevel(zerolog.WarnLevel)
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
 	b.ReportAllocs()
 	for i := 0; i < b.N; i++ {
 		a2lPath := "testing/ASAP2_Demo_V171_allKeywords.a2l"

a2l/a2ml_test.go

@@ -0,0 +1,33 @@
+package a2l
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+)
+
+//write a unit test for parseA2ML that checks the following:
+
+func TestParseA2ML_Valid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// valid a2ml file
+	tokenList = []string{"/begin A2ML", "1.0", "stuff", "stuff", "stuff", "/end A2ML"}
+	tok := newTokenGenerator()
+	_, err := parseA2ML(&tok)
+	if err != nil {
+		t.Fatalf("failed parsing with error: %s.", err)
+	}
+}
+
+func TestParseA2ML_Empty(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// empty a2ml file
+	tokenList = []string{emptyToken, emptyToken}
+	tok := newTokenGenerator()
+	_, err := parseA2ML(&tok)
+	if err == nil {
+		t.Fatalf("failed parsing with error: %s.", err)
+	}
+}

a2l/a2ml_version_test.go

@@ -0,0 +1,73 @@
+package a2l
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+)
+
+//write a unit test for parseA2MLVersion that checks the following:
+// - valid a2ml version
+// - empty a2ml version
+// - invalid a2ml version
+// - unexpected token
+
+func TestParseA2MLVersion_Valid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// valid a2ml version
+	tokenList = []string{"1", "0"}
+	tok := newTokenGenerator()
+	_, err := parseA2MLVersion(&tok)
+	if err != nil {
+		t.Fatalf("failed parsing with error: %s.", err)
+	}
+}
+
+func TestParseA2MLVersion_Empty(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// empty a2ml version
+	tokenList = []string{emptyToken}
+	tok := newTokenGenerator()
+	_, err := parseA2MLVersion(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseA2MLVersion_InvalidVersionNumber_1(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid a2ml version
+	tokenList = []string{emptyToken, "1", "A"}
+	tok := newTokenGenerator()
+	_, err := parseA2MLVersion(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseA2MLVersion_InvalidVersionNumber_2(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid a2ml version
+	tokenList = []string{emptyToken, "Oh Boy", "0"}
+	tok := newTokenGenerator()
+	_, err := parseA2MLVersion(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseA2MLVersion_UnexpectedToken(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// unexpected token
+	tokenList = []string{emptyToken, "1", beginAnnotationTextToken}
+	tok := newTokenGenerator()
+	_, err := parseA2MLVersion(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}

a2l/addr_epk_test.go

@@ -0,0 +1,49 @@
+package a2l
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+)
+
+//create unit tests for the following functions: parseAddrEpk
+// - valid addrEpk
+// - empty addrEpk
+// - invalid addrEpk
+// - unexpected token
+
+func TestParseAddrEpk_Valid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// valid addrEpk
+	tokenList = []string{emptyToken, "0x2000"}
+	tok := newTokenGenerator()
+	_, err := parseAddrEpk(&tok)
+	if err != nil {
+		t.Fatalf("failed parsing with error: %s.", err)
+	}
+}
+
+func TestParseAddrEpk_Empty(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// empty addrEpk
+	tokenList = []string{emptyToken, emptyToken}
+	tok := newTokenGenerator()
+	_, err := parseAddrEpk(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseAddrEpk_UnexpectedKeyword(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid addrEpk
+	tokenList = []string{emptyToken, beginA2mlToken}
+	tok := newTokenGenerator()
+	_, err := parseAddrEpk(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}

a2l/alignment_byte_test.go

@@ -0,0 +1,61 @@
+package a2l
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+)
+
+//create unit tests for the following functions: parseAlignmentByte
+// - valid alignmentByte
+// - empty alignmentByte
+// - invalid alignmentByte
+// - unexpected token
+
+func TestParseAlignmentByte_Valid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// valid alignmentByte
+	tokenList = []string{emptyToken, "4"}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentByte(&tok)
+	if err != nil {
+		t.Fatalf("failed parsing with error: %s.", err)
+	}
+}
+
+func TestParseAlignmentByte_Empty(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// empty alignmentByte
+	tokenList = []string{emptyToken, emptyToken}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentByte(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseAlignmentByte_UnexpectedKeyword(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid alignmentByte
+	tokenList = []string{emptyToken, beginA2mlToken}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentByte(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseAlignmentByte_Invalid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid alignmentByte
+	tokenList = []string{emptyToken, "9999999999999"}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentByte(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}

a2l/alignment_float16_ieee_test.go

@@ -0,0 +1,61 @@
+package a2l
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+)
+
+//create unit tests for the following functions: parseAlignmentFloat16Ieee
+// - valid alignmentFloat16Ieee
+// - empty alignmentFloat16Ieee
+// - invalid alignmentFloat16Ieee
+// - unexpected token
+
+func TestParseAlignmentFloat16Ieee_Valid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// valid alignmentFloat16Ieee
+	tokenList = []string{emptyToken, "4"}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentFloat16Ieee(&tok)
+	if err != nil {
+		t.Fatalf("failed parsing with error: %s.", err)
+	}
+}
+
+func TestParseAlignmentFloat16Ieee_Empty(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// empty alignmentFloat16Ieee
+	tokenList = []string{emptyToken, emptyToken}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentFloat16Ieee(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseAlignmentFloat16Ieee_UnexpectedKeyword(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid alignmentFloat16Ieee
+	tokenList = []string{emptyToken, beginA2mlToken}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentFloat16Ieee(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseAlignmentFloat16Ieee_Invalid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid alignmentFloat16Ieee
+	tokenList = []string{emptyToken, "9999999999999"}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentFloat16Ieee(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}

a2l/alignment_float32_ieee_test.go

@@ -0,0 +1,61 @@
+package a2l
+
+import (
+	"testing"
+
+	"github.com/rs/zerolog"
+)
+
+//create unit tests for the following functions: parseAlignmentFloat32Ieee
+// - valid alignmentFloat32Ieee
+// - empty alignmentFloat32Ieee
+// - invalid alignmentFloat32Ieee
+// - unexpected token
+
+func TestParseAlignmentFloat32Ieee_Valid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// valid alignmentFloat32Ieee
+	tokenList = []string{emptyToken, "4"}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentFloat32Ieee(&tok)
+	if err != nil {
+		t.Fatalf("failed parsing with error: %s.", err)
+	}
+}
+
+func TestParseAlignmentFloat32Ieee_Empty(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// empty alignmentFloat32Ieee
+	tokenList = []string{emptyToken, emptyToken}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentFloat32Ieee(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseAlignmentFloat32Ieee_UnexpectedKeyword(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid alignmentFloat32Ieee
+	tokenList = []string{emptyToken, beginA2mlToken}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentFloat32Ieee(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}
+
+func TestParseAlignmentFloat32Ieee_Invalid(t *testing.T) {
+	configureLogger()
+	zerolog.SetGlobalLevel(zerolog.ErrorLevel)
+	// invalid alignmentFloat32Ieee
+	tokenList = []string{emptyToken, "9999999999999"}
+	tok := newTokenGenerator()
+	_, err := parseAlignmentFloat32Ieee(&tok)
+	if err == nil {
+		t.Fatalf("failed test with undetected error: %s.", err)
+	}
+}