<option name="JD_P_AT_EMPTY_LINES" value="false" />
      <option name="JD_KEEP_EMPTY_PARAMETER" value="false" />
      <option name="JD_KEEP_EMPTY_EXCEPTION" value="false" />
      <option name="JD_KEEP_EMPTY_RETURN" value="false" />
    </JavaCodeStyleSettings>
    <JetCodeStyleSettings>
      <option name="PACKAGES_TO_USE_STAR_IMPORTS">
        <value>

    }
}


internal
fun Project.addSourceSet(testType: TestType): SourceSet {
    val prefix = testType.prefix
    val sourceSets = the<SourceSetContainer>()
    val main by sourceSets.getting
    return sourceSets.create("${prefix}Test") {
        compileClasspath += main.output
        runtimeClasspath += main.output
    }
}


internal
fun Project.createTasks(sourceSet: SourceSet, testType: TestType) {

    }

    private
    fun tasksExecuted(descriptor: CompositeProjectInitDescriptor): Int {
        val tasksExecuted = if (descriptor.componentType === ComponentType.LIBRARY) 4 else 7
        return tasksExecuted + if (descriptor.language === Language.KOTLIN) 1 else 0
    }

    private
    fun Directory.template(templateFragment: String) = file("$templateFragment.template").asFile.toURI().toURL()

    }

    String getId() { return id }

    String getName() { return className }

    String getSimpleName() { return simpleName }

    boolean isDeprecated() {
        return classMetaData.deprecated
    }

    boolean isIncubating() {
        return classMetaData.incubating
    }

    boolean isReplaced() {
        return classMetaData.replaced
    }

    @Override

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return String.format("%s.%s", ownerClass, name);
    }

    public TypeMetaData getType() {
        return type;
    }

    public void setType(TypeMetaData type) {
        this.type = type;
    }

    public boolean isWriteable() {
        return setter != null;
    }

public class JavaClassWithParameterizedTypes {
    Set<CombinedInterface> getSetProp() { return null; }

    Map<CombinedInterface, JavaClassWithParameterizedTypes> getMapProp() { return null; }

    List<?> getWildcardProp() { return null; }

    List<? extends CombinedInterface> getUpperBoundProp() { return null; }

    List<? super CombinedInterface> getLowerBoundProp() { return null; }

        if (!(member instanceof JApiClass)) {
            return null
        }

        if (!changed(member)) {
            return null
        }

        Optional<CtClass> oldClass = member.oldClass
        Optional<CtClass> newClass = member.newClass
        if (!oldClass.isPresent() || !newClass.isPresent()) {
            // breaking change would be reported
            return null
        }

            return null;
        }

        return acceptOrReject(member, Violation.error(member, SINCE_ERROR_MESSAGE + getCurrentVersion()));
    }

    private boolean shouldSkipViolationCheckFor(JApiCompatibility member) {
        return !isClassFieldConstructorOrMethod(member) ||
            isInject(member) ||

    }

    public boolean lookingAt(Pattern pattern) {
        Matcher m = pattern.matcher(input);
        m.region(pos, input.length());
        return m.lookingAt();
    }

    public String region() {
        return input.substring(markPos, pos);
    }

    /**
     * Moves the position to the next instance of the given character, or the end of the input if not found.
     */
    public void find(char c) {

    val functions = collectKtFunctionsFor(qualifiedBaseName, method)
    if (functions.isNotEmpty()) {
        return functions.all(predicate)
    }

    val properties = collectKtPropertiesFor(qualifiedBaseName, method)
    return properties.isNotEmpty() && properties.all(predicate)
}


private