val failingResponse = brotliInterceptor.decompress(response)
      failingResponse.body.string()
    }.also { ioe ->
      assertThat(ioe).hasMessage("Brotli stream decoding failed")
      assertThat(ioe.cause?.javaClass?.simpleName).isEqualTo("BrotliRuntimeException")
    }
  }

  @Test
  fun testSkipUncompressNoContentResponse() {
    val response =
      response("https://httpbin.org/brotli", EMPTY) {

   * this function.
   *
   * <p><b>Warning: do not depend</b> on the behavior of this method.
   *
   * <p>Historically, {@code Function} instances in this library have implemented this method to
   * recognize certain cases where distinct {@code Function} instances would in fact behave
   * identically. However, as code migrates to {@code java.util.function}, that behavior will
   * disappear. It is best not to depend on it.
   */
  @Override

a de-facto standard.  To achieve this, non-free programs must be
allowed to use the library.  A more frequent case is that a free
library does the same job as widely used non-free libraries.  In this
case, there is little to gain by limiting the free library to free
software only, so we use the Lesser General Public License.

  In other cases, permission to use a particular library in non-free

     * This method creates a new function that caches the results of the original function,
     * improving performance for repeated calls with the same input.
     *
     * @param callback The original function to be memoized. It takes a String as input and returns a String.
     * @return A new {@code UnaryOperator<String>} that caches the results of the original function.

		db.cacheStore.Store(preparedStmtDBKey, preparedStmt)
		db.ConnPool = preparedStmt
	}

	db.Statement = &Statement{
		DB:       db,
		ConnPool: db.ConnPool,
		Context:  context.Background(),
		Clauses:  map[string]clause.Clause{},
	}

	if err == nil && !config.DisableAutomaticPing {
		if pinger, ok := db.ConnPool.(interface{ Ping() error }); ok {
			err = pinger.Ping()
		}
	}

	if err != nil {

import okhttp3.tls.HandshakeCertificates
import okhttp3.tls.internal.TlsUtil.localhost

/**
 * OkHttp is usually tested with functional tests: these use public APIs to confirm behavior against
 * MockWebServer. In cases where logic is particularly tricky, we use unit tests. This class makes
 * it easy to get sample values to use in such tests.
 *
 * This class is pretty fast and loose with default values: it attempts to provide values that are

        }
    }

    @Test
    @DisplayName("Should handle case sensitivity")
    void testCaseSensitivity() {
        // Given
        String upperCase = "SERVER";
        String lowerCase = "server";
        String mixedCase = "Server";

        // Test different cases
        when(mockNetbiosName.getName()).thenReturn(upperCase);

        // Ensure no unexpected extra options
        assertEquals(3, returned.size(), "Only provided options are expected");
    }

    @Test
    @DisplayName("Null options cause IllegalArgumentException when retrieving entries (JAAS requires non-null options)")
    void nullOptions_throwOnAccess() {
        // Arrange
        StaticJAASConfiguration cfg = new StaticJAASConfiguration(null);

			nil,
			nil,
		},
		// Test - 4 - parse the chunk reader properly.
		{
			bufio.NewReader(readers[3]),
			nil,
			[]byte("1000"),
			[]byte("111123333333333333334444211"),
		},
	}
	// Valid test cases for each chunk line.
	for i, tt := range testCases {
		chunkSize, chunkSignature, err := readChunkLine(tt.reader)
		if err != tt.expectedErr {
			t.Errorf("Test %d: Expected %s, got %s", i+1, tt.expectedErr, err)
		}

}

func (d *DummyDataGen) Seek(offset int64, whence int) (int64, error) {
	switch whence {
	case io.SeekStart:
		if offset < 0 {
			return 0, errors.New("Invalid offset")
		}
		d.idx = offset
	case io.SeekCurrent:
		if d.idx+offset < 0 {
			return 0, errors.New("Invalid offset")
		}
		d.idx += offset
	case io.SeekEnd:
		if d.length+offset < 0 {
			return 0, errors.New("Invalid offset")
		}