}
	*np = n
	return w + wl + wr
}

// Test for bug where func var f used prototype's escape analysis results.
func prototype(xyz []string) {} // ERROR "xyz does not escape"
func bar() {
	var got [][]string
	f := prototype
	f = func(ss []string) { got = append(got, ss) } // ERROR "leaking param: ss" "func literal does not escape"
	s := "string"
	f([]string{s}) // ERROR "\[\]string{...} escapes to heap"
}

 * individual {@code char} values, it is not safe to assume that {@code escape(s)} is equivalent to
 * {@code escape(s.substring(0, n)) + escape(s.substring(n))} for arbitrary {@code n}. This is
 * because of the possibility of splitting a surrogate pair. The only case in which it is safe to
 * escape strings and concatenate the results is if you can rule out this possibility, either by

// These two tests verify that:
// small array literals are stack allocated;
// pointers stored in small array literals do not escape;
// large array literals are heap allocated;
// pointers stored in large array literals escape.
func hugeLeaks1(x **string, y **string) { // ERROR "leaking param content: x" "y does not escape"
	a := [10]*string{*y}
	_ = a

		{`'\x'`, "invalid character '\\'' in hexadecimal escape", 0, 3},
		{`'\y'`, "unknown escape", 0, 2},
		{`'\x0'`, "invalid character '\\'' in hexadecimal escape", 0, 4},
		{`'\00'`, "invalid character '\\'' in octal escape", 0, 4},
		{`'\377' /*`, "comment not terminated", 0, 7}, // valid octal escape
		{`'\378`, "invalid character '8' in octal escape", 0, 4},
		{`'\400'`, "octal escape value 256 > 255", 0, 5},

 * your own escapers extend this class and implement the {@link #escape(int)} method.
 *
 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class UnicodeEscaper extends Escaper {
  /** The amount of padding (chars) to use when growing the escape buffer. */
  private static final int DEST_PAD = 32;

  /** Constructor for use by subclasses. */

 * your own escapers extend this class and implement the {@link #escape(int)} method.
 *
 * @author David Beaumont
 * @since 15.0
 */
@GwtCompatible
@ElementTypesAreNonnullByDefault
public abstract class UnicodeEscaper extends Escaper {
  /** The amount of padding (chars) to use when growing the escape buffer. */
  private static final int DEST_PAD = 32;

  /** Constructor for use by subclasses. */

    </highlighter>
    <highlighter type="oneline-comment">//</highlighter>
    <highlighter type="string">
        <string>"</string>
        <escape>\</escape>
    </highlighter>
    <highlighter type="value">
        <string>`</string>
        <escape>\</escape>
    </highlighter>
    <highlighter type="annotation">
        <start>@</start>
        <valueStart>(</valueStart>
        <valueEnd>)</valueEnd>

	b.pos = len(b.buf)
}

// To escape a text segment, bracket it with Escape characters.
// For instance, the tab in this string "Ignore this tab: \xff\t\xff"
// does not terminate a cell and constitutes a single character of
// width one for formatting purposes.
//
// The value 0xff was chosen because it cannot appear in a valid UTF-8 sequence.
const Escape = '\xff'

// Start escaped mode.

import static org.junit.Assert.assertThat;

import org.junit.Test;

/**
 * @author shinsuke
 *
 */
public class JsonUtilTest {
    @Test
    public void escape() {
        assertThat(JsonUtil.escape("abc123あア亜"), is("abc123あア亜"));
        assertThat(JsonUtil.escape("\\\"/\b\t\n\f\r\0"), is("\\\\\\\"\\/\\b\\t\\n\\f\\r\\u0000"));
    }

// Test write barrier for implicit assignments to result parameters
// that have escaped to the heap.

package issue13587

import "errors"

func escape(p *error)

func F() (err error) {
	escape(&err)
	return errors.New("error") // ERROR "write barrier"