if debugNoExit {
				logger.Info("Not waiting for quorum since we are debugging.. possible cause unhealthy sets")
				logger.Info(result.String())
				break
			}
			d := time.Duration(r.Float64() * float64(time.Second))
			logger.Info("Waiting for quorum READ healthcheck to succeed retrying in %s.. possible cause unhealthy sets", d)
			logger.Info(result.String())
			time.Sleep(d)

         */
        public CompletableFuture<Void> getNotificationFuture() {
            return notificationFuture;
        }

        /**
         * Sets the future for asynchronous notification completion
         * @param future the notification future to set
         */
        public void setNotificationFuture(CompletableFuture<Void> future) {
            this.notificationFuture = future;
        }
    }

          }
          return true;
        }
      }
    }
    return false;
  }

  // Views

  @Override
  Set<E> createElementSet() {
    Set<E> delegate = countMap.keySet();
    return new ForwardingSet<E>() {
      @Override
      protected Set<E> delegate() {
        return delegate;
      }

      @Override
      public boolean contains(@Nullable Object object) {

//
// By default, [Scanner.Scan] uses an internal buffer and sets the
// maximum token size to [MaxScanTokenSize].
//
// Buffer panics if it is called after scanning has started.
func (s *Scanner) Buffer(buf []byte, max int) {
	if s.scanCalled {
		panic("Buffer called after Scan")
	}
	s.buf = buf[0:cap(buf)]
	s.maxTokenSize = max
}

// Split sets the split function for the [Scanner].

        }
        for (final String l : supportedLanguages) {
            if (l.equals(lang)) {
                return l;
            }
        }
        return null;
    }

    /**
     * Sets the language detector.
     *
     * @param detector The language detector.
     */
    public void setDetector(final LanguageDetector detector) {
        this.detector = detector;
    }

    /**

     */
    private static final String[] JVM_VENDOR_DEFAULT_PKGS = { "sun.net.www.protocol" };

    private static URLStreamHandlerFactory factory;

    private final CIFSContext transportContext;

    /**
     * Sets the URL stream handler factory for the environment. This
     * allows specification of the factory used in creating underlying
     * stream handlers. This can be called once per JVM instance.
     *
     * @param factory

    }

    // this optimizes testing equality of two range-backed sets
    if (values instanceof SortedSet) {
      SortedSet<? extends C> set = (SortedSet<? extends C>) values;
      Comparator<?> comparator = set.comparator();
      if (Ordering.natural().equals(comparator) || comparator == null) {
        return contains(set.first()) && contains(set.last());
      }
    }

    for (C value : values) {

  }

  @VisibleForTesting
  static <E extends @Nullable Object> Set<E> set(Set<E> set, @Nullable Object mutex) {
    return new SynchronizedSet<>(set, mutex);
  }

  static class SynchronizedSet<E extends @Nullable Object> extends SynchronizedCollection<E>
      implements Set<E> {

    SynchronizedSet(Set<E> delegate, @Nullable Object mutex) {
      super(delegate, mutex);
    }

    @Override

  }

  @VisibleForTesting
  static <E extends @Nullable Object> Set<E> set(Set<E> set, @Nullable Object mutex) {
    return new SynchronizedSet<>(set, mutex);
  }

  static class SynchronizedSet<E extends @Nullable Object> extends SynchronizedCollection<E>
      implements Set<E> {

    SynchronizedSet(Set<E> delegate, @Nullable Object mutex) {
      super(delegate, mutex);
    }

    @Override

        // Act + Assert
        assertThrows(PACDecodingException.class, () -> new KerberosApRequest(notASequence, null));
    }

    @Test
    @DisplayName("seq ctor: valid minimal sequence sets apOptions and leaves ticket null")
    void sequenceConstructor_minimal_valid_setsApOptions_noTicket() throws Exception {
        // Arrange
        byte ap = (byte) 0x7A;
        ASN1Sequence seq = buildMinimalApReqSeq(ap);