t.Errorf("Expected service command %v but received %v", expectedCmd, serviceCmd)
	}
}

// getServiceCmdRequest - Constructs a management REST API request for service
// subcommands for a given cmdType value.
func getServiceCmdRequest(cmd cmdType, cred auth.Credentials) (*http.Request, error) {
	queryVal := url.Values{}
	queryVal.Set("action", string(cmd.toServiceAction()))
	queryVal.Set("type", "2")

And it will save the returned value in a <abbr title="A utility/system to store computed/generated values, to reuse them instead of computing them again.">"cache"</abbr> and pass it to all the "dependants" that need it in that specific request, instead of calling the dependency multiple times for the same request.

func (a adminAPIHandlers) UpdateIdentityProviderCfg(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	addOrUpdateIDPHandler(ctx, w, r, true)
}

// ListIdentityProviderCfg:
//
// GET <admin-prefix>/idp-cfg/openid -> lists openid provider configs.
func (a adminAPIHandlers) ListIdentityProviderCfg(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

        ).hostnameVerifier(nullHostnameVerifier)
        .build()
    val request = Request(server.url("/"))
    val response1: Response = client.newCall(request).execute()
    val bodySource = response1.body.source()
    assertThat(bodySource.readUtf8()).isEqualTo("ABC.1")

    corruptor()

    return client.newCall(request).execute()
  }

  /**

		query := url.Values{}
		for key, value := range testCase.queryParams {
			query.Set(key, value)
		}
		// Create a request to use.
		req, err := http.NewRequest(http.MethodGet, "http://host/a/b?"+query.Encode(), nil)
		if err != nil {
			t.Errorf("(%d) failed to create http.Request, got %v", i, err)
		}
		if testCase.expected != ErrNone {
			// Should be set since we are simulating a http server.

            try {
                principal = getAuthenticator().authenticate(request, spnegoResponse);
                if (logger.isDebugEnabled()) {
                    logger.debug("principal: {}", principal);
                }
            } catch (final Exception e) {
                final String msg = "Failed to process Authorization Header: " + request.getHeader(Constants.AUTHZ_HEADER);
                if (logger.isDebugEnabled()) {

   * delimited by 'null'.
   *
   * @param callerIsIdle true if the caller isn't sending any more bytes until the peer responds.
   *     This is true after a `Expect-Continue` request, false for duplex requests, and false for
   *     all other requests.
   */
  @Throws(IOException::class)
  fun takeHeaders(callerIsIdle: Boolean = false): Headers {
    withLock {
      while (headersQueue.isEmpty() && errorCode == null) {

     * The flags for this DCERPC message
     */
    protected int flags = 0;
    /**
     * The total length of this DCERPC message
     */
    protected int length = 0;
    /**
     * The call ID for matching requests and responses
     */
    protected int call_id = 0;
    /**
     * The allocation hint for buffer sizing
     */
    protected int alloc_hint = 0;
    /**
     * The result code of the DCERPC operation

    /** Path names are caseless flag */
    int FLAGS_PATH_NAMES_CASELESS = 0x08;
    /** Path names canonicalized flag */
    int FLAGS_PATH_NAMES_CANONICALIZED = 0x10;
    /** Oplock requested or granted flag */
    int FLAGS_OPLOCK_REQUESTED_OR_GRANTED = 0x20;
    /** Notify of modify action flag */
    int FLAGS_NOTIFY_OF_MODIFY_ACTION = 0x40;
    /** Response flag */
    int FLAGS_RESPONSE = 0x80;

                try {
                    // Send SMB2 Change Notify request
                    Smb2ChangeNotifyRequest request = new Smb2ChangeNotifyRequest();
                    request.setFileId(handle.directoryFile.getFileId());
                    request.setCompletionFilter(getNotificationFilter());
                    request.setWatchTree(false);  // Non-recursive for now