/**
 * DefaultArtifactFactory
 *
 */
@Named
@Singleton
@SuppressWarnings("checkstyle:parameternumber")
public class DefaultArtifactFactory implements ArtifactFactory {
    private final ArtifactHandlerManager artifactHandlerManager;

    @Inject
    public DefaultArtifactFactory(ArtifactHandlerManager artifactHandlerManager) {
        this.artifactHandlerManager = artifactHandlerManager;
    }

public class DisniRdmaProvider implements RdmaProvider {

    /**
     * Creates a new DiSNI RDMA provider instance
     */
    public DisniRdmaProvider() {
        // Default constructor
    }

    private static final Logger log = LoggerFactory.getLogger(DisniRdmaProvider.class);

    // DiSNI components - these would be actual DiSNI objects in a real implementation
    private Object endpointGroup; // RdmaActiveEndpointGroup<DisniRdmaEndpoint>

     */
    static <T> T processObject(T object) {
        class ProcessorHolder {
            /**
             * Cached processor instance for performance.
             */
            private static final AtomicReference<ModelObjectProcessor> CACHED_PROCESSOR = new AtomicReference<>();
        }

        ModelObjectProcessor processor = ProcessorHolder.CACHED_PROCESSOR.get();
        if (processor == null) {

 * Artifacts matched by this map will be minified to only contain the specified
 * classes and the classes they depend on. The classes are not relocated, they all
 * remain in their original namespace. This reduces the final Gradle distribution
 * size and makes us more conscious of which parts of a library we really need.
 *
 * WARNING: if you decide to do the minification by hand, make sure that you cover all paths of loading classes:

                    archivesBaseName.get(),
                    projectVersion.get()
                )
            )
        );
        var publishing = extensions.getByType(PublishingExtension.class);
        final var mavenPublications = publishing.getPublications().withType(MavenPublication.class);
        addNameAndDescriptiontoPom(project, mavenPublications);
        mavenPublications.configureEach(publication -> {

    bufferHelper("three\rlines\rno newline at end", "three\r", "lines\r", "no newline at end");
    bufferHelper("mixed\nline\rendings\r\n", "mixed\n", "line\r", "endings\r\n");
  }

  private static final ImmutableSet<Integer> CHUNK_SIZES =
      ImmutableSet.of(1, 2, 3, Integer.MAX_VALUE);

  private static void bufferHelper(String input, String... expect) throws IOException {

  /** User's account name. */
  USER_NAME("user.name"),

  /** User's home directory. */
  USER_HOME("user.home"),

  /** User's current working directory. */
  USER_DIR("user.dir");

  private final String key;

  StandardSystemProperty(String key) {
    this.key = key;
  }

  /** Returns the key used to look up this system property. */
  public String key() {
    return key;
  }

  /**

/**
 * Provide public methods from {@link MetadataStaxReader}
 *
 * @deprecated Maven 3 compatability - please use {@link MetadataStaxReader}
 */
@Deprecated
public class MetadataXpp3Reader {

    private final MetadataStaxReader delegate;

    /**
     * Default constructor
     */
    public MetadataXpp3Reader() {
        delegate = new MetadataStaxReader();
    }

    /**

 *
 * @author Qian Huang
 */
@NullUnmarked
public class HashingInputStreamTest extends TestCase {
  private Hasher hasher;
  private HashFunction hashFunction;
  private static final byte[] testBytes = new byte[] {'y', 'a', 'm', 's'};
  private ByteArrayInputStream buffer;

  @SuppressWarnings("DoNotMock")
  @Override
  protected void setUp() throws Exception {
    super.setUp();

import java.util.Map;
import java.util.Set;
import org.jspecify.annotations.Nullable;

/**
 * Methods factored out so that they can be emulated differently in GWT.
 *
 * @author Hayward Chan
 */
@GwtCompatible
final class Platform {
  /** Returns the platform preferred implementation of a map based on a hash table. */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {