}
        };
    f.set("foo");
  }

  // Regression test for a case where we would fail to execute listeners immediately on done futures
  // this would be observable from a waiter that was just unblocked.
  public void testListenersExecuteImmediately_afterWaiterWakesUp() throws Exception {
    AbstractFuture<String> f =
        new AbstractFuture<String>() {
          @Override

				forward = forward[:idx]
			}
		}

		if s.walkMu != nil {
			s.walkMu.Lock()
		}
		entries, err := s.ListDir(ctx, "", opts.Bucket, current, -1)
		if s.walkMu != nil {
			s.walkMu.Unlock()
		}
		if err != nil {
			// Folder could have gone away in-between
			if err != errVolumeNotFound && err != errFileNotFound {
				internalLogOnceIf(ctx, err, "metacache-walk-scan-dir")
			}

		if globalIsDistErasure {
			// Top locks
			adminRouter.Methods(http.MethodGet).Path(adminVersion + "/top/locks").HandlerFunc(adminMiddleware(adminAPI.TopLocksHandler))
			// Force unlocks paths
			adminRouter.Methods(http.MethodPost).Path(adminVersion+"/force-unlock").
				Queries("paths", "{paths:.*}").HandlerFunc(adminMiddleware(adminAPI.ForceUnlockHandler))
		}

		ACB_SVRTRUST               = 0x00000100, /* 1 = Server trust account */
		ACB_PWNOEXP                = 0x00000200, /* 1 = User password does not expire */
		ACB_AUTOLOCK               = 0x00000400, /* 1 = Account auto locked */
		ACB_ENC_TXT_PWD_ALLOWED    = 0x00000800, /* 1 = Encryped text password is allowed */
		ACB_SMARTCARD_REQUIRED     = 0x00001000, /* 1 = Smart Card required */

    int NT_STATUS_PASSWORD_MUST_CHANGE = 0xC0000224;
    /** The object was not found */
    int NT_STATUS_NOT_FOUND = 0xC0000225;
    /** The referenced account is currently locked out */
    int NT_STATUS_ACCOUNT_LOCKED_OUT = 0xC0000234;
    /** The remote system refused the network connection */
    int NT_STATUS_CONNECTION_REFUSED = 0xC0000236;
    /** The pathname does not traverse a DFS junction */

// enforceRetentionForDeletion checks if it is appropriate to remove an
// object according to locking configuration when this is lifecycle/ bucket quota asking.
func enforceRetentionForDeletion(ctx context.Context, objInfo ObjectInfo) (locked bool) {
	if objInfo.DeleteMarker {
		return false
	}

	lhold := objectlock.GetObjectLegalHoldMeta(objInfo.UserDefined)
	if lhold.Status.Valid() && lhold.Status == objectlock.LegalHoldOn {
		return true
	}

		foreignField.GORMDataType = primaryFields[idx].GORMDataType
		if foreignField.Size == 0 {
			foreignField.Size = primaryFields[idx].Size
		}
		schema.Relationships.Mux.Unlock()
		if schema != foreignField.Schema {
			foreignField.Schema.Relationships.Mux.Unlock()
		}

		relation.References = append(relation.References, &Reference{
			PrimaryKey:    primaryFields[idx],
			ForeignKey:    foreignField,

   * Returns the name of the server the client requested via the SNI (Server Name Indication)
   * attribute in the TLS handshake. Unlike the rest of the HTTP exchange, this name is sent in
   * cleartext and may be monitored or blocked by a proxy or other middlebox.
   */
  public val handshakeServerNames: List<String>,
  /** A string like `GET` or `POST`. */
  public val method: String,
  /**
   * The request target from the original HTTP request.

        buf.append("\"classes\":{");
        append(buf, "loaded", () -> classes.getLoadedClassCount()).append(',');
        append(buf, "total_loaded", () -> classes.getTotalLoadedClassCount()).append(',');
        append(buf, "unloaded", () -> classes.getUnloadedClassCount());
        buf.append("},");
        append(buf, "uptime", () -> jvmStats.getUptime().getMillis());
        buf.append("},");
    }

    /** Cleanup collected entries when the lock is available. */
    void tryDrainReferenceQueues() {
      if (tryLock()) {
        try {
          maybeDrainReferenceQueues();
        } finally {
          unlock();
        }
      }
    }

    @GuardedBy("this")
    void drainKeyReferenceQueue(ReferenceQueue<K> keyReferenceQueue) {
      Reference<? extends K> ref;
      int i = 0;