/**
 * <p>
 * Context of dependency artifacts for a particular project.
 * </p>
 * <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
 *
 * @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;

        assertThat(ClassLoaderUtil.isAncestor(cl3, cl1), is(true));
        assertThat(ClassLoaderUtil.isAncestor(cl2, cl1), is(true));

        assertThat(ClassLoaderUtil.isAncestor(cl1, cl2), is(not(true)));
        assertThat(ClassLoaderUtil.isAncestor(cl1, cl3), is(not(true)));
    }

  "originates" from a Contributor if it was added to the Program by
  such Contributor itself or anyone acting on such Contributor's behalf.
  Contributions do not include changes or additions to the Program that
  are not Modified Works.

"Contributor" means any person or entity that Distributes the Program.

"Licensed Patents" mean patent claims licensable by a Contributor which

/*
 * Copyright 2012-2024 CodeLibs Project and the Others.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,

        bool((must, should, mustNot, filter) -> {
            filteredLambda.callback(must, filter);
        }, opLambda);
    }

    public void not(OperatorCall<GroupCQ> notLambda) {
        not(notLambda, null);
    }

    public void not(final OperatorCall<GroupCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
        bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);

                requireNotNull(context) {
                    "Not-null element must have a context"
                }
            }
        }
    }

    private object Directives : SimpleDirectivesContainer() {
        val IGNORE_STABILITY by stringDirective(
            description = "Symbol restoring for some symbols in current test is not supported yet",
        )

     * the returned model and must not rely on the input model being updated.
     *
     * @param model The model to interpolate, must not be {@code null}.
     * @param projectDir The project directory, may be {@code null} if the model does not belong to a local project but
     *            to some artifact's metadata.
     * @param request The model building request that holds further settings, must not be {@code null}.

        super(componentName + " is not available.");
    }

    public ContainerNotAvailableException(final String componentName, final Throwable cause) {
        super(componentName + " is not available.", cause);
        this.componentName = componentName;
    }

    public ContainerNotAvailableException(final Throwable cause) {
        super("Container is not avaiable.");
        this.componentName = "container";

     */
    public val KaPropertySymbol.getterDeprecationStatus: DeprecationInfo?
        get() = withValidityAssertion { analysisSession.symbolInfoProvider.getGetterDeprecation(this) }

    /**
     * Gets the deprecation status of the setter of this property symbol. Returns null if the setter it not deprecated or the property does
     * not have a setter.
     */

 *  * restoring symbols which came from Java source is not supported yet
 *  * for library symbols:
 *    * for function & property symbol if its signature was not changed
 *    * for local variable symbol if code block it was declared in was not changed
 *    * for class & type alias symbols if its qualified name was not changed
 *    * for package symbol if the package is still exists
 *