rangeSet.add(range);

      TreeRangeSet<Integer> complement = TreeRangeSet.create();
      complement.add(Range.<Integer>all());
      complement.remove(range);

      assertEquals(complement, rangeSet.complement());
      assertThat(rangeSet.complement().asRanges())
          .containsExactlyElementsIn(complement.asRanges())
          .inOrder();
    }
  }

    this(ranges, /* complement= */ null);
  }

  private ImmutableRangeSet(
      ImmutableList<Range<C>> ranges, @Nullable ImmutableRangeSet<C> complement) {
    this.ranges = ranges;
    this.complement = complement;
  }

  private final transient ImmutableList<Range<C>> ranges;
  private final transient @Nullable ImmutableRangeSet<C> complement;

  @Override

@NullUnmarked
public abstract class AbstractRangeSetTest extends TestCase {
  public static void testInvariants(RangeSet<?> rangeSet) {
    testInvariantsInternal(rangeSet);
    testInvariantsInternal(rangeSet.complement());
  }

  private static <C extends Comparable<?>> void testInvariantsInternal(RangeSet<C> rangeSet) {
    assertEquals(rangeSet.asRanges().isEmpty(), rangeSet.isEmpty());

        assertNotNull(zeroAvFlags, "AvFlags object should not be null for zero bytes");
        assertEquals(0, zeroAvFlags.getFlags(), "Flags should be 0 for zero bytes");

        // Test with negative integer (two's complement)
        byte[] negativeBytes = new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF }; // Represents -1
        AvFlags negativeAvFlags = new AvFlags(negativeBytes);

//
// If operating in binary mode, this assumes strict GNU binary mode; which means
// that the first byte can only be either 0x80 or 0xff. Thus, the first byte is
// equivalent to the sign bit in two's complement form.
func fitsInBase256(n int, x int64) bool {
	binBits := uint(n-1) * 8
	return n >= 9 || (x >= -1<<binBits && x < 1<<binBits)
}

// parseNumeric parses the input as being encoded in either base-256 or octal.

   * {@link EnumSet#complementOf}. Otherwise, the specified collection must contain at least one
   * element, in order to determine the element type. If the collection could be empty, use {@link
   * #complementOf(Collection, Class)} instead of this method.
   *
   * @param collection the collection whose complement should be stored in the enum set

<code>S1</code> and <code>S2</code> may have or share.
</p>

<p>
Every type that is a member of the type set of an interface implements that interface.
Any given type may implement several distinct interfaces.
For instance, all types implement the <i>empty interface</i> which stands for the set
of all (non-interface) types:
</p>

<pre>
interface{}
</pre>

<p>

* cross origin: cross origin (do not translate to "origen cruzado")
* plugin: plugin (do not translate to "complemento" or "extensión")
* plug-in: plug-in (do not translate to "complemento" or "extensión")
* plug-ins: plug-ins (do not translate to "complementos" or "extensiones")
* full stack: full stack (do not translate to "pila completa")
* full-stack: full-stack (do not translate to "de pila completa")

        assertNotNull(closeRequest, "Smb2CloseRequest should implement RequestWithFileId");
        assertNotNull(queryInfoRequest, "Smb2QueryInfoRequest should implement RequestWithFileId");
        assertNotNull(setInfoRequest, "Smb2SetInfoRequest should implement RequestWithFileId");
        assertNotNull(queryDirRequest, "Smb2QueryDirectoryRequest should implement RequestWithFileId");

- [ ] Define lease state constants (SMB2_LEASE_READ, SMB2_LEASE_HANDLE, SMB2_LEASE_WRITE)
- [ ] Implement lease key generation and management
- [ ] Add lease context to Create request/response
- [ ] Implement lease break notification handling
- [ ] Modify SmbFile to support lease-based caching
- [ ] Add lease upgrade/downgrade logic
- [ ] Implement lease epoch tracking for v2 leases

#### 1.3 Integration Points