3330

Committed 04 Apr 2026 08:39PM UTC coverage: 90.15% (-0.2%) from 90.317%

Build # 3330

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1257 from hazendaz/renovate/byte-buddy.version

Update byte-buddy.version to v1.18.8-jdk5

Run Details

286 of 331 branches covered (86.4%)

540 of 599 relevant lines covered (90.15%)

0.9 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.13

/src/main/java/com/codebox/bean/JavaBeanTesterWorker.java

/*
 * SPDX-License-Identifier: Apache-2.0
 * See LICENSE file for details.
 *
 * Copyright 2012-2026 hazendaz
 *
 * Portions of initial baseline code (getter/setter test) by Rob Dawson (CodeBox)
 */
package com.codebox.bean;

import com.codebox.enums.CheckClear;
import com.codebox.enums.CheckConstructor;
import com.codebox.enums.CheckEquals;
import com.codebox.enums.CheckSerialize;
import com.codebox.enums.LoadData;
import com.codebox.enums.LoadType;
import com.codebox.enums.SkipStrictSerialize;
import com.codebox.instance.ClassInstance;

import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Externalizable;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import lombok.Data;

import nl.jqno.equalsverifier.EqualsVerifier;
import nl.jqno.equalsverifier.Warning;

import org.junit.jupiter.api.Assertions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * The Class JavaBeanTesterWorker.
 *
 * @param <T>
 *            the generic type
 * @param <E>
 *            the element type
 */
@Data
class JavaBeanTesterWorker<T, E> {

    /** The Constant logger. */
    private static final Logger logger = LoggerFactory.getLogger(JavaBeanTesterWorker.class);

    /** The check clear. */
    private CheckClear checkClear;

    /** The check constructor. */
    private CheckConstructor checkConstructor;

    /** The check equals. */
    private CheckEquals checkEquals;

    /** The check serializable. */
    private CheckSerialize checkSerializable;

    /** The load data. */
    private LoadData loadData;

    /** The clazz. */
    private final Class<T> clazz;

    /** The extension. */
    private Class<E> extension;

    /** The skip strict serialize. */
    private SkipStrictSerialize skipStrictSerializable;

    /** The skip these. */
    private Set<String> skipThese = new HashSet<>();

    /**
     * Instantiates a new java bean tester worker.
     *
     * @param newClazz
     *            the clazz
     */
    JavaBeanTesterWorker(final Class<T> newClazz) {
        this.clazz = newClazz;
    }

    /**
     * Instantiates a new java bean tester worker.
     *
     * @param newClazz
     *            the clazz
     * @param newExtension
     *            the extension
     */
    JavaBeanTesterWorker(final Class<T> newClazz, final Class<E> newExtension) {
        this.clazz = newClazz;
        this.extension = newExtension;
    }

    /**
     * Tests the load methods of the specified class.
     *
     * @param <L>
     *            the type parameter associated with the class under test.
     * @param clazz
     *            the class under test.
     * @param instance
     *            the instance of class under test.
     * @param loadData
     *            load recursively all underlying data objects.
     * @param skipThese
     *            the names of any properties that should not be tested.
     *
     * @return the java bean tester worker
     */
    public static <L> JavaBeanTesterWorker<L, Object> load(final Class<L> clazz, final L instance,
            final LoadData loadData, final String... skipThese) {
        final JavaBeanTesterWorker<L, Object> worker = new JavaBeanTesterWorker<>(clazz);

        worker.setLoadData(loadData);
        if (skipThese != null) {
            worker.setSkipThese(new HashSet<>(Arrays.asList(skipThese)));
        }
        worker.getterSetterTests(instance);

        return worker;
    }

    /**
     * Tests the clear, get, set, equals, hashCode, toString, serializable, and constructor(s) methods of the specified
     * class.
     */
    public void test() {

        // Test Getter/Setter
        this.getterSetterTests(new ClassInstance<T>().newInstance(this.clazz));

        // Test Clear
        if (this.checkClear != CheckClear.OFF) {
            this.clearTest();
        }

        // Test constructor
        if (this.checkConstructor != CheckConstructor.OFF) {
            this.constructorsTest();
        }

        // Test Serializable (internally uses on/off/strict checks)
        this.checkSerializableTest();

        // Test Equals
        if (this.checkEquals == CheckEquals.ON) {
            this.equalsHashCodeToStringSymmetricTest();
        }

    }

    /**
     * Getter Setter Tests.
     *
     * @param instance
     *            the instance of class under test.
     */
    void getterSetterTests(final T instance) {
        final PropertyDescriptor[] props = this.getProps(this.clazz);
        for (final PropertyDescriptor prop : props) {
            Method getter = prop.getReadMethod();
            final Method setter = prop.getWriteMethod();

            // Java Metro Bug Patch (Boolean Wrapper usage of 'is' possible
            if (getter == null && setter != null) {
                final String isBooleanWrapper = "is" + setter.getName().substring(3);
                try {
                    getter = this.clazz.getMethod(isBooleanWrapper);
                } catch (NoSuchMethodException | SecurityException e) {
                    // Do nothing
                }
            }

            if (getter != null && setter != null) {
                // We have both a get and set method for this property
                final Class<?> returnType = getter.getReturnType();
                final Class<?>[] params = setter.getParameterTypes();

                if (params.length == 1 && params[0] == returnType) {
                    // The set method has 1 argument, which is of the same type as the return type of the get method, so
                    // we can test this property
                    try {
                        // Build a value of the correct type to be passed to the set method
                        final Object value = this.buildValue(returnType, LoadType.STANDARD_DATA);

                        // Build an instance of the bean that we are testing (each property test gets a new instance)
                        final T bean = new ClassInstance<T>().newInstance(this.clazz);

                        // Call the set method, then check the same value comes back out of the get method
                        setter.invoke(bean, value);

                        // Use data set on instance
                        setter.invoke(instance, value);

                        final Object expectedValue = value;
                        Object actualValue = getter.invoke(bean);

                        // java.util.Date normalization patch
                        //
                        // Date is zero based so it adds 1 through normalization. Since we always pass '1' here, it is
                        // the same as stating February. Thus we roll over the month quite often into March towards
                        // end of the month resulting in '1' != '2' situation. The reason we pass '1' is that we are
                        // testing the content of the object and have no idea it is a date to start with. It is simply
                        // that it sees getters/setters and tries to load them appropriately. The underlying problem
                        // with that is that the Date object performs normalization to avoid dates like 2-30 that do
                        // not exist and is not a typical getter/setter use-case. It is also deprecated but we don't
                        // want to simply skip all deprecated items as we intend to test as much as possible.
                        //
                        if (this.clazz == Date.class && prop.getName().equals("month")
                                && expectedValue.equals(Integer.valueOf("1"))
                                && actualValue.equals(Integer.valueOf("2"))) {
                            actualValue = Integer.valueOf("1");
                        }

                        Assertions.assertEquals(expectedValue, actualValue,
                                String.format("Failed while testing property '%s' of class '%s'", prop.getName(),
                                        this.clazz.getName()));

                    } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException
                            | SecurityException e) {
                        Assertions.fail(String.format(
                                "An exception was thrown while testing class '%s' with the property (getter/setter) '%s': '%s'",
                                this.clazz.getName(), prop.getName(), e.toString()));
                    }
                }
            }
        }
    }

    /**
     * Clear test.
     */
    void clearTest() {
        final Method[] methods = this.clazz.getDeclaredMethods();
        for (final Method method : methods) {
            if (method.getName().equals("clear")) {
                final T newClass = new ClassInstance<T>().newInstance(this.clazz);
                final T expectedClass = new ClassInstance<T>().newInstance(this.clazz);
                try {
                    // Perform any Post Construction on object without parameters
                    List<Annotation> annotations = null;
                    for (final Method mt : methods) {
                        annotations = Arrays.asList(mt.getAnnotations());
                        for (final Annotation annotation : annotations) {
                            // XXX On purpose logic change to support both javax and jakarta namespace for annotations
                            if ("PostConstruct".equals(annotation.annotationType().getSimpleName())
                                    && mt.getParameterTypes().length == 0) {
                                // Invoke method newClass
                                mt.invoke(newClass);
                                // Invoke method expectedClass
                                mt.invoke(expectedClass);
                            }
                        }
                    }
                    // Invoke clear only on newClass
                    newClass.getClass().getMethod("clear").invoke(newClass);
                    Assertions.assertEquals(expectedClass, newClass,
                            String.format("Clear method does not match new object '%s'", this.clazz));
                } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException
                        | NoSuchMethodException | SecurityException e) {
                    Assertions.fail(String.format("An exception was thrown while testing the Clear method '%s' : '%s'",
                            this.clazz.getName(), e.toString()));
                }
            }
        }
    }

    /**
     * Constructors test.
     */
    void constructorsTest() {
        for (final Constructor<?> constructor : this.clazz.getConstructors()) {

            // Skip deprecated constructors
            if (constructor.isAnnotationPresent(Deprecated.class)) {
                continue;
            }

            final Class<?>[] types = constructor.getParameterTypes();

            final Object[] values = new Object[constructor.getParameterTypes().length];

            // Load Data
            for (int i = 0; i < values.length; i++) {
                values[i] = this.buildValue(types[i], LoadType.STANDARD_DATA);
            }

            try {
                constructor.newInstance(values);
            } catch (final InstantiationException | IllegalAccessException | InvocationTargetException e) {
                Assertions.fail(
                        String.format("An exception was thrown while testing the constructor(s) '%s' with '%s': '%s'",
                                constructor.getName(), Arrays.toString(values), e.toString()));
            }

            // TODO 1/12/2019 JWL Add checking of new object properties
        }
    }

    /**
     * Check Serializable test.
     */
    void checkSerializableTest() {
        final T object = new ClassInstance<T>().newInstance(this.clazz);
        if (this.implementsSerializable(object)) {
            final T newObject = this.canSerialize(object);
            // Toggle to throw or not throw error with only one way working
            if (this.skipStrictSerializable != SkipStrictSerialize.ON) {
                Assertions.assertEquals(object, newObject);
            } else {
                Assertions.assertNotEquals(object, newObject);
            }
            return;
        }

        // Only throw error when specifically checking on serialization
        if (this.checkSerializable == CheckSerialize.ON) {
            Assertions.fail(String.format("Class is not serializable '%s'", object.getClass().getName()));
        }
    }

    /**
     * Implements serializable.
     *
     * @param object
     *            the object
     *
     * @return true, if successful
     */
    boolean implementsSerializable(final T object) {
        return object instanceof Externalizable || object instanceof Serializable;
    }

    /**
     * Can serialize.
     *
     * @param object
     *            the object
     *
     * @return object read after serialization
     */
    @SuppressWarnings("unchecked")
    T canSerialize(final T object) {
        byte[] byteArray = null;

        // Serialize data
        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(object);
            byteArray = baos.toByteArray();
        } catch (final IOException e) {
            Assertions.fail(String.format("An exception was thrown while serializing the class '%s': '%s',",
                    object.getClass().getName(), e.toString()));
            return null;
        }

        // Deserialize Data
        try (ByteArrayInputStream bais = new ByteArrayInputStream(byteArray);
                ObjectInputStream ois = new ObjectInputStream(bais)) {
            return (T) ois.readObject();
        } catch (final ClassNotFoundException | IOException e) {
            Assertions.fail(String.format("An exception was thrown while deserializing the class '%s': '%s',",
                    object.getClass().getName(), e.toString()));
        }
        return null;
    }

    /**
     * Builds the value.
     *
     * @param <R>
     *            the generic type
     * @param returnType
     *            the return type
     * @param loadType
     *            the load type
     *
     * @return the object
     */
    private <R> Object buildValue(final Class<R> returnType, final LoadType loadType) {
        final ValueBuilder valueBuilder = new ValueBuilder();
        valueBuilder.setLoadData(this.loadData);
        return valueBuilder.buildValue(returnType, loadType);
    }

    /**
     * Tests the equals/hashCode/toString methods of the specified class.
     */
    public void equalsHashCodeToStringSymmetricTest() {
        // Run Equals Verifier
        this.processEqualsVerifierSymmetricTest();

        // Create two new instances of the class under test and test equals, hashcode, and toString on them
        final T x = new ClassInstance<T>().newInstance(this.clazz);
        final T y = new ClassInstance<T>().newInstance(this.clazz);
        this.processClassEqualsHashCodeToStringSymmetricTest(x, y);

        // TODO 1/12/2019 JWL Internalize extension will require canEquals, equals, hashcode, and toString overrides.
        /*
         * try { this.extension = (Class<E>) new ExtensionBuilder<T>().generate(this.clazz); } catch (NotFoundException
         * e) { Assert.fail(e.getMessage()); } catch (CannotCompileException e) { Assert.fail(e.getMessage()); }
         */

        // If there is an extension, create an instance and test equals, hashcode, and toString on it against the empty
        // class instance
        if (this.extension != null) {
            final E ext = new ClassInstance<E>().newInstance(this.extension);
            this.processExtensionEqualsHashCodeToStringSymmetricTest(y, ext);
        }
    }

    /**
     * Process equals verifier symmetric test.
     */
    private void processEqualsVerifierSymmetricTest() {
        // Run Equals Verifier
        try {
            EqualsVerifier.simple().forClass(this.clazz).suppress(Warning.BIGDECIMAL_EQUALITY).verify();
        } catch (AssertionError e) {
            JavaBeanTesterWorker.logger.warn("EqualsVerifier attempt failed: {}", e.getMessage());
        }
    }

    /**
     * Process class equals hash code to string symmetric test.
     *
     * @param x
     *            the x
     * @param y
     *            the y
     */
    private void processClassEqualsHashCodeToStringSymmetricTest(final T x, final T y) {
        // Verify that the objects were created successfully before testing equals, hashcode, and toString
        Assertions.assertNotNull(x,
                String.format("Create new instance of class '%s' resulted in null", this.clazz.getName()));
        Assertions.assertNotNull(y,
                String.format("Create new instance of class '%s' resulted in null", this.clazz.getName()));

        // Test Equals, HashCode, and ToString on Empty Objects
        Assertions.assertEquals(x, y,
                String.format(".equals() should be consistent for two empty objects of type %s", this.clazz.getName()));
        Assertions.assertEquals(x.hashCode(), y.hashCode(), String
                .format(".hashCode() should be consistent for two empty objects of type %s", this.clazz.getName()));
        Assertions.assertEquals(x.toString(), y.toString(), String
                .format(".toString() should be consistent for two empty objects of type %s", this.clazz.getName()));

        // Test One Sided Tests on Empty Objects
        Assertions.assertNotEquals(x, null,
                String.format("An empty object of type %s should not be equal to null", this.clazz.getName()));
        Assertions.assertEquals(x, x,
                String.format("An empty object of type %s should be equal to itself", this.clazz.getName()));

        // If the class has setters, the previous tests would have been against empty classes
        // If so, load the classes and re-test
        if (this.classHasSetters(this.clazz)) {
            // Populate Side X
            JavaBeanTesterWorker.load(this.clazz, x, this.loadData);

            // ReTest Equals (flip)
            Assertions.assertNotEquals(y, x,
                    String.format(".equals() should not be consistent for one empty and one loaded object of type %s",
                            this.clazz.getName()));

            // Populate Side Y
            JavaBeanTesterWorker.load(this.clazz, y, this.loadData);

            // ReTest Equals and HashCode
            if (this.loadData == LoadData.ON) {
                Assertions.assertEquals(x, y,
                        String.format(".equals() should be equal for two instances of type %s with loaded data",
                                this.clazz.getName()));
                Assertions.assertEquals(x.hashCode(), y.hashCode(),
                        String.format(".hashCode() should be equal for two instances of type %s with loaded data",
                                this.clazz.getName()));
            } else {
                // Part of the data loaded may be the same, so we cannot guarantee that equals and hashcode will be
                // different, but we can at least check that they are not both the same
                // Assertions.assertNotEquals(x, y);
                // Assertions.assertNotEquals(x.hashCode(), y.hashCode());
                if (x.hashCode() == y.hashCode()) {
                    Assertions.assertEquals(x, y);
                    Assertions.assertEquals(x.hashCode(), y.hashCode());
                } else {
                    Assertions.assertNotEquals(x, y);
                    Assertions.assertNotEquals(x.hashCode(), y.hashCode());
                }
            }
        }

        // Create Immutable Instance
        try {
            final T e = new ClassInstance<T>().newInstance(this.clazz);
            ByteBuddyBeanCopier.copy(x, e, (value, targetType) -> {
                if (targetType == boolean.class) {
                    return value == null ? Boolean.FALSE : value;
                }
                return value;
            });
            Assertions.assertEquals(e, x);
        } catch (final Exception e) {
            JavaBeanTesterWorker.logger.trace("Do nothing class is not mutable", e);
        }
    }

    /**
     * Process extension equals hash code to string symmetric test.
     *
     * @param y
     *            the y
     * @param ext
     *            the ext
     */
    private void processExtensionEqualsHashCodeToStringSymmetricTest(final T y, final E ext) {
        // Verify that the objects were created successfully before testing equals, hashcode, and toString
        Assertions.assertNotNull(ext,
                String.format("Create new instance of extension %s resulted in null", this.extension.getName()));

        // Test Extension Equals, HashCode, and ToString on Empty Objects
        Assertions.assertNotEquals(ext, y,
                String.format(".equals() should not be equal for extension of type %s and empty object of type %s",
                        this.extension.getName(), this.clazz.getName()));
        Assertions.assertNotEquals(ext.hashCode(), y.hashCode(),
                String.format(".hashCode() should not be equal for extension of type %s and empty object of type %s",
                        this.extension.getName(), this.clazz.getName()));
        Assertions.assertNotEquals(ext.toString(), y.toString(),
                String.format(".toString() should not be equal for extension of type %s and empty object of type %s",
                        this.extension.getName(), this.clazz.getName()));

        // Test Extension One Sided Tests on Empty Objects
        Assertions.assertNotEquals(ext, null,
                String.format("An empty extension of type %s should not be equal to null", this.clazz.getName()));
        Assertions.assertEquals(ext, ext,
                String.format("An empty extension of type %s should be equal to itself", this.extension.getName()));

        // If the class has setters, the previous tests would have been against empty classes
        // If so, load the classes and re-test
        if (this.classHasSetters(this.clazz)) {
            // Populate Extension Side Ext
            JavaBeanTesterWorker.load(this.extension, ext, this.loadData);

            // ReTest Extension Equals (flip)
            Assertions.assertNotEquals(y, ext,
                    String.format(".equals() should not be equal for extension of type %s and empty object of type %s",
                            this.extension.getName(), this.clazz.getName()));

            // Populate Side Y
            JavaBeanTesterWorker.load(this.clazz, y, this.loadData);

            // ReTest Extension Equals, HashCode, and ToString
            Assertions.assertNotEquals(ext, y,
                    String.format(".equals() should not be equal for extension of type %s and empty object of type %s",
                            this.extension.getName(), this.clazz.getName()));
            Assertions.assertNotEquals(ext.hashCode(), y.hashCode(),
                    String.format(
                            ".hashCode() should not be equal for extension of type %s and empty object of type %s",
                            this.extension.getName(), this.clazz.getName()));
            Assertions.assertNotEquals(ext.toString(), y.toString(),
                    String.format(
                            ".toString() should not be equal for extension of type %s and empty object of type %s",
                            this.extension.getName(), this.clazz.getName()));
        }

        // If class is final, use Object.class for comparison needs
        if (Modifier.isFinal(clazz.getModifiers())) {
            JavaBeanTesterWorker.logger.trace("Final object does not go through final equals check");
            return;
        }

        // Create Extension Immutable Instance
        try {
            final E e = new ClassInstance<E>().newInstance(this.extension);
            ByteBuddyBeanCopier.copy(ext, e, (value, targetType) -> {
                if (targetType == boolean.class) {
                    return value == null ? Boolean.FALSE : value;
                }
                return value;
            });
            Assertions.assertEquals(e, ext);
        } catch (final Exception e) {
            JavaBeanTesterWorker.logger.trace("Do nothing class is not mutable", e);
        }
    }

    /**
     * Equals Tests will traverse one object changing values until all have been tested against another object. This is
     * done to effectively test all paths through equals.
     *
     * @param instance
     *            the class instance under test.
     * @param expected
     *            the instance expected for tests.
     */
    void equalsTests(final T instance, final T expected) {

        // Perform hashCode test dependent on data coming in
        // Assert.assertEquals(expected.hashCode(), instance.hashCode());
        if (expected.hashCode() == instance.hashCode()) {
            Assertions.assertEquals(expected.hashCode(), instance.hashCode());
        } else {
            Assertions.assertNotEquals(expected.hashCode(), instance.hashCode());
        }

        final ValueBuilder valueBuilder = new ValueBuilder();
        valueBuilder.setLoadData(this.loadData);

        final PropertyDescriptor[] props = this.getProps(instance.getClass());
        for (final PropertyDescriptor prop : props) {
            Method getter = prop.getReadMethod();
            final Method setter = prop.getWriteMethod();

            // Java Metro Bug Patch (Boolean Wrapper usage of 'is' possible
            if (getter == null && setter != null) {
                final String isBooleanWrapper = "is" + setter.getName().substring(3);
                try {
                    getter = this.clazz.getMethod(isBooleanWrapper);
                } catch (NoSuchMethodException | SecurityException e) {
                    // Do nothing
                }
            }

            if (getter != null && setter != null) {
                // We have both a get and set method for this property
                final Class<?> returnType = getter.getReturnType();
                final Class<?>[] params = setter.getParameterTypes();

                if (params.length == 1 && params[0] == returnType) {
                    // The set method has 1 argument, which is of the same type as the return type of the get method, so
                    // we can test this property
                    try {
                        // Save original value
                        final Object original = getter.invoke(instance);

                        // Build a value of the correct type to be passed to the set method using alternate test
                        Object value = valueBuilder.buildValue(returnType, LoadType.ALTERNATE_DATA);

                        // Call the set method, then check the same value comes back out of the get method
                        setter.invoke(instance, value);

                        // Check equals depending on data
                        if (instance.equals(expected)) {
                            Assertions.assertEquals(expected, instance);
                        } else {
                            Assertions.assertNotEquals(expected, instance);
                        }

                        // Build a value of the correct type to be passed to the set method using null test
                        value = valueBuilder.buildValue(returnType, LoadType.NULL_DATA);

                        // Call the set method, then check the same value comes back out of the get method
                        setter.invoke(instance, value);

                        // Check equals depending on data
                        if (instance.equals(expected)) {
                            Assertions.assertEquals(expected, instance);
                        } else {
                            Assertions.assertNotEquals(expected, instance);
                        }

                        // Reset to original value
                        setter.invoke(instance, original);

                    } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException
                            | SecurityException e) {
                        Assertions.fail(
                                String.format("An exception was thrown while testing the property (equals) '%s': '%s'",
                                        prop.getName(), e.toString()));
                    }
                }
            }
        }
    }

    /**
     * Class has setters.
     *
     * @param clazz
     *            the clazz
     *
     * @return true, if successful
     */
    private boolean classHasSetters(final Class<T> clazz) {
        return Arrays.stream(this.getProps(clazz))
                .anyMatch(propertyDescriptor -> propertyDescriptor.getWriteMethod() != null);
    }

    /**
     * Gets the props.
     *
     * @param clazz
     *            the clazz
     *
     * @return the props
     */
    private PropertyDescriptor[] getProps(final Class<?> clazz) {
        try {
            final List<PropertyDescriptor> usedProps = new ArrayList<>(
                    Introspector.getBeanInfo(clazz).getPropertyDescriptors().length);
            final List<PropertyDescriptor> props = Arrays
                    .asList(Introspector.getBeanInfo(clazz).getPropertyDescriptors());
            for (final PropertyDescriptor prop : props) {
                // Check the list of properties that we don't want to test
                if (this.skipThese.contains(prop.getName())) {
                    continue;
                }
                usedProps.add(prop);
            }
            return usedProps.toArray(new PropertyDescriptor[0]);
        } catch (final IntrospectionException e) {
            Assertions.fail(String.format("An exception was thrown while testing class '%s': '%s'",
                    this.clazz.getName(), e.toString()));
            return new PropertyDescriptor[0];
        }
    }

}

hazendaz / javabean-tester / 3330

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous