void awaitTimedWaiting(Thread thread) {
    while (true) {
      switch (thread.getState()) {
        case BLOCKED:
        case NEW:
        case RUNNABLE:
        case WAITING:
          Thread.yield();
          break;
        case TIMED_WAITING:
          return;
        case TERMINATED:
          throw new AssertionError();
      }
    }
  }

   *
   * <p>The returned comparator is serializable.
   *
   * <p><b>Java 8+ users:</b> Use the lambda expression {@code (a, b) -> 0} instead (in certain
   * cases you may need to cast that to {@code Comparator<YourType>}).
   *
   * @since 13.0
   */
  public static Ordering<@Nullable Object> allEqual() {
    return AllEqualOrdering.INSTANCE;
  }

  /**

 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */

package com.google.common.hash;

/**
 * Abstract interface for objects that can concurrently add longs.
 *
 * @author Louis Wasserman
 */
interface LongAddable {
  void increment();

  void add(long x);

  long sum();

    private byte[] salt;

    /**
     * Constructs a preauth integrity negotiate context with the specified parameters.
     *
     * @param config the SMB configuration
     * @param hashAlgos the supported hash algorithms
     * @param salt the salt value for preauth integrity
     */
    public PreauthIntegrityNegotiateContext(final Configuration config, final int[] hashAlgos, final byte[] salt) {
        this.hashAlgos = hashAlgos;

final class ImmutableEnumSet<E extends Enum<E>> extends ImmutableSet<E> {
  static <E extends Enum<E>> ImmutableSet<E> asImmutable(EnumSet<E> set) {
    switch (set.size()) {
      case 0:
        return ImmutableSet.of();
      case 1:
        return ImmutableSet.of(getOnlyElement(set));
      default:
        return new ImmutableEnumSet<>(set);
    }
  }

  /*
   * Notes on EnumSet and <E extends Enum<E>>:
   *

        // observed too that signatures on error responses are sometimes wrong??
        // Looks like the failure case also is just reflecting back the signature we sent

        // with SMB3's negotiation validation it's no longer possible to ignore this (on the validation response)
        // make sure that validation is performed in any case
        final Smb2SigningDigest dgst = getDigest();

    Collection<V> values = multimap().get(k3());
    if (values.size() == 0) {
      expectUnchanged();
      // Be extra thorough in case internal state was corrupted by the expected null.
      assertEquals(new ArrayList<>(), new ArrayList<>(values));
      assertEquals(size, multimap().size());
    } else {

    @Override
    public void addClient(final String regex, final CrawlerClient client, final int pos) {
        factory.addClient(regex, client, pos);
    }

    /**
     * Returns the hash code of the wrapped factory.
     * @return The hash code.
     */
    @Override
    public int hashCode() {
        return factory.hashCode();
    }

    /**
     * Adds a list of clients to the wrapped factory.

    }

    private byte[] createMockBuffer(byte infoLevel) {
        switch (infoLevel) {
        case FileInformation.FILE_BASIC_INFO:
            return createMockFileBasicInfoBuffer();
        case FileInformation.FILE_STANDARD_INFO:
            return createMockFileStandardInfoBuffer();
        case FileInformation.FILE_INTERNAL_INFO:
            return createMockFileInternalInfoBuffer();
        default:

        switch (messageType) {
        case WitnessNotificationMessage.WITNESS_RESOURCE_CHANGE:
            decodeResourceChangeMessage(buf, message);
            break;
        case WitnessNotificationMessage.WITNESS_CLIENT_MOVE:
            decodeClientMoveMessage(buf, message);
            break;
        case WitnessNotificationMessage.WITNESS_SHARE_MOVE: