// Choose the first selection to do...
    int requiredChosen = chooseNextSelection(allRequired, requiredFrom, requiredTo, from, to);
    int required = allRequired[requiredChosen];

    // ...do the first selection...
    selectInPlace(required, array, from, to);

    // ...then recursively perform the selections in the range below...
    int requiredBelow = requiredChosen - 1;

            log.error("Server returned invalid hash selection");
            return false;
        }
        return true;
    }


    private static boolean checkEncryptionContext ( Smb2NegotiateRequest req, EncryptionNegotiateContext ec ) {
        if ( ec.getCiphers() == null || ec.getCiphers().length != 1 ) {
            log.error("Server returned no cipher selection");
            return false;
        }

    boolean isDisablePlainTextPasswords ();


    /**
     * 
     * 
     * Property <tt>jcifs.resolveOrder</tt> (string, default <tt>LMHOSTS,DNS,WINS,BCAST</tt>)
     * 
     * @return order and selection of resolver modules, see {@link ResolverType}
     */
    List<ResolverType> getResolveOrder ();


    /**
     * 
     * Property <tt>jcifs.netbios.baddr</tt> (string, default <tt>255.255.255.255</tt>)

    assertEquals(Prepender.class, Prepender.constructor().getReturnType().getType());
  }

  private static class WithConstructorAndTypeParameter<T> {
    @SuppressWarnings("unused") // by reflection
    <X> WithConstructorAndTypeParameter() {}
  }

  public void testConstructor_returnType_hasTypeParameter() throws Exception {
    Class<WithConstructorAndTypeParameter> type = WithConstructorAndTypeParameter.class;

      assertThat(expected)
          .hasMessageThat()
          .isEqualTo("end index (0) must not be less than start index (1)");
    }
  }

  @GwtIncompatible("Reflection")
  @J2ktIncompatible
  public void testAllOverloads_checkArgument() throws Exception {
    for (ImmutableList<Class<?>> sig : allSignatures(boolean.class)) {
      Method checkArgumentMethod =

  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testKeySetBridgeMethods() {
    for (Method m : TreeMultimap.class.getMethods()) {
      if (m.getName().equals("keySet") && m.getReturnType().equals(SortedSet.class)) {
        return;
      }
    }
    fail("No bridge method found");
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  public void testAsMapBridgeMethods() {

        Class<?> optionalClass = Class.forName("java.util.Optional");
        /*
         * We don't *need* to use reflection to access Optional: It's available on all JDKs we
         * support, and Android code won't get this far, anyway, because ProcessHandle is
         * unavailable. But given how much other reflection we're using, we might as well use it
         * here, too, so that we don't need to also suppress an AndroidApiChecker error.

    assertEquals(Integer.MAX_VALUE, ms.tailMultiset("b", CLOSED).size());
    assertEquals(Integer.MAX_VALUE, ms.tailMultiset("a", CLOSED).size());
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  @AndroidIncompatible // Reflection bug, or actual binary compatibility problem?
  public void testElementSetBridgeMethods() {
    for (Method m : TreeMultiset.class.getMethods()) {

      return;
    }
    fail();
  }

  private static class BadEqualsFactory {
    /** oneConstantOnly matters now since it can be either null or the constant. */
    @SuppressWarnings("unused") // Called by reflection
    public static Object bad(String a, int b, @Nullable OneConstantEnum oneConstantOnly) {
      return new GoodEquals(a, b);
    }
  }

  public void testNullsOnReturnValues_good() throws Exception {

            .get());
    assertEquals(
        Integer.valueOf(5),
        reserialize(Suppliers.synchronizedSupplier(Suppliers.ofInstance(5))).get());
  }

  @J2ktIncompatible
  @GwtIncompatible // reflection
  @SuppressWarnings("Java7ApiChecker") // includes test of Java 8+ API
  public void testSuppliersNullChecks() throws Exception {
    new ClassSanityTester()
        .setDefault(Duration.class, Duration.ofSeconds(1))