},
		// Test case 5 object has many trailing separators.
		{
			path:   "/bucket/object/1///",
			bucket: "bucket",
			object: "object/1///",
		},
		// Test case 6 object has only trailing separators.
		{
			path:   "/bucket/object///////",
			bucket: "bucket",
			object: "object///////",
		},
		// Test case 7 object has preceding separators.
		{
			path:   "/bucket////object////",

    /** Constant for the supported comment characters.*/
    private static final String COMMENT_CHARS = "#!";

    /** The list of possible key/value separators */
    private static final char[] SEPARATORS = new char[] {'=', ':'};

    /** The white space characters used as key/value separators. */
    private static final char[] WHITE_SPACE = new char[] {' ', '\t', '\f'};

    /**
     * Unless standard java props, use UTF-8
     */

     *
     * @param expected the option value expected by the test
     * @return the expected value with separators of the host
     */
    private static String toPlatformSpecific(String expected) {
        return expected.replace("/", File.separator).replace(":", File.pathSeparator);
    }

    /**
     * Tests the formatting of an option without module name.
     */
    @Test

        assertNotNull(result);
        assertEquals(longName.toString(), result.getContent());
    }

    /**
     * Test extraction with filename containing path separators.
     */
    public void test_getText_withPathInFilename() {
        final InputStream in = new ByteArrayInputStream(new byte[0]);
        final Map<String, String> params = new HashMap<>();

    // deal with camel conversion
    StringBuilder out = null;
    int i = 0;
    int j = -1;
    while ((j = wordBoundary.indexIn(s, ++j)) != -1) {
      if (i == 0) {
        // include some extra space for separators
        out = new StringBuilder(s.length() + 4 * format.wordSeparator.length());
        out.append(format.normalizeFirstWord(s.substring(i, j)));
      } else {

    assert body == b'{"received":300}'


def _expected_large_payload_json_bytes() -> bytes:
    return json.dumps(
        LARGE_PAYLOAD,
        ensure_ascii=False,
        allow_nan=False,
        separators=(",", ":"),
    ).encode("utf-8")


def test_sync_return_large_dict_without_response_model(
    benchmark, client: TestClient
) -> None:
    status_code, body = _bench_get(

    // deal with camel conversion
    StringBuilder out = null;
    int i = 0;
    int j = -1;
    while ((j = wordBoundary.indexIn(s, ++j)) != -1) {
      if (i == 0) {
        // include some extra space for separators
        out = new StringBuilder(s.length() + 4 * format.wordSeparator.length());
        out.append(format.normalizeFirstWord(s.substring(i, j)));
      } else {

func isSeparator(r rune) bool {
	// ASCII alphanumerics and underscore are not separators
	if r <= 0x7F {
		switch {
		case '0' <= r && r <= '9':
			return false
		case 'a' <= r && r <= 'z':
			return false
		case 'A' <= r && r <= 'Z':
			return false
		case r == '_':
			return false
		}
		return true
	}
	// Letters and digits are not separators
	if unicode.IsLetter(r) || unicode.IsDigit(r) {
		return false

            String expectedPath = "pom-with-profiles" + separator + "pom.xml";

            // The test will pass with File.separator but this shows the platform differences
            assertTrue(
                    actualLocation.contains("pom-with-profiles/pom.xml"),
                    "Location should contain path with proper separators for " + fsName + " (actual: " + actualLocation
                            + ")\n"

    }

    /**
     * Test writeString method indirectly through writeBytesWireFormat
     */
    @Test
    @DisplayName("Test writeString handles path separators correctly")
    public void testWriteStringWithPathSeparators() {
        // Given
        String oldFileName = "folder\\oldFile.txt";
        String newFileName = "folder\\newFile.txt";