// Test with mock
            doNothing().when(mockReferralData).replaceCache();
            mockReferralData.replaceCache();
            verify(mockReferralData, times(1)).replaceCache();

            // Test with concrete implementation
            assertDoesNotThrow(() -> concreteImplementation.replaceCache());
        }

        @Test
        @DisplayName("Should check if resolve hashes")

     */
    void setCacheMap(Map<String, DfsReferralDataInternal> map);

    /**
     * Replaces the entry with key in the cache map with this referral
     */
    void replaceCache();

    /**
     * Not exactly sure what that is all about, certainly legacy stuff
     *
     * @return resolveHashes
     */
    boolean isResolveHashes();

    /**

                        if (dr != null) {
                            ct.setTreeReferral(dr);
                            if (dr != start) {
                                dr.unwrap(DfsReferralDataInternal.class).replaceCache();
                            }
                        }
                        switchTree(ct);
                        return new SmbTreeHandleImpl(loc, this);
                    }
                }

        this.map = map;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.dfs.DfsReferralDataInternal#replaceCache()
     */
    @Override
    public void replaceCache() {
        if (this.map != null && this.key != null) {
            this.map.put(this.key, this);
        }
    }

    @Override
    public DfsReferralDataImpl next() {

        @DisplayName("Should set cache map")
        void testSetCacheMap() {
            referralData.setCacheMap(cacheMap);
            // Verify by checking replaceCache doesn't throw
            referralData.setKey("test-key");
            referralData.replaceCache();
            assertEquals(referralData, cacheMap.get("test-key"));
        }

        @Test
        @DisplayName("Should replace cache entry with key")