Merge branch 'highlighting-assertion-fixtures' into multiple-lines-stage-add

Author: UdeshyaDhungana

internal/assertions/highlighting_assertion.go

@@ -1,6 +1,7 @@
 package assertions
 
 import (
+	"bytes"
 	"errors"
 	"fmt"
 	"strings"
@@ -19,8 +20,9 @@ type HighlightingAssertion struct {
 	ExpectedOutput string
 
 	// These are temporary values calculated and reset in each run
-	actualResult executable.ExecutableResult
-	logger       *logger.Logger
+	actualResult               executable.ExecutableResult
+	matchesShouldbeHighlighted bool
+	logger                     *logger.Logger
 }
 
 func (a *HighlightingAssertion) getExpectedOutputOnRowIdx(lineIdx int) string {
@@ -40,8 +42,10 @@ func (a *HighlightingAssertion) Run(result executable.ExecutableResult, logger *
 		a.logger = nil
 	}()
 
-	a.actualResult = result
+	// Presence of ANSI coloring sequence implies that matches should be highlighted
+	a.matchesShouldbeHighlighted = bytes.Contains(result.Stdout, []byte("\033[01;31m"))
 	a.logger = logger.Clone()
+	a.actualResult = result
 
 	expectedLines := utils.ProgramOutputToLines(a.ExpectedOutput)
 	actualLines := utils.ProgramOutputToLines(string(result.Stdout))
@@ -119,7 +123,7 @@ func (a *HighlightingAssertion) assertHighlighting(expectedScreenState, actualSc
 	// Log success messages for each row
 	actualLines := actualScreenState.GetLinesOfTextUptoCursor()
 	for rowIdx := 0; rowIdx <= lastSuccessFulRowIndex; rowIdx++ {
-		if screenStateComparator.highlightingIsTurnedOn {
+		if a.matchesShouldbeHighlighted {
 			a.logger.Successf("✓ All matches in the line %q are highlighted", actualLines[rowIdx])
 		} else {
 			a.logger.Successf("✓ Line %q is not highlighted", actualLines[rowIdx])
@@ -134,33 +138,33 @@ func (a *HighlightingAssertion) assertHighlighting(expectedScreenState, actualSc
 	return nil
 }
 
-func (a *HighlightingAssertion) buildError(compErr *ComparisonError) error {
+func (a *HighlightingAssertion) buildError(comparisonError *ComparisonError) error {
 	var b strings.Builder
 
 	// Comparison error message first
 	b.WriteString(
 		buildComparisonErrorMessageWithCursor(
-			a.getExpectedOutputOnRowIdx(compErr.RowIdx),
-			a.getActualOutputOnLineIdx(compErr.RowIdx),
-			compErr.ColumnIdx,
+			a.getExpectedOutputOnRowIdx(comparisonError.RowIdx),
+			a.getActualOutputOnLineIdx(comparisonError.RowIdx),
+			comparisonError.ColumnIdx,
 		),
 	)
 	b.WriteString("\n")
 
 	// Print success messages
-	for _, successLog := range compErr.SuccessLogs {
+	for _, successLog := range comparisonError.PartialSuccessLogs {
 		b.WriteString(colorizeString(color.FgHiGreen, successLog))
 		b.WriteString("\n")
 	}
 
 	// Print error message
-	b.WriteString(colorizeString(color.FgHiRed, fmt.Sprintf("⨯ %s\n", compErr.ErrorString)))
+	b.WriteString(colorizeString(color.FgHiRed, fmt.Sprintf("⨯ %s\n", comparisonError.ErrorString)))
 
-	// Print ANSI sequence comparison
+	// Print ANSI code comparison
 	b.WriteString(
 		buildAnsiCodeMismatchComplaint(
-			compErr.ExpectedCell.Style.String(),
-			compErr.ActualCell.Style.String(),
+			comparisonError.ExpectedANSICode,
+			comparisonError.ACtualANSICode,
 		),
 	)
 

internal/assertions/highlighting_assertion_panic_if_flawed.go

@@ -19,13 +19,14 @@ func (a HighlightingAssertion) panicIfExpectedScreenStateisFlawed(expectedScreen
 
 	expectedLinesCount := len(utils.ProgramOutputToLines(a.ExpectedOutput))
 
-	// Assert that expected screen state only has one line in the output
-	if len(linesUptoCursor) > expectedLinesCount {
+	// Assert that expected screen state has exact expected number of line in the output
+	if len(linesUptoCursor) != expectedLinesCount {
 
 		outputLines := strings.Join(linesUptoCursor, "\n")
 
 		panic(fmt.Sprintf(
-			"Codecrafters Internal Error - Expected one line in output, grep returned %d:\n%s",
+			"Codecrafters Internal Error - Expected %d line in output, grep returned %d:\n%s",
+			expectedLinesCount,
 			len(linesUptoCursor),
 			outputLines,
 		))

internal/assertions/highlighting_assertion_screen_state_comparator.go

@@ -5,7 +5,6 @@ import (
 	"strings"
 
 	uv "github.com/charmbracelet/ultraviolet"
-	"github.com/charmbracelet/x/ansi"
 	"github.com/codecrafters-io/grep-tester/virtual_terminal"
 	"github.com/dustin/go-humanize/english"
 )
@@ -18,30 +17,29 @@ import (
 // This one is involved only with error detection and propagation
 // Highlighting assertion is responsible for using this and building proper error
 type screenStateComparator struct {
-	successLogs            []string
-	highlightingIsTurnedOn bool
+	partialSuccessLogs []string
 }
 
 // ComparisonError represents an error found during screen state comparison
 type ComparisonError struct {
-	RowIdx       int
-	ColumnIdx    int
-	ExpectedCell *uv.Cell
-	ActualCell   *uv.Cell
-	ErrorString  error
-	SuccessLogs  []string
+	RowIdx             int
+	ColumnIdx          int
+	ExpectedANSICode   string
+	ACtualANSICode     string
+	ErrorString        error
+	PartialSuccessLogs []string
 }
 
 func newScreenStateComparator() *screenStateComparator {
 	return &screenStateComparator{}
 }
 
-func (c *screenStateComparator) resetSuccessLogs() {
-	c.successLogs = []string{}
+func (c *screenStateComparator) resetPartialSuccessLogs() {
+	c.partialSuccessLogs = []string{}
 }
 
-func (c *screenStateComparator) addSuccessLog(successLog string) {
-	c.successLogs = append(c.successLogs, successLog)
+func (c *screenStateComparator) addPartialSuccessLog(successLog string) {
+	c.partialSuccessLogs = append(c.partialSuccessLogs, successLog)
 }
 
 func (c *screenStateComparator) CompareHighlighting(expected, actual *virtual_terminal.ScreenState) *ComparisonError {
@@ -51,25 +49,25 @@ func (c *screenStateComparator) CompareHighlighting(expected, actual *virtual_te
 	for rowIdx := range cursorPosition.RowIndex + 1 {
 
 		// Compare upto the column before in which the cursor is present
-		columnsCount := expected.GetColumnsCount()
+		maxColumnsCount := expected.GetColumnsCount()
 		if cursorPosition.RowIndex == rowIdx {
-			columnsCount = cursorPosition.ColumnIndex
+			maxColumnsCount = cursorPosition.ColumnIndex
 		}
 
 		// Compare cells
-		for columnIdx := range columnsCount {
+		for columnIdx := range maxColumnsCount {
 
 			expectedCell := expected.MustGetCellAtPosition(rowIdx, columnIdx)
 			actualCell := actual.MustGetCellAtPosition(rowIdx, columnIdx)
 
 			if err := c.compareCells(expectedCell, actualCell); err != nil {
 				return &ComparisonError{
-					RowIdx:       rowIdx,
-					ColumnIdx:    columnIdx,
-					ExpectedCell: expectedCell,
-					ActualCell:   actualCell,
-					ErrorString:  err,
-					SuccessLogs:  c.successLogs,
+					RowIdx:             rowIdx,
+					ColumnIdx:          columnIdx,
+					ErrorString:        err,
+					PartialSuccessLogs: c.partialSuccessLogs,
+					ExpectedANSICode:   expectedCell.Style.String(),
+					ACtualANSICode:     actualCell.Style.String(),
 				}
 			}
 		}
@@ -79,13 +77,8 @@ func (c *screenStateComparator) CompareHighlighting(expected, actual *virtual_te
 }
 
 func (c *screenStateComparator) compareCells(expected, actual *uv.Cell) error {
-	// Reset for each comparison
-	c.resetSuccessLogs()
-
-	// If a single cell is found which should be highlighted, which means highlighting is turned on for this run
-	if expected.Style.Fg == ansi.Red && expected.Style.Attrs == uv.AttrBold {
-		c.highlightingIsTurnedOn = true
-	}
+	// Reset for each cell
+	c.resetPartialSuccessLogs()
 
 	var firstError error
 
@@ -112,7 +105,7 @@ func (c *screenStateComparator) checkFgColor(expectedCell, actualCell *uv.Cell)
 		return fmt.Errorf("Expected %s, got %s", getFgColorName(expectedCell.Style.Fg), getFgColorName(actualCell.Style.Fg))
 	}
 
-	c.addSuccessLog(fmt.Sprintf("✓ Color is %s", getFgColorName(expectedCell.Style.Fg)))
+	c.addPartialSuccessLog(fmt.Sprintf("✓ Color is %s", getFgColorName(expectedCell.Style.Fg)))
 	return nil
 }
 
@@ -124,14 +117,14 @@ func (c *screenStateComparator) checkBoldAttr(expectedCell, actualCell *uv.Cell)
 		if expectedBold {
 			return fmt.Errorf("Expected character to be bold (ANSI code 01), was not bold")
 		} else {
-			return fmt.Errorf("Expected character to not be bold, was bold")
+			return fmt.Errorf("Expected character to not be bold, was bold (ANSI code 01)")
 		}
 	}
 
 	if expectedBold {
-		c.addSuccessLog("✓ Bold attribute is present")
+		c.addPartialSuccessLog("✓ Bold attribute is present")
 	} else {
-		c.addSuccessLog("✓ Bold attribute is not present")
+		c.addPartialSuccessLog("✓ Bold attribute is not present")
 	}
 
 	return nil

internal/assertions/utils.go

@@ -107,7 +107,7 @@ func getBgColorName(c color.Color) string {
 	return colorCodeTocolorName(colorCodeString)
 }
 
-var attrMap = []struct {
+var attributesMap = []struct {
 	flag uint8
 	name string
 }{
@@ -129,7 +129,7 @@ func attributesToNames(attributes uint8) []string {
 
 	var names []string
 
-	for _, attr := range attrMap {
+	for _, attr := range attributesMap {
 		if attributes&attr.flag != 0 {
 			names = append(names, attr.name)
 		}