init:

runner/matcher.go

@@ -0,0 +1,134 @@
+package runner
+
+import (
+	"fmt"
+	"math"
+	"regexp"
+	"sort"
+	"strconv"
+	"strings"
+
+	"github.com/Mond1c/judge/dsl"
+)
+
+func applyMatcher(label string, m dsl.Matcher, actual string) []string {
+	switch m := m.(type) {
+	case dsl.NoMatcher:
+		return nil
+	case dsl.ExactMatcher:
+		if actual != m.Value {
+			return []string{fmt.Sprintf(
+				"%s mismatch:\n  expected: %q\n  actual:   %q",
+				label, m.Value, actual,
+			)}
+		}
+		return nil
+	case dsl.ContainsMatcher:
+		if !strings.Contains(actual, m.Substr) {
+			return []string{fmt.Sprintf(
+				"%s: expected to contain %q, got %q",
+				label, m.Substr, actual,
+			)}
+		}
+		return nil
+	case dsl.RegexMatcher:
+		re, err := regexp.Compile(m.Pattern)
+		if err != nil {
+			return []string{fmt.Sprintf("%s: invalid regex %q: %v", label, m.Pattern, err)}
+		}
+		if !re.MatchString(actual) {
+			return []string{fmt.Sprintf(
+				"%s: %q does not match regex %q",
+				label, actual, m.Pattern,
+			)}
+		}
+		return nil
+
+	case dsl.NumericEpsMatcher:
+		errs := matchNumericEps(label, m, actual)
+		return errs
+
+	case dsl.AnyOrderMatcher:
+		return matchAnyOrder(label, m, actual)
+
+	default:
+		return []string{fmt.Sprintf("unknown matcher type %T", m)}
+
+	}
+}
+
+func matchNumericEps(label string, m dsl.NumericEpsMatcher, actual string) []string {
+	expectedNums, err := parseNumbers(m.Value)
+	if err != nil {
+		return []string{fmt.Sprintf("%s: cannot parse expected numbers %q: %v", label, m.Value, err)}
+	}
+	actualNums, err := parseNumbers(actual)
+	if err != nil {
+		return []string{fmt.Sprintf("%s: cannot parse actual numbers %q: %v", label, actual, err)}
+	}
+	if len(expectedNums) != len(actualNums) {
+		return []string{fmt.Sprintf(
+			"%s: expected %d numbers, got %d (expected=%q, actual=%q)",
+			label, len(expectedNums), len(actualNums), m.Value, actual,
+		)}
+	}
+	var errs []string
+	for i, exp := range expectedNums {
+		act := actualNums[i]
+		if math.Abs(exp-act) > m.Epsilon {
+			errs = append(errs, fmt.Sprintf(
+				"%s: number[%d] expected %.10g ± %.10g, got %.10g",
+				label, i, exp, m.Epsilon, act,
+			))
+		}
+	}
+	return errs
+}
+
+func parseNumbers(s string) ([]float64, error) {
+	fields := strings.Fields(s)
+	nums := make([]float64, 0, len(fields))
+	for _, f := range fields {
+		n, err := strconv.ParseFloat(f, 64)
+		if err != nil {
+			return nil, fmt.Errorf("not a number: %q", f)
+		}
+		nums = append(nums, n)
+	}
+	return nums, nil
+}
+
+func matchAnyOrder(label string, m dsl.AnyOrderMatcher, actual string) []string {
+	actualLines := splitLines(actual)
+	expectedLines := make([]string, len(m.Lines))
+	copy(expectedLines, m.Lines)
+
+	sort.Strings(actualLines)
+	sort.Strings(expectedLines)
+
+	if len(actualLines) != len(expectedLines) {
+		return []string{fmt.Sprintf(
+			"%s anyOrder: expected %d lines, got %d",
+			label, len(expectedLines), len(actualLines),
+		)}
+	}
+
+	var errs []string
+	for i := range expectedLines {
+		if actualLines[i] != expectedLines[i] {
+			errs = append(errs, fmt.Sprintf(
+				"%s anyOrder: line mismatch: expected %q, got %q",
+				label, expectedLines[i], actualLines[i],
+			))
+		}
+	}
+	return errs
+}
+
+func splitLines(s string) []string {
+	s = strings.TrimRight(s, "\n")
+	if s == "" {
+		return []string{}
+	}
+	return strings.Split(s, "\n")
+}