/**
     * {@inheritDoc}
     */
    @Override
    SetProperty<T> convention(@Nullable Iterable<? extends T> elements);

    /**
     * {@inheritDoc}
     */
    @Override
    SetProperty<T> convention(Provider<? extends Iterable<? extends T>> provider);

    /**
     * {@inheritDoc}
     *
     * <p>

    /**
     * {@inheritDoc}
     */
    @Override
    ListProperty<T> convention(@Nullable Iterable<? extends T> elements);

    /**
     * {@inheritDoc}
     */
    @Override
    ListProperty<T> convention(Provider<? extends Iterable<? extends T>> provider);

    /**
     * {@inheritDoc}
     *
     * <p>

            } ?: relevantField
        }
    }


/**
 * Returns every property backing field for which a corresponding convention mapping flag field also exists.
 *
 * The convention mapping flag field is a Boolean field injected by [AsmBackedClassGenerator] in order to capture
 * whether a convention mapped property has been explicitly set or not.
 */
private
fun conventionAwareFieldsOf(beanType: Class<*>): Sequence<Pair<Field, Field>> =

/**
 * This class was added just to support FileSystemLocation properties in the convention mapping.
 *
 * Should be removed once ConventionMapping is removed.
 */
@NonNullApi
public interface FileSystemLocationPropertyInternal<T extends FileSystemLocation> extends FileSystemLocationProperty<T> {

    /**
     * Same as {@link FileSystemLocationProperty#convention(Provider)} but it also works with a Provider of a File.
     */

    Class<? extends T> getModelPublicType();

    Class<? extends Plugin<Project>> getPluginClass();

    Class<? extends Plugin<Settings>> getRegisteringPluginClass();

    void addConvention(Convention<?> rule);

    List<Convention<?>> getConventions();

    )
    def "inherited convention method is preferred over property with closure value"() {
        given:
        createDirs("child")
        settingsFile << "include 'child'"
        buildFile """
class ContactConvention {
    def contacts(String arg) { arg }
}

convention.plugins.contacts = new ContactConvention()

subprojects {

      panels.timeSeries.base('CPU Usage', queries.cpuUsage, 'CPU usage of each running instance'),
    ]),
    row.new('Network')
    + row.withPanels([
      panels.timeSeries.connections('Connections', queries.connections, 'Connections opened and closed per instance'),
      panels.timeSeries.bytesRate('Bytes Transmitted', queries.bytes, 'Bytes sent and recieved per instance'),

 *
 * The order of generations is important as calls in later generations can override calls in earlier generations, but no the
 * other way around.
 * For instance, a property assignment can override a convention assignment, but a convention assignment cannot override a property assignment.
 */
interface OperationGenerationId : Comparable<OperationGenerationId>, Serializable {
    val ordinal: Int

        }
    }

    @Override
    public void close() {
        try {
            CompositeStoppable.stoppable(connections.asMap().values()).stop();
        } finally {
            connections.invalidateAll();
        }
    }

    @NonNullApi
    private class ConsumerConnectionCreator implements Callable<ConsumerConnection> {

    }

    def "fails if a project doesn't follow convention"() {
        given:
        createDirs("1library")
        settingsFile << """
            include '1library'
        """

        when:
        fails 'help'

        then:
        failureDescriptionContains "Cannot generate project dependency accessors because project '1library' doesn't follow the naming convention: [a-zA-Z]([A-Za-z0-9\\-_])*"
    }