Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/Sources/formale Sprachen/Java/Openjdk/test/jdk/java/beans/Introspector/ (Sun/Oracle ^©) Datei vom 13.11.2022 mit Größe 6 kB

Quelle Test4619536.java Sprache: JAVA

/*
* Copyright (c) 2003, 2007, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

/*
* @test
* @bug 4619536
* @summary Tests resolving the ambiguities in the resolution of IndexedPropertyDescriptors
* @author Mark Davidson
*/

import java.beans.IndexedPropertyDescriptor;
import java.beans.PropertyDescriptor;
import java.util.Date;

public class Test4619536 {
    public static void main(String[] args) throws Exception {
        IndexedPropertyDescriptor ipd = BeanUtils.getIndexedPropertyDescriptor(A.class, "foo");
        if (!ipd.getIndexedPropertyType().equals(String.class)) {
            error(ipd, "A.foo should be String type");
        }
        PropertyDescriptor pd = BeanUtils.findPropertyDescriptor(B.class, "foo");
        if (pd instanceof IndexedPropertyDescriptor) {
            error(pd, "B.foo should not be an indexed property");
        }
        if (!pd.getPropertyType().equals(Date.class)) {
            error(pd, "B.foo should be Date type");
        }
        pd = BeanUtils.findPropertyDescriptor(Child.class, "foo");
        if (pd instanceof IndexedPropertyDescriptor) {
            error(pd, "Child.foo should not be an indexed property");
        }
        pd = BeanUtils.findPropertyDescriptor(Classic.class, "foo");
        if (pd instanceof IndexedPropertyDescriptor) {
            error(pd, "Classic.foo should not be an indexed property");
        }
        ipd = BeanUtils.getIndexedPropertyDescriptor(Index.class, "foo");
        if (!hasIPD(ipd)) {
            error(pd, "Index.foo should have ipd values");
        }
        if (hasPD(ipd)) {
            error(ipd, "Index.foo should not have pd values");
        }
        ipd = BeanUtils.getIndexedPropertyDescriptor(All.class, "foo");
        if (!hasPD(ipd) || !hasIPD(ipd)) {
            error(ipd, "All.foo should have all pd/ipd values");
        }
        if (!isValidType(ipd)) {
            error(ipd, "All.foo pdType should equal ipdType");
        }
        ipd = BeanUtils.getIndexedPropertyDescriptor(Getter.class, "foo");
        if (ipd.getReadMethod() == null || ipd.getWriteMethod() != null) {
            error(ipd, "Getter.foo classic methods incorrect");
        }
        if (!isValidType(ipd)) {
            error(ipd, "Getter.foo pdType should equal ipdType");
        }
        ipd = BeanUtils.getIndexedPropertyDescriptor(BadGetter.class, "foo");
        if (hasPD(ipd)) {
            error(ipd, "BadGetter.foo should not have classic methods");
        }
        ipd = BeanUtils.getIndexedPropertyDescriptor(Setter.class, "foo");
        if (ipd.getReadMethod() != null || ipd.getWriteMethod() == null) {
            error(ipd, "Setter.foo classic methods incorrect");
        }
        if (!isValidType(ipd)) {
            error(ipd, "Setter.foo pdType should equal ipdType");
        }
        ipd = BeanUtils.getIndexedPropertyDescriptor(BadSetter.class, "foo");
        if (hasPD(ipd)) {
            error(ipd, "BadSetter.foo should not have classic methods");
        }
    }

    public static boolean hasPD(PropertyDescriptor pd) {
        if (null == pd.getPropertyType()) {
            return false;
        }
        return (null != pd.getReadMethod())
            || (null != pd.getWriteMethod());
    }

    public static boolean hasIPD(IndexedPropertyDescriptor ipd) {
        if (null == ipd.getIndexedPropertyType()) {
            return false;
        }
        return (null != ipd.getIndexedReadMethod())
            || (null != ipd.getIndexedWriteMethod());
    }

    public static boolean isValidType(IndexedPropertyDescriptor ipd) {
        Class type = ipd.getPropertyType();
        return type.isArray() && type.getComponentType().equals(ipd.getIndexedPropertyType());
    }

    public static void error(PropertyDescriptor pd, String message) {
        BeanUtils.reportPropertyDescriptor(pd);
        throw new Error(message);
    }

    // Test case from 4619536
    public static class A {
        // prop foo on A should be indexed of type String
        public String getFoo(int x) {
            return null;
        }
    }

    public static class B extends A {
        // prop foo on should be non-indexed of type Date
        public Date getFoo() {
            return null;
        }
    }

    // Test case from 4812428 (this works in 1.5.0)
    public static class Parent {
        public void setFoo(String foo) {
        }

        public Child getFoo(int index) {
            return null;
        }
    }

    public static class Child extends Parent {
        public Child getFoo() {
            return null;
        }
    }

    // This class has a complete set of pd
    public static class Classic {
        public String[] getFoo() {
            return null;
        }

        public void setFoo(String[] foo) {
        }
    }

    // This class has a complete set of ipd
    public static class Index {
        public String getFoo(int i) {
            return null;
        }

        public void setFoo(int i, String f) {
        }
    }

    // This class adds a proper getter and setter
    public static class All extends Index {
        public String[] getFoo() {
            return null;
        }

        public void setFoo(String[] foo) {
        }
    }

    // This class adds a classic getter
    public static class Getter extends Index {
        public String[] getFoo() {
            return null;
        }
    }

    // This class has an alternate getter and should be merged
    public static class BadGetter extends Index {
        public String getFoo() {
            return null;
        }
    }

    // This class adds a classic setter
    public static class Setter extends Index {
        public void setFoo(String[] f) {
        }
    }

    // This class has an alternate setter and should be merged
    public static class BadSetter extends Index {
        public void setFoo(String f) {
        }
    }
}

quality97%

¤ Dauer der Verarbeitung: 0.12 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.