M block_test.go → block_test.go

@@ -27,13 +27,32 @@ return string(Markdown([]byte(input), renderer, extensions))
 }
 
 func doTestsBlock(t *testing.T, tests []string, extensions int) {
+	// catch and report panics
+	var candidate string
+	defer func() {
+		if err := recover(); err != nil {
+			t.Errorf("\npanic while processing [%#v]\n", candidate)
+		}
+	}()
+
 	for i := 0; i+1 < len(tests); i += 2 {
 		input := tests[i]
+		candidate = input
 		expected := tests[i+1]
-		actual := runMarkdownBlock(input, extensions)
+		actual := runMarkdownBlock(candidate, extensions)
 		if actual != expected {
 			t.Errorf("\nInput   [%#v]\nExpected[%#v]\nActual  [%#v]",
-				input, expected, actual)
+				candidate, expected, actual)
+		}
+
+		// now test every substring to stress test bounds checking
+		if !testing.Short() {
+			for start := 0; start < len(input); start++ {
+				for end := start + 1; end <= len(input); end++ {
+					candidate = input[start:end]
+					_ = runMarkdownBlock(candidate, extensions)
+				}
+			}
 		}
 	}
 }

M inline_test.go → inline_test.go

@@ -31,13 +31,32 @@ return string(Markdown([]byte(input), renderer, extensions))
 }
 
 func doTestsInline(t *testing.T, tests []string) {
+	// catch and report panics
+	var candidate string
+	defer func() {
+		if err := recover(); err != nil {
+			t.Errorf("\npanic while processing [%#v]\n", candidate)
+		}
+	}()
+
 	for i := 0; i+1 < len(tests); i += 2 {
 		input := tests[i]
+		candidate = input
 		expected := tests[i+1]
-		actual := runMarkdownInline(input)
+		actual := runMarkdownInline(candidate)
 		if actual != expected {
 			t.Errorf("\nInput   [%#v]\nExpected[%#v]\nActual  [%#v]",
-				input, expected, actual)
+				candidate, expected, actual)
+		}
+
+		// now test every substring to stress test bounds checking
+		if !testing.Short() {
+			for start := 0; start < len(input); start++ {
+				for end := start + 1; end <= len(input); end++ {
+					candidate = input[start:end]
+					_ = runMarkdownInline(candidate)
+				}
+			}
 		}
 	}
 }

M markdown.go → markdown.go

@@ -270,6 +270,12 @@
 			beg = end
 		}
 	}
+
+	// empty input?
+	if out.Len() == 0 {
+		out.WriteByte('\n')
+	}
+
 	return out.Bytes()
 }
 

M upskirtref_test.go → upskirtref_test.go

@@ -25,26 +25,45 @@ return string(Markdown([]byte(input), renderer, 0))
 }
 
 func doTestsReference(t *testing.T, files []string) {
+	// catch and report panics
+	var candidate string
+	defer func() {
+		if err := recover(); err != nil {
+			t.Errorf("\npanic while processing [%#v]\n", candidate)
+		}
+	}()
+
 	for _, basename := range files {
-		fn := filepath.Join("upskirtref", basename+".text")
-		actualdata, err := ioutil.ReadFile(fn)
+		filename := filepath.Join("upskirtref", basename+".text")
+		inputBytes, err := ioutil.ReadFile(filename)
 		if err != nil {
-			t.Errorf("Couldn't open '%s', error: %v\n", fn, err)
+			t.Errorf("Couldn't open '%s', error: %v\n", filename, err)
 			continue
 		}
-		fn = filepath.Join("upskirtref", basename+".html")
-		expecteddata, err := ioutil.ReadFile(fn)
+		input := string(inputBytes)
+
+		filename = filepath.Join("upskirtref", basename+".html")
+		expectedBytes, err := ioutil.ReadFile(filename)
 		if err != nil {
-			t.Errorf("Couldn't open '%s', error: %v\n", fn, err)
+			t.Errorf("Couldn't open '%s', error: %v\n", filename, err)
 			continue
 		}
+		expected := string(expectedBytes)
 
-		actual := string(actualdata)
-		actual = string(runMarkdownReference(actual))
-		expected := string(expecteddata)
+		actual := string(runMarkdownReference(input))
 		if actual != expected {
 			t.Errorf("\n    [%#v]\nExpected[%#v]\nActual  [%#v]",
 				basename+".text", expected, actual)
+		}
+
+		// now test every substring of every input to check for
+		// bounds checking
+		if !testing.Short() {
+			start := 0
+			for end := start + 1; end <= len(input); end++ {
+				candidate = input[start:end]
+				_ = runMarkdownReference(candidate)
+			}
 		}
 	}
 }