*   <li>Each other step is derived from one or more input steps. At each step, zero or more objects
 *       can be captured for later closing.
 *   <li>There is one last step (the root of the tree), from which you can extract the final result
 *       of the computation. After that result is available (or the computation fails), all objects
 *       captured by any of the steps in the pipeline are closed.
 * </ol>
 *

            return false;
        }
        final KuromojiItem other = (KuromojiItem) obj;
        if (!Objects.equals(pos, other.pos) || !Objects.equals(reading, other.reading) || !Objects.equals(segmentation, other.segmentation)
                || !Objects.equals(token, other.token)) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {

        MethodMetaData that = (MethodMetaData) o;
        return Objects.equals(name, that.name) &&
            Objects.equals(ownerClass.getClassName(), that.ownerClass.getClassName()) &&
            Objects.equals(parameters, that.parameters) &&
            Objects.equals(returnType, that.returnType);
    }

    @Override
    public int hashCode() {
        return Objects.hash(super.hashCode(), name, ownerClass, parameters, returnType);
    }

    public int hashCode() {
        return Objects.hash(input, output);
    }

    @Override
    public boolean equals(final Object obj) {
        if (this == obj) {
            return true;
        }
        if (obj == null || getClass() != obj.getClass()) {
            return false;
        }
        final StemmerOverrideItem other = (StemmerOverrideItem) obj;

import javax.xml.stream.XMLStreamException;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.nio.file.Files;
import java.util.Map;
import java.util.Objects;

import org.apache.maven.api.settings.InputSource;
import org.apache.maven.settings.Settings;
import org.apache.maven.settings.v4.SettingsStaxReader;

/**

        }
        return this;
    }

    private Plugin findPlugin(Model model, String groupId, String artifactId) {
        if (Objects.requireNonNull(groupId, "groupId cannot be null").isEmpty()) {
            throw new IllegalArgumentException("groupId cannot be empty");
        }
        if (Objects.requireNonNull(artifactId, "artifactId cannot be null").isEmpty()) {
            throw new IllegalArgumentException("artifactId cannot be empty");

)

open class ErrorProneSourceSetExtension(
    val enabled: Property<Boolean>
)

val errorproneExtension = project.extensions.create<ErrorProneProjectExtension>("errorprone", project.objects.listProperty<String>())
errorproneExtension.disabledChecks.addAll(
    // DISCUSS
    "EnumOrdinal", // This violation is ubiquitous, though most are benign.

    public org.apache.maven.model.Model read(File file, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(file, "file cannot be null");
        return read(file.toPath(), options);
    }

    @Override
    public org.apache.maven.model.Model read(Path path, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(path, "path cannot be null");

     */
    SSPContext createContext ( CIFSContext tc, String targetDomain, String host, byte[] initialToken, boolean doSigning ) throws SmbException;


    /**
     * @return subject associated with the credentials
     */
    Subject getSubject ();


    /**
     * @throws CIFSException
     * 
     */
    void refresh () throws CIFSException;

			continue
		}

		if len(result.Objects) != len(testCase.objectsAfterDelete) {
			t.Errorf("Test %d: %s: mismatch number of objects after delete, expected = %v, found = %v", i+1, instanceType, testCase.objectsAfterDelete, result.Objects)
			continue
		}

		for idx := range result.Objects {
			if result.Objects[idx].Name != testCase.objectsAfterDelete[idx] {