/**
     * 操作の対象に含めるプロパティ名を追加します。
     *
     * @param propertyNames
     *            プロパティ名の並び。{@literal null}や空配列であってはいけません
     * @return このインスタンス自身
     */
    public CopyOptions include(final CharSequence... propertyNames) {
        assertArgumentNotEmpty("propertyNames", propertyNames);

        includePropertyNames.addAll(toStringList(propertyNames));
        return this;
    }

    /**

    def "deviant bean properties are considered as such by Java"() {
        expect:
        def propertyNames = Introspector.getBeanInfo(DeviantBean).propertyDescriptors.collect { it.name }
        propertyNames.contains("tingStarted")
        propertyNames.contains("ccCompiler")
        propertyNames.contains("idore")
        propertyNames.contains("tings")
    }

    def "deviant bean properties are considered as such by Groovy"() {

     *
     * @param propertyNames
     *            プロパティ名の配列。{@literal null}や空配列であってはいけません
     * @return 操作の対象に含めるプロパティ名を指定した{@link CopyOptions}
     * @see CopyOptions#include(CharSequence...)
     */
    public static CopyOptions include(final CharSequence... propertyNames) {
        return new CopyOptions().include(propertyNames);
    }

    /**

        expect:
        def details = ClassInspector.inspect(PropNames)

        details.propertyNames == ['class', 'metaClass', 'a', 'b', 'URL', 'url', '_A'] as Set
    }

    def "extracts properties of a Groovy interface"() {
        expect:
        def details = ClassInspector.inspect(SomeInterface)

        details.propertyNames == ['prop', 'readOnly', 'writeOnly'] as Set

        def prop = details.getProperty('prop')

import static JavaPropertyReflectionUtil.propertyNames
import static JavaPropertyReflectionUtil.readableProperty
import static JavaPropertyReflectionUtil.writeableProperty

class JavaPropertyReflectionUtilTest extends Specification {
    JavaTestSubject myProperties = new JavaTestSubject()

    def "property names"() {
        expect:

     */
    public Set<String> getPropertyNames() {
        Set<String> propertyNames = new TreeSet<String>();
        propertyNames.addAll(declaredProperties.keySet());
        ClassMetaData superClass = getSuperClass();
        if (superClass != null) {
            propertyNames.addAll(superClass.getPropertyNames());
        }
        return propertyNames;
    }

    private PropertyMetaData getProperty(String name) {

    val propertyNames =
        if (hasIsGetterName) listOf(method.name)
        else {
            val prefixRemoved = method.name.drop(3)
            if (hasSetterName && isBoolean) listOf("is$prefixRemoved", prefixRemoved.decapitalize())
            else listOf(prefixRemoved.decapitalize())
        }

    val propertyQualifiedNames =
        propertyNames.map { "$qualifiedBaseName.$it" }

fun Project.gradleProperty(propertyName: String) = providers.gradleProperty(propertyName)


fun Project.systemProperty(propertyName: String) = providers.systemProperty(propertyName)


fun Project.environmentVariable(propertyName: String) = providers.environmentVariable(propertyName)


fun Project.propertyFromAnySource(propertyName: String) = gradleProperty(propertyName)
    .orElse(systemProperty(propertyName))

        this._source = source;
        this._convention = convention;
        this._propertyNames = JavaPropertyReflectionUtil.propertyNames(source);
        this._ineligiblePropertyNames = new HashSet<>();
    }

    private MappedProperty map(String propertyName, MappedPropertyImpl mapping) {
        if (!_propertyNames.contains(propertyName)) {
            throw new InvalidUserDataException(

        (1.._) * onAccess.accept('other', 'otherValue')
        0 * onAccess._

        where:
        methodName                                | operation
        "propertyNames()"                         | call(p -> p.propertyNames())
        "keys()"                                  | call(p -> p.keys())
        "elements()"                              | call(p -> p.elements())