Merge pull request #219 from Mystigan/master

Add tests for Levenshtein distance and naive search algorithms

Author: Mystigan

.github/workflows/golangci-lint.yml

@@ -29,6 +29,8 @@ jobs:
       - run: golangci-lint run --no-config other                              || true
       - 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/...
       - 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/levenshteinDistance.go renamed to strings/levenshteindistance/levenshteinDistance.go

@@ -4,16 +4,11 @@ Parameters: two strings to compare and weights of insertion, substitution and de
 Output: distance between both strings
 */
 
-package main
-
-import (
-	"fmt"
-)
+package levenshteindistance
 
 func levenshteinDistance(str1, str2 string, icost, scost, dcost int) int {
 	row1 := make([]int, len(str2)+1)
 	row2 := make([]int, len(str2)+1)
-	var tmp []int
 
 	for i := 1; i <= len(str2); i++ {
 		row1[i] = i * icost
@@ -39,35 +34,8 @@ func levenshteinDistance(str1, str2 string, icost, scost, dcost int) int {
 				}
 			}
 		}
-
-		tmp = row1
-		row1 = row2
-		row2 = tmp
+		row1, row2 = row2, row1
 	}
 
 	return row1[len(row1)-1]
 }
-
-func min(str1, str2 int) int {
-	if str1 < str2 {
-		return str1
-	}
-	return str2
-}
-
-func main() {
-	str1 := "stingy"
-	str2 := "ring"
-
-	// Using weight 1 for insertion, substitution and deletion
-	strDistance1 := levenshteinDistance(str1, str2, 1, 1, 1)
-	fmt.Printf("Distance between \"%s\" and \"%s\" is: %d.\n", str1, str2, strDistance1)
-	// Output: Distance between "stingy" and "ring" is: 3.
-
-	// Using weight 1 for insertion/substitution and weight 3 for deletion
-	strDistance2 := levenshteinDistance(str1, str2, 1, 1, 3)
-	fmt.Printf("Distance between \"%s\" and \"%s\" is: %d.\n", str1, str2, strDistance2)
-	// Output: Distance between "stingy" and "ring" is: 7.
-
-	return
-}

strings/levenshteindistance/levenshteinDistance_test.go

@@ -0,0 +1,52 @@
+package levenshteindistance
+
+import "testing"
+
+var testCases = []struct {
+	name             string
+	string1          string
+	string2          string
+	insertionCost    int
+	substitutionCost int
+	deletionCost     int
+	expected         int
+}{
+	{
+		"strings with equal operation weights.",
+		"stingy",
+		"ring",
+		1,
+		1,
+		1,
+		3,
+	},
+	{
+		"strings with different operation weights.",
+		"stingy",
+		"ring",
+		1,
+		1,
+		3,
+		7,
+	},
+	{
+		"strings with different operation weights.",
+		"kitten",
+		"sitting",
+		1,
+		1,
+		1,
+		3,
+	},
+}
+
+func TestLevenshteinDistance(t *testing.T) {
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := levenshteinDistance(tc.string1, tc.string2, tc.insertionCost, tc.substitutionCost, tc.deletionCost)
+			if actual != tc.expected {
+				t.Errorf("Expected Levenshtein distance between strings: '%s' and '%s' is %v, but got: %v", tc.string1, tc.string2, tc.expected, actual)
+			}
+		})
+	}
+}

strings/naiveStringSearch.go renamed to strings/naivesearch/naiveStringSearch.go

@@ -8,15 +8,11 @@ Time Complexity : O(n*m)
     m = length of pattern
 */
 
-package main
-
-import (
-	"fmt"
-)
+package naivesearch
 
 func naivePatternSearch(text string, pattern string) []int {
 	var positions []int
-	for i := 0; i < len(text)-len(pattern); i++ {
+	for i := 0; i <= len(text)-len(pattern); i++ {
 		var match bool = true
 		for j := 0; j < len(pattern); j++ {
 			if text[i+j] != pattern[j] {
@@ -31,15 +27,3 @@ func naivePatternSearch(text string, pattern string) []int {
 	}
 	return positions
 }
-
-func main() {
-	text := "ABAAABCDBBABCDDEBCABC"
-	pattern := "ABC"
-	var positions []int = naivePatternSearch(text, pattern)
-	if len(positions) == 0 {
-		fmt.Printf("Pattern not found in given text!")
-	} else {
-		fmt.Printf("Pattern found in following position:\n")
-		fmt.Printf("%v", positions)
-	}
-}

strings/naivesearch/naiveStringSearch_test.go

@@ -0,0 +1,49 @@
+package naivesearch
+
+import (
+	"reflect"
+	"testing"
+)
+
+var testCases = []struct {
+	name     string
+	input    string
+	pattern  string
+	expected []int
+}{
+	{
+		"string with multiple pattern matches",
+		"ABAAABCDBBABCDDEBCABC",
+		"ABC",
+		[]int{4, 10, 18},
+	},
+	{
+		"string with single pattern match",
+		"ABCDEFGHIJKLMN",
+		"CDE",
+		[]int{2},
+	},
+	{
+		"string with no pattern match",
+		"ABCDEFGHIJKLMN",
+		"XYZ",
+		[]int(nil),
+	},
+	{
+		"empty string",
+		"",
+		"XYZ",
+		[]int(nil),
+	},
+}
+
+func TestNaivePatternSearch(t *testing.T) {
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			actual := naivePatternSearch(tc.input, tc.pattern)
+			if !reflect.DeepEqual(actual, tc.expected) {
+				t.Errorf("Expected matches for pattern '%s' for string '%s' are: %v, but actual matches are: %v", tc.pattern, tc.input, tc.expected, actual)
+			}
+		})
+	}
+}