* under the License.
 */
package org.apache.maven.repository;

import org.apache.maven.artifact.handler.ArtifactHandler;

/**
 * Assists unit testing.
 *
 */
@Deprecated
class TestArtifactHandler implements ArtifactHandler {

    private String type;

    private String extension;

    TestArtifactHandler(String type) {
        this(type, type);
    }

                }
              },
              isParallel)
          .onClose(stream::close);
    }
    final class Splitr extends MapWithIndexSpliterator<Spliterator<T>, R, Splitr>
        implements Consumer<T> {
      @Nullable T holder;

      Splitr(Spliterator<T> splitr, long index) {
        super(splitr, index);
      }

      @Override
      public void accept(@ParametricNullness T t) {

        .createTestSuite();
  }

  /**
   * To avoid infinite recursion, test suites with these marker features won't have derived suites
   * created for them.
   */
  enum NoRecurse implements Feature<Void> {
    SUBMULTISET,
    DESCENDING;

    @Override
    public Set<Feature<? super Void>> getImpliedFeatures() {
      return emptySet();
    }
  }

        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * @author mbechler
     *
     */
    private static final class ResourceFilterWrapper implements ResourceFilter {

        /**
         *
         */
        private final SmbFileFilter ff;

        /**
         * @param ff
         */

        assertEquals((byte) 0xCC, buffer[24]);
    }

    @Test
    @DisplayName("Test request implements RequestWithFileId interface correctly")
    void testRequestWithFileIdInterface() {
        // Verify the class implements RequestWithFileId
        assertTrue(request instanceof jcifs.internal.smb2.RequestWithFileId);

        // Test interface method

 * {@code new FIFOEntry(anEntry)} instead of a plain entry object.
 *
 * <pre>{@code
 * class FIFOEntry<E extends Comparable<? super E>> implements Comparable<FIFOEntry<E>> {
 *   static final AtomicLong seq = new AtomicLong();
 *
 *   final long seqNum;
 *   final E entry;
 *
 *   public FIFOEntry(E entry) {
 *     seqNum = seq.getAndIncrement();

   * element returned.
   *
   * <p>See <a href="https://bugs.openjdk.org/browse/JDK-6529795">JDK-6529795</a>
   */
  static class IteratorWithJdkBug6529795<T> implements Iterator<T> {
    Iterator<T> iterator;
    boolean nextThrewException;

    IteratorWithJdkBug6529795(Iterator<T> iterator) {
      this.iterator = iterator;
    }

    @Override

        builder.put(i, elements[i]);
      }
      return builder.buildOrThrow().values().asList();
    }
  }

  public static class ImmutableMapEntryListGenerator
      implements TestListGenerator<Entry<String, Integer>> {

    @Override
    public SampleElements<Entry<String, Integer>> samples() {
      return new SampleElements<>(
          mapEntry("foo", 5),

            }
          };
    }
    SUPPLIER = supplier;
  }

  public static LongAddable create() {
    return SUPPLIER.get();
  }

  private static final class PureJavaLongAddable extends AtomicLong implements LongAddable {
    @Override
    public void increment() {
      getAndIncrement();
    }

    @Override
    public void add(long x) {
      getAndAdd(x);
    }

    @Override

    return transform(inputFuture, new ComposeFunction(), directExecutor());
  }

  @Override
  protected String getSuccessfulResult() {
    return RESULT_DATA;
  }

  private class ComposeFunction implements Function<Integer, String> {
    @Override
    public String apply(Integer input) {
      if (input.intValue() == VALID_INPUT_DATA) {
        return RESULT_DATA;
      } else {
        throw WRAPPED_EXCEPTION;