public static final UnsignedInteger ONE = fromIntBits(1);
  public static final UnsignedInteger MAX_VALUE = fromIntBits(-1);

  private final int value;

  private UnsignedInteger(int value) {
    // GWT doesn't consistently overflow values to make them 32-bit, so we need to force it.
    this.value = value & 0xffffffff;
  }

  /**
   * Returns an {@code UnsignedInteger} corresponding to a given bit representation. The argument is

            this.cachedSubject = s;
            return this.cachedSubject;
        } catch (LoginException e) {
            log.error("Failed to create login context", e);
            // Cache null to ensure consistent behavior across calls
            this.cachedSubject = null;
            return null;
        }
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.smb.SmbRenewableCredentials#renew()

  /**
   * Returns an immutable map containing the same entries as {@code map}. If {@code map} somehow
   * contains entries with duplicate keys (for example, if it is a {@code SortedMap} whose
   * comparator is not <i>consistent with equals</i>), the results of this method are undefined.
   *
   * <p><b>Note:</b> Despite what the method name suggests, if {@code map} is an {@code
   * ImmutableClassToInstanceMap}, no copy will actually be performed.

    }

    // Test multiple calls to getServletPath
    public void test_getServletPath_multipleCallsReturnSameResult() {
        final String customPath = "/api/v1/consistent";
        mockRequest.setQueryString("query=test");
        webApiRequest = new WebApiRequest(mockRequest, customPath);

        String firstCall = webApiRequest.getServletPath();

  }

  @Override
  public int hashCode() {
    return Sets.hashCodeImpl(this);
  }

  // This declaration is needed to make Set.iterator() and
  // ImmutableCollection.iterator() appear consistent to javac's type inference.
  @Override
  public abstract UnmodifiableIterator<E> iterator();

  abstract static class CachingAsList<E> extends ImmutableSet<E> {
    @LazyInit private transient ImmutableList<E> asList;

            int expectedAlignedSize = (expectedSize + 7) & ~7;

            assertEquals(expectedAlignedSize, echoRequest.size());
        }

        @Test
        @DisplayName("Size should be consistent across multiple calls")
        void testSizeConsistency() {
            int size1 = echoRequest.size();
            int size2 = echoRequest.size();

            assertEquals(size1, size2);
        }

   * <i>not</i> needed, it may be faster to copy {@code Iterables.filter(unfiltered, predicate)} and
   * use the copy.
   *
   * <p><b>Warning:</b> {@code predicate} must be <i>consistent with equals</i>, as documented at
   * {@link Predicate#apply}. Do not provide a predicate such as {@code
   * Predicates.instanceOf(ArrayList.class)}, which is inconsistent with equals. (See {@link

            assertEquals(200L, SMBUtil.readInt8(smallBuffer, 8));
            assertEquals(1, SMBUtil.readInt4(smallBuffer, 16));
        }

        @ParameterizedTest
        @DisplayName("Should encode consistently with various flag values")
        @ValueSource(ints = { 0, 1, 2, 4, 16, 0xFF, 0xFFFF, 0xFFFFFF, 0x7FFFFFFF, -1 })
        void testEncodingWithVariousFlags(int flags) {
            lock = new Smb2Lock(1024L, 2048L, flags);

   */
  public abstract N target();

  /**
   * If this {@link EndpointPair} {@link #isOrdered()} returns the {@link #source()}; otherwise,
   * returns an arbitrary (but consistent) endpoint of the origin edge.
   */
  public final N nodeU() {
    return nodeU;
  }

  /**
   * Returns the node {@link #adjacentNode(Object) adjacent} to {@link #nodeU()} along the origin

      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this
      License. However, in accepting such obligations, You may act only
      on Your own behalf and on Your sole responsibility, not on behalf
      of any other Contributor, and only if You agree to indemnify,