* invocation of finalize methods) and waits for it to complete. Ensures that at least one weak
   * reference has been cleared and one {@code finalize} method has been run before this method
   * returns. This method may be useful when testing the garbage collection mechanism itself, or
   * inhibiting a spontaneous GC initiation in subsequent code.
   *

    final Method method =
        ExampleDerivedInterfaceTester.class.getMethod("testRequiringConflictingFeatures");
    ConflictingRequirementsException e =
        assertThrows(
            ConflictingRequirementsException.class,
            () -> FeatureUtil.buildTesterRequirements(method));
    assertThat(e.getConflicts()).contains(ExampleBaseFeature.BASE_FEATURE_1);

    final Method method =
        ExampleDerivedInterfaceTester.class.getMethod("testRequiringConflictingFeatures");
    ConflictingRequirementsException e =
        assertThrows(
            ConflictingRequirementsException.class,
            () -> FeatureUtil.buildTesterRequirements(method));
    assertThat(e.getConflicts()).contains(ExampleBaseFeature.BASE_FEATURE_1);

 * {@code Iterable}. Except as noted, each method has a corresponding {@link Iterator}-based method
 * in the {@link Iterators} class.
 *
 * <p><b>Java 8+ users:</b> several common uses for this class are now more comprehensively
 * addressed by the new {@link java.util.stream.Stream} library. Read the method documentation below

 *
 * <p>On the other hand, a <i>parameter</i> type of {@link ImmutableList} is generally a nuisance to
 * callers. Instead, accept {@link Iterable} and have your method or constructor body pass it to the
 * appropriate {@code copyOf} method itself.
 *
 * <p>Expressing the immutability guarantee directly in the type that user code references is a

        outputContains "START [Test method pass(SomeTest)] [pass]\n"
        outputContains "FINISH [Test method pass(SomeTest)] [pass] [null]\n"
        outputContains "START [Test method fail(SomeTest)] [fail]\n"
        outputContains "FINISH [Test method fail(SomeTest)] [fail] [java.lang.AssertionError]\n"
        outputContains "START [Test method knownError(SomeTest)] [knownError]\n"

        method.addStatement("$N._POP()", METHOD_VISITOR_FIELD); // pops the default method signature marker
        maybeGenerateLoadBinaryClassNameCall(method, interceptedCallable);
        maybeGenerateGetStaticInjectVisitorContext(method, interceptedCallable);

        return this;
    }

    /**
     * Appends a method name to the current node.
     */
    public TreeFormatter appendMethod(Method method) {
        // Implementation is currently dumb, can be made smarter
        append(method.getDeclaringClass().getSimpleName());
        append(".");
        append(method.getName());
        append("()");
        return this;
    }

    /**

   * despite the @IgnoreJRERequirement annotation there. My assumption is that, because javac
   * generates a synthetic method for the body of the lambda, the actual method calls that Animal
   * Sniffer is flagging don't appear inside toImmutableSortedMultiset but rather inside that
   * synthetic method. By moving those calls to a named method, we're able to apply
   * @IgnoreJRERequirement somewhere that it will help.
   */

      return oldValue;
    }
  }

  /**
   * If {@code (key, expectedOldValue)} is currently in the map, this method replaces {@code
   * expectedOldValue} with {@code newValue} and returns true; otherwise, this method returns false.
   *
   * <p>If {@code expectedOldValue} is zero, this method will succeed if {@code (key, zero)} is
   * currently in the map, or if {@code key} is not in the map at all.
   */