/**
     * Checks if the response has been received.
     *
     * @return whether the response is received
     */
    boolean isReceived();

    /**
     * Set received status
     */
    void received();

    /**
     * Unset received status
     */
    void clearReceived();

    /**
     * Gets the number of credits granted by the server.
     *

                logger.debug("Exception in parsing BodyPart.", e);
            }
        }
    }

    /**
     * Gets the received date from a message by parsing the received headers.
     *
     * @param message the message to get the received date from
     * @return the received date or null if not found
     * @throws MessagingException if message access fails
     */

        void testReset() {
            // Set initial state
            response.received();
            assertTrue(response.isReceived());

            // Reset
            response.reset();

            assertFalse(response.isReceived());
        }

        @Test
        @DisplayName("Should handle received notification")
        void testReceived() throws InterruptedException {

    }

    @Test
    @DisplayName("Test Response interface methods - isReceived")
    void testIsReceived() {
        // Given
        when(response.isReceived()).thenReturn(true);

        // When
        boolean received = response.isReceived();

        // Then
        assertTrue(received);
        verify(response).isReceived();
    }

    @Test

     *
     * @return bytes sent
     */
    public long getBytesSent() {
        return bytesSent.get();
    }

    /**
     * Get number of bytes received
     *
     * @return bytes received
     */
    public long getBytesReceived() {
        return bytesReceived.get();
    }

    /**
     * Get number of requests sent
     *
     * @return requests sent

                         * loop around and try again.
                         */
                        if (response.received && request.questionType == response.recordType) {
                            return;
                        }

                        response.received = false;
                        timeout -= System.currentTimeMillis() - start;
                    }

            this.received = false;
            this.errorCode = 0;
            this.exception = null;
        }

        // Methods from jcifs.util.transport.Response interface
        @Override
        public boolean isReceived() {
            return received;
        }

        @Override
        public void received() {
            this.received = true;
        }

        when(tree.send(any(Trans2FindFirst2.class), any(Trans2FindFirst2Response.class))).thenAnswer((InvocationOnMock inv) -> {
            Trans2FindFirst2Response resp = inv.getArgument(1);
            resp.received(); // mark as received
            throw new SmbException(NtStatus.NT_STATUS_NO_SUCH_FILE, (Throwable) null);
        });

        DirFileEntryEnumIterator1 it = new DirFileEntryEnumIterator1(tree, parent, "*", null, 0);

 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

    response: Response,
  ) {
  }

  /**
   * Invoked when a result is served from the cache. The Response provided is the top level
   * Response and normal event sequences will not be received.
   *
   * This event will only be received when a Cache is configured for the client.
   */
  open fun cacheHit(
    call: Call,
    response: Response,
  ) {
  }

  /**