public boolean offer(E element) {
    checkNotNull(element);
    modCount++;
    int insertIndex = size++;

    growIfNeeded();

    // Adds the element to the end of the heap and bubbles it up to the correct
    // position.
    heapForIndex(insertIndex).bubbleUp(insertIndex, element);
    return size <= maximumSize || pollLast() != element;
  }

  @CanIgnoreReturnValue
  @Override

        setErrorCode(response, 0);

        int bytesRead = response.readDataWireFormat(fullBuffer, startIndex, buffer.length);

        // Verify the method returns the correct number of bytes read
        assertTrue(bytesRead > 0);
        assertTrue(bytesRead <= buffer.length);
    }

    /**
     * Helper method to create a valid security descriptor buffer
     */

        byte[] buffer = new byte[32];
        int bytesWritten = hmac.engineDigest(buffer, 5, 16);

        assertEquals(16, bytesWritten);
        // Check that bytes were written to the correct position
        byte[] extractedResult = Arrays.copyOfRange(buffer, 5, 21);
        assertEquals(16, extractedResult.length);
    }

    @Test
    void testEngineDigestWithInsufficientBuffer() {

 *
 * the access check would fail because the direct ACE has an access mask
 * of <code>0x001200A9</code> which doesn't have the
 * <code>FILE_WRITE_DATA</code> bit on (bit <code>0x00000002</code>). Actually, this isn't quite correct. If
 * <code>WNET\alice</code> is in the local <code>Administrators</code> group the access check
 * will succeed because the inherited ACE allows local <code>Administrators</code>

        // Then
        assertNotNull(transCallNamedPipe);
        assertEquals(TEST_PIPE_NAME, transCallNamedPipe.name);
    }

    @Test
    @DisplayName("Test writeSetupWireFormat writes correct bytes")
    void testWriteSetupWireFormat() {
        // Given
        transCallNamedPipe = new TransCallNamedPipe(mockConfig, TEST_PIPE_NAME, TEST_DATA, 0, TEST_DATA.length);
        byte[] dst = new byte[10];

        Future<?> possiblyIgnoredError = executor.submit(task);
      }
      awaitUnchecked(barrier);
      assertThat(future.isDone()).isTrue();
      // inspect state and ensure it is correct!
      // asserts that all get calling threads received the same value
      Object result = Iterables.getOnlyElement(finalResults);
      if (result == CancellationException.class) {
        assertTrue(future.isCancelled());

        // The setup count should be initialized to 0x04 in the constructor
        // We can't directly access it, but we can verify the behavior is correct
        assertNotNull(notifyChange);
    }

    @Test
    @DisplayName("Test combined completion filters")
    void testCombinedCompletionFilters() {
        int combinedFilter =

            assertTrue(cause instanceof SMBProtocolDecodingException, "Actual cause should be SMBProtocolDecodingException");
            assertEquals("Structure size is not 16", cause.getMessage(), "Should have correct error message");
        }

        @Test
        @DisplayName("Should write empty bytes for wire format")
        void testWriteBytesWireFormat() throws Exception {
            // Given

        int encodedLength = request.encode(buffer, offset);

        // Verify encoded length
        assertEquals(request.size(), encodedLength);

        // Verify data at correct offset
        assertEquals(DEFAULT_CAPABILITIES, SMBUtil.readInt4(buffer, offset));
        assertEquals(DEFAULT_SECURITY_MODE, SMBUtil.readInt2(buffer, offset + 20));

        when(standardInfo.getFileInformationLevel()).thenReturn(FileInformation.FILE_STANDARD_INFO);
        when(internalInfo.getFileInformationLevel()).thenReturn(FileInformation.FILE_INTERNAL_INFO);

        // Verify each has correct level
        assertEquals(FileInformation.FILE_BASIC_INFO, basicInfo.getFileInformationLevel());
        assertEquals(FileInformation.FILE_STANDARD_INFO, standardInfo.getFileInformationLevel());