name: Publish

on:
  release:
    types:
      - created

jobs:
  publish:
    runs-on: ubuntu-latest
    permissions:
      id-token: write
      contents: read
    steps:
      - name: Dump GitHub context
        env:
          GITHUB_CONTEXT: ${{ toJson(github) }}
        run: echo "$GITHUB_CONTEXT"
      - uses: actions/checkout@v6
      - name: Set up Python
        uses: actions/setup-python@v6
        with:

    /** User agent string */
    protected String userAgent = "Crawler";

    /** HTTP client context for requests */
    protected HttpClientContext httpClientContext = HttpClientContext.create();

    /** Proxy host name */
    protected String proxyHost;

    /** Proxy port number */
    protected Integer proxyPort;

    /** Proxy authentication scheme */

    private final String modelId;

    private final String message;

    private final Exception exception;

    private final Severity severity;

    private final Version version;

    /**
     * Creates a new problem with the specified message and exception.
     *
     * @param message The message describing the problem, may be {@code null}.
     * @param severity The severity level of the problem, may be {@code null} to default to

 */
@Deprecated(since = "4.0.0")
public class ModelBuildingException extends Exception {

    private final ModelBuildingResult result;

    /**
     * Creates a new exception with the specified problems.
     *
     * @param model The model that could not be built, may be {@code null}.
     * @param modelId The identifier of the model that could not be built, may be {@code null}.

* **`200 - 299`** are for "Successful" responses. These are the ones you would use the most.
    * `200` is the default status code, which means everything was "OK".
    * Another example would be `201`, "Created". It is commonly used after creating a new record in the database.
    * A special case is `204`, "No Content".  This response is used when there is no content to return to the client, and so the response must not have a body.

                    .collect(Collectors.toMap(Pair::getFirst, Pair::getSecond)));
            return result;
        } catch (InstantiationException | IllegalAccessException e) {
            final String msg = "Cannot create a new instance: " + entityType.getName();
            throw new IllegalBehaviorStateException(msg, e);
        }
    }

    private boolean isAttribute(final String key) {

          # - you want to enable the Branch-Protection check on a *public* repository, or
          # - you are installing Scorecard on a *private* repository
          # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action#authentication-with-pat.
          # repo_token: ${{ secrets.SCORECARD_TOKEN }}

          # Public repositories:

  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testRemove_duplicate() {
    ArrayWithDuplicate<E> arrayAndDuplicate = createArrayWithDuplicateElement();
    collection = getSubjectGenerator().create(arrayAndDuplicate.elements);
    E duplicate = arrayAndDuplicate.duplicate;

    int firstIndex = getList().indexOf(duplicate);
    int initialSize = getList().size();

  @CollectionSize.Require(absent = ZERO)
  public void testAdd_supportedNullPresent() {
    E[] array = createArrayWithNullElement();
    collection = getSubjectGenerator().create(array);
    assertFalse("add(nullPresent) should return false", getSet().add(null));
    expectContents(array);
  }

  /**
   * Returns the {@link Method} instance for {@link #testAdd_supportedNullPresent()} so that tests

import java.util.Deque;

/**
 * Utility class for disposing of resources at the end of an application.
 * <p>
 * If there are resources that must be disposed of at the end of the application,
 * create a class that implements {@link Disposable} and register it with this class.
 * </p>
 *
 * @author koichik
 */
public abstract class DisposableUtil {

    /**
     * Do not instantiate.
     */