/**
     * 操作の対象に含めるプロパティ名を追加します。
     *
     * @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')

        schema instanceof ManagedImplStructSchema
        schema instanceof ManagedImplSchema
        schema instanceof CompositeSchema
        schema instanceof StructSchema
        schema.propertyNames == ['readOnlyString', 'strings'] as SortedSet
        schema.properties*.name == ['readOnlyString', 'strings']
        schema.getProperty('readOnlyString').type == ModelType.of(String)

        schema instanceof RuleSourceSchema
        !(schema instanceof ManagedImplSchema)
        !(schema instanceof CompositeSchema)
        schema instanceof StructSchema
        schema.propertyNames.empty
        schema.properties.isEmpty()
    }

    static abstract class SomeRules extends RuleSource {
        abstract String getReadOnlyString()
        abstract List<String> getStrings()

        schema instanceof StructSchema
        schema.annotated
        schema.propertyNames == ['readOnlyString'] as SortedSet
    }

    def "assembles schema for unmanaged type that references itself"() {
        expect:
        def schema = store.getSchema(ModelType.of(Person))
        schema instanceof UnmanagedImplStructSchema
        schema.propertyNames == ['parent'] as SortedSet
        schema.properties*.name == ['parent']

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

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

    def "property names"() {
        expect:

                }

                val propertyNames = packageFragmentProto.`package`.propertyList
                    .map { propertyProto -> nameResolver.getName(propertyProto.name) }

                val functionNames = packageFragmentProto.`package`.functionList
                    .map { functionProto -> nameResolver.getName(functionProto.name) }

                val callableNames = (propertyNames + functionNames).distinct()

     */
    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) {