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

                blob.toBuilder().setMetadata(tags).build().update();
            } else {
                throw new StorageException("Object not found: " + objectName);
            }
        } catch (final StorageException e) {
            throw e;
        } catch (final Exception e) {
            throw new StorageException("Failed to update tags for " + objectName, e);
        }
    }

    @Override

  @Override
  @DoNotCall("Always throws UnsupportedOperationException")
  public final @Nullable E pollFirst() {
    throw new UnsupportedOperationException();
  }

  /**
   * Guaranteed to throw an exception and leave the set unmodified.
   *
   * @since 12.0
   * @throws UnsupportedOperationException always
   * @deprecated Unsupported operation.
   */
  @CanIgnoreReturnValue
  @Deprecated

    if (key == null) {
      throw new NullPointerException("null key in entry: null=" + value);
    } else if (value == null) {
      throw new NullPointerException("null value in entry: " + key + "=null");
    }
  }

  @CanIgnoreReturnValue
  static int checkNonnegative(int value, String name) {
    if (value < 0) {
      throw new IllegalArgumentException(name + " cannot be negative but was: " + value);

        if (buffer == null || buffer.length < bufferIndex + 65) {
            throw new SMBProtocolDecodingException("Buffer too small for SMB2 negotiate response (minimum 65 bytes required)");
        }

        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 65) {
            throw new SMBProtocolDecodingException("Structure size is not 65, got: " + structureSize);
        }

import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import java.io.IOException;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;

        searchEngineClient = new SearchEngineClient() {
            @Override
            public long deleteByQuery(String index, QueryBuilder query) {
                throw new RuntimeException("Delete operation failed");
            }
        };
        ComponentUtil.register(searchEngineClient, "searchEngineClient");

        // Execute the job

            throw new TransferCancelledException();
        }
        put(event, false);
    }

    @Override
    public void transferProgressed(TransferEvent event) throws TransferCancelledException {
        if (ongoing.get(new TransferResourceIdentifier(event.getResource())) == Boolean.FALSE) {
            throw new TransferCancelledException();
        }

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {

        return caught;
      }
      throw new AssertionError(
          "expected to throw " + expectedThrowable.getSimpleName() + " but threw " + t, t);
    }
    if (userPassedSupplier) {
      throw new AssertionError(
          "expected to throw "
              + expectedThrowable.getSimpleName()
              + " but returned result: "
              + result);
    } else {