* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
package jcifs;

/**
 * An empty iterator implementation for SMB resources.
 * This iterator contains no elements and immediately returns false for hasNext().
 *
 * @author mbechler
 */
public class EmptyIterator implements CloseableIterator<SmbResource> {

    /**
     * Default constructor for EmptyIterator.

    public val shutdownInput: Boolean = false,
    public val shutdownOutput: Boolean = false,
  ) : SocketEffect

  /**
   * On HTTP/2, send a [GOAWAY frame](https://tools.ietf.org/html/rfc7540#section-6.8) immediately
   * after the response and will close the connection when the client's socket is exhausted.
   *
   * On HTTP/1 this closes the socket.
   */
  public object ShutdownConnection : SocketEffect

  /**

     * @return the parsed invoker request. Caller must start by checking {@link InvokerRequest#parsingFailed()} as
     * if there are parser errors, this request may not be fully processed and should immediately be failed.
     */
    @Nonnull
    InvokerRequest parseInvocation(@Nonnull ParserRequest parserRequest);

   * specified array and the size of the specified collection.
   *
   * <p>If the collection fits in the specified array with room to spare (i.e., the array has more
   * elements than the collection), the element in the array immediately following the end of the
   * collection is set to {@code null}. This is useful in determining the length of the collection
   * <i>only</i> if the caller knows that the collection does not contain any null elements.
   *

```
mc ilm rule add --noncurrent-expire-days 30 --noncurrent-expire-newer 5 --prefix "user-uploads/" myminio/mydata
```

#### 3.2.a Automatic removal of noncurrent versions keeping only most recent ones immediately (MinIO only extension)

This is available only on MinIO as an extension to the NewerNoncurrentVersions feature. The following rule makes it possible to remove older noncurrent versions

        startAnotherThread()
      }
    }
  }

  /**
   * Returns an immediately-executable task for the calling thread to execute, sleeping as necessary
   * until one is ready. If there are no ready queues, or if other threads have everything under
   * control this will return null. If there is more than a single task ready to execute immediately
   * this will start another thread to handle that work.
   */

    @DisplayName("TestLocking increments numComplete")
    void testNumCompleteIncrement() {
        TestLocking t = new TestLocking();
        t.url = "smb://test/file.txt";
        t.numIter = 0; // Set to 0 so run() exits immediately

        // Run the method
        t.run();

        // Verify numComplete was incremented
        assertEquals(1, t.numComplete, "numComplete should be incremented after run");
    }

    @Nested

    }

    /**
     * Adds a bad word.
     * @param badWord The bad word to add.
     * @param apply Whether to apply the change immediately.
     * @return The SuggestDeleteResponse.
     */
    public SuggestDeleteResponse addBadWord(final String badWord, final boolean apply) {
        ensureOperations();

    /**
     * Flag indicating an unlock operation to release a previously held lock.
     */
    public static final int SMB2_LOCKFLAG_UNLOCK = 0x4;

    /**
     * Flag indicating the lock should fail immediately if it cannot be granted.
     */
    public static final int SMB2_LOCKFLAG_FAIL_IMMEDIATELY = 0x10;

    private final long offset;
    private final long length;
    private final int flags;

    /**

          taskDone = true;
          return 6;
        };
    Future<Integer> future =
        TestingExecutors.sameThreadScheduledExecutor().schedule(task, 10000, MILLISECONDS);
    assertTrue("Should run callable immediately", taskDone);
    assertEquals(6, (int) future.get());
  }

  public void testSameThreadScheduledExecutorWithException() throws InterruptedException {
    Runnable runnable =
        () -> {