"scopes":        "A collection of filters that must match each object tracked by a quota. If not specified, the quota matches all objects.",

# This test checks that the CC environment variable may contain quotes and
# spaces. Arguments are normally split on spaces, tabs, newlines. If an
# argument contains these characters, the entire argument may be quoted
# with single or double quotes. This is the same as -gcflags and similar
# options.

[short] skip
[!exec:clang] [!exec:gcc] skip
[!cgo] skip

env GOENV=$WORK/go.env
mkdir 'program files'

}

// fieldNeedsQuotes reports whether our field must be enclosed in quotes.
// Fields with a Comma, fields with a quote or newline, and
// fields which start with a space must be enclosed in quotes.
// We used to quote empty strings, but we do not anymore (as of Go 1.4).
// The two representations should be equivalent, but Postgres distinguishes
// quoted vs non-quoted empty string during database imports, and it has

        '"quoted"'                         | 'quoted'
        '"with space"'                     | 'with space'
        '"with\\\\"quote\\\\"internal"'    | 'with"quote"internal'
        '"with \\\\"quote\\\\" and space"' | 'with "quote" and space'
    }

    @ToBeFixedForConfigurationCache
    def "compiler and linker args can contain quotes and spaces"() {
        given:

  // More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/
  repeated ResourceQuota items = 2;
}

// ResourceQuotaSpec defines the desired hard limits to enforce for Quota.
message ResourceQuotaSpec {
  // hard is the set of desired hard limits for each named resource.
  // More info: https://kubernetes.io/docs/concepts/policy/resource-quotas/
  // +optional

	f.Add([]byte(`unescaped space`))
	f.Add([]byte(`escaped\ space`))
	f.Add([]byte(`"unterminated quote`))
	f.Add([]byte(`'unterminated quote`))
	f.Add([]byte(`unterminated escape\`))
	f.Add([]byte(`"quote with unterminated escape\`))
	f.Add([]byte(`'quoted "double quotes"'`))
	f.Add([]byte(`"quoted 'single quotes'"`))
	f.Add([]byte(`"\$0"`))
	f.Add([]byte(`"\$\0"`))
	f.Add([]byte(`"\$"`))
	f.Add([]byte(`"\$ "`))

      when {
        token == null -> {
          // Value is "double-quoted". That's valid and our regex group already strips the quotes.
          parameter.groups[3]!!.value
        }
        token.startsWith("'") && token.endsWith("'") && token.length > 2 -> {
          // If the token is 'single-quoted' it's invalid! But we're lenient and strip the quotes.
          token.substring(1, token.length - 1)
        }
        else -> token

	escaped := false
	quoted := false
	quote := '\x00'
	i := 0
	for _, rune := range s {
		switch {
		case escaped:
			escaped = false
		case rune == '\\':
			escaped = true
			continue
		case quote != '\x00':
			if rune == quote {
				quote = '\x00'
				continue
			}
		case rune == '"' || rune == '\'':
			quoted = true
			quote = rune
			continue

		{name: "space", args: []string{"a ", "b"}, want: "'a ' b"},
		{name: "newline", args: []string{"a\n", "b"}, want: "'a\n' b"},
		{name: "quote", args: []string{`'a `, "b"}, want: `"'a " b`},
		{name: "unquoteable", args: []string{`'"`}, wantErr: "contains both single and double quotes and cannot be quoted"},
	} {
		t.Run(test.name, func(t *testing.T) {
			got, err := Join(test.args)
			if err != nil {
				if test.wantErr == "" {

package markdown

import (
	"bytes"
)

type Quote struct {
	Position
	Blocks []Block
}

func (b *Quote) PrintHTML(buf *bytes.Buffer) {
	buf.WriteString("<blockquote>\n")
	for _, c := range b.Blocks {
		c.PrintHTML(buf)
	}
	buf.WriteString("</blockquote>\n")
}

func (b *Quote) printMarkdown(buf *bytes.Buffer, s mdState) {
	s.prefix += "> "