int i = 0;
    for (Object e : elements) {
      array[i++] = (UnhashableObject) e;
    }
    return create(array);
  }

  /**
   * Creates a new collection containing the given elements; implement this method instead of {@link
   * #create(Object...)}.
   */
  protected abstract T create(UnhashableObject[] elements);

  @Override
  public UnhashableObject[] createArray(int length) {
    return new UnhashableObject[length];

 * // ... perform domtrip operations ...
 * // Document is automatically updated
 * </pre>
 */
public abstract class AbstractUpgradeStrategy implements UpgradeStrategy {

    /**
     * Template method that handles common logging and error handling.
     * Subclasses implement the actual upgrade logic in doApply().
     */
    @Override
    public final UpgradeResult apply(UpgradeContext context, Map<Path, Document> pomMap) {

     * git trees at each tag.
     * <p>
     * If the supplied version is the very first in a new major series, then the method will look tag in the previous
     * major series. Otherwise, all git tags in the current major series will be inspected.
     *
     * @param gitWrapper used for git operations

import org.junit.jupiter.api.Test;

/**
 * Tests for RankFusionSearcher abstract base class.
 */
public class RankFusionSearcherTest extends UnitFessTestCase {

    /**
     * Test getName() method derives name from class name.
     */
    @Test
    public void test_getNameFromClassName() {
        final TestSearcher searcher = new TestSearcher();
        assertEquals("test", searcher.getName());
    }

 * but works with any {@link CharSequence}.
 *
 * @author Colin Decker
 */
// TODO(cgdecker): make this public? as a type, or a method in CharStreams?
@J2ktIncompatible
@GwtIncompatible
final class CharSequenceReader extends Reader {

  private @Nullable CharSequence seq;
  private int pos;
  private int mark;

        assertTrue(exception instanceof CIFSException, "NbtException should be an instance of CIFSException");
    }

    /**
     * Test the getErrorString method with various error classes and codes to ensure all branches are covered.
     */
    @ParameterizedTest
    @MethodSource("provideErrorClassAndCodeForGetErrorString")

        }

        private void callIfVagrantTask(Task task, Consumer<VagrantMachine> method) {
            if (task instanceof VagrantShellTask) {
                VagrantMachine service = task.getProject().getExtensions().getByType(VagrantMachine.class);
                method.accept(service);
            }
        }

        @Override

      return chain.proceed(originalRequest);
    }

    Request compressedRequest = originalRequest.newBuilder()
        .header("Content-Encoding", "gzip")
        .method(originalRequest.method(), gzip(originalRequest.body()))
        .build();
    return chain.proceed(compressedRequest);
  }

  private RequestBody gzip(final RequestBody body) {
    return new RequestBody() {

  val cacheUrlOverride = cacheUrlOverride

  // Allow POST and QUERY caching only when there is a cacheUrlOverride
  return if (cacheUrlOverride != null && (HttpMethod.isCacheable(method) || method == "POST")) {
    newBuilder()
      .get()
      .url(cacheUrlOverride)
      .cacheUrlOverride(null)
      .build()
  } else {
    this
  }

     * <strong>Note:</strong>
     * The logger returned by this method must not be cached in an instance field during the construction of the mojo.
     * This would cause the mojo to use a wrongly configured default logger when being run by Maven. The proper logger
     * gets injected by the Plexus container after the mojo has been constructed. Therefore, simply call this