go/src/strings/strings_test.go

func collect(t *testing.T, seq iter.Seq[string]) []string {}

type LinesTest

var linesTests

func TestLines(t *testing.T) {}

var abcd

var faces

var commas

var dots

type IndexTest

var indexTests

var lastIndexTests

var indexAnyTests

var lastIndexAnyTests

// Execute f on each test case.  funcName should be the name of f; it's used
// in failure reports.
func runIndexTests(t *testing.T, f func(s, sep string) int, funcName string, testCases []IndexTest) {}

func TestIndex(t *testing.T)     {}

func TestLastIndex(t *testing.T) {}

func TestIndexAny(t *testing.T)  {}

func TestLastIndexAny(t *testing.T) {}

func TestIndexByte(t *testing.T) {}

func TestLastIndexByte(t *testing.T) {}

func simpleIndex(s, sep string) int {}

func TestIndexRandom(t *testing.T) {}

func TestIndexRune(t *testing.T) {}

const benchmarkString

func BenchmarkIndexRune(b *testing.B) {}

var benchmarkLongString

func BenchmarkIndexRuneLongString(b *testing.B) {}

func BenchmarkIndexRuneFastPath(b *testing.B) {}

func BenchmarkIndex(b *testing.B) {}

func BenchmarkLastIndex(b *testing.B) {}

func BenchmarkIndexByte(b *testing.B) {}

type SplitTest

var splittests

func TestSplit(t *testing.T) {}

var splitaftertests

func TestSplitAfter(t *testing.T) {}

type FieldsTest

var fieldstests

func TestFields(t *testing.T) {}

var FieldsFuncTests

func TestFieldsFunc(t *testing.T) {}

type StringTest

// Execute f on each test case.  funcName should be the name of f; it's used
// in failure reports.
func runStringTests(t *testing.T, f func(string) string, funcName string, testCases []StringTest) {}

var upperTests

var lowerTests

const space

var trimSpaceTests

func tenRunes(ch rune) string {}

// User-defined self-inverse mapping function
func rot13(r rune) rune {}

func TestMap(t *testing.T) {}

func TestToUpper(t *testing.T) {}

func TestToLower(t *testing.T) {}

var toValidUTF8Tests

func TestToValidUTF8(t *testing.T) {}

func BenchmarkToUpper(b *testing.B) {}

func BenchmarkToLower(b *testing.B) {}

func BenchmarkMapNoChanges(b *testing.B) {}

func TestSpecialCase(t *testing.T) {}

func TestTrimSpace(t *testing.T) {}

var trimTests

func TestTrim(t *testing.T) {}

func BenchmarkTrim(b *testing.B) {}

func BenchmarkToValidUTF8(b *testing.B) {}

type predicate

var isSpace

var isDigit

var isUpper

var isValidRune

func not(p predicate) predicate {}

var trimFuncTests

func TestTrimFunc(t *testing.T) {}

var indexFuncTests

func TestIndexFunc(t *testing.T) {}

func equal(m string, s1, s2 string, t *testing.T) bool {}

func TestCaseConsistency(t *testing.T) {}

var longString

var longSpaces

var RepeatTests

func TestRepeat(t *testing.T) {}

func repeat(s string, count int) (err error) {}

// See Issue golang.org/issue/16237
func TestRepeatCatchesOverflow(t *testing.T) {}

func runesEqual(a, b []rune) bool {}

var RunesTests

func TestRunes(t *testing.T) {}

func TestReadByte(t *testing.T) {}

func TestReadRune(t *testing.T) {}

var UnreadRuneErrorTests

func TestUnreadRuneError(t *testing.T) {}

var ReplaceTests

func TestReplace(t *testing.T) {}

var TitleTests

func TestTitle(t *testing.T) {}

var ContainsTests

func TestContains(t *testing.T) {}

var ContainsAnyTests

func TestContainsAny(t *testing.T) {}

var ContainsRuneTests

func TestContainsRune(t *testing.T) {}

func TestContainsFunc(t *testing.T) {}

var EqualFoldTests

func TestEqualFold(t *testing.T) {}

func BenchmarkEqualFold(b *testing.B) {}

var CountTests

func TestCount(t *testing.T) {}

var cutTests

func TestCut(t *testing.T) {}

var cutPrefixTests

func TestCutPrefix(t *testing.T) {}

var cutSuffixTests

func TestCutSuffix(t *testing.T) {}

func makeBenchInputHard() string {}

var benchInputHard

func benchmarkIndexHard(b *testing.B, sep string) {}

func benchmarkLastIndexHard(b *testing.B, sep string) {}

func benchmarkCountHard(b *testing.B, sep string) {}

func BenchmarkIndexHard1(b *testing.B) {}

func BenchmarkIndexHard2(b *testing.B) {}

func BenchmarkIndexHard3(b *testing.B) {}

func BenchmarkIndexHard4(b *testing.B) {}

func BenchmarkLastIndexHard1(b *testing.B) {}

func BenchmarkLastIndexHard2(b *testing.B) {}

func BenchmarkLastIndexHard3(b *testing.B) {}

func BenchmarkCountHard1(b *testing.B) {}

func BenchmarkCountHard2(b *testing.B) {}

func BenchmarkCountHard3(b *testing.B) {}

var benchInputTorture

var benchNeedleTorture

func BenchmarkIndexTorture(b *testing.B) {}

func BenchmarkCountTorture(b *testing.B) {}

func BenchmarkCountTortureOverlapping(b *testing.B) {}

func BenchmarkCountByte(b *testing.B) {}

var makeFieldsInput

var makeFieldsInputASCII

var stringdata

func BenchmarkFields(b *testing.B) {}

func BenchmarkFieldsFunc(b *testing.B) {}

func BenchmarkSplitEmptySeparator(b *testing.B) {}

func BenchmarkSplitSingleByteSeparator(b *testing.B) {}

func BenchmarkSplitMultiByteSeparator(b *testing.B) {}

func BenchmarkSplitNSingleByteSeparator(b *testing.B) {}

func BenchmarkSplitNMultiByteSeparator(b *testing.B) {}

func BenchmarkRepeat(b *testing.B) {}

func BenchmarkRepeatLarge(b *testing.B) {}

func BenchmarkRepeatSpaces(b *testing.B) {}

func BenchmarkIndexAnyASCII(b *testing.B) {}

func BenchmarkIndexAnyUTF8(b *testing.B) {}

func BenchmarkLastIndexAnyASCII(b *testing.B) {}

func BenchmarkLastIndexAnyUTF8(b *testing.B) {}

func BenchmarkTrimASCII(b *testing.B) {}

func BenchmarkTrimByte(b *testing.B) {}

func BenchmarkIndexPeriodic(b *testing.B) {}

func BenchmarkJoin(b *testing.B) {}

func BenchmarkTrimSpace(b *testing.B) {}

var stringSink

func BenchmarkReplaceAll(b *testing.B) {}