fuzz all the things

check.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 GREEN='\033[1;32m'
 RED='\033[0;31m'

processor/tui.go

@@ -167,6 +167,8 @@ func drawResults(app *tview.Application, results []*fileJob, textView *tview.Tex
 					// unlike in others where we throw away the results afterwards
 					t := []int{s[0] - v3.StartPos, s[1] - v3.StartPos}
 					l = append(l, t)
+				} else {
+					debugLogger(fmt.Sprintf("%d", s[0] - v3.StartPos))
 				}
 			}
 		}

string/.gitignore

@@ -0,0 +1,4 @@
+string-fuzz.zip
+corpus
+crashes
+supressions

string/README.md

@@ -0,0 +1,5 @@
+Fuzz test run for almost an hour
+
+```
+020/05/20 14:23:13 workers: 12, corpus: 1473 (52m38s ago), crashers: 0, restarts: 1/9996, execs: 171550918 (54048/sec), cover: 299, uptime: 52m54s
+```

string/fuzz.go

@@ -0,0 +1,21 @@
+package string
+
+import (
+	"crypto/md5"
+	"encoding/hex"
+)
+
+// For fuzz testing...
+// https://github.com/dvyukov/go-fuzz
+// install both go-fuzz-build and go-fuzz
+// go-fuzz-build && go-fuzz
+func Fuzz(data []byte) int {
+
+	md5_d := md5.New()
+	find := hex.EncodeToString(md5_d.Sum(data))
+
+	IndexAll(string(data), find[:8], -1)
+	l := IndexAllIgnoreCaseUnicode(string(data), find[:8], -1)
+	HighlightString(string(data), l, "__IN__", "__OUT__")
+	return 1
+}

string/fuzz.sh

@@ -0,0 +1,2 @@
+#!/usr/bin/env bash
+go-fuzz-build && go-fuzz

string/index.go

@@ -29,6 +29,11 @@ import (
 // Note that this method is explicitly case sensitive in its matching.
 // A return value of nil indicates no match.
 func IndexAll(haystack string, needle string, limit int) [][]int {
+	// The below needed to avoid timeout crash found using go-fuzz
+	if len(haystack) == 0 || len(needle) == 0 {
+		return nil
+	}
+
 	// Return contains a slice of slices where index 0 is the location of the match in bytes
 	// and index 1 contains the end location in bytes of the match
 	locs := [][]int{}
@@ -88,6 +93,11 @@ var __permuteCacheLock = sync.Mutex{}
 // for S will search for S s and ſ which a simple strings.ToLower over the haystack
 // and the needle will not.
 func IndexAllIgnoreCaseUnicode(haystack string, needle string, limit int) [][]int {
+	// The below needed to avoid timeout crash found using go-fuzz
+	if len(haystack) == 0 || len(needle) == 0 {
+		return nil
+	}
+
 	// One of the problems with finding locations ignoring case is that
 	// the different case representations can have different byte counts
 	// which means the locations using strings or bytes Index can be off
@@ -109,8 +119,8 @@ func IndexAllIgnoreCaseUnicode(haystack string, needle string, limit int) [][]in
 	// you the need to validate a potential match after you have found one.
 	// The confirmation match is done in a loop because for some literals regular expression
 	// is still to slow, although for most its a valid option.
-
 	locs := [][]int{}
+
 	// Char limit is the cut-off where we switch from all case permutations
 	// to just the first 3 and then check for an actual match
 	// in my tests 3 speeds things up the most against test data

string/index_test.go

@@ -95,6 +95,14 @@ func TestDropInReplacementMultiple(t *testing.T) {
 	}
 }
 
+func TestIndexAllIgnoreCaseUnicodeEmpty(t *testing.T) {
+	matches := IndexAllIgnoreCaseUnicode("", "2", -1)
+
+	if matches != nil {
+		t.Error("Expected no matches")
+	}
+}
+
 func TestIndexAllIgnoreCaseUnicodeLongNeedleNoMatch(t *testing.T) {
 	matches := IndexAllIgnoreCaseUnicode("aaaaabbbbb", "aaaaaa", -1)