Map<String, DfsState> stateMap,
            LinkedList<String> cycle) {
        if (children != null) {
            for (String v : children) {
                DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
                if (state == null) {
                    cycle.addLast(v);
                    List<String> ret = visitCycle(graph, graph.get(v), stateMap, cycle);
                    if (ret != null) {

 * 2. Direct dependencies should override the scope of dependencyManagement.
 * 3. Direct dependencies should inherit scope from dependencyManagement when
 *    they do not explicitly state a scope.
 *
 */
@Deprecated
class ProjectInheritanceTest extends AbstractProjectInheritanceTestCase {
    // ----------------------------------------------------------------------
    //
    // p1 inherits from p0

    /*
      At the moment, this class is totally immutable, and this is in line with thoughts about the
      pre-calculated execution plan that stays the same during the execution.

      If deciding to add mutable state to this class, it should be at least considered to
      separate this into a separate mutable structure.

    */

    private final List<ExecutionPlanItem> planItem;

     * <code>null</code>, the context value is removed from this project. Context values are intended to allow core
     * extensions to associate derived state with project instances.
     */
    public void setContextValue(String key, Object value) {
        if (context == null) {
            context = new HashMap<>();
        }
        if (value != null) {

        throw new UnsupportedOperationException("transformed artifact file cannot be set");
    }

    @Override
    public synchronized File getFile() {
        try {
            String state = mayUpdate();
            if (state == null) {
                return null;
            }
            return target.toFile();
        } catch (IOException | NoSuchAlgorithmException | XMLStreamException | ModelBuildingException e) {

 *
 * @since 3.0
 */
// TODO From a concurrency perspective, this class is not good. The combination of mutable/immutable state is not nice
public class DependencyContext {

    private final MavenProject project;

    private final Collection<String> scopesToCollectForCurrentProject;

        ChecksumCalculator getCalculator();
    }

    /**
     * The checksum calculator.
     */
    interface ChecksumCalculator {
        /**
         * Updates the checksum algorithm inner state with input.
         *
         * @throws NullPointerException if passed in buffer is {@code null}.
         */
        void update(@Nonnull ByteBuffer input);

        /**

     * <p>
     * Using ClassWorld to determine plugin/extensions realm parent classloaders gives m2e and integration test harness
     * flexibility to load multiple version of maven into dedicated classloaders without assuming state of jvm system
     * classloader.
     */
    private static final ClassLoader PARENT_CLASSLOADER = ClassWorld.class.getClassLoader();

    private final Logger logger = LoggerFactory.getLogger(getClass());

          <description>
            Whether this parameter is required for the Mojo to function. This is used to validate the configuration
            for a Mojo before it is injected, and before the Mojo is executed from some half-state.
          </description>
        </field>
        <field>
          <name>editable</name>
          <version>1.0.0+</version>
          <type>boolean</type>
          <defaultValue>true</defaultValue>

  not active (in most cases, localhost should be available, even if the rest of
  the network is not). Therefore, let's concentrate on the state where no
  network <beyond localhost> exists, and leave the more extreme state to users
  to diagnose and correct as necessary.

* Why is Offline Mode Important?

  Offline mode is essential for breaking the requirement that m2 operate in a