int hash = entry.getHash();
    segmentFor(hash).reclaimValue(entry.getKey(), hash, valueReference);
  }

  void reclaimKey(ReferenceEntry<K, V> entry) {
    int hash = entry.getHash();
    segmentFor(hash).reclaimKey(entry, hash);
  }

  /**
   * This method is a convenience for testing. Code should call {@link Segment#getLiveValue}
   * instead.
   */

    public String getId() {
        return id;
    }

    public org.apache.maven.api.Lifecycle getDelegate() {
        return lifecycle;
    }

    public List<String> getPhases() {
        return phases;
    }

    static Map<String, LifecyclePhase> getDefaultPhases(org.apache.maven.api.Lifecycle lifecycle) {
        Map<String, List<String>> goals = new HashMap<>();

     */
    public void setLifecyclePhases(Map<String, LifecyclePhase> lifecyclePhases) {
        this.lifecyclePhases = lifecyclePhases;
    }

    @Deprecated
    public Map<String, String> getPhases() {
        Map<String, LifecyclePhase> lphases = getLifecyclePhases();
        if (lphases == null) {
            return null;
        }

        if (lphases.isEmpty()) {
            return Collections.emptyMap();

        // Check if cache entry is valid
        if (entry != null && entry.needsRefresh()) {
            // Check if lease is still valid
            LeaseManager.LeaseEntry leaseEntry = baseLeaseManager.getLease(entry.getLeaseKey());
            if (leaseEntry == null || !leaseEntry.hasReadCache()) {
                // Lease lost, remove cache entry
                directoryCache.remove(directoryPath);
                return null;

        } else if ("default".equals(lifecycle)) {
            return phases;
        } else {
            return null;
        }
    }

    @Deprecated
    @Override
    public Map<String, String> getPhases(String lifecycle) {
        return LifecyclePhase.toLegacyMap(getLifecyclePhases(lifecycle));
    }

            assertEquals("localhost", smbFile.getServer());
        }

        @Test
        void testGetShare() {
            // Act & Assert
            assertEquals("share", smbFile.getShare());
        }

        @Test
        void testGetUncPath() {
            // Arrange
            doReturn("\\localhost\share\file.txt").when(smbFile).getUncPath();

            // Act & Assert

                }

                PluginExecution execution = new PluginExecution();
                execution.setId(getExecutionId(plugin, gs.goal));
                execution.setPhase(phase);
                execution.setPriority(i - mojos.size());
                execution.getGoals().add(gs.goal);

                execution.setLocation("", location);

    }

    /**
     * @return the service
     */
    public String getService() {
        return this.service;
    }

    /**
     * @return the share
     */
    public String getShare() {
        return this.share;
    }

    /**
     * @return whether this is a DFS share
     */
    public boolean isDfs() {
        return this.inDfs;
    }

    /**
     *

                final Lifecycle lifecycle = defaultLifecycles.get(phase);
                if (lifecycle != null) {
                    totalPhaseSet.addAll(lifecycle.getPhases());
                }
            }
        }
        this.phasesInExecutionPlan = new ArrayList<>(totalPhaseSet);

        Map<String, ExecutionPlanItem> lastInExistingPhases = new HashMap<>();

    assertThat(newFirst.getValueReference().get()).isSameInstanceAs(valueTwo);
    assertThat(newFirst.getHash()).isEqualTo(hashTwo);
    newFirst = newFirst.getNext();
    assertThat(newFirst.getKey()).isSameInstanceAs(keyThree);
    assertThat(newFirst.getValueReference().get()).isSameInstanceAs(valueThree);
    assertThat(newFirst.getHash()).isEqualTo(hashThree);
    assertThat(newFirst.getNext()).isNull();
  }