Fix formula exact text matching not match substrings (#2267)

- Update unit test
- Add tilde wildcard criteria support

Author: jpoz

calc.go

@@ -101,6 +101,20 @@ const (
 )
 
 var (
+	// wildcardTokenRE tokenizes an Excel wildcard pattern into tilde-escaped
+	// sequences, bare wildcards (* ?), or any other single character.
+	wildcardTokenRE = regexp.MustCompile(`~[*?~]|[*?]|[\s\S]`)
+	// wildcardPatternMap maps each token produced by wildcardTokenRE to its
+	// regular-expression equivalent. Tokens absent from the map are literals.
+	wildcardPatternMap = map[string]string{
+		"~*": regexp.QuoteMeta("*"),
+		"~?": regexp.QuoteMeta("?"),
+		"~~": regexp.QuoteMeta("~"),
+		"*":  ".*",
+		"?":  ".",
+	}
+	// wildcardBareTokens is the set of tokens that represent real wildcards.
+	wildcardBareTokens = map[string]bool{"*": true, "?": true}
 	// tokenPriority defined basic arithmetic operator priority
 	tokenPriority = map[string]int{
 		"^":  5,
@@ -1184,12 +1198,20 @@ func calcPow(rOpd, lOpd formulaArg, opdStack *Stack) error {
 
 // calcEq evaluate equal arithmetic operations.
 func calcEq(rOpd, lOpd formulaArg, opdStack *Stack) error {
+	if rOpd.Type == ArgString && lOpd.Type == ArgString {
+		opdStack.Push(newBoolFormulaArg(strings.EqualFold(lOpd.Value(), rOpd.Value())))
+		return nil
+	}
 	opdStack.Push(newBoolFormulaArg(rOpd.Value() == lOpd.Value()))
 	return nil
 }
 
 // calcNEq evaluate not equal arithmetic operations.
 func calcNEq(rOpd, lOpd formulaArg, opdStack *Stack) error {
+	if rOpd.Type == ArgString && lOpd.Type == ArgString {
+		opdStack.Push(newBoolFormulaArg(!strings.EqualFold(lOpd.Value(), rOpd.Value())))
+		return nil
+	}
 	opdStack.Push(newBoolFormulaArg(rOpd.Value() != lOpd.Value()))
 	return nil
 }
@@ -1860,13 +1882,21 @@ func formulaCriteriaParser(exp formulaArg) *formulaCriteria {
 			return fc
 		}
 	}
-	if strings.Contains(val, "?") {
-		val = strings.ReplaceAll(val, "?", ".")
-	}
-	if strings.Contains(val, "*") {
-		val = strings.ReplaceAll(val, "*", ".*")
+	hasWildcard := false
+	pattern := wildcardTokenRE.ReplaceAllStringFunc(val, func(m string) string {
+		hasWildcard = hasWildcard || wildcardBareTokens[m]
+		if r, ok := wildcardPatternMap[m]; ok {
+			return r
+		}
+		return regexp.QuoteMeta(m)
+	})
+	if hasWildcard {
+		fc.Type, fc.Condition = criteriaRegexp, newStringFormulaArg("(?i)^"+pattern+"$")
+		return fc
 	}
-	fc.Type, fc.Condition = criteriaRegexp, newStringFormulaArg(val)
+	fc.Type, fc.Condition = criteriaEq, newStringFormulaArg(
+		strings.NewReplacer("~~", "~", "~*", "*", "~?", "?").Replace(val),
+	)
 	if num := fc.Condition.ToNumber(); num.Type == ArgNumber {
 		fc.Condition = num
 	}

calc_test.go

@@ -5739,6 +5739,47 @@ func TestCalcSUMIFSAndAVERAGEIFS(t *testing.T) {
 	}
 }
 
+func TestCalcSUMIFExactMatch(t *testing.T) {
+	cellData := [][]interface{}{
+		{"Category", "Amount"},
+		{"text", 100},
+		{"***_***_text", 200},
+		{"text", 150},
+		{"***_text_***", 300},
+		{"TEXT", 50},
+		{"other", 400},
+	}
+	f := prepareCalcData(cellData)
+	formulaList := map[string]string{
+		`SUMIF(A2:A7,"text",B2:B7)`:           "300",
+		`COUNTIF(A2:A7,"text")`:               "3",
+		`SUMIF(A2:A7,".",B2:B7)`:              "0",
+		`SUMIF(A2:A7,".*",B2:B7)`:             "0",
+		`SUMIF(A2:A7,".?",B2:B7)`:             "0",
+		`SUMIF(A2:A7,"*text*",B2:B7)`:         "800",
+		`SUMIF(A2:A7,"text*",B2:B7)`:          "300",
+		`SUMIF(A2:A7,"*text",B2:B7)`:          "500",
+		`SUMIF(A2:A7,"*",B2:B7)`:              "1200",
+		`SUMIF(A2:A7,"othe?",B2:B7)`:          "400",
+		`SUMIF(A2:A7,"~**",B2:B7)`:            "500",
+		`COUNTIF(A2:A7,"*text*")`:             "5",
+		`COUNTIF(A2:A7,"~*")`:                 "0",
+		`COUNTIF(A2:A7,"~~")`:                 "0",
+		`COUNTIF(A2:A7,"~?")`:                 "0",
+		`COUNTIF(A2:A7,"*~**")`:               "2",
+		`COUNTIF(A2:A7,"~*~*~*_~*~*~*_text")`: "1",
+		`COUNTIF(A2:A7,"~*~*~*_text_~*~*~*")`: "1",
+		`COUNTIF(A2:A7,"~a")`:                 "0",
+		`COUNTIF(A2:A7,"<>text")`:             "3",
+	}
+	for formula, expected := range formulaList {
+		assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula))
+		result, err := f.CalcCellValue("Sheet1", "C1")
+		assert.NoError(t, err, formula)
+		assert.Equal(t, expected, result, formula)
+	}
+}
+
 func TestCalcXIRR(t *testing.T) {
 	cellData := [][]interface{}{
 		{-100.00, 42370},