return false
	}
	return isVchar(r)
}

// isQtext reports whether r is an RFC 5322 qtext character.
func isQtext(r rune) bool {
	// Printable US-ASCII, excluding backslash or quote.
	if r == '\\' || r == '"' {
		return false
	}
	return isVchar(r)
}

// quoteString renders a string as an RFC 5322 quoted-string.
func quoteString(s string) string {
	var b strings.Builder

        run 'copy'

        then:
        executedAndNotSkipped(':copy')
        file('dest/a.txt').text == "1 + 2"
    }

    def "can expand tokens with escaped backslash when copying"() {
        file('files/a.txt').text = "\$one\\n\${two}"
        buildScript """
            task copy(type: Copy) {
                from 'files'
                into 'dest'

	}, {
		testName: "RunAsUserName containing too many backslashes",
		windowsOptions: &core.WindowsSecurityContextOptions{
			RunAsUserName: toPtr("Container\\Foo\\Lish"),
		},
		expectedErrorSubstring: "runAsUserName cannot contain more than one backslash",
	}, {
		testName: "RunAsUserName containing backslash but empty Domain",
		windowsOptions: &core.WindowsSecurityContextOptions{

// quoted region, and are removed from the resulting substrings. If a quote in s
// isn't closed err will be set and r will have the unclosed argument as the
// last element. The backslash is used for escaping.
//
// For example, the following string:
//
//	a b:"c d" 'e''f'  "g\""
//
// Would be parsed as:
//
//	[]string{"a", "b:c d", "ef", `g"`}

	{`(abc`, "missing closing ): `(abc`"},
	{`abc)`, "unexpected ): `abc)`"},
	{`x[a-z`, "missing closing ]: `[a-z`"},
	{`[z-a]`, "invalid character class range: `z-a`"},
	{`abc\`, "trailing backslash at end of expression"},
	{`a**`, "invalid nested repetition operator: `**`"},
	{`a*+`, "invalid nested repetition operator: `*+`"},
	{`\x`, "invalid escape sequence: `\\x`"},

	quote := byte(0)  // what is the quote character around the current string?

	for _, c := range out {
		if escaped {
			if quote == '"' {
				// “The <backslash> shall retain its special meaning as an escape
				// character … only when followed by one of the following characters
				// when considered special:”
				switch c {
				case '$', '`', '"', '\\', '\n':

	}
	if _, err := rdfs.ReadDir("nonexistent"); err == nil {
		t.Error("fs.ReadDir of nonexistent directory succeeded")
	}

	// Test that the error message does not contain a backslash,
	// and does not contain the DirFS argument.
	const nonesuch = "dir/nonesuch"
	_, err := fsys.Open(nonesuch)
	if err == nil {
		t.Error("fs.Open of nonexistent file succeeded")
	} else {

	"𝒜":                            "\U0001d49c",
	"≔":                          "\u2254",
	"Ã":                          "\u00c3",
	"Ä":                            "\u00c4",
	"∖":                       "\u2216",
	"⫧":                            "\u2ae7",
	"⌆":                          "\u2306",
	"Б":                             "\u0411",
	"∵":                         "\u2235",

		"Ascr;":                            '\U0001D49C',
		"Assign;":                          '\U00002254',
		"Atilde;":                          '\U000000C3',
		"Auml;":                            '\U000000C4',
		"Backslash;":                       '\U00002216',
		"Barv;":                            '\U00002AE7',
		"Barwed;":                          '\U00002306',
		"Bcy;":                             '\U00000411',

//
// You should avoid the following characters in a key name because of
// significant special handling for consistency across all
// applications.
//
// Rejects strings with following characters.
//
// - Backslash ("\")
//
// additionally minio does not support object names with trailing SlashSeparator.
func IsValidObjectName(object string) bool {
	if len(object) == 0 {
		return false
	}