}

            if ( request != null ) {
                log.debug("Restting request");
                request.reset();
            }
            if ( rpath != null ) {
                // resolveDfs() and tree.send() modify the request packet.
                // I want to restore it before retrying. request.reset()

            }
        }

        request.uid = uid;
        request.auth = auth;
        try {
            transport.send( request, response );
        } catch (SmbException se) {
            if (request instanceof SmbComTreeConnectAndX) {
                logoff(true);
            }
            request.digest = null;
            throw se;
        }
}
    }

	}

	globalActiveCred = creds
	testCases := []struct {
		Request *http.Request
		ErrCode APIErrorCode
	}{
		{Request: mustNewRequest(http.MethodGet, "http://127.0.0.1:9000", 0, nil, t), ErrCode: ErrAccessDenied},
		{Request: mustNewSignedRequest(http.MethodGet, "http://127.0.0.1:9000", 0, nil, t), ErrCode: ErrNone},

        SettingsBuildingRequest request = new DefaultSettingsBuildingRequest();
        request.setUserSettingsFile(userSettingsFile);
        request.setGlobalSettingsFile(globalSettingsFile);
        request.setSystemProperties(SystemProperties.getSystemProperties());
        return build(request);
    }

    public Settings buildSettings(File userSettingsFile, boolean useCachedSettings)

            // try TreeConnectAndX with the request
            // this does not make any sense if we are disconnecting right now
            T chainedResponse = null;
            if ( ! ( request instanceof SmbComTreeDisconnect ) && ! ( request instanceof Smb2TreeDisconnectRequest ) ) {
                chainedResponse = treeConnect(request, response);
            }

        request.isBroadcast = request.addr == null || isBroadcastAddress(request.addr);

        if ( request.isBroadcast ) {
            if ( request.addr == null ) {
                request.addr = this.baddr;
            }
            n = config.getNetbiosRetryCount();
        }
        else {
            n = 1;
        }

        do {
            try {

  fun testBasicAuth() {
    fakeDns["server"] = listOf(InetAddress.getLocalHost())

    val route = factory.newRoute()

    val request =
      Request.Builder()
        .url("https://server/robots.txt")
        .build()
    val response =
      Response.Builder()
        .request(request)
        .code(401)
        .header("WWW-Authenticate", "Basic realm=\"User Visible Realm\"")
        .protocol(HTTP_2)

        // read and validate raw model
        Model fileModel = readFileModel(request, problems);

        request.setFileModel(fileModel);
        result.setFileModel(fileModel.clone());

        activateFileModel(request, result, problems);

        if (!request.isTwoPhaseBuilding()) {
            return build(request, result, importIds);
        } else if (hasModelErrors(problems)) {

    try (Response response = client.newCall(request).execute()) {
      System.out.println(response.request().header("Date"));
    }
  }

  static class CurrentDateInterceptor implements Interceptor {
    @Override public Response intercept(Chain chain) throws IOException {
      Request request = chain.request();
      Headers newHeaders = request.headers()
          .newBuilder()
          .add("Date", new Date())
          .build();

     *
     * @param model The model to validate, must not be {@code null}.
     * @param request The model building request that holds further settings, must not be {@code null}.
     * @param problems The container used to collect problems that were encountered, must not be {@code null}.
     */
    default void validateFileModel(Model model, ModelBuildingRequest request, ModelProblemCollector problems) {
        // do nothing
    }

    /**