* and allowing callers to pass arguments that a nullness checker believes could be null.
   *
   * We still encourage people to use requireNonNull over checkNotNull for non-precondition checks.
   */

  /**
   * Ensures that an object reference passed as a parameter to the calling method is not null.
   *
   * @param reference an object reference

---


# Recipes

We've written some recipes that demonstrate how to solve common problems with OkHttp. Read through them to learn about how everything works together. Cut-and-paste these examples freely; that's what they're for.

### Synchronous Get ([.kt][SynchronousGetKotlin], [.java][SynchronousGetJava])

Download a file, print its headers, and print its response body as a string.

        if (handlerParameterMap == null) {
            handlerParameterMap = ParameterUtil.parse(getHandlerParameter());
        }
        return handlerParameterMap;
    }

    public Map<String, String> getHandlerScriptMap() {
        if (handlerScriptMap == null) {
            handlerScriptMap = ParameterUtil.parse(getHandlerScript());
        }
        return handlerScriptMap;
    }

    @Override

                }
                if (values.length > 1) {
                    cb.query().setUpdatedAt_LessEqual(LocalDateTime.parse(values[1], formatter));
                }
            } catch (final Exception e) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to parse {}", pager.requestedTimeRange, e);
                }

package clause_test

import (
	"sync"
	"testing"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"
	"gorm.io/gorm/utils/tests"
)

func BenchmarkSelect(b *testing.B) {
	user, _ := schema.Parse(&tests.User{}, &sync.Map{}, db.NamingStrategy)

	for i := 0; i < b.N; i++ {
		stmt := gorm.Statement{DB: db, Table: user.Table, Schema: user, Clauses: map[string]clause.Clause{}}

    @Mock
    private rpc.sid_t mockSid;

    // Use ArgumentCaptor to capture the MsrpcSamrOpenDomain instance passed to sendrecv
    private ArgumentCaptor<MsrpcSamrOpenDomain> openDomainCaptor;
    // Use ArgumentCaptor to capture the MsrpcSamrCloseHandle instance passed to sendrecv
    private ArgumentCaptor<MsrpcSamrCloseHandle> closeHandleCaptor;

    @BeforeEach
    void setUp() {

  /**
   * Invoked when a {@code Future} computation fails or is canceled.
   *
   * <p>If the future's {@link Future#get() get} method throws an {@link ExecutionException}, then
   * the cause is passed to this method. Any other thrown object is passed unaltered.
   */
  void onFailure(Throwable t);

import org.codelibs.fess.util.ComponentUtil;
import org.dbflute.optional.OptionalEntity;

/**
 * Character mapping file handler for managing character mapping dictionaries.
 * This class provides functionality to load, parse, and manage character mapping
 * rules that define how input characters should be transformed to output characters
 * during text analysis and search processing.
 *
 * Character mapping files contain mapping rules in the format:

        // nothing
    }

    /**
     * Parses parameter string into a map.
     *
     * @param value the parameter string
     * @return the parameter map
     */
    public static Map<String, String> parse(final String value) {
        final Map<String, String> paramMap = new LinkedHashMap<>();
        if (value != null) {
            int unknownKey = 0;

      var unexpectedValues = false

      // Parse each header.
      for (i in 0 until responseHeaders.size) {
        if (!responseHeaders.name(i).equals(HEADER_WEB_SOCKET_EXTENSION, ignoreCase = true)) {
          continue // Not a header we're interested in.
        }
        val header = responseHeaders.value(i)

        // Parse each extension.
        var pos = 0
        while (pos < header.length) {