// one is still running.
            //
            // Now, maybe we could tweak our implementation to not start the next task until the
            // callable actually completes. (We could detect completion in our wrapper
            // `AsyncCallable task`.) However, our contract also promises:
            //
            // 2. not to cancel any Future the user returned from an AsyncCallable
            //

            ki--;
        }
        if (ki < key.length()) {
            key = key.substring(0, ki);
        }

        /* Subtract the server and share from the pathConsumed so that
         * it refects the part of the relative path consumed and not
         * the entire path.
         */
        dr.pathConsumed -= 1 + server.length() + 1 + share.length();

import junit.framework.AssertionFailedError;
import junit.framework.TestCase;
import org.jspecify.annotations.Nullable;

/**
 * Tests for {@link ForwardingWrapperTester}. Live in a different package to detect reflection
 * access issues, if any.
 *
 * @author Ben Yu
 */
public class ForwardingWrapperTesterTest extends TestCase {

  private final ForwardingWrapperTester tester = new ForwardingWrapperTester();

    /**
     * Check for and report resource leaks
     */
    public void checkForLeaks() {
        if (!leakDetectionEnabled) {
            return;
        }

        // Process phantom references to detect leaks
        Reference<?> ref;
        while ((ref = referenceQueue.poll()) != null) {
            handlePhantomReference(ref);
        }

        // Check for old unclosed resources

        </field>
      </fields>
    </class>
    <class>
      <name>ActivationOS</name>
      <version>1.0.0</version>
      <description><![CDATA[
        This is an activator which will detect an operating system's attributes in order to activate
        its profile.
      ]]></description>
      <fields>
        <field>
          <name>name</name>
          <version>1.0.0</version>

            assertEquals(ServerMessageBlock2.SMB2_FLAGS_DFS_OPERATIONS, testMessage.getFlags());
        }

        @Test
        @DisplayName("Should detect response flag")
        void testIsResponse() {
            assertFalse(testMessage.isResponse());
            testMessage.addFlags(ServerMessageBlock2.SMB2_FLAGS_SERVER_TO_REDIR);

   * of edges in a graph arranged to form a path (a sequence of adjacent outgoing edges) starting
   * and ending with the same node.
   *
   * <p>This method will detect any non-empty cycle, including self-loops (a cycle of length 1).
   */
  public static <N> boolean hasCycle(Graph<N> graph) {
    int numEdges = graph.edges().size();
    if (numEdges == 0) {

   * of edges in a graph arranged to form a path (a sequence of adjacent outgoing edges) starting
   * and ending with the same node.
   *
   * <p>This method will detect any non-empty cycle, including self-loops (a cycle of length 1).
   */
  public static <N> boolean hasCycle(Graph<N> graph) {
    int numEdges = graph.edges().size();
    if (numEdges == 0) {

    try {
      new NullPointerTester().testInstanceMethods(instance, visibility);
    } catch (AssertionError expected) {
      return;
    }
    fail("Should detect problem in " + instance.getClass().getSimpleName());
  }

  private static void shouldFail(Object instance) {
    shouldFail(instance, Visibility.PACKAGE);
    shouldFail(instance, Visibility.PROTECTED);

 *
 * This class tracks header values line-by-line. A field with multiple comma- separated values on
 * the same line will be treated as a field with a single value by this class. It is the caller's
 * responsibility to detect and split on commas if their field permits multiple values. This
 * simplifies use of single-valued fields whose values routinely contain commas, such as cookies or
 * dates.
 *