/**
 * Tests <code>NearestConflictResolver</code>.
 *
 * @see NearestConflictResolver
 */
@Deprecated
class NearestConflictResolverTest extends AbstractConflictResolverTest {
    // constructors -----------------------------------------------------------

    public NearestConflictResolverTest() throws Exception {
        super("nearest");
    }

     */
    boolean addAllInternal(Collection<? extends Task> task);

    /**
     * Creates an instance of the given task type without invoking its constructors. This is used to recreate a task instance from the configuration cache.
     *
     * TODO:configuration-cache - review this
     */
    <T extends Task> T createWithoutConstructor(String name, Class<T> type, long uniqueId);

 public:
  /// Initializer enables constructing an Input object from various kinds of C++
  /// constants such as simple primitive constants and nested initializer lists
  /// representing a multi-dimensional array. Initializer constructors are all
  /// templates, so the aforementioned kinds of C++ constants can be used to
  /// construct an Initializer. Initializer stores the value it got constructed
  /// with in a Tensor object.
  struct Initializer {

/**
 * Tests <code>OldestConflictResolver</code>.
 *
 * @see OldestConflictResolver
 */
@Deprecated
class OldestConflictResolverTest extends AbstractConflictResolverTest {
    // constructors -----------------------------------------------------------

    public OldestConflictResolverTest() throws Exception {
        super("oldest");
    }

                .anyMatch(method -> method.isAnnotatedWith(Inject.class));
        }
    };

    private static final DescribedPredicate<JavaClass> injected_by_constructor = new DescribedPredicate<JavaClass>("injected into constructors via @Inject") {
        @Override
        public boolean test(JavaClass javaClass) {
            return javaClass
                .getMethodsWithParameterTypeOfSelf()
                .stream()

   *     constructor that omits the cause.
   */
  @Deprecated
  protected UncheckedExecutionException() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *
   * @deprecated Prefer {@linkplain UncheckedExecutionException(String, Throwable)} a constructor

        }
    }

    private GradleHandle setupStubs(AbstractContinuousIntegrationTest sampleTest) {
        sampleTest.results = [] // fields are null for some reason, perhaps Spock internally modifies constructors
        def gradleHandle = Stub(GradleHandle)
        gradleExecuter.withStdinPipe() >> gradleExecuter
        gradleExecuter.withTasks(_) >> gradleExecuter
        gradleExecuter.withForceInteractive(_) >> gradleExecuter

    override val name: FqName,
    override val supertypes: Set<FqName>,
    override val properties: List<DataProperty>,
    override val memberFunctions: List<SchemaMemberFunction>,
    override val constructors: List<DataConstructor>
) : DataClass {

    override fun toString(): String = name.simpleName

    companion object Empty : DataClass {
        override val name: FqName = FqName.Empty

   *     #initCause} later, so it is not quite equivalent to using a constructor that omits the
   *     cause.
   */
  @Deprecated
  protected ExecutionError() {}

  /**
   * Creates a new instance with the given detail message and no cause.
   *
   * @deprecated Prefer {@linkplain ExecutionError(String, Error)} a constructor that accepts a

        MemberType.TYPE -> hasTypeFlags(kmClass, jvmSignature, predicate)
        MemberType.FIELD -> hasPropertyFlags(kmClass::properties, jvmSignature, predicate)
        MemberType.CONSTRUCTOR -> hasConstructorFlags(kmClass::constructors, jvmSignature, predicate)
        MemberType.METHOD -> hasFunctionFlags(kmClass::functions, jvmSignature, predicate) ||
            hasPropertyFlags(kmClass::properties, jvmSignature, predicate)
    }
}