}

  /**
   * Returns a splitter that behaves equivalently to {@code this} splitter, but automatically
   * removes leading and trailing {@linkplain CharMatcher#whitespace whitespace} from each returned
   * substring; equivalent to {@code trimResults(CharMatcher.whitespace())}. For example, {@code
   * Splitter.on(',').trimResults().split(" a, b ,c ")} returns an iterable containing {@code ["a",
   * "b", "c"]}.
   *

        // single project build entry point
        Exception ex = assertThrows(Exception.class, () -> projectBuilder.build(pomFile, configuration));
        assertThat(ex.getMessage(), containsString("Received non-all-whitespace CHARACTERS or CDATA event"));

        // multi projects build entry point
        ProjectBuildingException pex = assertThrows(
                ProjectBuildingException.class,

        then:
        //mind the trailing whitespace at the empty commented line
        assertOutputFile("""$COMMON_START
 */

repositories {
    // Use Maven Central
    // ${""}
    // Alternatively:
    // - Could use Google's Maven repository
    // - Or a local mirror
    mavenCentral()
}
"""
        )
    }

            "    // Use Maven Central\n" +
            "    // \n" + // mind the trailing whitespace!
            "    // Alternatively:\n" +
            "    // - Could use Google's Maven repository\n" +
            "    // - Or a local mirror\n" +
            "    mavenCentral()\n" +
            "}\n"
        )
    }

    def "vertical whitespace is included around statements with comments and around blocks"() {
        given:

 * simplifies use of single-valued fields whose values routinely contain commas, such as cookies or
 * dates.
 *
 * This class trims whitespace from values. It never returns values with leading or trailing
 * whitespace.
 *
 * Instances of this class are immutable. Use [Builder] to create instances.
 */
@Suppress("NAME_SHADOWING")
class Headers internal constructor(

</WhitespaceValuesParent>
`

// golang.org/issues/22146
func TestUnmarshalWhitespaceValues(t *testing.T) {
	v := WhitespaceValuesParent{}
	if err := Unmarshal([]byte(whitespaceValuesXML), &v); err != nil {
		t.Fatalf("whitespace values: Unmarshal failed: got %v", err)
	}

	want := WhitespaceValuesParent{
		BFalse: false,
		BTrue:  true,
		I:      266703,
		INeg:   -266703,
		I8:     112,
		I8Neg:  -112,
		I16:    6703,

	{
		var Addrs int32
		const rtaRtMask = 1
		var i uint
		if Addrs&rtaRtMask&(1<<i) == 0 {}
	}

	// from src/text/scanner/scanner.go:540
	{
		var s struct { Whitespace uint64 }
		var ch rune
		for s.Whitespace&(1<<uint(ch)) != 0 {}
	}
}

func issue5895() {
	var x = 'a' << 1 // type of x must be rune
	var _ rune = x
}

func issue11325() {

	}
}

func TestScanZeroMode(t *testing.T) {
	src := makeSource("%s\n")
	str := src.String()
	s := new(Scanner).Init(src)
	s.Mode = 0       // don't recognize any token classes
	s.Whitespace = 0 // don't skip any whitespace
	tok := s.Scan()
	for i, ch := range str {
		if tok != ch {
			t.Fatalf("%d. tok = %s, want %s", i, TokenString(tok), TokenString(ch))
		}
		tok = s.Scan()
	}
	if tok != EOF {

// license that can be found in the LICENSE file.

package template

import (
	"bytes"
	"encoding/json"
	"fmt"
	"reflect"
	"strings"
	"unicode/utf8"
)

// jsWhitespace contains all of the JS whitespace characters, as defined
// by the \s character class.
// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions/Character_classes.

	{token.SWITCH, "switch", keyword},
	{token.TYPE, "type", keyword},
	{token.VAR, "var", keyword},
}

const whitespace = "  \t  \n\n\n" // to separate tokens

var source = func() []byte {
	var src []byte
	for _, t := range tokens {
		src = append(src, t.lit...)
		src = append(src, whitespace...)
	}
	return src
}()

func newlineCount(s string) int {
	n := 0
	for i := 0; i < len(s); i++ {