Type2Message.writeULong(invalidType, 8, Type2Message.NTLMSSP_TYPE1);

            // When & Then
            IOException thrown = assertThrows(IOException.class, () -> new Type2Message(invalidType));
            assertEquals("Not a Type 2 message.", thrown.getMessage());
        }
    }

    @Nested
    @DisplayName("Default Flags Tests")
    class DefaultFlagsTests {

        @Test

  }

  public void testSubscriberThrowsExceptionHandlerThrowsException() throws Exception {
    EventBus eventBus =
        new EventBus(
            new SubscriberExceptionHandler() {
              @Override
              public void handleException(Throwable exception, SubscriberExceptionContext context) {
                throw new RuntimeException();
              }
            });
    Object subscriber =

  }

  public void testSubscriberThrowsExceptionHandlerThrowsException() throws Exception {
    EventBus eventBus =
        new EventBus(
            new SubscriberExceptionHandler() {
              @Override
              public void handleException(Throwable exception, SubscriberExceptionContext context) {
                throw new RuntimeException();
              }
            });
    Object subscriber =

        verify(initialOutputStream).close();
    }

    /**
     * Test that a RuntimeCIFSException is thrown when the handshake fails due to an underlying exception.
     * @throws IOException
     */
    @Test
    void testHandshakeThrowsRuntimeExceptionOnFailure() throws Exception {
        // Arrange
        when(mockConnection.getHeaderField(0)).thenThrow(new RuntimeException("Connection failed"));

        @Override
        public byte[] getSessionKey() throws CIFSException {
            return sessionKey;
        }

        @Override
        protected void doSendFragment(byte[] buf, int off, int length) throws IOException {
            // Mock implementation for testing
        }

        @Override
        protected int doReceiveFragment(byte[] buf) throws IOException {
            return doReceiveFragmentReturn;

   * sees an Error?
   */
  @AndroidIncompatible
  public void testTaskThrowsError() throws Exception {
    class MyError extends Error {}
    CyclicBarrier barrier = new CyclicBarrier(2);
    // we need to make sure the error gets thrown on a different thread.
    ExecutorService service = newSingleThreadExecutor();
    try {

   *
   * <p><b>Note:</b> <i>all exceptions thrown during refresh will be logged and then swallowed</i>.
   *
   * @param duration the length of time after an entry is created that it should be considered
   *     stale, and thus eligible for refresh
   * @return this {@code CacheBuilder} instance (for chaining)
   * @throws IllegalArgumentException if {@code duration} is negative

  }

  /**
   * @return the number of exceptions that were suppressed on the expected thrown exception
   */
  private static int runSuppressionFailureTest(CharSource in, CharSink out) {
    try {
      in.copyTo(out);
      fail();
    } catch (IOException expected) {
      return expected.getSuppressed().length;
    }
    throw new AssertionError(); // can't happen
  }

                q.setResponse(qr);
                // Now emulate error thrown by transport for create chain
                throw new SmbException(NtStatus.NT_STATUS_NO_SUCH_FILE, false);
            }
            return null;
        }).when(tree).send(any(Request.class));

        // Act: constructing the iterator must not throw and results in empty iterator

                        throw new ArtifactDescriptorException(result);
                    }
                }
                invalidDescriptor(session, trace, a, e);
                if ((getPolicy(session, a, request) & ArtifactDescriptorPolicy.IGNORE_INVALID) != 0) {
                    return null;
                }
                result.addException(e);
                throw new ArtifactDescriptorException(result);