Go Test Helpers for String Manipulation

This challenge focuses on building reusable test helper functions in Go to streamline the process of testing string manipulation logic. Well-crafted test helpers reduce boilerplate code, improve test readability, and ensure consistent testing practices across your codebase.

Problem Description

Your task is to create a set of Go test helper functions that can be used to assert the expected outcomes of various string manipulation operations. Specifically, you need to implement functions that:

1. Check if a string contains a substring: This helper should verify if a given string contains another specified substring.
2. Check if a string starts with a prefix: This helper should verify if a given string begins with a specified prefix.
3. Check if a string ends with a suffix: This helper should verify if a given string concludes with a specified suffix.

These helpers should integrate seamlessly with Go's standard testing package, providing clear error messages when assertions fail.

Key Requirements:

• Each helper function should accept the t *testing.T object as its first argument.
• The helper functions should have clear, descriptive names (e.g., AssertStringContains, AssertStringStartsWith, AssertStringEndsWith).
• Upon failure, each helper should use t.Errorf or t.Fatalf to report the discrepancy with a user-friendly message. The message should clearly indicate what was expected and what was received.
• The helpers should handle empty strings and nil values gracefully (though for this challenge, assume valid string inputs for simplicity unless otherwise specified in constraints).

Expected Behavior:

• If the assertion passes, the test should continue execution.
• If the assertion fails, the test should report an error and potentially stop execution (depending on whether Errorf or Fatalf is used).

Edge Cases:

• Empty target strings.
• Empty search strings (substrings, prefixes, suffixes).
• Target strings that are identical to the search string.

Examples

Example 1: String Contains Helper

// Assume this is in a _test.go file and we are testing a hypothetical function:
// func ProcessString(input string) string { ... }

func TestProcessString_Contains(t *testing.T) {
	input := "Hello, World!"
	expectedSubstring := "World"
	actualOutput := "Hello, World!" // Assuming ProcessString returns this for this input

	// Test Helper Call
	AssertStringContains(t, actualOutput, expectedSubstring)
}

Expected Output (if actualOutput did not contain expectedSubstring):

FAIL: TestProcessString_Contains
    your_test_file.go:15: String "..." did not contain substring "..."

Explanation: The AssertStringContains helper would be called with the actual output of a function and the expected substring. If the actualOutput does not contain expectedSubstring, an error is reported.

Example 2: String Starts With Helper

func TestProcessString_StartsWith(t *testing.T) {
	input := "Go Programming"
	expectedPrefix := "Go"
	actualOutput := "Go Programming"

	// Test Helper Call
	AssertStringStartsWith(t, actualOutput, expectedPrefix)
}

Expected Output (if actualOutput did not start with expectedPrefix):

FAIL: TestProcessString_StartsWith
    your_test_file.go:25: String "..." did not start with prefix "..."

Explanation: The AssertStringStartsWith helper checks if actualOutput begins with expectedPrefix.

Example 3: String Ends With Helper

func TestProcessString_EndsWith(t *testing.T) {
	input := "Testing in Go"
	expectedSuffix := "Go"
	actualOutput := "Testing in Go"

	// Test Helper Call
	AssertStringEndsWith(t, actualOutput, expectedSuffix)
}

Expected Output (if actualOutput did not end with expectedSuffix):

FAIL: TestProcessString_EndsWith
    your_test_file.go:35: String "..." did not end with suffix "..."

Explanation: The AssertStringEndsWith helper verifies if actualOutput concludes with expectedSuffix.

Constraints

• The helper functions should only use standard Go libraries, specifically the testing package and its built-in string functions (e.g., strings.Contains, strings.HasPrefix, strings.HasSuffix).
• Focus on clear and informative error messages. The specific wording of the error message is less important than its clarity and the inclusion of expected vs. actual values.
• Performance is not a primary concern for these helper functions; readability and correctness are paramount.

Notes

• Consider using t.Helper() within your test helper functions. This is a crucial Go testing idiom that improves the reporting of errors by marking the helper function as such, so that the line number reported in a test failure points to the line in the test function, not within the helper.
• You will be writing the helper functions themselves, not the code that uses them (though the examples show how they would be used).
• Think about how to make the error messages as helpful as possible when a test fails. What information would you want to see if one of these assertions broke?