import static com.google.common.collect.testing.features.CollectionSize.ONE;
import static com.google.common.collect.testing.features.CollectionSize.SEVERAL;
import static com.google.common.collect.testing.features.CollectionSize.ZERO;
import static com.google.common.collect.testing.testers.ReflectionFreeAssertThrows.assertThrows;

import com.google.common.annotations.GwtCompatible;
import com.google.common.collect.testing.features.CollectionFeature;

        // Test case 3: Zero value
        int zeroValue = 0;
        NdrLong ndrLongZero = new NdrLong(zeroValue);
        assertEquals(zeroValue, ndrLongZero.value, "Constructor should correctly initialize with zero.");

        // Test case 4: Max int value
        int maxIntValue = Integer.MAX_VALUE;

	got := crc32.ChecksumIEEE(key)
	if want != got {
		return fmt.Errorf("Invalid key checksum, want %x, got %x", want, got)
	}

	stream, err := sio.AES_256_GCM.Stream(key)
	if err != nil {
		return err
	}
	// Zero nonce, we only use each key once, and 32 bytes is plenty.
	nonce := make([]byte, stream.NonceSize())
	encr := stream.DecryptReader(r, nonce, nil)
	_, err = io.Copy(w, encr)
	if err == nil {
		fmt.Println(okMsg)
	}

    }

    @Test
    @DisplayName("release() below zero usage throws RuntimeCIFSException")
    void release_withoutAcquire_throwsRuntimeCIFSException() {
        // Arrange
        CIFSContext ctx = mock(CIFSContext.class);
        SmbTreeConnectionTrace trace = new SmbTreeConnectionTrace(ctx);

        // Act & Assert: calling release without prior acquire drops usage below zero

              public Set<String> create(String[] elements) {
                return emptySet();
              }
            })
        .named("emptySet")
        .withFeatures(CollectionFeature.SERIALIZABLE, CollectionSize.ZERO)
        .suppressing(suppressForEmptySet())
        .createTestSuite();
  }

  public Test testsForEmptyNavigableSet() {
    return SetTestSuiteBuilder.using(
            new TestStringSortedSetGenerator() {

        }

        @Test
        @DisplayName("Should initialize count to zero")
        void testInitialCountValue() {
            assertEquals(0, response.getCount());
        }

        @Test
        @DisplayName("Should initialize remaining to zero")
        void testInitialRemainingValue() {
            assertEquals(0, response.getRemaining());
        }
    }

    try {
      long remainingNanos = unit.toNanos(timeout);
      long end = System.nanoTime() + remainingNanos;

      while (true) {
        try {
          // CountDownLatch treats negative timeouts just like zero.
          return latch.await(remainingNanos, NANOSECONDS);
        } catch (InterruptedException e) {
          interrupted = true;
          remainingNanos = end - System.nanoTime();
        }
      }

        // Then
        assertEquals(8, result);
        assertEquals(0xffffL, instance.getCount());
    }

    /**
     * Test of readParameterWordsWireFormat with zero count
     */
    @Test
    public void testReadParameterWordsWireFormatZeroCount() {
        // Given
        byte[] buffer = new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 };

	line   int
	pos    int
}

func NewSlice(base *src.PosBase, line int, tokens []Token) *Slice {
	return &Slice{
		tokens: tokens,
		base:   base,
		line:   line,
		pos:    -1, // Next will advance to zero.
	}
}

func (s *Slice) Next() ScanToken {
	s.pos++
	if s.pos >= len(s.tokens) {
		return scanner.EOF
	}
	return s.tokens[s.pos].ScanToken
}

func (s *Slice) Text() string {

        assertEquals(action, notifyInfo.getAction());
        assertEquals(fileName, notifyInfo.getFileName());
    }

    @Test
    @DisplayName("Test decode with multiple entries (non-zero next offset)")
    void testDecodeWithNextEntry() throws SMBProtocolDecodingException {
        String fileName = "test.txt";
        int action = FileNotifyInformation.FILE_ACTION_REMOVED;