ires 0.1.3 → 0.1.4

data/ext/vendor/golang.org/x/text/cases/context.go

@@ -0,0 +1,376 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+import "golang.org/x/text/transform"
+
+// A context is used for iterating over source bytes, fetching case info and
+// writing to a destination buffer.
+//
+// Casing operations may need more than one rune of context to decide how a rune
+// should be cased. Casing implementations should call checkpoint on context
+// whenever it is known to be safe to return the runes processed so far.
+//
+// It is recommended for implementations to not allow for more than 30 case
+// ignorables as lookahead (analogous to the limit in norm) and to use state if
+// unbounded lookahead is needed for cased runes.
+type context struct {
+	dst, src []byte
+	atEOF    bool
+
+	pDst int // pDst points past the last written rune in dst.
+	pSrc int // pSrc points to the start of the currently scanned rune.
+
+	// checkpoints safe to return in Transform, where nDst <= pDst and nSrc <= pSrc.
+	nDst, nSrc int
+	err        error
+
+	sz   int  // size of current rune
+	info info // case information of currently scanned rune
+
+	// State preserved across calls to Transform.
+	isMidWord bool // false if next cased letter needs to be title-cased.
+}
+
+func (c *context) Reset() {
+	c.isMidWord = false
+}
+
+// ret returns the return values for the Transform method. It checks whether
+// there were insufficient bytes in src to complete and introduces an error
+// accordingly, if necessary.
+func (c *context) ret() (nDst, nSrc int, err error) {
+	if c.err != nil || c.nSrc == len(c.src) {
+		return c.nDst, c.nSrc, c.err
+	}
+	// This point is only reached by mappers if there was no short destination
+	// buffer. This means that the source buffer was exhausted and that c.sz was
+	// set to 0 by next.
+	if c.atEOF && c.pSrc == len(c.src) {
+		return c.pDst, c.pSrc, nil
+	}
+	return c.nDst, c.nSrc, transform.ErrShortSrc
+}
+
+// retSpan returns the return values for the Span method. It checks whether
+// there were insufficient bytes in src to complete and introduces an error
+// accordingly, if necessary.
+func (c *context) retSpan() (n int, err error) {
+	_, nSrc, err := c.ret()
+	return nSrc, err
+}
+
+// checkpoint sets the return value buffer points for Transform to the current
+// positions.
+func (c *context) checkpoint() {
+	if c.err == nil {
+		c.nDst, c.nSrc = c.pDst, c.pSrc+c.sz
+	}
+}
+
+// unreadRune causes the last rune read by next to be reread on the next
+// invocation of next. Only one unreadRune may be called after a call to next.
+func (c *context) unreadRune() {
+	c.sz = 0
+}
+
+func (c *context) next() bool {
+	c.pSrc += c.sz
+	if c.pSrc == len(c.src) || c.err != nil {
+		c.info, c.sz = 0, 0
+		return false
+	}
+	v, sz := trie.lookup(c.src[c.pSrc:])
+	c.info, c.sz = info(v), sz
+	if c.sz == 0 {
+		if c.atEOF {
+			// A zero size means we have an incomplete rune. If we are atEOF,
+			// this means it is an illegal rune, which we will consume one
+			// byte at a time.
+			c.sz = 1
+		} else {
+			c.err = transform.ErrShortSrc
+			return false
+		}
+	}
+	return true
+}
+
+// writeBytes adds bytes to dst.
+func (c *context) writeBytes(b []byte) bool {
+	if len(c.dst)-c.pDst < len(b) {
+		c.err = transform.ErrShortDst
+		return false
+	}
+	// This loop is faster than using copy.
+	for _, ch := range b {
+		c.dst[c.pDst] = ch
+		c.pDst++
+	}
+	return true
+}
+
+// writeString writes the given string to dst.
+func (c *context) writeString(s string) bool {
+	if len(c.dst)-c.pDst < len(s) {
+		c.err = transform.ErrShortDst
+		return false
+	}
+	// This loop is faster than using copy.
+	for i := 0; i < len(s); i++ {
+		c.dst[c.pDst] = s[i]
+		c.pDst++
+	}
+	return true
+}
+
+// copy writes the current rune to dst.
+func (c *context) copy() bool {
+	return c.writeBytes(c.src[c.pSrc : c.pSrc+c.sz])
+}
+
+// copyXOR copies the current rune to dst and modifies it by applying the XOR
+// pattern of the case info. It is the responsibility of the caller to ensure
+// that this is a rune with a XOR pattern defined.
+func (c *context) copyXOR() bool {
+	if !c.copy() {
+		return false
+	}
+	if c.info&xorIndexBit == 0 {
+		// Fast path for 6-bit XOR pattern, which covers most cases.
+		c.dst[c.pDst-1] ^= byte(c.info >> xorShift)
+	} else {
+		// Interpret XOR bits as an index.
+		// TODO: test performance for unrolling this loop. Verify that we have
+		// at least two bytes and at most three.
+		idx := c.info >> xorShift
+		for p := c.pDst - 1; ; p-- {
+			c.dst[p] ^= xorData[idx]
+			idx--
+			if xorData[idx] == 0 {
+				break
+			}
+		}
+	}
+	return true
+}
+
+// hasPrefix returns true if src[pSrc:] starts with the given string.
+func (c *context) hasPrefix(s string) bool {
+	b := c.src[c.pSrc:]
+	if len(b) < len(s) {
+		return false
+	}
+	for i, c := range b[:len(s)] {
+		if c != s[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// caseType returns an info with only the case bits, normalized to either
+// cLower, cUpper, cTitle or cUncased.
+func (c *context) caseType() info {
+	cm := c.info & 0x7
+	if cm < 4 {
+		return cm
+	}
+	if cm >= cXORCase {
+		// xor the last bit of the rune with the case type bits.
+		b := c.src[c.pSrc+c.sz-1]
+		return info(b&1) ^ cm&0x3
+	}
+	if cm == cIgnorableCased {
+		return cLower
+	}
+	return cUncased
+}
+
+// lower writes the lowercase version of the current rune to dst.
+func lower(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cLower {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		return c.copyXOR()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+	if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
+		return c.writeString(e[offset : offset+nLower])
+	}
+	return c.copy()
+}
+
+func isLower(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cLower {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// upper writes the uppercase version of the current rune to dst.
+func upper(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cUpper {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		return c.copyXOR()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+	// Get length of first special case mapping.
+	n := (e[1] >> lengthBits) & lengthMask
+	if ct == cTitle {
+		// The first special case mapping is for lower. Set n to the second.
+		if n == noChange {
+			n = 0
+		}
+		n, e = e[1]&lengthMask, e[n:]
+	}
+	if n != noChange {
+		return c.writeString(e[offset : offset+n])
+	}
+	return c.copy()
+}
+
+// isUpper writes the isUppercase version of the current rune to dst.
+func isUpper(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cUpper {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	// Get length of first special case mapping.
+	n := (e[1] >> lengthBits) & lengthMask
+	if ct == cTitle {
+		n = e[1] & lengthMask
+	}
+	if n != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// title writes the title case version of the current rune to dst.
+func title(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cTitle {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		if ct == cLower {
+			return c.copyXOR()
+		}
+		return c.copy()
+	}
+	// Get the exception data.
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+
+	nFirst := (e[1] >> lengthBits) & lengthMask
+	if nTitle := e[1] & lengthMask; nTitle != noChange {
+		if nFirst != noChange {
+			e = e[nFirst:]
+		}
+		return c.writeString(e[offset : offset+nTitle])
+	}
+	if ct == cLower && nFirst != noChange {
+		// Use the uppercase version instead.
+		return c.writeString(e[offset : offset+nFirst])
+	}
+	// Already in correct case.
+	return c.copy()
+}
+
+// isTitle reports whether the current rune is in title case.
+func isTitle(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cTitle {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		if ct == cLower {
+			c.err = transform.ErrEndOfSpan
+			return false
+		}
+		return true
+	}
+	// Get the exception data.
+	e := exceptions[c.info>>exceptionShift:]
+	if nTitle := e[1] & lengthMask; nTitle != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	nFirst := (e[1] >> lengthBits) & lengthMask
+	if ct == cLower && nFirst != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// foldFull writes the foldFull version of the current rune to dst.
+func foldFull(c *context) bool {
+	if c.info&hasMappingMask == 0 {
+		return c.copy()
+	}
+	ct := c.caseType()
+	if c.info&exceptionBit == 0 {
+		if ct != cLower || c.info&inverseFoldBit != 0 {
+			return c.copyXOR()
+		}
+		return c.copy()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	n := e[0] & lengthMask
+	if n == 0 {
+		if ct == cLower {
+			return c.copy()
+		}
+		n = (e[1] >> lengthBits) & lengthMask
+	}
+	return c.writeString(e[2 : 2+n])
+}
+
+// isFoldFull reports whether the current run is mapped to foldFull
+func isFoldFull(c *context) bool {
+	if c.info&hasMappingMask == 0 {
+		return true
+	}
+	ct := c.caseType()
+	if c.info&exceptionBit == 0 {
+		if ct != cLower || c.info&inverseFoldBit != 0 {
+			c.err = transform.ErrEndOfSpan
+			return false
+		}
+		return true
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	n := e[0] & lengthMask
+	if n == 0 && ct == cLower {
+		return true
+	}
+	c.err = transform.ErrEndOfSpan
+	return false
+}

data/ext/vendor/golang.org/x/text/cases/context_test.go

@@ -0,0 +1,438 @@
+// Copyright 2014 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package cases
+
+import (
+	"strings"
+	"testing"
+	"unicode"
+
+	"golang.org/x/text/internal/testtext"
+	"golang.org/x/text/language"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+	"golang.org/x/text/unicode/rangetable"
+)
+
+// The following definitions are taken directly from Chapter 3 of The Unicode
+// Standard.
+
+func propCased(r rune) bool {
+	return propLower(r) || propUpper(r) || unicode.IsTitle(r)
+}
+
+func propLower(r rune) bool {
+	return unicode.IsLower(r) || unicode.Is(unicode.Other_Lowercase, r)
+}
+
+func propUpper(r rune) bool {
+	return unicode.IsUpper(r) || unicode.Is(unicode.Other_Uppercase, r)
+}
+
+func propIgnore(r rune) bool {
+	if unicode.In(r, unicode.Mn, unicode.Me, unicode.Cf, unicode.Lm, unicode.Sk) {
+		return true
+	}
+	return caseIgnorable[r]
+}
+
+func hasBreakProp(r rune) bool {
+	// binary search over ranges
+	lo := 0
+	hi := len(breakProp)
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		bp := &breakProp[m]
+		if bp.lo <= r && r <= bp.hi {
+			return true
+		}
+		if r < bp.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return false
+}
+
+func contextFromRune(r rune) *context {
+	c := context{dst: make([]byte, 128), src: []byte(string(r)), atEOF: true}
+	c.next()
+	return &c
+}
+
+func TestCaseProperties(t *testing.T) {
+	if unicode.Version != UnicodeVersion {
+		// Properties of existing code points may change by Unicode version, so
+		// we need to skip.
+		t.Skipf("Skipping as core Unicode version %s different than %s", unicode.Version, UnicodeVersion)
+	}
+	assigned := rangetable.Assigned(UnicodeVersion)
+	coreVersion := rangetable.Assigned(unicode.Version)
+	for r := rune(0); r <= lastRuneForTesting; r++ {
+		if !unicode.In(r, assigned) || !unicode.In(r, coreVersion) {
+			continue
+		}
+		c := contextFromRune(r)
+		if got, want := c.info.isCaseIgnorable(), propIgnore(r); got != want {
+			t.Errorf("caseIgnorable(%U): got %v; want %v (%x)", r, got, want, c.info)
+		}
+		// New letters may change case types, but existing case pairings should
+		// not change. See Case Pair Stability in
+		// http://unicode.org/policies/stability_policy.html.
+		if rf := unicode.SimpleFold(r); rf != r && unicode.In(rf, assigned) {
+			if got, want := c.info.isCased(), propCased(r); got != want {
+				t.Errorf("cased(%U): got %v; want %v (%x)", r, got, want, c.info)
+			}
+			if got, want := c.caseType() == cUpper, propUpper(r); got != want {
+				t.Errorf("upper(%U): got %v; want %v (%x)", r, got, want, c.info)
+			}
+			if got, want := c.caseType() == cLower, propLower(r); got != want {
+				t.Errorf("lower(%U): got %v; want %v (%x)", r, got, want, c.info)
+			}
+		}
+		if got, want := c.info.isBreak(), hasBreakProp(r); got != want {
+			t.Errorf("isBreak(%U): got %v; want %v (%x)", r, got, want, c.info)
+		}
+	}
+	// TODO: get title case from unicode file.
+}
+
+func TestMapping(t *testing.T) {
+	assigned := rangetable.Assigned(UnicodeVersion)
+	coreVersion := rangetable.Assigned(unicode.Version)
+	if coreVersion == nil {
+		coreVersion = assigned
+	}
+	apply := func(r rune, f func(c *context) bool) string {
+		c := contextFromRune(r)
+		f(c)
+		return string(c.dst[:c.pDst])
+	}
+
+	for r, tt := range special {
+		if got, want := apply(r, lower), tt.toLower; got != want {
+			t.Errorf("lowerSpecial:(%U): got %+q; want %+q", r, got, want)
+		}
+		if got, want := apply(r, title), tt.toTitle; got != want {
+			t.Errorf("titleSpecial:(%U): got %+q; want %+q", r, got, want)
+		}
+		if got, want := apply(r, upper), tt.toUpper; got != want {
+			t.Errorf("upperSpecial:(%U): got %+q; want %+q", r, got, want)
+		}
+	}
+
+	for r := rune(0); r <= lastRuneForTesting; r++ {
+		if !unicode.In(r, assigned) || !unicode.In(r, coreVersion) {
+			continue
+		}
+		if rf := unicode.SimpleFold(r); rf == r || !unicode.In(rf, assigned) {
+			continue
+		}
+		if _, ok := special[r]; ok {
+			continue
+		}
+		want := string(unicode.ToLower(r))
+		if got := apply(r, lower); got != want {
+			t.Errorf("lower:%q (%U): got %q %U; want %q %U", r, r, got, []rune(got), want, []rune(want))
+		}
+
+		want = string(unicode.ToUpper(r))
+		if got := apply(r, upper); got != want {
+			t.Errorf("upper:%q (%U): got %q %U; want %q %U", r, r, got, []rune(got), want, []rune(want))
+		}
+
+		want = string(unicode.ToTitle(r))
+		if got := apply(r, title); got != want {
+			t.Errorf("title:%q (%U): got %q %U; want %q %U", r, r, got, []rune(got), want, []rune(want))
+		}
+	}
+}
+
+func runeFoldData(r rune) (x struct{ simple, full, special string }) {
+	x = foldMap[r]
+	if x.simple == "" {
+		x.simple = string(unicode.ToLower(r))
+	}
+	if x.full == "" {
+		x.full = string(unicode.ToLower(r))
+	}
+	if x.special == "" {
+		x.special = x.full
+	}
+	return
+}
+
+func TestFoldData(t *testing.T) {
+	assigned := rangetable.Assigned(UnicodeVersion)
+	coreVersion := rangetable.Assigned(unicode.Version)
+	if coreVersion == nil {
+		coreVersion = assigned
+	}
+	apply := func(r rune, f func(c *context) bool) (string, info) {
+		c := contextFromRune(r)
+		f(c)
+		return string(c.dst[:c.pDst]), c.info.cccType()
+	}
+	for r := rune(0); r <= lastRuneForTesting; r++ {
+		if !unicode.In(r, assigned) || !unicode.In(r, coreVersion) {
+			continue
+		}
+		x := runeFoldData(r)
+		if got, info := apply(r, foldFull); got != x.full {
+			t.Errorf("full:%q (%U): got %q %U; want %q %U (ccc=%x)", r, r, got, []rune(got), x.full, []rune(x.full), info)
+		}
+		// TODO: special and simple.
+	}
+}
+
+func TestCCC(t *testing.T) {
+	assigned := rangetable.Assigned(UnicodeVersion)
+	normVersion := rangetable.Assigned(norm.Version)
+	for r := rune(0); r <= lastRuneForTesting; r++ {
+		if !unicode.In(r, assigned) || !unicode.In(r, normVersion) {
+			continue
+		}
+		c := contextFromRune(r)
+
+		p := norm.NFC.PropertiesString(string(r))
+		want := cccOther
+		switch p.CCC() {
+		case 0:
+			want = cccZero
+		case above:
+			want = cccAbove
+		}
+		if got := c.info.cccType(); got != want {
+			t.Errorf("%U: got %x; want %x", r, got, want)
+		}
+	}
+}
+
+func TestWordBreaks(t *testing.T) {
+	for _, tt := range breakTest {
+		testtext.Run(t, tt, func(t *testing.T) {
+			parts := strings.Split(tt, "|")
+			want := ""
+			for _, s := range parts {
+				found := false
+				// This algorithm implements title casing given word breaks
+				// as defined in the Unicode standard 3.13 R3.
+				for _, r := range s {
+					title := unicode.ToTitle(r)
+					lower := unicode.ToLower(r)
+					if !found && title != lower {
+						found = true
+						want += string(title)
+					} else {
+						want += string(lower)
+					}
+				}
+			}
+			src := strings.Join(parts, "")
+			got := Title(language.Und).String(src)
+			if got != want {
+				t.Errorf("got %q; want %q", got, want)
+			}
+		})
+	}
+}
+
+func TestContext(t *testing.T) {
+	tests := []struct {
+		desc       string
+		dstSize    int
+		atEOF      bool
+		src        string
+		out        string
+		nSrc       int
+		err        error
+		ops        string
+		prefixArg  string
+		prefixWant bool
+	}{{
+		desc:    "next: past end, atEOF, no checkpoint",
+		dstSize: 10,
+		atEOF:   true,
+		src:     "12",
+		out:     "",
+		nSrc:    2,
+		ops:     "next;next;next",
+		// Test that calling prefix with a non-empty argument when the buffer
+		// is depleted returns false.
+		prefixArg:  "x",
+		prefixWant: false,
+	}, {
+		desc:       "next: not at end, atEOF, no checkpoint",
+		dstSize:    10,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortSrc,
+		ops:        "next;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "next: past end, !atEOF, no checkpoint",
+		dstSize:    10,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortSrc,
+		ops:        "next;next;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "next: past end, !atEOF, checkpoint",
+		dstSize:    10,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       2,
+		ops:        "next;next;checkpoint;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "copy: exact count, atEOF, no checkpoint",
+		dstSize:    2,
+		atEOF:      true,
+		src:        "12",
+		out:        "12",
+		nSrc:       2,
+		ops:        "next;copy;next;copy;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "copy: past end, !atEOF, no checkpoint",
+		dstSize:    2,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortSrc,
+		ops:        "next;copy;next;copy;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "copy: past end, !atEOF, checkpoint",
+		dstSize:    2,
+		atEOF:      false,
+		src:        "12",
+		out:        "12",
+		nSrc:       2,
+		ops:        "next;copy;next;copy;checkpoint;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "copy: short dst",
+		dstSize:    1,
+		atEOF:      false,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortDst,
+		ops:        "next;copy;next;copy;checkpoint;next",
+		prefixArg:  "12",
+		prefixWant: false,
+	}, {
+		desc:       "copy: short dst, checkpointed",
+		dstSize:    1,
+		atEOF:      false,
+		src:        "12",
+		out:        "1",
+		nSrc:       1,
+		err:        transform.ErrShortDst,
+		ops:        "next;copy;checkpoint;next;copy;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "writeString: simple",
+		dstSize:    3,
+		atEOF:      true,
+		src:        "1",
+		out:        "1ab",
+		nSrc:       1,
+		ops:        "next;copy;writeab;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "writeString: short dst",
+		dstSize:    2,
+		atEOF:      true,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortDst,
+		ops:        "next;copy;writeab;next",
+		prefixArg:  "2",
+		prefixWant: true,
+	}, {
+		desc:       "writeString: simple",
+		dstSize:    3,
+		atEOF:      true,
+		src:        "12",
+		out:        "1ab",
+		nSrc:       2,
+		ops:        "next;copy;next;writeab;next",
+		prefixArg:  "",
+		prefixWant: true,
+	}, {
+		desc:       "writeString: short dst",
+		dstSize:    2,
+		atEOF:      true,
+		src:        "12",
+		out:        "",
+		nSrc:       0,
+		err:        transform.ErrShortDst,
+		ops:        "next;copy;next;writeab;next",
+		prefixArg:  "1",
+		prefixWant: false,
+	}, {
+		desc:    "prefix",
+		dstSize: 2,
+		atEOF:   true,
+		src:     "12",
+		out:     "",
+		nSrc:    0,
+		// Context will assign an ErrShortSrc if the input wasn't exhausted.
+		err:        transform.ErrShortSrc,
+		prefixArg:  "12",
+		prefixWant: true,
+	}}
+	for _, tt := range tests {
+		c := context{dst: make([]byte, tt.dstSize), src: []byte(tt.src), atEOF: tt.atEOF}
+
+		for _, op := range strings.Split(tt.ops, ";") {
+			switch op {
+			case "next":
+				c.next()
+			case "checkpoint":
+				c.checkpoint()
+			case "writeab":
+				c.writeString("ab")
+			case "copy":
+				c.copy()
+			case "":
+			default:
+				t.Fatalf("unknown op %q", op)
+			}
+		}
+		if got := c.hasPrefix(tt.prefixArg); got != tt.prefixWant {
+			t.Errorf("%s:\nprefix was %v; want %v", tt.desc, got, tt.prefixWant)
+		}
+		nDst, nSrc, err := c.ret()
+		if err != tt.err {
+			t.Errorf("%s:\nerror was %v; want %v", tt.desc, err, tt.err)
+		}
+		if out := string(c.dst[:nDst]); out != tt.out {
+			t.Errorf("%s:\nout was %q; want %q", tt.desc, out, tt.out)
+		}
+		if nSrc != tt.nSrc {
+			t.Errorf("%s:\nnSrc was %d; want %d", tt.desc, nSrc, tt.nSrc)
+		}
+	}
+}