this.hreflang = hreflang;
    }

    /**
     * Gets the href URL.
     * @return the href URL
     */
    public String getHref() {
        return href;
    }

    /**
     * Sets the href URL.
     * @param href the href URL to set
     */
    public void setHref(final String href) {
        this.href = href;
    }

    @Override
    public String toString() {

        assertEquals("en", link1.getHreflang());
        assertEquals("http://www.example.com/en/page.html", link1.getHref());

        final SitemapAlternateLink link2 = sitemapUrl.getAlternateLinks().get(1);
        assertEquals("ja", link2.getHreflang());
        assertEquals("http://www.example.com/ja/page.html", link2.getHref());

        final SitemapAlternateLink link3 = sitemapUrl.getAlternateLinks().get(2);

        return this.ctx.getConfig();
    }

    private synchronized SmbTreeImpl getTree() {
        final SmbTreeImpl t = this.tree;
        if (t != null) {
            return t.acquire(false);
        }
        if (this.delegate != null) {
            this.tree = this.delegate.getTree();
            return this.tree;
        }
        return t;
    }

    /**
     * @return

        }

        @Test
        @DisplayName("Should define getFree method")
        void shouldDefineGetFreeMethod() throws NoSuchMethodException {
            // Verify method exists with correct signature
            assertNotNull(AllocInfo.class.getMethod("getFree"));
            assertEquals(long.class, AllocInfo.class.getMethod("getFree").getReturnType());
        }

        @Test

            // Then
            long expectedFree = free * sectPerAlloc * bytesPerSect;
            assertEquals(expectedFree, fileFsSizeInfo.getFree());
            assertEquals(2097152L, fileFsSizeInfo.getFree()); // 512 * 8 * 512
        }

        @Test
        @DisplayName("Should handle overflow in capacity calculation")

            // Then
            long expectedFree = callerFree * sectPerAlloc * bytesPerSect;
            assertEquals(expectedFree, fileFsFullSizeInfo.getFree());
            assertEquals(2097152L, fileFsFullSizeInfo.getFree()); // 512 * 8 * 512
        }

        @Test
        @DisplayName("Should handle overflow in capacity calculation")

        when(mockAllocInfo.getFree()).thenReturn(400L);

        assertEquals(1000L, mockAllocInfo.getCapacity(), "capacity should match stubbed value");
        assertEquals(400L, mockAllocInfo.getFree(), "free space should match stubbed value");
        verify(mockAllocInfo, times(1)).getCapacity();
        verify(mockAllocInfo, times(1)).getFree();
    }

    /**

        // Verify - all zeros should result in 0 capacity and free
        assertEquals(0L, smbInfoAllocation.getCapacity());
        assertEquals(0L, smbInfoAllocation.getFree());
    }

    @Test
    @DisplayName("Test getFree with maximum values")
    void testGetFreeWithMaximumValues() throws SMBProtocolDecodingException {
        // Prepare test data with maximum int values
        byte[] buffer = new byte[22];

        SmbInfoAllocation info = (SmbInfoAllocation) response.getInfo();
        assertEquals(8L * 1000000L * 512L, info.getCapacity());
        assertEquals(8L * 500000L * 512L, info.getFree());
    }

    @Test
    void testReadDataWireFormat_FileFsSizeInformation() throws Exception {
        // Test reading FS_SIZE_INFO data

    }

    /**
     * Test that getTree() returns the correct SmbTreeHandle.
     */
    @Test
    void testGetTree() {
        when(smbFileHandle.getTree()).thenReturn(smbTreeHandle);
        SmbTreeHandle result = smbFileHandle.getTree();
        assertEquals(smbTreeHandle, result, "getTree should return the mocked SmbTreeHandle.");
        verify(smbFileHandle, times(1)).getTree();
    }

    /**