*
 * @author Colin Decker
 */
@NullUnmarked
public class TestCharSource extends CharSource implements TestStreamSupplier {

  private final TestByteSource byteSource;

  public TestCharSource(String content, TestOption... options) {
    this.byteSource = new TestByteSource(content.getBytes(UTF_8), options);
  }

  @Override
  public boolean wasStreamOpened() {
    return byteSource.wasStreamOpened();
  }

/**
 * Configuration for slf4j-log4j2.
 *
 * @since 3.1.0
 */
public class Log4j2Configuration extends BaseSlf4jConfiguration {
    @Override
    public void setRootLoggerLevel(Level level) {
        String value =
                switch (level) {
                    case DEBUG -> "debug";
                    case INFO -> "info";
                    default -> "error";
                };

 *
 * TODO I think this is equiv. to exclusion set filter in maven-core
 */
public class ExcludesArtifactFilter extends IncludesArtifactFilter {
    public ExcludesArtifactFilter(List<String> patterns) {
        super(patterns);
    }

    @Override
    public boolean include(Artifact artifact) {
        return !super.include(artifact);
    }

package main

import (
	"errors"
	"fmt"
	"io"
	"os"
	"path/filepath"
	"strings"
	"unicode/utf8"

	"github.com/minio/madmin-go/v3/estream"
)

type keepFileErr struct {
	error
}

func extractInspectV2(pks [][]byte, r io.Reader, extractDir string) error {
	sr, err := estream.NewReader(r)
	if err != nil {
		return err
	}
	for _, pk := range pks {

    <E extends Comparable<E>> Collection<E> create(Collection<E> contents);

    String name();
  }

  public interface MapsImplEnum {
    <K extends Comparable<K>, V> Map<K, V> create(Map<K, V> contents);

    String name();
  }

  public interface InternerImplEnum {
    <E> Interner<E> create(Collection<E> contents);

    String name();
  }

  public enum SetImpl implements CollectionsImplEnum {

        }
        List<String> failures = getFiles().getFiles()
            .stream()
            .filter(FilePermissionsTask::isExecutableFile)
            .map(file -> "Source file is executable: " + file)
            .collect(Collectors.toList());

        if (failures.isEmpty() == false) {
            throw new GradleException("Found invalid file permissions:\n" + String.join("\n", failures));
        }

import org.gradle.kotlin.dsl.configure
import org.gradle.kotlin.dsl.getByType
import org.gradle.kotlin.dsl.named
import org.jetbrains.kotlin.gradle.tasks.KotlinJvmCompile

fun Project.applyJavaModules(
  moduleName: String,
  defaultVersion: Int = 8,
  javaModuleVersion: Int = 9,
  enableValidation: Boolean = true,
) {
  plugins.apply("me.champeau.mrjar")

  configure<MultiReleaseExtension> {

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class ListIndexOfTester<E> extends AbstractListIndexOfTester<E> {
  @Override
  protected int find(Object o) {
    return getList().indexOf(o);
  }

  @Override
  protected String getMethodName() {
    return "indexOf";
  }

  @CollectionFeature.Require(absent = REJECTS_DUPLICATES_AT_CREATION)
  @CollectionSize.Require(absent = {ZERO, ONE})
  public void testIndexOf_duplicate() {

    @Override
    public ArtifactVersion getApplicationVersion() {
        return applicationVersion;
    }

    @Override
    public void initialize() throws InitializationException {
        String mavenVersion = rtInfo.getMavenVersion();

        if (mavenVersion == null || mavenVersion.isEmpty()) {
            throw new InitializationException("Unable to read Maven version from maven-core");
        }

 */
public class SearchBody extends BaseSearchBody {

    /**
     * Default constructor.
     */
    public SearchBody() {
        super();
    }

    /** Job log ID */
    public String id;