abstract T returningT();

    abstract void acceptT(T t);

    abstract <X extends T> X returningX();

    abstract <X> void acceptX(X x);

    abstract <T2 extends Enum<T2> & CharSequence> T2 returningT2();

    abstract <T2 extends CharSequence & Iterable<T2>> void acceptT2(T2 t2);

    static void verifyConsistentRawType() {

        verify(smbFile, times(1)).length();

        // positive size -> accept
        reset(smbFile);
        when(smbFile.length()).thenReturn(42L);
        assertTrue(filter.accept(smbFile), "Positive size should be accepted");
        verify(smbFile, times(1)).length();
        verifyNoMoreInteractions(smbFile);
    }

    @Test

		for {
			conn, err := ln.Accept()
			select {
			case listener.acceptCh <- acceptResult{conn, err, idx}:
			case <-listener.ctxDoneCh:
				return
			}
		}
	}

	// Start separate goroutine for each listener to handle connection.
	for idx, ln := range listener.listeners {
		go handleListener(idx, ln)
	}
}

            // Accept files in /share/folder/ that are text files
            return path.equals("/share/folder/") && name != null && name.endsWith(".txt");
        };

        // Act & Assert: test with different file names
        assertTrue(filter.accept(mockDir, "document.txt"), "Should accept .txt files in the correct path");
        assertFalse(filter.accept(mockDir, "image.png"), "Should reject non-.txt files");

        // Filter accepts names starting with "keep"
        when(filter.accept(any())).thenAnswer(inv -> {
            SmbResource res = inv.getArgument(0);
            return res.getName().startsWith("keep");
        });

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), filter);

        // Returns only accepted resources
        assertTrue(it.hasNext());

   * empty list of cookies for the network request.
   *
   * Simple implementations will return the accepted cookies that have not yet expired and that
   * [match][Cookie.matches] [url].
   */
  fun loadForRequest(url: HttpUrl): List<Cookie>

  companion object {
    /** A cookie jar that never accepts any cookies. */
    @JvmField
    val NO_COOKIES: CookieJar = NoCookies()

    private class NoCookies : CookieJar {

        // When the accept method is called
        boolean result = dosFileFilter.accept(mockFile);

        // Then the result should be as expected
        if (expectedResult) {
            assertTrue(result, "File should be accepted");
        } else {
            assertFalse(result, "File should not be accepted");
        }
    }

    /**

 */
public class SmbFileFilterTest {

    /**
     * A minimal implementation that accepts every {@link SmbFile}.
     */
    private final SmbFileFilter ALWAYSACTIVE = new SmbFileFilter() {
        @Override
        public boolean accept(SmbFile file) throws SmbException {
            // Never inspect the file – simply accept.
            return true;
        }
    };

    /**

        // With filter, resource should be closed due to try-with-resources
        verify(filter).accept(resource);
        verify(resource).close();
    }

    @Test
    @DisplayName("Iterator with rejecting filter - finds next acceptable")
    void iteratorWithRejectingFilter() throws Exception {
        // Setup: first entry rejected, second accepted
        FileEntry entry1 = mock(FileEntry.class);

                        alert("You must enter a reason to accept all changes.");
                        return;
                    }

                    var textToWrite = JSON.stringify(appendErrorCorrections(reason), null, 4) + "\\n";
                    var textFileAsBlob = new Blob([textToWrite], {type:'text/plain'});
                    var fileNameToSaveAs = 'accepted-public-api-changes.json';