this.writer = writer;
        this.backslashEscape = backslashEscape;
        this.quotablePattern = quotablePattern;
    }

    /**
     * Double quotes around args containing whitespace, backslash chars are escaped using double backslash, platform line separators.
     */
    public static ArgWriter unixStyle(PrintWriter writer) {
        return new ArgWriter(writer, true, WHITESPACE);
    }

			} else if !backslash && quote == c {
				quote = '\000'
			} else if (quote == '\000' || quote == '"') && !backslash && c == '\\' {
				backslash = true
			} else {
				backslash = false
			}
		}
	}
	if !lastSpace {
		cc = append(cc, s[start:])
	}

	// Force reallocation (and avoid aliasing bugs) for tests that append to cc.
	cc = cc[:len(cc):len(cc)]

	return cc
}

        def slash = '/' as char
        def backslash = '\\' as char

        expect:
        compareCharsIgnoringCase(slash, backslash) == 0
        compareCharsIgnoringCase(backslash, slash) == 0
        compareChars(slash, backslash) == 0
        compareChars(backslash, slash) == 0
        equalChars(slash, backslash, caseSensitivity)
        equalChars(backslash, slash, caseSensitivity)
    }

                    '''let value = 42
                        let rawString = #"Raw string are ones with "quotes", backslash (\\), but can do special string interpolation (\\#(value))"#
                        XCTAssertEqual(rawString, "Raw string are ones with \\"quotes\\", backslash (\\\\), but can do special string interpolation (42)")''')]
            }
        }]
    }

			} else if !backslash && quote == c {
				quote = '\000'
			} else if (quote == '\000' || quote == '"') && !backslash && c == '\\' {
				backslash = true
			} else {
				backslash = false
			}
		}
	}
	if !lastSpace {
		flags = append(flags, GOGCCFLAGS[start:])
	}

	cmd := exec.Command(CC, flags...)
	cmd.Args = append(cmd.Args, args...)
	return cmd, nil
}

type version struct {

    }

    @Override
    List<XCTestCaseElement> getTestCases() {
        return [
            testCase("testRawStrings",
            '''XCTAssertEqual(getRawString(), "Raw string are ones with \\"quotes\\", backslash (\\\\), but can do special string interpolation (42)"))'''),
            testCase("testCodeWasCompiledWithSwift5Compiler",
                """#if swift(>=6.0)

				return errors.New("invalid header configuration. Expecting '\"'")
			}

		case StringParserState:
			// Consume a JSON string (ignoring backslash-escaped chars).
			if ch == '\\' {
				if !hasNextCh {
					return errors.New("invalid header configuration. Un-terminated backslash in JSON string")
				}

				// Skip escaped char.
				pos++
			} else if ch == ')' {
				state = ExpectVariableEndParserState

    /**
     * Whether or not the parser is currently in the middle of a string literal.
     */
    private boolean inString;

    /**
     * Whether or not the last char has been a backslash.
     */
    private boolean quoted;

    public PreprocessingReader(Reader reader) {
        this.reader = reader;
        readAheadChars[0] = -1;
        readAheadChars[1] = -1;
    }

    /**

	{"foo/BAR", map[string]string{"quote": `With "quote`}, `foo/bar; quote="With \"quote"`},
	{"foo/BAR", map[string]string{"bslash": `With \backslash`}, `foo/bar; bslash="With \\backslash"`},
	{"foo/BAR", map[string]string{"both": `With \backslash and "quote`}, `foo/bar; both="With \\backslash and \"quote"`},
	{"foo/BAR", map[string]string{"": "empty attribute"}, ""},
	{"foo/BAR", map[string]string{"bad attribute": "baz"}, ""},

    <modelVersion>4.0.0</modelVersion>
    <groupId>util</groupId>
    <artifactId>util</artifactId>
    <version>2.5</version>
    <name>A description \ with a backslash</name>
    <packaging>jar</packaging>