3227

Committed 16 Feb 2026 12:20AM UTC coverage: 87.5% (-0.4%) from 87.852%

Build # 3227

Build Type

push

github

Committed by

hazendaz

Commit Message

Found possible bug in handling, its not always possible to be purist on current code for equals

noted what the expectation was, its not achieved, so just allow it through.  This was an existing problem that the tests didn't catch due to sub objects.  I had added a test when looking at lombok builder pattern and stumbled onto it.  In the equals only tests, its actually doing almost same thing.  This area is known not strong enough and is additionally using equals verifier to try to compensate.

Coverage Stats

285 of 331 branches covered (86.1%)

5 of 5 new or added lines in 1 file covered. (100.0%)

67 existing lines in 6 files now uncovered.

525 of 600 relevant lines covered (87.5%)

0.88 hits per line

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

68.57

/src/main/java/com/codebox/instance/ClassInstance.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.instance;

import com.codebox.bean.ValueBuilder;
import com.codebox.enums.LoadData;
import com.codebox.enums.LoadType;
import com.codebox.util.LombokBuilderUtil;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Arrays;

import org.junit.jupiter.api.Assertions;

/**
 * The Class Instance.
 *
 * @param <T>
 *            the element type
 */
public class ClassInstance<T> {

    /**
     * New instance. This will get the first available constructor to run the test on. This allows for instances where
     * there is intentionally not a no-arg constructor.
     *
     * @param clazz
     *            the class
     *
     * @return the t
     */
    @SuppressWarnings("unchecked")
    public final T newInstance(final Class<T> clazz) {
        // If class is null, return null
        if (clazz == null) {
            return null;
        }

        // Check if class has Lombok @Builder pattern (static builder() method)
        Method builderMethod = LombokBuilderUtil.getLombokBuilderMethod(clazz);
        if (builderMethod != null) {
            try {
                return this.createInstanceWithBuilder(clazz, builderMethod);
            } catch (final IllegalAccessException | IllegalArgumentException | InvocationTargetException
                    | NoSuchMethodException | SecurityException e) {
                Assertions.fail(String.format(
                        "An exception was thrown while creating instance using Lombok @Builder for class '%s': '%s'",
                        clazz.getName(), e.toString()));
            }
        }

        // Try no-arg constructor first
        for (final Constructor<?> constructor : clazz.getConstructors()) {
            // Skip deprecated constructors
            if (constructor.isAnnotationPresent(Deprecated.class)) {
                continue;
            }

            // Find available no-arg constructor and return it
            if (constructor.getParameterCount() == 0) {
                try {
                    return (T) constructor.newInstance();
                } catch (final InstantiationException | IllegalAccessException | InvocationTargetException e) {
                    Assertions.fail(String.format(
                            "An exception was thrown while testing class no-arg constructor (new instance) '%s': '%s'",
                            constructor.getName(), e.toString()));
                }
            }
        }

        // Try any constructor
        for (final Constructor<?> constructor : 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 {
                return (T) constructor.newInstance(values);
            } catch (final InstantiationException | IllegalAccessException | InvocationTargetException e) {
                Assertions.fail(String.format(
                        "An exception was thrown while testing the class (new instance) '%s' with '%s': '%s'",
                        constructor.getName(), Arrays.toString(values), e.toString()));
            }
        }
        return null;
    }

    /**
     * Create an instance using Lombok's builder pattern.
     *
     * @param clazz
     *            the class to instantiate
     * @param builderMethod
     *            the builder method
     * @return the instance created via builder
     * @throws IllegalAccessException
     *             the illegal access exception
     * @throws IllegalArgumentException
     *             the illegal argument exception
     * @throws InvocationTargetException
     *             the invocation target exception
     * @throws NoSuchMethodException
     *             the no such method exception
     * @throws SecurityException
     *             the security exception
     */
    @SuppressWarnings("unchecked")
    private T createInstanceWithBuilder(final Class<T> clazz, final Method builderMethod) throws IllegalAccessException,
            IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
        // Invoke the builder() method to get a builder instance
        final T builder = (T) builderMethod.invoke(null);
        // Find the build() method on the builder
        Method buildMethod = builder.getClass().getMethod("build");
        // Invoke build() to create the instance
        return (T) buildMethod.invoke(builder);
    }

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

}

1	/*
2	* SPDX-License-Identifier: Apache-2.0
3	* See LICENSE file for details.
4	*
5	* Copyright 2012-2026 hazendaz
6	*
7	* Portions of initial baseline code (getter/setter test) by Rob Dawson (CodeBox)
8	*/
9	package com.codebox.instance;
10
11	import com.codebox.bean.ValueBuilder;
12	import com.codebox.enums.LoadData;
13	import com.codebox.enums.LoadType;
14	import com.codebox.util.LombokBuilderUtil;
15
16	import java.lang.reflect.Constructor;
17	import java.lang.reflect.InvocationTargetException;
18	import java.lang.reflect.Method;
19	import java.util.Arrays;
20
21	import org.junit.jupiter.api.Assertions;
22
23	/**
24	* The Class Instance.
25	*
26	* @param <T>
27	* the element type
28	*/
29	public class ClassInstance<T> {	1✔
30
31	/**
32	* New instance. This will get the first available constructor to run the test on. This allows for instances where
33	* there is intentionally not a no-arg constructor.
34	*
35	* @param clazz
36	* the class
37	*
38	* @return the t
39	*/
40	@SuppressWarnings("unchecked")
41	public final T newInstance(final Class<T> clazz) {
42	// If class is null, return null
43	if (clazz == null) {	1!
UNCOV 44	return null;	×
45	}
46
47	// Check if class has Lombok @Builder pattern (static builder() method)
48	Method builderMethod = LombokBuilderUtil.getLombokBuilderMethod(clazz);	1✔
49	if (builderMethod != null) {	1✔
50	try {
51	return this.createInstanceWithBuilder(clazz, builderMethod);	1✔
UNCOV 52	} catch (final IllegalAccessException \| IllegalArgumentException \| InvocationTargetException	×
53	\| NoSuchMethodException \| SecurityException e) {
UNCOV 54	Assertions.fail(String.format(	×
55	"An exception was thrown while creating instance using Lombok @Builder for class '%s': '%s'",
UNCOV 56	clazz.getName(), e.toString()));	×
57	}
58	}
59
60	// Try no-arg constructor first
61	for (final Constructor<?> constructor : clazz.getConstructors()) {	1✔
62	// Skip deprecated constructors
63	if (constructor.isAnnotationPresent(Deprecated.class)) {	1✔
64	continue;	1✔
65	}
66
67	// Find available no-arg constructor and return it
68	if (constructor.getParameterCount() == 0) {	1✔
69	try {
70	return (T) constructor.newInstance();	1✔
UNCOV 71	} catch (final InstantiationException \| IllegalAccessException \| InvocationTargetException e) {	×
UNCOV 72	Assertions.fail(String.format(	×
73	"An exception was thrown while testing class no-arg constructor (new instance) '%s': '%s'",
UNCOV 74	constructor.getName(), e.toString()));	×
75	}
76	}
77	}
78
79	// Try any constructor
80	for (final Constructor<?> constructor : clazz.getConstructors()) {	1!
81
82	// Skip deprecated constructors
83	if (constructor.isAnnotationPresent(Deprecated.class)) {	1✔
84	continue;	1✔
85	}
86
87	final Class<?>[] types = constructor.getParameterTypes();	1✔
88
89	final Object[] values = new Object[constructor.getParameterTypes().length];	1✔
90
91	// Load Data
92	for (int i = 0; i < values.length; i++) {	1✔
93	values[i] = this.buildValue(types[i], LoadType.STANDARD_DATA);	1✔
94	}
95
96	try {
97	return (T) constructor.newInstance(values);	1✔
UNCOV 98	} catch (final InstantiationException \| IllegalAccessException \| InvocationTargetException e) {	×
UNCOV 99	Assertions.fail(String.format(	×
100	"An exception was thrown while testing the class (new instance) '%s' with '%s': '%s'",
UNCOV 101	constructor.getName(), Arrays.toString(values), e.toString()));	×
102	}
103	}
UNCOV 104	return null;	×
105	}
106
107	/**
108	* Create an instance using Lombok's builder pattern.
109	*
110	* @param clazz
111	* the class to instantiate
112	* @param builderMethod
113	* the builder method
114	* @return the instance created via builder
115	* @throws IllegalAccessException
116	* the illegal access exception
117	* @throws IllegalArgumentException
118	* the illegal argument exception
119	* @throws InvocationTargetException
120	* the invocation target exception
121	* @throws NoSuchMethodException
122	* the no such method exception
123	* @throws SecurityException
124	* the security exception
125	*/
126	@SuppressWarnings("unchecked")
127	private T createInstanceWithBuilder(final Class<T> clazz, final Method builderMethod) throws IllegalAccessException,
128	IllegalArgumentException, InvocationTargetException, NoSuchMethodException, SecurityException {
129	// Invoke the builder() method to get a builder instance
130	final T builder = (T) builderMethod.invoke(null);	1✔
131	// Find the build() method on the builder
132	Method buildMethod = builder.getClass().getMethod("build");	1✔
133	// Invoke build() to create the instance
134	return (T) buildMethod.invoke(builder);	1✔
135	}
136
137	/**
138	* Builds the value.
139	*
140	* @param <R>
141	* the generic type
142	* @param returnType
143	* the return type
144	* @param loadType
145	* the load type
146	*
147	* @return the object
148	*/
149	public <R> Object buildValue(final Class<R> returnType, final LoadType loadType) {
150	final ValueBuilder valueBuilder = new ValueBuilder();	1✔
151	valueBuilder.setLoadData(LoadData.ON);	1✔
152	return valueBuilder.buildValue(returnType, loadType);	1✔
153	}
154
155	}

hazendaz / javabean-tester / 3227

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