aboutsummaryrefslogtreecommitdiff
path: root/src/pkg/strings
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/strings')
-rw-r--r--src/pkg/strings/reader.go20
-rw-r--r--src/pkg/strings/strings.go164
-rw-r--r--src/pkg/strings/strings_test.go160
3 files changed, 172 insertions, 172 deletions
diff --git a/src/pkg/strings/reader.go b/src/pkg/strings/reader.go
index 80c745bb8b..7cefbd24bb 100644
--- a/src/pkg/strings/reader.go
+++ b/src/pkg/strings/reader.go
@@ -11,28 +11,28 @@ import "os"
type Reader string
func (r *Reader) Read(b []byte) (n int, err os.Error) {
- s := *r;
+ s := *r
if len(s) == 0 {
return 0, os.EOF
}
for n < len(s) && n < len(b) {
- b[n] = s[n];
- n++;
+ b[n] = s[n]
+ n++
}
- *r = s[n:];
- return;
+ *r = s[n:]
+ return
}
func (r *Reader) ReadByte() (b byte, err os.Error) {
- s := *r;
+ s := *r
if len(s) == 0 {
return 0, os.EOF
}
- b = s[0];
- *r = s[1:];
- return;
+ b = s[0]
+ *r = s[1:]
+ return
}
// NewReader returns a new Reader reading from s.
// It is similar to bytes.NewBufferString but more efficient and read-only.
-func NewReader(s string) *Reader { return (*Reader)(&s) }
+func NewReader(s string) *Reader { return (*Reader)(&s) }
diff --git a/src/pkg/strings/strings.go b/src/pkg/strings/strings.go
index 4e375b4d5b..ae34a5f3c3 100644
--- a/src/pkg/strings/strings.go
+++ b/src/pkg/strings/strings.go
@@ -6,8 +6,8 @@
package strings
import (
- "unicode";
- "utf8";
+ "unicode"
+ "utf8"
)
// explode splits s into an array of UTF-8 sequences, one per Unicode character (still strings) up to a maximum of n (n <= 0 means no limit).
@@ -16,21 +16,21 @@ func explode(s string, n int) []string {
if n <= 0 {
n = len(s)
}
- a := make([]string, n);
- var size, rune int;
- na := 0;
+ a := make([]string, n)
+ var size, rune int
+ na := 0
for len(s) > 0 {
if na+1 >= n {
- a[na] = s;
- na++;
- break;
+ a[na] = s
+ na++
+ break
}
- rune, size = utf8.DecodeRuneInString(s);
- s = s[size:];
- a[na] = string(rune);
- na++;
+ rune, size = utf8.DecodeRuneInString(s)
+ s = s[size:]
+ a[na] = string(rune)
+ na++
}
- return a[0:na];
+ return a[0:na]
}
// Count counts the number of non-overlapping instances of sep in s.
@@ -38,24 +38,24 @@ func Count(s, sep string) int {
if sep == "" {
return utf8.RuneCountInString(s) + 1
}
- c := sep[0];
- n := 0;
+ c := sep[0]
+ n := 0
for i := 0; i+len(sep) <= len(s); i++ {
if s[i] == c && (len(sep) == 1 || s[i:i+len(sep)] == sep) {
- n++;
- i += len(sep) - 1;
+ n++
+ i += len(sep) - 1
}
}
- return n;
+ return n
}
// Index returns the index of the first instance of sep in s, or -1 if sep is not present in s.
func Index(s, sep string) int {
- n := len(sep);
+ n := len(sep)
if n == 0 {
return 0
}
- c := sep[0];
+ c := sep[0]
if n == 1 {
// special case worth making fast
for i := 0; i < len(s); i++ {
@@ -63,23 +63,23 @@ func Index(s, sep string) int {
return i
}
}
- return -1;
+ return -1
}
for i := 0; i+n <= len(s); i++ {
if s[i] == c && (n == 1 || s[i:i+n] == sep) {
return i
}
}
- return -1;
+ return -1
}
// LastIndex returns the index of the last instance of sep in s, or -1 if sep is not present in s.
func LastIndex(s, sep string) int {
- n := len(sep);
+ n := len(sep)
if n == 0 {
return len(s)
}
- c := sep[0];
+ c := sep[0]
if n == 1 {
// special case worth making fast
for i := len(s) - 1; i >= 0; i-- {
@@ -87,14 +87,14 @@ func LastIndex(s, sep string) int {
return i
}
}
- return -1;
+ return -1
}
for i := len(s) - n; i >= 0; i-- {
if s[i] == c && (n == 1 || s[i:i+n] == sep) {
return i
}
}
- return -1;
+ return -1
}
// Generic split: splits after each instance of sep,
@@ -106,26 +106,26 @@ func genSplit(s, sep string, sepSave, n int) []string {
if n <= 0 {
n = Count(s, sep) + 1
}
- c := sep[0];
- start := 0;
- a := make([]string, n);
- na := 0;
+ c := sep[0]
+ start := 0
+ a := make([]string, n)
+ na := 0
for i := 0; i+len(sep) <= len(s) && na+1 < n; i++ {
if s[i] == c && (len(sep) == 1 || s[i:i+len(sep)] == sep) {
- a[na] = s[start : i+sepSave];
- na++;
- start = i + len(sep);
- i += len(sep) - 1;
+ a[na] = s[start : i+sepSave]
+ na++
+ start = i + len(sep)
+ i += len(sep) - 1
}
}
- a[na] = s[start:];
- return a[0 : na+1];
+ a[na] = s[start:]
+ return a[0 : na+1]
}
// Split splits the string s around each instance of sep, returning an array of substrings of s.
// If sep is empty, Split splits s after each UTF-8 sequence.
// If n > 0, Split splits s into at most n substrings; the last substring will be the unsplit remainder.
-func Split(s, sep string, n int) []string { return genSplit(s, sep, 0, n) }
+func Split(s, sep string, n int) []string { return genSplit(s, sep, 0, n) }
// SplitAfter splits the string s after each instance of sep, returning an array of substrings of s.
// If sep is empty, SplitAfter splits s after each UTF-8 sequence.
@@ -143,28 +143,28 @@ func Join(a []string, sep string) string {
if len(a) == 1 {
return a[0]
}
- n := len(sep) * (len(a) - 1);
+ n := len(sep) * (len(a) - 1)
for i := 0; i < len(a); i++ {
n += len(a[i])
}
- b := make([]byte, n);
- bp := 0;
+ b := make([]byte, n)
+ bp := 0
for i := 0; i < len(a); i++ {
- s := a[i];
+ s := a[i]
for j := 0; j < len(s); j++ {
- b[bp] = s[j];
- bp++;
+ b[bp] = s[j]
+ bp++
}
if i+1 < len(a) {
- s = sep;
+ s = sep
for j := 0; j < len(s); j++ {
- b[bp] = s[j];
- bp++;
+ b[bp] = s[j]
+ bp++
}
}
}
- return string(b);
+ return string(b)
}
// HasPrefix tests whether the string s begins with prefix.
@@ -184,105 +184,105 @@ func Map(mapping func(rune int) int, s string) string {
// In the worst case, the string can grow when mapped, making
// things unpleasant. But it's so rare we barge in assuming it's
// fine. It could also shrink but that falls out naturally.
- maxbytes := len(s); // length of b
- nbytes := 0; // number of bytes encoded in b
- b := make([]byte, maxbytes);
+ maxbytes := len(s) // length of b
+ nbytes := 0 // number of bytes encoded in b
+ b := make([]byte, maxbytes)
for _, c := range s {
- rune := mapping(c);
+ rune := mapping(c)
if rune >= 0 {
- wid := 1;
+ wid := 1
if rune >= utf8.RuneSelf {
wid = utf8.RuneLen(rune)
}
if nbytes+wid > maxbytes {
// Grow the buffer.
- maxbytes = maxbytes*2 + utf8.UTFMax;
- nb := make([]byte, maxbytes);
+ maxbytes = maxbytes*2 + utf8.UTFMax
+ nb := make([]byte, maxbytes)
for i, c := range b[0:nbytes] {
nb[i] = c
}
- b = nb;
+ b = nb
}
- nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes]);
+ nbytes += utf8.EncodeRune(rune, b[nbytes:maxbytes])
}
}
- return string(b[0:nbytes]);
+ return string(b[0:nbytes])
}
// Repeat returns a new string consisting of count copies of the string s.
func Repeat(s string, count int) string {
- b := make([]byte, len(s)*count);
- bp := 0;
+ b := make([]byte, len(s)*count)
+ bp := 0
for i := 0; i < count; i++ {
for j := 0; j < len(s); j++ {
- b[bp] = s[j];
- bp++;
+ b[bp] = s[j]
+ bp++
}
}
- return string(b);
+ return string(b)
}
// ToUpper returns a copy of the string s with all Unicode letters mapped to their upper case.
-func ToUpper(s string) string { return Map(unicode.ToUpper, s) }
+func ToUpper(s string) string { return Map(unicode.ToUpper, s) }
// ToLower returns a copy of the string s with all Unicode letters mapped to their lower case.
-func ToLower(s string) string { return Map(unicode.ToLower, s) }
+func ToLower(s string) string { return Map(unicode.ToLower, s) }
// ToTitle returns a copy of the string s with all Unicode letters mapped to their title case.
-func ToTitle(s string) string { return Map(unicode.ToTitle, s) }
+func ToTitle(s string) string { return Map(unicode.ToTitle, s) }
// Trim returns a slice of the string s, with all leading and trailing white space
// removed, as defined by Unicode.
func TrimSpace(s string) string {
- start, end := 0, len(s);
+ start, end := 0, len(s)
for start < end {
- wid := 1;
- rune := int(s[start]);
+ wid := 1
+ rune := int(s[start])
if rune >= utf8.RuneSelf {
rune, wid = utf8.DecodeRuneInString(s[start:end])
}
if !unicode.IsSpace(rune) {
break
}
- start += wid;
+ start += wid
}
for start < end {
- wid := 1;
- rune := int(s[end-1]);
+ wid := 1
+ rune := int(s[end-1])
if rune >= utf8.RuneSelf {
// Back up carefully looking for beginning of rune. Mustn't pass start.
for wid = 2; start <= end-wid && !utf8.RuneStart(s[end-wid]); wid++ {
}
- if start > end-wid { // invalid UTF-8 sequence; stop processing
+ if start > end-wid { // invalid UTF-8 sequence; stop processing
return s[start:end]
}
- rune, wid = utf8.DecodeRuneInString(s[end-wid : end]);
+ rune, wid = utf8.DecodeRuneInString(s[end-wid : end])
}
if !unicode.IsSpace(rune) {
break
}
- end -= wid;
+ end -= wid
}
- return s[start:end];
+ return s[start:end]
}
// Bytes returns a new slice containing the bytes in s.
func Bytes(s string) []byte {
- b := make([]byte, len(s));
+ b := make([]byte, len(s))
for i := 0; i < len(s); i++ {
b[i] = s[i]
}
- return b;
+ return b
}
// Runes returns a slice of runes (Unicode code points) equivalent to the string s.
func Runes(s string) []int {
- t := make([]int, utf8.RuneCountInString(s));
- i := 0;
+ t := make([]int, utf8.RuneCountInString(s))
+ i := 0
for _, r := range s {
- t[i] = r;
- i++;
+ t[i] = r
+ i++
}
- return t;
+ return t
}
diff --git a/src/pkg/strings/strings_test.go b/src/pkg/strings/strings_test.go
index e3e7f38aed..eb0f8d1fb5 100644
--- a/src/pkg/strings/strings_test.go
+++ b/src/pkg/strings/strings_test.go
@@ -5,10 +5,10 @@
package strings_test
import (
- . "strings";
- "testing";
- "unicode";
- "utf8";
+ . "strings"
+ "testing"
+ "unicode"
+ "utf8"
)
func eq(a, b []string) bool {
@@ -20,7 +20,7 @@ func eq(a, b []string) bool {
return false
}
}
- return true;
+ return true
}
var abcd = "abcd"
@@ -29,9 +29,9 @@ var commas = "1,2,3,4"
var dots = "1....2....3....4"
type IndexTest struct {
- s string;
- sep string;
- out int;
+ s string
+ sep string
+ out int
}
var indexTests = []IndexTest{
@@ -76,22 +76,22 @@ var lastIndexTests = []IndexTest{
// in failure reports.
func runIndexTests(t *testing.T, f func(s, sep string) int, funcName string, testCases []IndexTest) {
for _, test := range testCases {
- actual := f(test.s, test.sep);
+ actual := f(test.s, test.sep)
if actual != test.out {
t.Errorf("%s(%q,%q) = %v; want %v", funcName, test.s, test.sep, actual, test.out)
}
}
}
-func TestIndex(t *testing.T) { runIndexTests(t, Index, "Index", indexTests) }
+func TestIndex(t *testing.T) { runIndexTests(t, Index, "Index", indexTests) }
-func TestLastIndex(t *testing.T) { runIndexTests(t, LastIndex, "LastIndex", lastIndexTests) }
+func TestLastIndex(t *testing.T) { runIndexTests(t, LastIndex, "LastIndex", lastIndexTests) }
type ExplodeTest struct {
- s string;
- n int;
- a []string;
+ s string
+ n int
+ a []string
}
var explodetests = []ExplodeTest{
@@ -102,12 +102,12 @@ var explodetests = []ExplodeTest{
func TestExplode(t *testing.T) {
for _, tt := range explodetests {
- a := Split(tt.s, "", tt.n);
+ a := Split(tt.s, "", tt.n)
if !eq(a, tt.a) {
- t.Errorf("explode(%q, %d) = %v; want %v", tt.s, tt.n, a, tt.a);
- continue;
+ t.Errorf("explode(%q, %d) = %v; want %v", tt.s, tt.n, a, tt.a)
+ continue
}
- s := Join(a, "");
+ s := Join(a, "")
if s != tt.s {
t.Errorf(`Join(explode(%q, %d), "") = %q`, tt.s, tt.n, s)
}
@@ -115,10 +115,10 @@ func TestExplode(t *testing.T) {
}
type SplitTest struct {
- s string;
- sep string;
- n int;
- a []string;
+ s string
+ sep string
+ n int
+ a []string
}
var splittests = []SplitTest{
@@ -138,12 +138,12 @@ var splittests = []SplitTest{
func TestSplit(t *testing.T) {
for _, tt := range splittests {
- a := Split(tt.s, tt.sep, tt.n);
+ a := Split(tt.s, tt.sep, tt.n)
if !eq(a, tt.a) {
- t.Errorf("Split(%q, %q, %d) = %v; want %v", tt.s, tt.sep, tt.n, a, tt.a);
- continue;
+ t.Errorf("Split(%q, %q, %d) = %v; want %v", tt.s, tt.sep, tt.n, a, tt.a)
+ continue
}
- s := Join(a, tt.sep);
+ s := Join(a, tt.sep)
if s != tt.s {
t.Errorf("Join(Split(%q, %q, %d), %q) = %q", tt.s, tt.sep, tt.n, tt.sep, s)
}
@@ -168,12 +168,12 @@ var splitaftertests = []SplitTest{
func TestSplitAfter(t *testing.T) {
for _, tt := range splitaftertests {
- a := SplitAfter(tt.s, tt.sep, tt.n);
+ a := SplitAfter(tt.s, tt.sep, tt.n)
if !eq(a, tt.a) {
- t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, a, tt.a);
- continue;
+ t.Errorf(`Split(%q, %q, %d) = %v; want %v`, tt.s, tt.sep, tt.n, a, tt.a)
+ continue
}
- s := Join(a, "");
+ s := Join(a, "")
if s != tt.s {
t.Errorf(`Join(Split(%q, %q, %d), %q) = %q`, tt.s, tt.sep, tt.n, tt.sep, s)
}
@@ -182,14 +182,14 @@ func TestSplitAfter(t *testing.T) {
// Test case for any function which accepts and returns a single string.
type StringTest struct {
- in, out string;
+ in, out string
}
// 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) {
for _, tc := range testCases {
- actual := f(tc.in);
+ actual := f(tc.in)
if actual != tc.out {
t.Errorf("%s(%q) = %q; want %q", funcName, tc.in, actual, tc.out)
}
@@ -201,7 +201,7 @@ var upperTests = []StringTest{
StringTest{"abc", "ABC"},
StringTest{"AbC123", "ABC123"},
StringTest{"azAZ09_", "AZAZ09_"},
- StringTest{"\u0250\u0250\u0250\u0250\u0250", "\u2C6F\u2C6F\u2C6F\u2C6F\u2C6F"}, // grows one byte per char
+ StringTest{"\u0250\u0250\u0250\u0250\u0250", "\u2C6F\u2C6F\u2C6F\u2C6F\u2C6F"}, // grows one byte per char
}
var lowerTests = []StringTest{
@@ -209,7 +209,7 @@ var lowerTests = []StringTest{
StringTest{"abc", "abc"},
StringTest{"AbC123", "abc123"},
StringTest{"azAZ09_", "azaz09_"},
- StringTest{"\u2C6D\u2C6D\u2C6D\u2C6D\u2C6D", "\u0251\u0251\u0251\u0251\u0251"}, // shrinks one byte per char
+ StringTest{"\u2C6D\u2C6D\u2C6D\u2C6D\u2C6D", "\u0251\u0251\u0251\u0251\u0251"}, // shrinks one byte per char
}
const space = "\t\v\r\f\n\u0085\u00a0\u2000\u3000"
@@ -223,59 +223,59 @@ var trimSpaceTests = []StringTest{
StringTest{" \t\r\n x\t\t\r\r\n\n ", "x"},
StringTest{" \u2000\t\r\n x\t\t\r\r\ny\n \u3000", "x\t\t\r\r\ny"},
StringTest{"1 \t\r\n2", "1 \t\r\n2"},
- StringTest{" x\x80", "x\x80"}, // invalid UTF-8 on end
- StringTest{" x\xc0", "x\xc0"}, // invalid UTF-8 on end
+ StringTest{" x\x80", "x\x80"}, // invalid UTF-8 on end
+ StringTest{" x\xc0", "x\xc0"}, // invalid UTF-8 on end
}
func tenRunes(rune int) string {
- r := make([]int, 10);
+ r := make([]int, 10)
for i := range r {
r[i] = rune
}
- return string(r);
+ return string(r)
}
// User-defined self-inverse mapping function
func rot13(rune int) int {
- step := 13;
+ step := 13
if rune >= 'a' && rune <= 'z' {
return ((rune - 'a' + step) % 26) + 'a'
}
if rune >= 'A' && rune <= 'Z' {
return ((rune - 'A' + step) % 26) + 'A'
}
- return rune;
+ return rune
}
func TestMap(t *testing.T) {
// Run a couple of awful growth/shrinkage tests
- a := tenRunes('a');
+ a := tenRunes('a')
// 1. Grow. This triggers two reallocations in Map.
- maxRune := func(rune int) int { return unicode.MaxRune };
- m := Map(maxRune, a);
- expect := tenRunes(unicode.MaxRune);
+ maxRune := func(rune int) int { return unicode.MaxRune }
+ m := Map(maxRune, a)
+ expect := tenRunes(unicode.MaxRune)
if m != expect {
t.Errorf("growing: expected %q got %q", expect, m)
}
// 2. Shrink
- minRune := func(rune int) int { return 'a' };
- m = Map(minRune, tenRunes(unicode.MaxRune));
- expect = a;
+ minRune := func(rune int) int { return 'a' }
+ m = Map(minRune, tenRunes(unicode.MaxRune))
+ expect = a
if m != expect {
t.Errorf("shrinking: expected %q got %q", expect, m)
}
// 3. Rot13
- m = Map(rot13, "a to zed");
- expect = "n gb mrq";
+ m = Map(rot13, "a to zed")
+ expect = "n gb mrq"
if m != expect {
t.Errorf("rot13: expected %q got %q", expect, m)
}
// 4. Rot13^2
- m = Map(rot13, Map(rot13, "a to zed"));
- expect = "a to zed";
+ m = Map(rot13, Map(rot13, "a to zed"))
+ expect = "a to zed"
if m != expect {
t.Errorf("rot13: expected %q got %q", expect, m)
}
@@ -285,50 +285,50 @@ func TestMap(t *testing.T) {
if unicode.Is(unicode.Latin, rune) {
return rune
}
- return -1;
- };
- m = Map(dropNotLatin, "Hello, 세계");
- expect = "Hello";
+ return -1
+ }
+ m = Map(dropNotLatin, "Hello, 세계")
+ expect = "Hello"
if m != expect {
t.Errorf("drop: expected %q got %q", expect, m)
}
}
-func TestToUpper(t *testing.T) { runStringTests(t, ToUpper, "ToUpper", upperTests) }
+func TestToUpper(t *testing.T) { runStringTests(t, ToUpper, "ToUpper", upperTests) }
-func TestToLower(t *testing.T) { runStringTests(t, ToLower, "ToLower", lowerTests) }
+func TestToLower(t *testing.T) { runStringTests(t, ToLower, "ToLower", lowerTests) }
-func TestTrimSpace(t *testing.T) { runStringTests(t, TrimSpace, "TrimSpace", trimSpaceTests) }
+func TestTrimSpace(t *testing.T) { runStringTests(t, TrimSpace, "TrimSpace", trimSpaceTests) }
func equal(m string, s1, s2 string, t *testing.T) bool {
if s1 == s2 {
return true
}
- e1 := Split(s1, "", 0);
- e2 := Split(s2, "", 0);
+ e1 := Split(s1, "", 0)
+ e2 := Split(s2, "", 0)
for i, c1 := range e1 {
if i > len(e2) {
break
}
- r1, _ := utf8.DecodeRuneInString(c1);
- r2, _ := utf8.DecodeRuneInString(e2[i]);
+ r1, _ := utf8.DecodeRuneInString(c1)
+ r2, _ := utf8.DecodeRuneInString(e2[i])
if r1 != r2 {
t.Errorf("%s diff at %d: U+%04X U+%04X", m, i, r1, r2)
}
}
- return false;
+ return false
}
func TestCaseConsistency(t *testing.T) {
// Make a string of all the runes.
- a := make([]int, unicode.MaxRune+1);
+ a := make([]int, unicode.MaxRune+1)
for i := range a {
a[i] = i
}
- s := string(a);
+ s := string(a)
// convert the cases.
- upper := ToUpper(s);
- lower := ToLower(s);
+ upper := ToUpper(s)
+ lower := ToLower(s)
// Consistency checks
if n := utf8.RuneCountInString(upper); n != unicode.MaxRune+1 {
@@ -360,8 +360,8 @@ func TestCaseConsistency(t *testing.T) {
}
type RepeatTest struct {
- in, out string;
- count int;
+ in, out string
+ count int
}
var RepeatTests = []RepeatTest{
@@ -376,10 +376,10 @@ var RepeatTests = []RepeatTest{
func TestRepeat(t *testing.T) {
for _, tt := range RepeatTests {
- a := Repeat(tt.in, tt.count);
+ a := Repeat(tt.in, tt.count)
if !equal("Repeat(s)", a, tt.out, t) {
- t.Errorf("Repeat(%v, %d) = %v; want %v", tt.in, tt.count, a, tt.out);
- continue;
+ t.Errorf("Repeat(%v, %d) = %v; want %v", tt.in, tt.count, a, tt.out)
+ continue
}
}
}
@@ -393,13 +393,13 @@ func runesEqual(a, b []int) bool {
return false
}
}
- return true;
+ return true
}
type RunesTest struct {
- in string;
- out []int;
- lossy bool;
+ in string
+ out []int
+ lossy bool
}
var RunesTests = []RunesTest{
@@ -414,14 +414,14 @@ var RunesTests = []RunesTest{
func TestRunes(t *testing.T) {
for _, tt := range RunesTests {
- a := Runes(tt.in);
+ a := Runes(tt.in)
if !runesEqual(a, tt.out) {
- t.Errorf("Runes(%q) = %v; want %v", tt.in, a, tt.out);
- continue;
+ t.Errorf("Runes(%q) = %v; want %v", tt.in, a, tt.out)
+ continue
}
if !tt.lossy {
// can only test reassembly if we didn't lose information
- s := string(a);
+ s := string(a)
if s != tt.in {
t.Errorf("string(Runes(%q)) = %x; want %x", tt.in, s, tt.in)
}
generated by cgit v1.3 (git 2.53.0) at 2026-04-16 21:14:24 +0000