StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING))) {
            oos.writeObject(info);
            log.debug("Persisted handle: {}", info.getPath());
        } catch (IOException e) {
            log.error("Failed to persist handle: " + info.getPath(), e);
        }
    }

    private void removePersistedHandle(HandleInfo info) {
        if (info.getType() != HandleType.PERSISTENT) {
            return;

                    throw new DictionaryException("Failed to update " + dictFile.getPath());
                }
            } catch (final IOException e) {
                throw new DictionaryException("Failed to update " + dictFile.getPath(), e);
            }

        }).orElse(() -> {
            throw new DictionaryException(dictFile.getPath() + " does not exist.");
        });
    }

    /**

            this.path = requireNonNull(path, "path").normalize();
            this.location = location != null ? location : this.path.toString();
        }

        @Override
        @Nullable
        public Path getPath() {
            return path;
        }

        @Override
        @Nonnull
        public InputStream openStream() throws IOException {
            return Files.newInputStream(path);
        }

    }

    @Override
    public String getPathForLocalMetadata(Metadata metadata) {
        return getPath(metadata, "local");
    }

    @Override
    public String getPathForRemoteMetadata(Metadata metadata, RemoteRepository repository, String context) {
        return getPath(metadata, getRepositoryKey(repository, context));
    }

    String getRepositoryKey(RemoteRepository repository, String context) {

                            public Optional<Path> getPath(org.apache.maven.api.Artifact artifact) {
                                Path path = paths.get(artifact.key());
                                if (path == null && artifact instanceof DefaultArtifact defaultArtifact) {
                                    path = defaultArtifact.getArtifact().getPath();
                                }

        final PathInfo pi = convertToItem(id);
        if (StringUtil.isEmpty(pi.getPath()) && StringUtil.isEmpty(pi.getName())) {
            return StringUtil.EMPTY;
        }
        if (StringUtil.isEmpty(pi.getPath())) {
            return pi.getName();
        }
        return pi.getPath() + "/" + pi.getName();
    }

    /**

            assertEquals("path2", combined.getPath());
            assertEquals("DOMAIN", combined.getDomain());
            assertEquals(second.getExpiration(), combined.getExpiration());

            // Path consumed should be combined
            int expectedPathConsumed = 20 + 15;
            if (first.getPath() != null) {
                expectedPathConsumed -= (first.getPath().length() + 1);
            }

    if (directoryLeaseManager != null && 
        directoryLeaseManager.canCacheDirectoryListing(getPath())) {
        
        List<SmbFile> cachedFiles = directoryLeaseManager.getCachedDirectoryListing(getPath());
        if (cachedFiles != null) {
            log.debug("Using cached directory listing for: {}", getPath());
            return cachedFiles.toArray(new SmbFile[0]);
        }
    }
    

            return str.substring(0, i + 1);
        }

        return "smb://";
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbResourceLocator#getPath()
     */

    @Override
    public String getPath() {
        return this.url.toString();
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbResourceLocator#getCanonicalURL()
     */
    @Override

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

            // Test with concrete implementation
            String concretePath = concreteImplementation.getPath();
            // Should be path based on our initialization