assertEquals(5, referralData.getPathConsumed());
        }

        @Test
        @DisplayName("Should strip exact path consumed")
        void testStripExactPathConsumed() {
            setupReferralDataWithPathConsumed(10);

            referralData.stripPathConsumed(10);
            assertEquals(0, referralData.getPathConsumed());
        }

        @Test

        @Test
        @DisplayName("Should initialize with null referrals")
        void testInitialState() {
            assertNull(buffer.getReferrals());
            assertEquals(0, buffer.getPathConsumed());
            assertEquals(0, buffer.getNumReferrals());
            assertEquals(0, buffer.getTflags());
        }
    }

    @Nested
    @DisplayName("Decode Tests")
    class DecodeTests {

                    } while (next != dr);

                    if (dr.getPathConsumed() > (path != null ? path.length() : 0)) {
                        log.error("Consumed more than we provided");
                    }

                    link = path != null && dr.getPathConsumed() > 0 ? path.substring(0, dr.getPathConsumed()) : "\\";
                    dr.setLink(link);
                    if (log.isTraceEnabled()) {

            // Test with mock
            when(mockReferralData.getPathConsumed()).thenReturn(pathConsumed);
            assertEquals(pathConsumed, mockReferralData.getPathConsumed());
            verify(mockReferralData, times(1)).getPathConsumed();

            // Test with concrete implementation
            int concretePathConsumed = concreteImplementation.getPathConsumed();
            assertTrue(concretePathConsumed >= 0);
        }

        }
        return Objects.equals(getServer(), other.getServer()) && Objects.equals(getShare(), other.getShare())
                && Objects.equals(getPath(), other.getPath()) && Objects.equals(getPathConsumed(), other.getPathConsumed());
    }

    /**
     * Set the referral data from a referral response
     *
     * @param ref the referral response
     * @param reqPath the requested path

        when(dr.getServer()).thenReturn("dfs-server");
        when(dr.getShare()).thenReturn("dfs-share");
        when(dr.getPath()).thenReturn("dfs/path");
        when(dr.getPathConsumed()).thenReturn(2); // consume leading \\ from UNC

        String newUnc = l.handleDFSReferral(dr, "\\req\\");
        // dunc is "\\" + path + remaining  - note: path may not have leading backslashes

        }
        if (this.unc == null) {
            canonicalizePath();
        }
        final String oldUncPath = uncBeforeDfsReferal != null ? uncBeforeDfsReferal : this.unc;

        int pathConsumed = dr.getPathConsumed();
        if (pathConsumed < 0) {
            log.warn("Path consumed out of range " + pathConsumed);
            pathConsumed = 0;
        } else if (pathConsumed > this.unc.length()) {