executor.shutdown();
        }
    }

    /**
     * Test close() method
     */
    @Test
    void testClose() throws CIFSException {
        // Execute
        watchHandle.close();

        // Verify close was called
        verify(watchHandle, times(1)).close();
    }

    /**
     * Test close() method throwing CIFSException
     */
    @Test

        }

        @Test
        @DisplayName("Should close pool with active transports")
        void testClosePoolWithActiveTransports() throws CIFSException {
            // Given
            when(transportPool.close()).thenReturn(true);

            // When
            boolean result = transportPool.close();

            // Then
            assertTrue(result);
            verify(transportPool).close();

import jcifs.internal.smb2.ServerMessageBlock2Request;
import jcifs.internal.smb2.Smb2Constants;
import jcifs.internal.util.SMBUtil;
import jcifs.util.Hexdump;

/**
 * SMB2 Close request message. This command is used to close a file or directory
 * that was previously opened.
 *
 * @author mbechler
 *
 */
public class Smb2CloseRequest extends ServerMessageBlock2Request<Smb2CloseResponse> implements RequestWithFileId {

            return invocation.getArgument(1);
        });

        // When: Create iterator and close multiple times
        NetServerEnumIterator iterator = new NetServerEnumIterator(parent, treeHandle, "*", 0, null);

        iterator.close();
        iterator.close(); // Second close should be safe

        // Then: Tree handle should be released only once
        verify(treeHandle, times(1)).release();

	dstRec.SelectFormat = sql.SelectFmtJSON
	return dstRec, nil
}

// Close - closes underlying reader.
func (r *PReader) Close() error {
	if r.close != nil {
		close(r.close)
		r.readerWg.Wait()
		r.close = nil
	}
	r.recordsRead = len(r.current)
	if r.err == nil {
		r.err = io.EOF
	}
	return r.readCloser.Close()
}

// nextSplit will attempt to skip a number of bytes and

# limitations under the License.
# ============================================================================

name: Close inactive issues
on:
  schedule:
    - cron: "30 1 * * *"

permissions:
  contents: read

jobs:
  close-issues:
    # Don't do this in forks
    if: github.repository == 'tensorflow/tensorflow'
    runs-on: ubuntu-latest
    permissions:
      issues: write

	}
	w := NewWriter(&buf)
	if _, err := w.CreateHeader(h); err != nil {
		t.Fatalf("unexpected CreateHeader error: %v", err)
	}
	if err := w.Close(); err != nil {
		t.Fatalf("unexpected Close error: %v", err)
	}

	want, err := os.ReadFile("testdata/time-go.zip")
	if err != nil {
		t.Fatalf("unexpected ReadFile error: %v", err)
	}

        }
    }

    @Test
    @DisplayName("EmptyIterator should handle close operations multiple times")
    void testMultipleCloseOperations() {
        // When & Then
        assertDoesNotThrow(() -> {
            try {
                emptyIterator.close();
                emptyIterator.close();
                emptyIterator.close();
            } catch (CIFSException e) {
                throw new RuntimeException(e);

        TestIterator iterator = new TestIterator(null);
        iterator.close();

        verify(delegate).close();
    }

    @Test
    @DisplayName("Close propagates exception")
    void closeException() throws CIFSException {
        when(delegate.hasNext()).thenReturn(false);
        doThrow(new CIFSException("Close failed")).when(delegate).close();

        TestIterator iterator = new TestIterator(null);

                            timingRatio, TIMING_TOLERANCE, timeStart, timeMiddle, timeEnd));
        } finally {
            // Clean up resources
            baseAuth.close();
            startAuth.close();
            middleAuth.close();
            endAuth.close();
        }
    }

    /**
     * Test constant-time comparison with various password lengths.
     */
    @Test