} catch (PluginResolutionException e) {
            throw new PluginNotFoundException(plugin, project.getPluginArtifactRepositories());
        } catch (PluginDescriptorParsingException | InvalidPluginDescriptorException e) {
            throw new PluginManagerException(plugin, e.getMessage(), e);
        }
    }

      startUpCalled = true;
      throw new UnsupportedOperationException("kaboom!");
    }

    @Override
    protected void run() {
      throw new AssertionError("run() should not be called");
    }

    @Override
    protected Executor executor() {
      return exceptionCatchingExecutor;
    }
  }

  public void testServiceThrowOnRun() throws Exception {

     * @throws PACDecodingException if the token cannot be decoded
     */
    public KerberosApRequest(byte[] token, KerberosKey[] keys) throws PACDecodingException {
        this(parseSequence(token), keys);
    }

    private static ASN1Sequence parseSequence(byte[] token) throws PACDecodingException {
        if (token.length <= 0) {
            throw new PACDecodingException("Empty kerberos ApReq");

                    disconnect(true);
                    throw new NbtException(NbtException.ERR_SSN_SRVC, errorCode);
                }
                break;
            case -1:
                disconnect(true);
                throw new NbtException(NbtException.ERR_SSN_SRVC, NbtException.CONNECTION_REFUSED);
            default:
                disconnect(true);
                throw new NbtException(NbtException.ERR_SSN_SRVC, 0);

     * @throws CrawlerSystemException if the MIME type is blank or maxLength is negative
     */
    public void addMaxLength(final String mimeType, final long maxLength) {
        if (StringUtil.isBlank(mimeType)) {
            throw new CrawlerSystemException("MIME type is a blank.");
        }
        if (maxLength < 0) {
            throw new CrawlerSystemException("The value of maxLength is invalid.");

     *
     * @throws CIFSException if an error occurs while opening the file
     */
    public void open() throws CIFSException {
        try (SmbFileHandleImpl fh = ensureOpen()) {}
    }

    /**
     * @param file
     * @param openFlags
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {

    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the map unmodified.
   *
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @Deprecated
  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final boolean remove(@Nullable Object key, @Nullable Object value) {

     * @return initialized Mac instance
     * @throws GeneralSecurityException if Mac cannot be created
     */
    private Mac createMacInstance() throws GeneralSecurityException {
        if (this.closed) {
            throw new IllegalStateException("SigningDigest is closed");
        }
        if (this.signingKey == null) {
            throw new IllegalStateException("Signing key has been wiped");
        }

      } else {
        throw ProtocolException("Unexpected status line: $statusLine")
      }

      // Parse response code like "200". Always 3 digits.
      if (statusLine.length < codeStart + 3) {
        throw ProtocolException("Unexpected status line: $statusLine")
      }
      val code =
        statusLine.substring(codeStart, codeStart + 3).toIntOrNull()
          ?: throw ProtocolException(

            }, "Rename operations should not throw exception");

            verify(mockResource).renameTo(destination);
            verify(mockResource).renameTo(destination, true);
        }

        @Test
        @DisplayName("renameTo should throw NullPointerException for null destination")
        void testRenameTo_NullDestination() throws CIFSException {
            // Given