},
		// Non parsable ip is assumed to be hostname and gets preserved
		// as the left most elements, regardless of IP based sorting.
		{
			ipList:       []string{"hostname", "127.0.0.1", "192.168.1.106"},
			sortedIPList: []string{"hostname", "192.168.1.106", "127.0.0.1"},
		},
		// Non parsable ip is assumed to be hostname, with a mixed input of ip and hostname.
		// gets preserved and moved into left most elements, regardless of

			Optional:    true,
			Type:        "boolean",
		},
		config.HelpKV{
			Key:         browserReferrerPolicy,
			Description: `set Referrer-Policy response header value` + defaultHelpPostfix(browserReferrerPolicy),
			Optional:    true,
			Type:        "string",
		},
	}

@Beta
@J2ktIncompatible
@GwtIncompatible
public abstract class RateLimiter {
  /**
   * Creates a {@code RateLimiter} with the specified stable throughput, given as "permits per
   * second" (commonly referred to as <i>QPS</i>, queries per second).
   *
   * <p>The returned {@code RateLimiter} ensures that on average no more than {@code
   * permitsPerSecond} are issued during any given second, with sustained requests being smoothly

// goroutine. When a function F calls panic, normal execution of F stops
// immediately. Any functions whose execution was deferred by F are run in
// the usual way, and then F returns to its caller. To the caller G, the
// invocation of F then behaves like a call to panic, terminating G's
// execution and running any deferred functions. This continues until all
// functions in the executing goroutine have stopped, in reverse order. At

            upgradeGoal.testExecuteWithTargetModel(context, "4.0.0");

            assertTrue(Files.exists(existingFile), "Existing file should be preserved");
            assertEquals("existing content", Files.readString(existingFile), "Existing content should be preserved");
        }

        @Test
        @DisplayName("should create .mvn directory for custom model versions")

 * limitations under the License.
 */
package okhttp3.internal.platform.android

import javax.net.ssl.SSLSocket
import okhttp3.Protocol

/**
 * Deferred implementation of SocketAdapter that works by observing the socket
 * and initializing on first use.
 *
 * We use this because eager classpath checks cause confusion and excessive logging in Android,

  @CollectionFeature.Require(SERIALIZABLE)
  public void testReserialize() {
    // For a bare Collection, the most we can guarantee is that the elements are preserved.
    assertEqualIgnoringOrder(actualContents(), SerializableTester.reserialize(actualContents()));
  }

    @Test
    @DisplayName("parseURL: explicit port is preserved")
    void testParseURL_ExplicitPortPreserved() throws MalformedURLException {
        // Arrange & Act
        Handler handler = newHandler();
        URL url = new URL(null, "smb://server:1234/share", handler);

        // Assert
        assertEquals(1234, url.getPort(), "Explicit port should be preserved");
        assertEquals("smb", url.getProtocol());
    }

```Python
# Some Python code
```

### Triple backticks inside quadruple backticks { #triple-backticks-inside-quadruple-backticks }

Comments inside nested code block will NOT be preserved.

````
Here is a code block with quadruple backticks that contains triple backticks inside:

```python
# This is a sample Python code block
def hello_world():
    print("Hello, world!")  # Print greeting

    @Mock
    private rpc.unicode_string mockUnicodeString;

    @Mock
    private lsarpc.LsarSidArray mockLsarSidArray;

    @BeforeEach
    void setUp() {
        // Directly set the deferred field on the mock
        mockNdrBuffer.deferred = mockDeferredBuffer;

        // Configure mocks for NdrBuffer interactions
        lenient().when(mockDeferredBuffer.derive(anyInt())).thenReturn(mockDeferredBuffer);