claudetool/edit_test.go - sketch - Gitiles

 package claudetool

 import (
 	"context"
 	"encoding/json"
 	"os"
 	"path/filepath"
 	"strings"
 	"testing"
 )

 // setupTestFile creates a temporary file with given content for testing
 func setupTestFile(t *testing.T, content string) string {
 	t.Helper()

 	// Create a temporary directory
 	tempDir, err := os.MkdirTemp("", "anthropic_edit_test_*")
 	if err != nil {
 		t.Fatalf("Failed to create temp directory: %v", err)
 	}

 	// Create a test file in the temp directory
 	testFile := filepath.Join(tempDir, "test_file.txt")
 	if err := os.WriteFile(testFile, []byte(content), 0o644); err != nil {
 		os.RemoveAll(tempDir)
 		t.Fatalf("Failed to write test file: %v", err)
 	}

 	// Register cleanup function
 	t.Cleanup(func() {
 		os.RemoveAll(tempDir)
 	})

 	return testFile
 }

 // callEditTool is a helper to call the edit tool with specific parameters
 func callEditTool(t *testing.T, input map[string]any) string {
 	t.Helper()

 	// Convert input to JSON
 	inputJSON, err := json.Marshal(input)
 	if err != nil {
 		t.Fatalf("Failed to marshal input: %v", err)
 	}

 	// Call the tool
 	result, err := EditRun(context.Background(), inputJSON)
 	if err != nil {
 		t.Fatalf("Tool execution failed: %v", err)
 	}

 	return ContentToString(result)
 }

 // TestEditToolView tests the view command functionality
 func TestEditToolView(t *testing.T) {
 	content := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
 	testFile := setupTestFile(t, content)

 	// Test the view command
 	result := callEditTool(t, map[string]any{
 		"command": "view",
 		"path":    testFile,
 	})

 	// Verify results
 	if !strings.Contains(result, "Line 1") {
 		t.Errorf("View result should contain the file content, got: %s", result)
 	}

 	// Test view with range
 	result = callEditTool(t, map[string]any{
 		"command":    "view",
 		"path":       testFile,
 		"view_range": []int{2, 4},
 	})

 	// Verify range results
 	if strings.Contains(result, "Line 1") || !strings.Contains(result, "Line 2") {
 		t.Errorf("View with range should show only specified lines, got: %s", result)
 	}
 }

 // TestEditToolStrReplace tests the str_replace command functionality
 func TestEditToolStrReplace(t *testing.T) {
 	content := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
 	testFile := setupTestFile(t, content)

 	// Test the str_replace command
 	result := callEditTool(t, map[string]any{
 		"command": "str_replace",
 		"path":    testFile,
 		"old_str": "Line 3",
 		"new_str": "Modified Line 3",
 	})

 	// Verify the file was modified
 	modifiedContent, err := os.ReadFile(testFile)
 	if err != nil {
 		t.Fatalf("Failed to read test file: %v", err)
 	}

 	if !strings.Contains(string(modifiedContent), "Modified Line 3") {
 		t.Errorf("File content should be modified, got: %s", string(modifiedContent))
 	}

 	// Verify the result contains a snippet
 	if !strings.Contains(result, "Modified Line 3") {
 		t.Errorf("Result should contain the modified content, got: %s", result)
 	}
 }

 // TestEditToolInsert tests the insert command functionality
 func TestEditToolInsert(t *testing.T) {
 	content := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
 	testFile := setupTestFile(t, content)

 	// Test the insert command
 	result := callEditTool(t, map[string]any{
 		"command":     "insert",
 		"path":        testFile,
 		"insert_line": 2,
 		"new_str":     "Inserted Line",
 	})

 	// Verify the file was modified
 	modifiedContent, err := os.ReadFile(testFile)
 	if err != nil {
 		t.Fatalf("Failed to read test file: %v", err)
 	}

 	expected := "Line 1\nLine 2\nInserted Line\nLine 3\nLine 4\nLine 5"
 	if string(modifiedContent) != expected {
 		t.Errorf("File content incorrect after insert. Expected:\n%s\nGot:\n%s", expected, string(modifiedContent))
 	}

 	// Verify the result contains a snippet
 	if !strings.Contains(result, "Inserted Line") {
 		t.Errorf("Result should contain the inserted content, got: %s", result)
 	}
 }

 // TestEditToolCreate tests the create command functionality
 func TestEditToolCreate(t *testing.T) {
 	tempDir, err := os.MkdirTemp("", "anthropic_edit_test_create_*")
 	if err != nil {
 		t.Fatalf("Failed to create temp directory: %v", err)
 	}

 	t.Cleanup(func() {
 		os.RemoveAll(tempDir)
 	})

 	newFilePath := filepath.Join(tempDir, "new_file.txt")
 	content := "This is a new file\nWith multiple lines"

 	// Test the create command
 	result := callEditTool(t, map[string]any{
 		"command":   "create",
 		"path":      newFilePath,
 		"file_text": content,
 	})

 	// Verify the file was created with the right content
 	createdContent, err := os.ReadFile(newFilePath)
 	if err != nil {
 		t.Fatalf("Failed to read created file: %v", err)
 	}

 	if string(createdContent) != content {
 		t.Errorf("Created file content incorrect. Expected:\n%s\nGot:\n%s", content, string(createdContent))
 	}

 	// Verify the result message
 	if !strings.Contains(result, "File created successfully") {
 		t.Errorf("Result should confirm file creation, got: %s", result)
 	}
 }

 // TestEditToolUndoEdit tests the undo_edit command functionality
 func TestEditToolUndoEdit(t *testing.T) {
 	originalContent := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
 	testFile := setupTestFile(t, originalContent)

 	// First modify the file
 	callEditTool(t, map[string]any{
 		"command": "str_replace",
 		"path":    testFile,
 		"old_str": "Line 3",
 		"new_str": "Modified Line 3",
 	})

 	// Then undo the edit
 	result := callEditTool(t, map[string]any{
 		"command": "undo_edit",
 		"path":    testFile,
 	})

 	// Verify the file was restored to original content
 	restoredContent, err := os.ReadFile(testFile)
 	if err != nil {
 		t.Fatalf("Failed to read test file: %v", err)
 	}

 	if string(restoredContent) != originalContent {
 		t.Errorf("File content should be restored to original, got: %s", string(restoredContent))
 	}

 	// Verify the result message
 	if !strings.Contains(result, "undone successfully") {
 		t.Errorf("Result should confirm undo operation, got: %s", result)
 	}
 }

 // TestEditToolErrors tests various error conditions
 func TestEditToolErrors(t *testing.T) {
 	content := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
 	testFile := setupTestFile(t, content)

 	testCases := []struct {
 		name   string
 		input  map[string]any
 		errMsg string
 	}{
 		{
 			name: "Invalid command",
 			input: map[string]any{
 				"command": "invalid_command",
 				"path":    testFile,
 			},
 			errMsg: "unrecognized command",
 		},
 		{
 			name: "Non-existent file",
 			input: map[string]any{
 				"command": "view",
 				"path":    "/non/existent/file.txt",
 			},
 			errMsg: "does not exist",
 		},
 		{
 			name: "Missing required parameter",
 			input: map[string]any{
 				"command": "str_replace",
 				"path":    testFile,
 				// Missing old_str
 			},
 			errMsg: "parameter old_str is required",
 		},
 		{
 			name: "Multiple occurrences in str_replace",
 			input: map[string]any{
 				"command": "str_replace",
 				"path":    testFile,
 				"old_str": "Line", // Appears multiple times
 				"new_str": "Modified Line",
 			},
 			errMsg: "Multiple occurrences",
 		},
 		{
 			name: "Invalid view range",
 			input: map[string]any{
 				"command":    "view",
 				"path":       testFile,
 				"view_range": []int{10, 20}, // Out of range
 			},
 			errMsg: "invalid view_range",
 		},
 	}

 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			inputJSON, err := json.Marshal(tc.input)
 			if err != nil {
 				t.Fatalf("Failed to marshal input: %v", err)
 			}

 			_, err = EditRun(context.Background(), inputJSON)
 			if err == nil {
 				t.Fatalf("Expected error but got none")
 			}

 			if !strings.Contains(err.Error(), tc.errMsg) {
 				t.Errorf("Error message does not contain expected text. Expected to contain: %q, Got: %q", tc.errMsg, err.Error())
 			}
 		})
 	}
 }

 // TestHandleStrReplaceEdgeCases tests the handleStrReplace function specifically for edge cases
 // that could cause panics like "index out of range [0] with length 0"
 func TestHandleStrReplaceEdgeCases(t *testing.T) {
 	// The issue was with strings.Split returning an empty slice when the separator wasn't found
 	// This test directly tests the internal implementation with conditions that might cause this

 	// Create a test file with empty content
 	emptyFile := setupTestFile(t, "")

 	// Test with empty file content and arbitrary oldStr
 	_, err := handleStrReplace(emptyFile, "some string that doesn't exist", "new content")
 	if err == nil {
 		t.Fatal("Expected error for empty file but got none")
 	}
 	if !strings.Contains(err.Error(), "did not appear verbatim") {
 		t.Errorf("Expected error message to indicate missing string, got: %s", err.Error())
 	}

 	// Create a file with content that doesn't match oldStr
 	nonMatchingFile := setupTestFile(t, "This is some content\nthat doesn't contain the target string")

 	// Test with content that doesn't contain oldStr
 	_, err = handleStrReplace(nonMatchingFile, "target string not present", "replacement")
 	if err == nil {
 		t.Fatal("Expected error for non-matching content but got none")
 	}
 	if !strings.Contains(err.Error(), "did not appear verbatim") {
 		t.Errorf("Expected error message to indicate missing string, got: %s", err.Error())
 	}

 	// Test handling of the edge case that could potentially cause the "index out of range" panic
 	// This directly verifies that the handleStrReplace function properly handles the case where
 	// strings.Split returns an empty or unexpected result

 	// Verify that the protection against empty parts slice works
 	fileContent := ""
 	oldStr := "some string"
 	parts := strings.Split(fileContent, oldStr)
 	if len(parts) == 0 {
 		// This should match the protection in the code
 		parts = []string{""}
 	}

 	// This should not panic with the fix in place
 	_ = strings.Count(parts[0], "\n") // This line would have panicked without the fix
 }

 // TestViewRangeWithStrReplace tests that the view_range parameter works correctly
 // with the str_replace command (tests the full workflow)
 func TestViewRangeWithStrReplace(t *testing.T) {
 	// Create test file with multiple lines
 	content := "Line 1: First line\nLine 2: Second line\nLine 3: Third line\nLine 4: Fourth line\nLine 5: Fifth line"
 	testFile := setupTestFile(t, content)

 	// First view a subset of the file using view_range
 	viewResult := callEditTool(t, map[string]any{
 		"command":    "view",
 		"path":       testFile,
 		"view_range": []int{2, 4}, // Only lines 2-4
 	})

 	// Verify that we only see the specified lines
 	if strings.Contains(viewResult, "Line 1:") || strings.Contains(viewResult, "Line 5:") {
 		t.Errorf("View with range should only show lines 2-4, got: %s", viewResult)
 	}
 	if !strings.Contains(viewResult, "Line 2:") || !strings.Contains(viewResult, "Line 4:") {
 		t.Errorf("View with range should show lines 2-4, got: %s", viewResult)
 	}

 	// Now perform a str_replace on one of the lines we viewed
 	replaceResult := callEditTool(t, map[string]any{
 		"command": "str_replace",
 		"path":    testFile,
 		"old_str": "Line 3: Third line",
 		"new_str": "Line 3: MODIFIED Third line",
 	})

 	// Check that the replacement was successful
 	if !strings.Contains(replaceResult, "Line 3: MODIFIED Third line") {
 		t.Errorf("Replace result should contain the modified line, got: %s", replaceResult)
 	}

 	// Verify the file content was updated correctly
 	modifiedContent, err := os.ReadFile(testFile)
 	if err != nil {
 		t.Fatalf("Failed to read test file after modification: %v", err)
 	}

 	expectedContent := "Line 1: First line\nLine 2: Second line\nLine 3: MODIFIED Third line\nLine 4: Fourth line\nLine 5: Fifth line"
 	if string(modifiedContent) != expectedContent {
 		t.Errorf("File content after replacement is incorrect.\nExpected:\n%s\nGot:\n%s",
 			expectedContent, string(modifiedContent))
 	}

 	// View the modified file with a different view_range
 	finalViewResult := callEditTool(t, map[string]any{
 		"command":    "view",
 		"path":       testFile,
 		"view_range": []int{3, 3}, // Only the modified line
 	})

 	// Verify we can see only the modified line
 	if !strings.Contains(finalViewResult, "Line 3: MODIFIED Third line") {
 		t.Errorf("Final view should show the modified line, got: %s", finalViewResult)
 	}
 	if strings.Contains(finalViewResult, "Line 2:") || strings.Contains(finalViewResult, "Line 4:") {
 		t.Errorf("Final view should only show line 3, got: %s", finalViewResult)
 	}
 }
	package claudetool

	import (
	"context"
	"encoding/json"
	"os"
	"path/filepath"
	"strings"
	"testing"
	)

	// setupTestFile creates a temporary file with given content for testing
	func setupTestFile(t *testing.T, content string) string {
	t.Helper()

	// Create a temporary directory
	tempDir, err := os.MkdirTemp("", "anthropic_edit_test_*")
	if err != nil {
	t.Fatalf("Failed to create temp directory: %v", err)
	}

	// Create a test file in the temp directory
	testFile := filepath.Join(tempDir, "test_file.txt")
	if err := os.WriteFile(testFile, []byte(content), 0o644); err != nil {
	os.RemoveAll(tempDir)
	t.Fatalf("Failed to write test file: %v", err)
	}

	// Register cleanup function
	t.Cleanup(func() {
	os.RemoveAll(tempDir)
	})

	return testFile
	}

	// callEditTool is a helper to call the edit tool with specific parameters
	func callEditTool(t *testing.T, input map[string]any) string {
	t.Helper()

	// Convert input to JSON
	inputJSON, err := json.Marshal(input)
	if err != nil {
	t.Fatalf("Failed to marshal input: %v", err)
	}

	// Call the tool
	result, err := EditRun(context.Background(), inputJSON)
	if err != nil {
	t.Fatalf("Tool execution failed: %v", err)
	}

	return ContentToString(result)
	}

	// TestEditToolView tests the view command functionality
	func TestEditToolView(t *testing.T) {
	content := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
	testFile := setupTestFile(t, content)

	// Test the view command
	result := callEditTool(t, map[string]any{
	"command": "view",
	"path": testFile,
	})

	// Verify results
	if !strings.Contains(result, "Line 1") {
	t.Errorf("View result should contain the file content, got: %s", result)
	}

	// Test view with range
	result = callEditTool(t, map[string]any{
	"command": "view",
	"path": testFile,
	"view_range": []int{2, 4},
	})

	// Verify range results
	if strings.Contains(result, "Line 1") \|\| !strings.Contains(result, "Line 2") {
	t.Errorf("View with range should show only specified lines, got: %s", result)
	}
	}

	// TestEditToolStrReplace tests the str_replace command functionality
	func TestEditToolStrReplace(t *testing.T) {
	content := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
	testFile := setupTestFile(t, content)

	// Test the str_replace command
	result := callEditTool(t, map[string]any{
	"command": "str_replace",
	"path": testFile,
	"old_str": "Line 3",
	"new_str": "Modified Line 3",
	})

	// Verify the file was modified
	modifiedContent, err := os.ReadFile(testFile)
	if err != nil {
	t.Fatalf("Failed to read test file: %v", err)
	}

	if !strings.Contains(string(modifiedContent), "Modified Line 3") {
	t.Errorf("File content should be modified, got: %s", string(modifiedContent))
	}

	// Verify the result contains a snippet
	if !strings.Contains(result, "Modified Line 3") {
	t.Errorf("Result should contain the modified content, got: %s", result)
	}
	}

	// TestEditToolInsert tests the insert command functionality
	func TestEditToolInsert(t *testing.T) {
	content := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
	testFile := setupTestFile(t, content)

	// Test the insert command
	result := callEditTool(t, map[string]any{
	"command": "insert",
	"path": testFile,
	"insert_line": 2,
	"new_str": "Inserted Line",
	})

	// Verify the file was modified
	modifiedContent, err := os.ReadFile(testFile)
	if err != nil {
	t.Fatalf("Failed to read test file: %v", err)
	}

	expected := "Line 1\nLine 2\nInserted Line\nLine 3\nLine 4\nLine 5"
	if string(modifiedContent) != expected {
	t.Errorf("File content incorrect after insert. Expected:\n%s\nGot:\n%s", expected, string(modifiedContent))
	}

	// Verify the result contains a snippet
	if !strings.Contains(result, "Inserted Line") {
	t.Errorf("Result should contain the inserted content, got: %s", result)
	}
	}

	// TestEditToolCreate tests the create command functionality
	func TestEditToolCreate(t *testing.T) {
	tempDir, err := os.MkdirTemp("", "anthropic_edit_test_create_*")
	if err != nil {
	t.Fatalf("Failed to create temp directory: %v", err)
	}

	t.Cleanup(func() {
	os.RemoveAll(tempDir)
	})

	newFilePath := filepath.Join(tempDir, "new_file.txt")
	content := "This is a new file\nWith multiple lines"

	// Test the create command
	result := callEditTool(t, map[string]any{
	"command": "create",
	"path": newFilePath,
	"file_text": content,
	})

	// Verify the file was created with the right content
	createdContent, err := os.ReadFile(newFilePath)
	if err != nil {
	t.Fatalf("Failed to read created file: %v", err)
	}

	if string(createdContent) != content {
	t.Errorf("Created file content incorrect. Expected:\n%s\nGot:\n%s", content, string(createdContent))
	}

	// Verify the result message
	if !strings.Contains(result, "File created successfully") {
	t.Errorf("Result should confirm file creation, got: %s", result)
	}
	}

	// TestEditToolUndoEdit tests the undo_edit command functionality
	func TestEditToolUndoEdit(t *testing.T) {
	originalContent := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
	testFile := setupTestFile(t, originalContent)

	// First modify the file
	callEditTool(t, map[string]any{
	"command": "str_replace",
	"path": testFile,
	"old_str": "Line 3",
	"new_str": "Modified Line 3",
	})

	// Then undo the edit
	result := callEditTool(t, map[string]any{
	"command": "undo_edit",
	"path": testFile,
	})

	// Verify the file was restored to original content
	restoredContent, err := os.ReadFile(testFile)
	if err != nil {
	t.Fatalf("Failed to read test file: %v", err)
	}

	if string(restoredContent) != originalContent {
	t.Errorf("File content should be restored to original, got: %s", string(restoredContent))
	}

	// Verify the result message
	if !strings.Contains(result, "undone successfully") {
	t.Errorf("Result should confirm undo operation, got: %s", result)
	}
	}

	// TestEditToolErrors tests various error conditions
	func TestEditToolErrors(t *testing.T) {
	content := "Line 1\nLine 2\nLine 3\nLine 4\nLine 5"
	testFile := setupTestFile(t, content)

	testCases := []struct {
	name string
	input map[string]any
	errMsg string
	}{
	{
	name: "Invalid command",
	input: map[string]any{
	"command": "invalid_command",
	"path": testFile,
	},
	errMsg: "unrecognized command",
	},
	{
	name: "Non-existent file",
	input: map[string]any{
	"command": "view",
	"path": "/non/existent/file.txt",
	},
	errMsg: "does not exist",
	},
	{
	name: "Missing required parameter",
	input: map[string]any{
	"command": "str_replace",
	"path": testFile,
	// Missing old_str
	},
	errMsg: "parameter old_str is required",
	},
	{
	name: "Multiple occurrences in str_replace",
	input: map[string]any{
	"command": "str_replace",
	"path": testFile,
	"old_str": "Line", // Appears multiple times
	"new_str": "Modified Line",
	},
	errMsg: "Multiple occurrences",
	},
	{
	name: "Invalid view range",
	input: map[string]any{
	"command": "view",
	"path": testFile,
	"view_range": []int{10, 20}, // Out of range
	},
	errMsg: "invalid view_range",
	},
	}

	for _, tc := range testCases {
	t.Run(tc.name, func(t *testing.T) {
	inputJSON, err := json.Marshal(tc.input)
	if err != nil {
	t.Fatalf("Failed to marshal input: %v", err)
	}

	_, err = EditRun(context.Background(), inputJSON)
	if err == nil {
	t.Fatalf("Expected error but got none")
	}

	if !strings.Contains(err.Error(), tc.errMsg) {
	t.Errorf("Error message does not contain expected text. Expected to contain: %q, Got: %q", tc.errMsg, err.Error())
	}
	})
	}
	}

	// TestHandleStrReplaceEdgeCases tests the handleStrReplace function specifically for edge cases
	// that could cause panics like "index out of range [0] with length 0"
	func TestHandleStrReplaceEdgeCases(t *testing.T) {
	// The issue was with strings.Split returning an empty slice when the separator wasn't found
	// This test directly tests the internal implementation with conditions that might cause this

	// Create a test file with empty content
	emptyFile := setupTestFile(t, "")

	// Test with empty file content and arbitrary oldStr
	_, err := handleStrReplace(emptyFile, "some string that doesn't exist", "new content")
	if err == nil {
	t.Fatal("Expected error for empty file but got none")
	}
	if !strings.Contains(err.Error(), "did not appear verbatim") {
	t.Errorf("Expected error message to indicate missing string, got: %s", err.Error())
	}

	// Create a file with content that doesn't match oldStr
	nonMatchingFile := setupTestFile(t, "This is some content\nthat doesn't contain the target string")

	// Test with content that doesn't contain oldStr
	_, err = handleStrReplace(nonMatchingFile, "target string not present", "replacement")
	if err == nil {
	t.Fatal("Expected error for non-matching content but got none")
	}
	if !strings.Contains(err.Error(), "did not appear verbatim") {
	t.Errorf("Expected error message to indicate missing string, got: %s", err.Error())
	}

	// Test handling of the edge case that could potentially cause the "index out of range" panic
	// This directly verifies that the handleStrReplace function properly handles the case where
	// strings.Split returns an empty or unexpected result

	// Verify that the protection against empty parts slice works
	fileContent := ""
	oldStr := "some string"
	parts := strings.Split(fileContent, oldStr)
	if len(parts) == 0 {
	// This should match the protection in the code
	parts = []string{""}
	}

	// This should not panic with the fix in place
	_ = strings.Count(parts[0], "\n") // This line would have panicked without the fix
	}

	// TestViewRangeWithStrReplace tests that the view_range parameter works correctly
	// with the str_replace command (tests the full workflow)
	func TestViewRangeWithStrReplace(t *testing.T) {
	// Create test file with multiple lines
	content := "Line 1: First line\nLine 2: Second line\nLine 3: Third line\nLine 4: Fourth line\nLine 5: Fifth line"
	testFile := setupTestFile(t, content)

	// First view a subset of the file using view_range
	viewResult := callEditTool(t, map[string]any{
	"command": "view",
	"path": testFile,
	"view_range": []int{2, 4}, // Only lines 2-4
	})

	// Verify that we only see the specified lines
	if strings.Contains(viewResult, "Line 1:") \|\| strings.Contains(viewResult, "Line 5:") {
	t.Errorf("View with range should only show lines 2-4, got: %s", viewResult)
	}
	if !strings.Contains(viewResult, "Line 2:") \|\| !strings.Contains(viewResult, "Line 4:") {
	t.Errorf("View with range should show lines 2-4, got: %s", viewResult)
	}

	// Now perform a str_replace on one of the lines we viewed
	replaceResult := callEditTool(t, map[string]any{
	"command": "str_replace",
	"path": testFile,
	"old_str": "Line 3: Third line",
	"new_str": "Line 3: MODIFIED Third line",
	})

	// Check that the replacement was successful
	if !strings.Contains(replaceResult, "Line 3: MODIFIED Third line") {
	t.Errorf("Replace result should contain the modified line, got: %s", replaceResult)
	}

	// Verify the file content was updated correctly
	modifiedContent, err := os.ReadFile(testFile)
	if err != nil {
	t.Fatalf("Failed to read test file after modification: %v", err)
	}

	expectedContent := "Line 1: First line\nLine 2: Second line\nLine 3: MODIFIED Third line\nLine 4: Fourth line\nLine 5: Fifth line"
	if string(modifiedContent) != expectedContent {
	t.Errorf("File content after replacement is incorrect.\nExpected:\n%s\nGot:\n%s",
	expectedContent, string(modifiedContent))
	}

	// View the modified file with a different view_range
	finalViewResult := callEditTool(t, map[string]any{
	"command": "view",
	"path": testFile,
	"view_range": []int{3, 3}, // Only the modified line
	})

	// Verify we can see only the modified line
	if !strings.Contains(finalViewResult, "Line 3: MODIFIED Third line") {
	t.Errorf("Final view should show the modified line, got: %s", finalViewResult)
	}
	if strings.Contains(finalViewResult, "Line 2:") \|\| strings.Contains(finalViewResult, "Line 4:") {
	t.Errorf("Final view should only show line 3, got: %s", finalViewResult)
	}
	}