* @param <T> the type of array elements
 */
public class ArrayIterator<T> implements Iterator<T> {

    /** The array of elements to iterate over */
    protected final T[] items;

    /** The index of the currently referenced element */
    protected int index = 0;

    /**
     * Returns an {@link Iterable} that wraps the array for use in a for-each statement.
     *
     * @param <T> the type of elements

        // Test that allow takes precedence over disallow
        RobotsTxt robotsTxt = new RobotsTxt();

        Directive directive = new Directive("MyBot");
        directive.addDisallow("/admin/");
        directive.addAllow("/admin/public/");
        robotsTxt.addDirective(directive);

        // Allow should take precedence
        assertTrue(robotsTxt.allows("/admin/public/page.html", "MyBot"));

        assertEquals("SystemOS", context.getConfig().getNativeOs());
    }

    @Test
    void testInitPropertyPrecedence(@TempDir Path tempDir) throws IOException, CIFSException {
        // Test property precedence: custom > system > jcifs.properties
        Path jcifsPropertiesPath = tempDir.resolve("jcifs.properties");
        Files.writeString(jcifsPropertiesPath, "jcifs.smb.client.nativeOs=FileOS");

 * This form extends CreateForm to include fields necessary for updating existing stemmer override entries.
 * Stemmer overrides define custom stemming rules that take precedence over the default stemming algorithm.
 *
 */
public class EditForm extends CreateForm {

    /**
     * Creates a new EditForm instance.
     */
    public EditForm() {
        super();
    }

                this.tid = -1;

                // Clear any cached resources
                // Note: Most fields in SmbTreeImpl are final or managed differently

                // Clear session reference if mutable
                // Note: session field may be final, cannot be nulled
            }
        } catch (Exception e) {
            log.error("Failed to perform emergency tree cleanup", e);
        }
    }

        assertEquals(creds.isAnonymous(), copy.isAnonymous());
        assertEquals(creds.isGuest(), copy.isGuest());
        assertSame(subject, copy.getSubject(), "subject is the same reference in clone");
    }

    @Test
    @DisplayName("createContext returns SSPContext and interacts with CIFSContext")
    void createContext_happy_interacts_and_returns_context() throws Exception {
        // Arrange

             * returned by the Node Status. A new NbtAddress object should not be
             * created for it because the original is potentially being actively
             * referenced by other objects. We must populate the existing object's
             * data explicitly (and carefully).
             */
            if (!addrFound && this.queryAddress.hostName.hexCode == hexCode

        assertEquals(remaining, getFieldValue(write, "remaining"), "Remaining should match constructor arg");
        assertEquals(buffer, getFieldValue(write, "b"), "Buffer reference should be set");
        assertEquals(off, getFieldValue(write, "off"), "Off should match constructor arg");
        assertEquals(len, getFieldValue(write, "count"), "Count should equal len");
    }

    /**

         * According to RFC 9309:
         * 1. Find the longest matching pattern (by priority length)
         * 2. If both Allow and Disallow patterns match with the same length, Allow takes precedence
         * 3. If no pattern matches, the path is allowed by default
         *
         * @param path the path to check
         * @return true if the path is allowed, false otherwise
         */

     */
    protected final Map<Long, Response> response_map = new ConcurrentHashMap<>(10);
    private final AtomicLong usageCount = new AtomicLong(1);

    /**
     * Acquires a reference to this transport, incrementing the usage count.
     *
     * @return session increased usage count
     */
    public Transport acquire() {
        final long usage = this.usageCount.incrementAndGet();