*/
    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();

        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            // Ignore
        }

        // When lease is lost, cache entry should be removed
        when(baseLeaseManager.getLease(leaseKey)).thenReturn(null);

        assertNull(directoryLeaseManager.getCacheEntry(directoryPath));
    }

    @Test
    public void testCanCacheDirectoryListing() {

        // 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));
    }

        return baseVersion;
    }

    public String getMajor() {
        return major;
    }

    public String getBuild() {
        return build;
    }

    public String getHash() {
        return hash;
    }

    public String getPath() {
        return configuration.getSingleFile().toString();
    }

    public String getConfigurationName() {

  void setValueReference(ValueReference<K, V> valueReference);

  /** Returns the next entry in the chain. */
  @Nullable ReferenceEntry<K, V> getNext();

  /** Returns the entry's hash. */
  int getHash();

  /** Returns the key for this entry. */
  @Nullable K getKey();

  /*
   * Used by entries that use access order. Access entries are maintained in a doubly-linked list.

            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

  void setValueReference(ValueReference<K, V> valueReference);

  /** Returns the next entry in the chain. */
  @Nullable ReferenceEntry<K, V> getNext();

  /** Returns the entry's hash. */
  int getHash();

  /** Returns the key for this entry. */
  @Nullable K getKey();

  /*
   * Used by entries that use access order. Access entries are maintained in a doubly-linked list.

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

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

                }

                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);