Implement custom shell command tests and pipeline stages

.gitignore

@@ -11,5 +11,4 @@ my_exe
 anticheat
 notes.md
 shell_notes.md
-
 .devcontainer

Makefile

@@ -24,6 +24,9 @@ tests_excluding_ash:
 test_cat_against_bsd_cat:
 	TESTER_DIR=$(shell pwd) go test -count=1 -p 1 -v ./internal/custom_executable/cat/... -system
 
+test_grep_against_bsd_grep:
+	TESTER_DIR=$(shell pwd) go test -count=1 -p 1 -v ./internal/custom_executable/grep/... -system
+
 test_head_against_bsd_head:
 	TESTER_DIR=$(shell pwd) go test -count=1 -p 1 -v ./internal/custom_executable/head/... -system
 
@@ -41,6 +44,7 @@ test_yes_against_bsd_yes:
 
 test_executables_against_their_bsd_counterparts:
 	make test_cat_against_bsd_cat
+	test_grep_against_bsd_grep
 	make test_head_against_bsd_head
 	make test_ls_against_bsd_ls
 	make test_tail_against_bsd_tail
@@ -82,8 +86,9 @@ build_executables:
 		for arch in $$arches; do \
 		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/signature_printer_$${os}_$${arch} ./internal/custom_executable/signature_printer/main.go; \
 		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/cat_$${os}_$${arch} ./internal/custom_executable/cat/cat.go; \
-		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/ls_$${os}_$${arch} ./internal/custom_executable/ls/ls.go; \
+		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/grep_$${os}_$${arch} ./internal/custom_executable/grep/grep.go; \
 		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/head_$${os}_$${arch} ./internal/custom_executable/head/head.go; \
+		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/ls_$${os}_$${arch} ./internal/custom_executable/ls/ls.go; \
 		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/tail_$${os}_$${arch} ./internal/custom_executable/tail/tail.go; \
 		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/wc_$${os}_$${arch} ./internal/custom_executable/wc/wc.go; \
 		GOOS="$$os" GOARCH="$$arch" go build -o built_executables/yes_$${os}_$${arch} ./internal/custom_executable/yes/yes.go; \
@@ -146,6 +151,14 @@ define _COMPLETIONS_STAGES_COMPLEX
   {"slug":"wh6","tester_log_prefix":"tester::#wh6","title":"Stage#5: completion with multiple executables"}
 endef
 
+define _PIPELINE_STAGES
+[ \
+	{"slug":"br6","tester_log_prefix":"tester::#br6","title":"Stage#1: Basic dual-command pipeline"}, \
+	{"slug":"ny9","tester_log_prefix":"tester::#ny9","title":"Stage#4: Pipelines with built-ins"}, \
+	{"slug":"xk3","tester_log_prefix":"tester::#xk3","title":"Stage#6: Multi-command pipelines"} \
+]
+endef
+
 # Use eval to properly escape the stage arrays
 define quote_strings
 	$(shell echo '$(1)' | sed 's/"/\\"/g')
@@ -170,6 +183,7 @@ QUOTING_STAGES = $(call quote_strings,$(_QUOTING_STAGES))
 REDIRECTIONS_STAGES = $(call quote_strings,$(_REDIRECTIONS_STAGES))
 COMPLETIONS_STAGES_ZSH = $(call quote_strings,$(_COMPLETION_STAGES_BASE))
 COMPLETIONS_STAGES = $(shell echo '$(_COMPLETION_STAGES_BASE)' | sed 's/]$$/, $(_COMPLETIONS_STAGES_COMPLEX)]/' | sed 's/"/\\"/g')
+PIPELINE_STAGES = $(call quote_strings,$(_PIPELINE_STAGES))
 
 test_base_w_ash: build
 	$(call run_test,$(BASE_STAGES),ash)
@@ -201,6 +215,9 @@ test_redirections_w_bash: build
 test_completions_w_bash: build
 	$(call run_test,$(COMPLETIONS_STAGES),bash)
 
+test_pipeline_w_bash: build
+	$(call run_test,$(PIPELINE_STAGES),bash)
+
 test_base_w_dash: build
 	$(call run_test,$(BASE_STAGES),dash)
 

internal/assertions/single_line_assertion.go

@@ -27,8 +27,8 @@ func (a SingleLineAssertion) Inspect() string {
 }
 
 func (a SingleLineAssertion) Run(screenState [][]string, startRowIndex int) (processedRowCount int, err *AssertionError) {
-	if a.ExpectedOutput == "" {
-		panic("CodeCrafters Internal Error: ExpectedOutput must be provided")
+	if a.ExpectedOutput == "" && len(a.FallbackPatterns) == 0 {
+		panic("CodeCrafters Internal Error: ExpectedOutput or fallbackPatterns must be provided")
 	}
 
 	processedRowCount = 1

internal/custom_executable/build/grep.go

@@ -0,0 +1,11 @@
+package custom_executable
+
+import "fmt"
+
+func CreateGrepExecutable(outputPath string) error {
+	err := createExecutableForOSAndArch("grep", outputPath)
+	if err != nil {
+		return fmt.Errorf("CodeCrafters Internal Error: creating executable %s failed: %w", "grep", err)
+	}
+	return nil
+}

internal/custom_executable/grep/grep.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"strings"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Fprintln(os.Stderr, "Usage: grep PATTERN")
+		os.Exit(2) // Standard exit code for grep usage error
+	}
+
+	pattern := os.Args[1]
+	scanner := bufio.NewScanner(os.Stdin)
+	found := false
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.Contains(line, pattern) {
+			fmt.Println(line)
+			found = true
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		fmt.Fprintf(os.Stderr, "grep: error reading input: %v\n", err)
+		os.Exit(2)
+	}
+
+	if !found {
+		os.Exit(1) // Standard exit code for grep when no lines match
+	}
+
+	os.Exit(0)
+}

internal/custom_executable/grep/grep_test.go

@@ -0,0 +1,182 @@
+package main
+
+import (
+	"bytes"
+	"errors"
+	"flag"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"testing"
+)
+
+// Pass the -system flag to use system grep instead of custom implementation
+// go test ./... -system
+// Tests only pass against BSD implementation of grep, not GNU implementation
+// Run on darwin only
+var useSystemGrep = flag.Bool("system", false, "Use system grep instead of custom implementation")
+
+func getGrepExecutable(t *testing.T) string {
+	testerDir := filepath.Join(os.Getenv("TESTER_DIR"), "built_executables")
+	if *useSystemGrep {
+		return "grep"
+	}
+
+	switch runtime.GOOS {
+	case "darwin":
+		switch runtime.GOARCH {
+		case "arm64":
+			return filepath.Join(testerDir, "grep_darwin_arm64")
+		case "amd64":
+			return filepath.Join(testerDir, "grep_darwin_amd64")
+		}
+	case "linux":
+		switch runtime.GOARCH {
+		case "amd64":
+			return filepath.Join(testerDir, "grep_linux_amd64")
+		case "arm64":
+			return filepath.Join(testerDir, "grep_linux_arm64")
+		}
+	}
+	t.Fatalf("Unsupported OS: %s", runtime.GOOS)
+	return ""
+}
+
+// runGrep runs the grep executable with given arguments and returns its output and error if any
+func runGrep(t *testing.T, stdinContent string, args ...string) (string, string, int, error) {
+	executable := getGrepExecutable(t)
+
+	t.Helper()
+	prettyPrintCommand(args)
+	cmd := exec.Command(executable, args...)
+
+	if stdinContent != "" {
+		cmd.Stdin = strings.NewReader(stdinContent)
+	}
+
+	var stdout, stderr bytes.Buffer
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	err := cmd.Run()
+
+	exitCode := 0
+	if err != nil {
+		var exitError *exec.ExitError
+		if errors.As(err, &exitError) {
+			exitCode = exitError.ExitCode()
+		}
+	}
+
+	return stdout.String(), stderr.String(), exitCode, err // Return err as well
+}
+
+func prettyPrintCommand(args []string) {
+	// Basic pretty printing, similar to cat/wc tests
+	displayArgs := make([]string, len(args))
+	copy(displayArgs, args)
+	// Potentially shorten paths or quote arguments if needed here
+
+	out := fmt.Sprintf("=== RUN:  > grep %s", strings.Join(displayArgs, " "))
+	fmt.Println(out)
+}
+
+// TestGrepStdin tests grep functionality reading from standard input.
+func TestGrepStdin(t *testing.T) {
+	tests := []struct {
+		name         string
+		pattern      string
+		input        string
+		expectedOut  string
+		expectedErr  string
+		expectedExit int
+	}{
+		{
+			name:         "Simple match",
+			pattern:      "hello",
+			input:        "hello world\nthis is a test\nhello again",
+			expectedOut:  "hello world\nhello again\n",
+			expectedErr:  "",
+			expectedExit: 0,
+		},
+		{
+			name:         "No match",
+			pattern:      "goodbye",
+			input:        "hello world\nthis is a test",
+			expectedOut:  "",
+			expectedErr:  "",
+			expectedExit: 1,
+		},
+		{
+			name:         "Empty input",
+			pattern:      "test",
+			input:        "",
+			expectedOut:  "",
+			expectedErr:  "",
+			expectedExit: 1,
+		},
+		{
+			name:         "Match on empty string pattern",
+			pattern:      "", // Our simple strings.Contains matches everything
+			input:        "line1\nline2",
+			expectedOut:  "line1\nline2\n",
+			expectedErr:  "",
+			expectedExit: 0,
+			// Note: Real grep might error or behave differently with empty pattern
+		},
+		{
+			name:         "Usage error - no pattern",
+			pattern:      "", // Args will be empty
+			input:        "test",
+			expectedOut:  "",
+			expectedErr:  "Usage: grep PATTERN\n",
+			expectedExit: 2,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var args []string
+
+			if *useSystemGrep && tt.name == "Usage error - no pattern" {
+				return // Skip this test for System grep
+			}
+			if tt.name != "Usage error - no pattern" {
+				args = append(args, tt.pattern)
+			} // else args remains empty
+
+			stdout, stderr, exitCode, runErr := runGrep(t, tt.input, args...)
+
+			// Check exit code first, as stderr/stdout might be irrelevant if exit code is wrong
+			if exitCode != tt.expectedExit {
+				// Include stdout/stderr in the error message for better debugging
+				t.Errorf("Expected exit code %d, got %d. Stderr: %q, Stdout: %q, RunErr: %v",
+					tt.expectedExit, exitCode, stderr, stdout, runErr)
+			}
+
+			// Now check stdout and stderr
+			if stdout != tt.expectedOut {
+				t.Errorf("Expected stdout %q, got %q", tt.expectedOut, stdout)
+			}
+
+			if stderr != tt.expectedErr {
+				t.Errorf("Expected stderr %q, got %q", tt.expectedErr, stderr)
+			}
+
+			// Handle expected usage error specifically
+			if tt.expectedExit == 2 && runErr == nil {
+				t.Errorf("Expected a non-nil error for usage error case, but got nil")
+			} else if tt.expectedExit != 2 && runErr != nil {
+				// If we didn't expect an error exit, but got one, check if it was *exec.ExitError
+				if _, ok := runErr.(*exec.ExitError); !ok {
+					// It was some other error during execution
+					t.Errorf("Command execution failed unexpectedly: %v", runErr)
+				}
+				// If it *was* an ExitError, we already checked the exit code above.
+			}
+		})
+	}
+}

internal/custom_executable/head/head.go

@@ -264,20 +264,40 @@ func processLines(reader io.Reader, lineCount int) error {
 		return nil
 	}
 
-	scanner := bufio.NewScanner(reader)
-
 	if lineCount > 0 {
 		// Print first N lines
 		linesRead := 0
-		for scanner.Scan() && linesRead < lineCount {
-			fmt.Println(scanner.Text())
-			linesRead++
+		// Use bufio.Reader to preserve original line endings
+		bufReader := bufio.NewReader(reader)
+		for linesRead < lineCount {
+			lineBytes, err := bufReader.ReadBytes('\n')
+			if len(lineBytes) > 0 {
+				// Write the bytes read, including the newline if present
+				_, writeErr := os.Stdout.Write(lineBytes)
+				if writeErr != nil {
+					return writeErr
+				}
+				// Only increment linesRead if we actually wrote something that ended with a newline
+				// or if it was the last line of the file without a newline
+				if err == nil || (err == io.EOF && len(lineBytes) > 0) {
+					linesRead++
+				}
+			}
+			if err != nil {
+				if err == io.EOF {
+					break // Reached end of file
+				}
+				return err // Return other errors
+			}
 		}
-		return scanner.Err()
+		return nil // Success
 	}
 
 	// For negative line count (all but last N lines)
-	// We need to keep a rolling buffer of the last N lines
+	// Scanner logic is likely okay here as we print lines *before* the last N
+	// Keep existing scanner logic for negative count
+	scanner := bufio.NewScanner(reader)
+
 	absCount := -lineCount
 	var lines []string
 	for scanner.Scan() {