assertTrue(iterator.hasNext());
        assertSame(resource, iterator.next());
        assertFalse(iterator.hasNext());
        assertNull(iterator.next());

        // Without filter, resource should not be closed
        verify(resource, never()).close();
    }

    @Test
    @DisplayName("Iterator with accepting filter")
    void iteratorWithAcceptingFilter() throws Exception {
        // Setup

 */
package gradlebuild.jvm.extension

import org.gradle.api.tasks.TaskContainer
import org.gradle.api.tasks.compile.JavaCompile
import org.gradle.kotlin.dsl.*


/**
 * Strict compilation options honored by [gradlebuild.Strict_compile_gradle].
 */
abstract class StrictCompileExtension(val tasks: TaskContainer) {

    fun ignoreDeprecations() {
        tasks.withType<JavaCompile>().configureEach {

	weSleep    func() bool
	shouldHeal func() bool

	disks       []StorageAPI
	disksQuorum int

	// If set updates will be sent regularly to this channel.
	// Will not be closed when returned.
	updates    chan<- dataUsageEntry
	lastUpdate time.Time

	// updateCurrentPath should be called whenever a new path is scanned.
	updateCurrentPath func(string)
}

        // Assert
        assertFalse(it.hasNext(), "No next when opened with null initial");
        verify(tree, times(1)).release(); // closed in constructor
    }

    @Test
    @DisplayName("open() throwing CIFSException triggers close and rethrow")
    void constructorOpenThrows() {
        // Arrange
        stubAcquireReturnsSelf();

  Closer(Suppressor suppressor) {
    this.suppressor = checkNotNull(suppressor); // checkNotNull to satisfy null tests
  }

  /**
   * Registers the given {@code closeable} to be closed when this {@code Closer} is {@linkplain
   * #close closed}.
   *
   * @return the given {@code closeable}
   */
  // close. this word no longer has any meaning to me.
  @CanIgnoreReturnValue
  @ParametricNullness

        }

        /**
         * Verifies that the isOpen method returns false for a closed handle.
         */
        @Test
        public void testIsOpen_ReturnsFalseWhenClosed() {
            when(smbPipeHandle.isOpen()).thenReturn(false);
            assertFalse(smbPipeHandle.isOpen(), "isOpen() should return false when the handle is closed.");
        }
    }

    /**

	for i, testCase := range testCases {
		output := prepareUpdateMessage(testCase.dlURL, testCase.older)
		line1 := fmt.Sprintf("%s %s", plainMsg, color.YellowBold(testCase.expectedSubStr))
		line2 := fmt.Sprintf("Update: %s", color.CyanBold(testCase.dlURL))
		// Uncomment below to see message appearance:
		// fmt.Println(output)
		switch {
		case testCase.dlURL == "" && output != "":

import org.jline.reader.LineReaderBuilder;
import org.jline.reader.UserInterruptException;
import org.jline.terminal.Terminal;
import org.jline.utils.AttributedStyle;
import org.jline.utils.Colors;

/**
 * mvnenc invoker implementation.
 */
public class EncryptInvoker extends LookupInvoker<EncryptContext> {

    public static final int OK = 0; // OK
    public static final int ERROR = 1; // "generic" error

import org.jline.reader.LineReaderBuilder;
import org.jline.reader.UserInterruptException;
import org.jline.terminal.Terminal;
import org.jline.utils.AttributedStyle;
import org.jline.utils.Colors;

/**
 * mvnup invoker implementation.
 */
public class UpgradeInvoker extends LookupInvoker<UpgradeContext> {

    public static final int OK = 0; // OK
    public static final int ERROR = 1; // "generic" error

    )


private
typealias ApiTypeSupplier = () -> ApiType


/**
 * Provides [ApiType] instances by Kotlin source name from a class path.
 *
 * Keeps JAR files open for fast lookup, must be closed.
 * Once closed, type graph navigation from [ApiType] and [ApiFunction] instances
 * will throw [IllegalStateException].
 *
 * Limitations:
 * - supports Java byte code only, not Kotlin