file = new File(targetFile, paths[i] + "_" + j);
                        if (!file.exists()) {
                            if (!file.mkdirs()) {
                                throw new CrawlerSystemException("Could not create " + file.getAbsolutePath());
                            }
                            break;
                        }
                        if (file.isDirectory()) {

        // When
        int bytesRead = response.readBytesWireFormat(buffer, offset);

        // Then
        assertEquals(4, bytesRead);
    }

    @DisplayName("Should throw exception for invalid structure size")
    @ParameterizedTest
    @ValueSource(ints = { 0, 1, 2, 3, 5, 10, 100, 65535 })
    void testReadBytesWireFormatInvalidStructureSize(int structureSize) {
        // Given

   * {@code key} while the new value was loading then a removal notification will be sent for the
   * new value.
   *
   * <p>If the cache loader associated with this cache is known not to throw checked exceptions,
   * then prefer {@link #getUnchecked} over this method.
   *
   * @throws ExecutionException if a checked exception was thrown while loading the value. ({@code
   *     ExecutionException} is thrown <a

        // Should not throw any exception and simply return.
        assertDoesNotThrow(() -> dfsImpl.cache(mockContext, "\\\\server\\share\\path", mockReferral));
    }

    @Test
    void testCache_InvalidPath() {
        // Scenario: The UNC path provided is invalid.
        DfsReferralDataInternal mockReferral = mock(DfsReferralDataInternal.class);
        // Should not throw any exception.

                        Files.writeString(tmpPom, interpolatedPom);
                        artifact = artifact.setPath(tmpPom);
                    }
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }
            newArtifacts.add(artifact);
        }
        return newArtifacts;
    }

    @SuppressWarnings("unchecked")

    }

    @Override
    public synchronized void write(final byte[] b, int off, final int len) throws IOException {
        if (len > 0xFFFF) {
            throw new IOException("write too large: " + len);
        }
        if (off < 4) {
            throw new IOException("NetBIOS socket output buffer requires 4 bytes available before off");
        }

        off -= 4;

    @Override
    public CacheRecord get(Key key) throws LifecycleExecutionException {
        CacheRecord cacheRecord = cache.get(key);
        if (cacheRecord != null && cacheRecord.getException() != null) {
            throw cacheRecord.getException();
        }
        return cacheRecord;
    }

    @Override
    public CacheRecord put(Key key, Set<Artifact> projectArtifacts) {

    }

    @Test
    @DisplayName("Should throw UnknownHostException for empty address list")
    void testUnknownHostException() throws Exception {
        // Given: No addresses returned
        when(nameSvc.getAllByName(eq("unknown.host"), eq(true))).thenReturn(new Address[0]);

        // When/Then: Should throw UnknownHostException

      fun readHeaders() {
        while (!source.exhausted()) {
          val b = source.readByte() and 0xff
          when {
            b == 0x80 -> {
              // 10000000
              throw IOException("index == 0")
            }
            b and 0x80 == 0x80 -> {
              // 1NNNNNNN
              val index = readInt(b, PREFIX_7_BITS)
              readIndexedHeader(index - 1)
            }

            } catch (final Exception e) {
                logger.info("[{}] {}", i + 1, e.getMessage());
            }
            ThreadUtil.sleep(200L);
        }
        if (!connected) {
            throw new IllegalStateException("Could not connect to the Samba server");
        }
    }

    @Override
    protected void tearDown() throws Exception {
        if (sambaServer != null) {