values.add(0, new ScopeState());
    }

    protected ScopeState getScopeState() {
        if (values.isEmpty()) {
            throw new OutOfScopeException("Cannot access session scope outside of a scoping block");
        }
        return values.get(0);
    }

    public void exit() {
        if (values.isEmpty()) {
            throw new IllegalStateException();
        }
        values.remove(0);
    }

        // Do not share an ArtifactSet if the artifacts are modified by the dependency.
        if (!dependency.getDependencyMetadata().getArtifacts().isEmpty() ||
            !dependency.getAttributes().isEmpty() ||
            dependency.getExclusions().mayExcludeArtifacts()
        ) {
            int id = nextId++;

        ongoing.remove(new TransferResourceIdentifier(event.getResource()));
        put(event, ongoing.isEmpty());
    }

    @Override
    public void transferFailed(TransferEvent event) {
        ongoing.remove(new TransferResourceIdentifier(event.getResource()));
        put(event, ongoing.isEmpty());
    }

    private static class Exchange {
        private final TransferEvent event;

    }

    @Override
    protected List<? extends DependencyMetadata> getAllDependencies() {
        List<? extends DependencyMetadata> superDependencies = super.getAllDependencies();
        if (syntheticDependencies.isEmpty()) {
            return superDependencies;
        }
        int expectedSize = superDependencies.size() + syntheticDependencies.size();

        SimpleProblemCollector problems = new SimpleProblemCollector();
        List<Profile> active = selector.getActiveProfiles(profiles, context, problems);
        assertTrue(active.isEmpty());
        assertEquals(1, problems.getErrors().size());
        assertEquals(
                "Failed to determine activation for profile one: BOOM",
                problems.getErrors().get(0));
    }

            .filter(Optional::isPresent)
            .map(annotation -> annotation.get().name())
            .sorted()
            .collect(Collectors.toList());

        if (exposedSoftwareTypes.isEmpty()) {
            typeValidationContext.visitTypeProblem(problem ->
                problem.withAnnotationType(softwareTypePluginImplClass)

    map.put(new Object(), Boolean.TRUE);
    GcFinalization.awaitDone(
        new FinalizationPredicate() {
          @Override
          public boolean isDone() {
            return map.isEmpty();
          }
        });
    assertTrue(map.isEmpty());
  }

  // ----------------------------------------------------------------
  // Test that interrupts result in RuntimeException, not InterruptedException.

            @Override
            public <Q> Supplier<Q> getCompiledBinding(Key<Q> key) {
                Set<Binding<Q>> res = getBindings(key);
                if (res != null && !res.isEmpty()) {
                    List<Binding<Q>> bindingList = new ArrayList<>(res);
                    Comparator<Binding<Q>> comparing = Comparator.comparing(Binding::getPriority);

                .setRootDirectory(Paths.get("src/test/resources/consumer/simple"));
        Model model = builder.build(session, project, file);

        assertNotNull(model);
        assertTrue(model.getProfiles().isEmpty());
    }

    @Named
    @Singleton
    @Priority(10)
    public static class MyModelResolver implements ModelResolver {
        @Override
        public ModelSource resolveModel(

        String experimentalProperty = internalOptions.getOption(CACHING_DISABLED_PROPERTY).get();
        if (experimentalProperty != null) {
            if (experimentalProperty.isEmpty() || experimentalProperty.equals("true")) {
                return true;
            }
            List<String> disabledTransformClasses = Arrays.asList(experimentalProperty.split(","));