import com.google.common.annotations.J2ktIncompatible;
import java.io.Closeable;
import java.io.Flushable;
import java.io.IOException;
import java.io.Writer;
import javax.annotation.CheckForNull;

/**
 * Writer that places all output on an {@link Appendable} target. If the target is {@link Flushable}
 * or {@link Closeable}, flush()es and close()s will also be delegated to the target.
 *
 * @author Alan Green

 * limitations under the License.
 */

package org.gradle.performance.results;

import java.io.Closeable;
import java.util.Arrays;
import java.util.stream.Collectors;

public interface DataReporter<T extends PerformanceTestResult> extends Closeable {
    void report(T results);

    default String insertStatement(String table, String... columns) {
        return "insert into " +

package org.gradle.test;

import org.gradle.test.sub.*;
import org.gradle.test.sub2.Sub2Interface;

import java.io.Closeable;
import java.io.IOException;

public class JavaClassWithImports extends SubClass implements SubJavaInterface, Sub2Interface, Closeable {
    public void close() throws IOException {
    }

        else
            input.invoke()

    /**
     * Wraps an inner closeable into an outer closeable, while ensuring that
     * if the wrapper function fails, the inner closeable is closed before
     * the exception is thrown.
     *
     * @param innerSupplier the supplier that produces the inner closeable that is to be safely wrapped
     * @param unsafeWrapper a wrapping function that is potentially unsafe

import org.gradle.internal.service.scopes.GradleUserHomeScopeServiceRegistry;
import org.gradle.internal.service.scopes.Scope;

import java.io.Closeable;
import java.util.function.Function;

/**
 * Encapsulates the state for a build session.
 */
public class BuildSessionState implements Closeable {
    private final GradleUserHomeScopeServiceRegistry userHomeScopeServiceRegistry;
    private final ServiceRegistry userHomeServices;

import javax.tools.JavaCompiler;
import java.io.Closeable;
import java.nio.charset.Charset;
import java.util.Locale;

/**
 * Cleans up resources (e.g. file handles) after compilation has finished.
 */
class ResourceCleaningCompilationTask implements JavaCompiler.CompilationTask {
    private final JavaCompiler.CompilationTask delegate;
    private final Closeable fileManager;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.kotlin.dsl.support

import java.io.Closeable


interface ProgressMonitor : Closeable {
    fun onProgress()

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.file.archive;

import java.io.Closeable;

public interface ZipInput extends Iterable<ZipEntry>, Closeable {

import org.gradle.internal.file.FileAccessTimeJournal
import java.io.Closeable


internal
class KotlinDslWorkspaceProvider(
    cacheBuilderFactory: GlobalScopedCacheBuilderFactory,
    fileAccessTimeJournal: FileAccessTimeJournal,
    cacheConfigurations: CacheConfigurationsInternal
) : Closeable {

    private
    val kotlinDslWorkspace = CacheBasedImmutableWorkspaceProvider.createWorkspaceProvider(

        }
    }

  fun enable(
    loggerClass: String,
    handler: Handler = logHandler(),
  ): Closeable {
    val logger = Logger.getLogger(loggerClass)
    if (configuredLoggers.add(logger)) {
      logger.addHandler(handler)
      logger.level = Level.FINEST
    }
    return Closeable {
      logger.removeHandler(handler)
    }
  }

  fun enable(loggerClass: KClass<*>) = enable(loggerClass.java.name)