if (!dependency.equals(className) && !dependenciesToAll.containsKey(dependency)) {
                addDependency(privateDependents, dependency, className);
            }
        }
        for (String dependency : accessibleClassDependencies) {
            if (!dependency.equals(className) && !dependenciesToAll.containsKey(dependency)) {
                addDependency(accessibleDependents, dependency, className);

        final Map<String, String[]> params = request.getParameterMap();
        if (logger.isDebugEnabled()) {
            logger.debug("params: {}", params);
        }
        return params.containsKey(ERROR) || params.containsKey(ID_TOKEN) || params.containsKey(CODE);
    }

    public void updateMemberOf(final AzureAdUser user) {
        final List<String> groupList = new ArrayList<>();
        final List<String> roleList = new ArrayList<>();

  }

  @CollectionSize.Require(absent = ZERO)
  public void testHeadMapInclusive() {
    assertTrue(navigableMap.headMap(a.getKey(), true).containsKey(a.getKey()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testTailMapExclusive() {
    assertFalse(navigableMap.tailMap(a.getKey(), false).containsKey(a.getKey()));
  }

  }

  @CollectionSize.Require(absent = ZERO)
  public void testHeadMapInclusive() {
    assertTrue(navigableMap.headMap(a.getKey(), true).containsKey(a.getKey()));
  }

  @CollectionSize.Require(absent = ZERO)
  public void testTailMapExclusive() {
    assertFalse(navigableMap.tailMap(a.getKey(), false).containsKey(a.getKey()));
  }

    }

    @Override
    public void withVariantsFromConfiguration(Configuration outgoingConfiguration, Action<? super ConfigurationVariantDetails> action) {
        checkNotObserved();
        if (!variants.containsKey(outgoingConfiguration)) {
            throw new InvalidUserDataException("Variant for configuration " + outgoingConfiguration.getName() + " does not exist in component " + componentName);
        }

        return attributes.size();
    }

    @Override
    public boolean isEmpty() {
        return attributes.isEmpty();
    }

    @Override
    public boolean containsKey(Object key) {
        return attributes.containsKey(key);
    }

    @Override
    public boolean containsValue(Object value) {
        return attributes.containsValue(value);
    }

    @Override

        List<Object> key = asList(requested, from, constraint);
        if (!unresolvedDependencies.containsKey(key)) {
            unresolvedDependencies.put(key, new DefaultUnresolvedDependencyResult(requested, constraint, reason, from, failure));
        }
        return unresolvedDependencies.get(key);
    }

    }

    private ResultsStore getStoreForTest(PerformanceExperiment experiment) {
        buildTests();
        if (!tests.containsKey(experiment)) {
            throw new IllegalArgumentException(String.format("Unknown test '%s'.", experiment));
        }
        return tests.get(experiment);
    }

    private void buildTests() {

rootProject.name = "developer-ci-setup"
// tag::developer-ci-setup[]
val isCiServer = System.getenv().containsKey("CI")

buildCache {
    remote<HttpBuildCache> {
        url = uri("https://example.com:8123/cache/")
        isPush = isCiServer
    }
}

    }

    @Override
    public Collection<ModelProperty<?>> getProperties() {
        return properties.values();
    }

    @Override
    public boolean hasProperty(String name) {
        return properties.containsKey(name);
    }

    @Override
    public ModelProperty<?> getProperty(String name) {
        return properties.get(name);
    }

    @Override