Added test on multiple string matching algorithm (#232)

Author: WilliamChang80

.github/workflows/golangci-lint.yml

@@ -29,7 +29,7 @@ jobs:
       - run: golangci-lint run --no-config searches                           || true
       - run: golangci-lint run --no-config sorts
       # - run: golangci-lint run --no-config strings/...
-      - run: golangci-lint run --no-config "strings/multiple string matching" || true
+      - run: golangci-lint run --no-config "strings/multiple-string-matching" || true
       # - run: golangci-lint run --no-config "strings/single string matching"   || true
       - run: golangci-lint run --no-config strings/levenshteindistance
       - run: golangci-lint run --no-config strings/naivesearch

strings/multiple string matching/adac.go renamed to strings/multiple-string-matching/advanced-aho-corasick/adac.go

@@ -1,4 +1,4 @@
-package main
+package advancedahocorasick
 
 import (
 	"fmt"
@@ -13,14 +13,18 @@ import (
 // Set to false for quick and quiet execution.
 const debugMode bool = true
 
+type result struct {
+	occurrences map[string][]int
+}
+
 // Implementation of Advanced Aho-Corasick algorithm (Prefix based).
 // Searches for a set of strings (patterns.txt) in text.txt.
 func main() {
-	patFile, err := ioutil.ReadFile("patterns.txt")
+	patFile, err := ioutil.ReadFile("../patterns.txt")
 	if err != nil {
 		log.Fatal(err)
 	}
-	textFile, err := ioutil.ReadFile("text.txt")
+	textFile, err := ioutil.ReadFile("../text.txt")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -40,14 +44,25 @@ func main() {
 	if debugMode == true {
 		fmt.Printf("\n\nIn text (%d chars long): \n%q\n\n", len(textFile), textFile)
 	}
-	ahoCorasick(string(textFile), patterns)
+	r := ahoCorasick(string(textFile), patterns)
+	for key, value := range r.occurrences { //prints all occurrences of each pattern (if there was at least one)
+		fmt.Printf("\nThere were %d occurences for word: %q at positions: ", len(value), key)
+		for i := range value {
+			fmt.Printf("%d", value[i])
+			if i != len(value)-1 {
+				fmt.Printf(", ")
+			}
+		}
+		fmt.Printf(".")
+	}
+	return
 }
 
 // Function performing the Advanced Aho-Corasick alghoritm.
-// Finds and prints occurences of each pattern.
-func ahoCorasick(t string, p []string) {
+// Finds and prints occurrences of each pattern.
+func ahoCorasick(t string, p []string) result {
 	startTime := time.Now()
-	occurences := make(map[int][]int)
+	occurrences := make(map[int][]int)
 	ac, f := buildExtendedAc(p)
 	if debugMode == true {
 		fmt.Printf("\n\nAC:\n\n")
@@ -66,26 +81,24 @@ func ahoCorasick(t string, p []string) {
 					if debugMode == true {
 						fmt.Printf("Occurence at position %d, %q = %q\n", pos-len(p[f[current][i]])+1, p[f[current][i]], p[f[current][i]])
 					}
-					newOccurences := intArrayCapUp(occurences[f[current][i]])
-					occurences[f[current][i]] = newOccurences
-					occurences[f[current][i]][len(newOccurences)-1] = pos - len(p[f[current][i]]) + 1
+					newOccurrences := intArrayCapUp(occurrences[f[current][i]])
+					occurrences[f[current][i]] = newOccurrences
+					occurrences[f[current][i]][len(newOccurrences)-1] = pos - len(p[f[current][i]]) + 1
 				}
 			}
 		}
 	}
 	elapsed := time.Since(startTime)
 	fmt.Printf("\n\nElapsed %f secs\n", elapsed.Seconds())
-	for key, value := range occurences { //prints all occurences of each pattern (if there was at least one)
-		fmt.Printf("\nThere were %d occurences for word: %q at positions: ", len(value), p[key])
-		for i := range value {
-			fmt.Printf("%d", value[i])
-			if i != len(value)-1 {
-				fmt.Printf(", ")
-			}
-		}
-		fmt.Printf(".")
+
+	var resultOccurrences = make(map[string][]int)
+	for key, value := range occurrences {
+		resultOccurrences[p[key]] = value
+	}
+
+	return result{
+		resultOccurrences,
 	}
-	return
 }
 
 // Functions that builds extended Aho Corasick automaton.

strings/multiple-string-matching/advanced-aho-corasick/adac_test.go

@@ -0,0 +1,79 @@
+package advancedahocorasick
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+var testCases = []struct {
+	name     string
+	words    []string
+	text     string
+	expected result
+}{
+
+	{
+		"String comparison on all patterns found",
+		[]string{"announce", "annual", "annually"},
+		"CPM_annual_conferenceannounce_announce_annually_announce",
+		result{
+			map[string][]int{
+				"annual":   {4, 39},
+				"announce": {21, 30, 48},
+				"annually": {39},
+			},
+		},
+	},
+	{
+		"String comparison on not all patterns found",
+		[]string{"announce", "annual", "annually"},
+		"CPM_annual_conference_announce",
+		result{
+			map[string][]int{
+				"annual":   {4},
+				"announce": {22},
+			},
+		},
+	},
+	{
+		"String comparison on not all patterns found",
+		[]string{"announce", "annual", "annually"},
+		"CPM_annual_conference_announce",
+		result{
+			map[string][]int{
+				"annual":   {4},
+				"announce": {22},
+			},
+		},
+	},
+}
+
+func TestAhoCorasick(t *testing.T) {
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := ahoCorasick(tc.text, tc.words)
+			if !reflect.DeepEqual(actual, tc.expected) {
+				actualString := convertToString(actual)
+				expectedString := convertToString(tc.expected)
+				t.Errorf("Expected matches for patterns %s for string '%s' are: patterns and positions found %v, but actual matches are: patterns and positions found %v",
+					tc.words, tc.text, actualString, expectedString)
+			}
+		})
+	}
+}
+
+func convertToString(res result) string {
+	var r string
+	for key, val := range res.occurrences {
+		r = r + fmt.Sprintf("Word: '%s' at positions: ", key)
+		for i := range val {
+			r = r + fmt.Sprintf("%d", val[i])
+			if i != len(val)-1 {
+				r = r + fmt.Sprintf(", ")
+			}
+		}
+		r = r + fmt.Sprintf(". ")
+	}
+	return r
+}

strings/multiple string matching/ac.go renamed to strings/multiple-string-matching/aho-corasick/ac.go

@@ -1,4 +1,4 @@
-package main
+package ahocorasick
 
 import (
 	"fmt"
@@ -13,14 +13,18 @@ import (
 // Set to false for quick and quiet execution.
 const debugMode bool = true
 
+type result struct {
+	occurrences map[string][]int
+}
+
 // Implementation of Basic Aho-Corasick algorithm (Prefix based).
 // Searches for a set of strings (patterns.txt) in text.txt.
 func main() {
-	patFile, err := ioutil.ReadFile("patterns.txt")
+	patFile, err := ioutil.ReadFile("../patterns.txt")
 	if err != nil {
 		log.Fatal(err)
 	}
-	textFile, err := ioutil.ReadFile("text.txt")
+	textFile, err := ioutil.ReadFile("../text.txt")
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -40,14 +44,24 @@ func main() {
 	if debugMode == true {
 		fmt.Printf("\n\nIn text (%d chars long): \n%q\n\n", len(textFile), textFile)
 	}
-	ahoCorasick(string(textFile), patterns)
+	r := ahoCorasick(string(textFile), patterns)
+	for key, value := range r.occurrences { //prints all occurrences of each pattern (if there was at least one)
+		fmt.Printf("\nThere were %d occurences for word: %q at positions: ", len(value), key)
+		for i := range value {
+			fmt.Printf("%d", value[i])
+			if i != len(value)-1 {
+				fmt.Printf(", ")
+			}
+		}
+		fmt.Printf(".")
+	}
 }
 
-// Function performing the Basic Aho-Corasick alghoritm.
-// Finds and prints occurences of each pattern.
-func ahoCorasick(t string, p []string) {
+// Function performing the Basic Aho-Corasick algorithm.
+// Finds and prints occurrences of each pattern.
+func ahoCorasick(t string, p []string) result {
 	startTime := time.Now()
-	occurences := make(map[int][]int)
+	occurrences := make(map[int][]int)
 	ac, f, s := buildAc(p)
 	if debugMode == true {
 		fmt.Printf("\n\nAC:\n\n")
@@ -76,26 +90,23 @@ func ahoCorasick(t string, p []string) {
 					if debugMode == true {
 						fmt.Printf("Occurence at position %d, %q = %q\n", pos-len(p[f[current][i]])+1, p[f[current][i]], p[f[current][i]])
 					}
-					newOccurences := intArrayCapUp(occurences[f[current][i]])
-					occurences[f[current][i]] = newOccurences
-					occurences[f[current][i]][len(newOccurences)-1] = pos - len(p[f[current][i]]) + 1
+					newOccurrences := intArrayCapUp(occurrences[f[current][i]])
+					occurrences[f[current][i]] = newOccurrences
+					occurrences[f[current][i]][len(newOccurrences)-1] = pos - len(p[f[current][i]]) + 1
 				}
 			}
 		}
 	}
 	elapsed := time.Since(startTime)
 	fmt.Printf("\n\nElapsed %f secs\n", elapsed.Seconds())
-	for key, value := range occurences { //prints all occurences of each pattern (if there was at least one)
-		fmt.Printf("\nThere were %d occurences for word: %q at positions: ", len(value), p[key])
-		for i := range value {
-			fmt.Printf("%d", value[i])
-			if i != len(value)-1 {
-				fmt.Printf(", ")
-			}
-		}
-		fmt.Printf(".")
+	var resultOccurrences = make(map[string][]int)
+	for key, value := range occurrences {
+		resultOccurrences[p[key]] = value
+	}
+
+	return result{
+		resultOccurrences,
 	}
-	return
 }
 
 // Functions that builds Aho Corasick automaton.
@@ -191,7 +202,7 @@ func constructTrie(p []string) (trie map[int]map[uint8]int, stateIsTerminal []bo
 }
 
 /**
-Returns 'true' if arry of int's 's' contains int 'e', 'false' otherwise.
+Returns 'true' if array of int's 's' contains int 'e', 'false' otherwise.
 
 @author Mostafa http://stackoverflow.com/a/10485970
 */

strings/multiple-string-matching/aho-corasick/ac_test.go

@@ -0,0 +1,79 @@
+package ahocorasick
+
+import (
+	"fmt"
+	"reflect"
+	"testing"
+)
+
+var testCases = []struct {
+	name     string
+	words    []string
+	text     string
+	expected result
+}{
+
+	{
+		"String comparison on all patterns found",
+		[]string{"announce", "annual", "annually"},
+		"CPM_annual_conferenceannounce_announce_annually_announce",
+		result{
+			map[string][]int{
+				"annual":   {4, 39},
+				"announce": {21,30,48},
+				"annually": {39},
+			},
+		},
+	},
+	{
+		"String comparison on not all patterns found",
+		[]string{"announce", "annual", "annually"},
+		"CPM_annual_conference_announce",
+		result{
+			map[string][]int{
+				"annual":   {4},
+				"announce": {22},
+			},
+		},
+	},
+	{
+		"String comparison on not all patterns found",
+		[]string{"announce", "annual", "annually"},
+		"CPM_annual_conference_announce",
+		result{
+			map[string][]int{
+				"annual":   {4},
+				"announce": {22},
+			},
+		},
+	},
+}
+
+func TestAhoCorasick(t *testing.T) {
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := ahoCorasick(tc.text, tc.words)
+			if !reflect.DeepEqual(actual, tc.expected) {
+				actualString := convertToString(actual)
+				expectedString := convertToString(tc.expected)
+				t.Errorf("Expected matches for patterns %s for string '%s' are: patterns and positions found %v, but actual matches are: patterns and positions found %v",
+					tc.words, tc.text, actualString, expectedString)
+			}
+		})
+	}
+}
+
+func convertToString(res result) string {
+	var r string
+	for key, val := range res.occurrences {
+		r = r + fmt.Sprintf("Word: '%s' at positions: ", key)
+		for i := range val {
+			r = r + fmt.Sprintf("%d", val[i])
+			if i != len(val)-1 {
+				r = r + fmt.Sprintf(", ")
+			}
+		}
+		r = r + fmt.Sprintf(". ")
+	}
+	return r
+}