leeonky / test-charm-java / 156

Committed 20 Mar 2025 01:53PM UTC coverage: 74.243% (-0.2%) from 74.475%

Build # 156

Build Type

push

circleci

Committed by

leeonky

Commit Message

Refactor

Run Details

14 of 15 new or added lines in 12 files covered. (93.33%)

126 existing lines in 29 files now uncovered.

7947 of 10704 relevant lines covered (74.24%)

0.74 hits per line

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

86.79

/bean-util/src/main/java/com/github/leeonky/util/Classes.java

package com.github.leeonky.util;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Constructor;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.*;
import java.util.function.Supplier;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import static com.github.leeonky.util.function.Extension.getFirstPresent;
import static java.util.Collections.emptyList;
import static java.util.stream.Collectors.toList;

public class Classes {
    public static List<Class<?>> allTypesIn(String packageName) {
        return new ArrayList<>(new HashSet<Class<?>>() {{
            try {
                Enumeration<URL> resources = getClassLoader().getResources(packageName.replaceAll("[.]", "/"));
                while (resources.hasMoreElements())
                    addAll(getClasses(packageName, resources.nextElement()));
            } catch (Exception ignore) {
            }
        }});
    }

    private static ClassLoader getClassLoader() {
        return getFirstPresent(() -> classLoader(Thread.currentThread()::getContextClassLoader),
                () -> classLoader(Classes.class::getClassLoader),
                () -> classLoader(ClassLoader::getSystemClassLoader))
                .orElseThrow(IllegalStateException::new);
    }

    private static Optional<ClassLoader> classLoader(Supplier<ClassLoader> factory) {
        ClassLoader classLoader = null;
        try {
            classLoader = factory.get();
        } catch (Throwable ignore) {
        }
        return Optional.ofNullable(classLoader);
    }

    private static List<Class<?>> getClasses(String packageName, URL resource) {
        try {
            if ("jar".equals(resource.getProtocol()))
                return ((JarURLConnection) resource.openConnection()).getJarFile().stream()
                        .map(jarEntry -> jarEntry.getName().replace('/', '.'))
                        .filter(name -> name.endsWith(".class") && name.startsWith(packageName))
                        .map(name -> Sneaky.get(() -> Class.forName(name.substring(0, name.length() - 6))))
                        .collect(toList());
            else {
                InputStream stream = resource.openStream();
                List<String> lines = stream == null ? emptyList()
                        : new BufferedReader(new InputStreamReader(stream)).lines().collect(toList());
                return Stream.concat(lines.stream().filter(line -> !line.endsWith(".class"))
                        .map(subPackage -> allTypesIn(packageName + "." + subPackage))
                        .flatMap(List::stream), lines.stream().filter(line -> line.endsWith(".class"))
                        .map(line -> toClass(line, packageName))).collect(toList());
            }
        } catch (Exception ignore) {
            return emptyList();
        }
    }

    private static Class<?> toClass(String className, String packageName) {
        return Sneaky.get(() -> Class.forName(packageName + "." + className.substring(0, className.lastIndexOf('.'))));
    }

    public static <T> List<Class<? extends T>> subTypesOf(Class<T> superClass, String packageName) {
        return assignableTypesOf(superClass, packageName).stream().filter(c -> !superClass.equals(c))
                .map(c -> (Class<? extends T>) c)
                .collect(toList());
    }

    @SuppressWarnings("unchecked")
    public static <T> List<Class<? extends T>> assignableTypesOf(Class<T> superClass, String packageName) {
        return allTypesIn(packageName).stream().filter(superClass::isAssignableFrom)
                .map(c -> (Class<? extends T>) c)
                .collect(toList());
    }

    public static int compareByExtends(Class<?> type1, Class<?> type2) {
        return type1.equals(type2) ? 0 : type1.isAssignableFrom(type2) ? 1 : -1;
    }

    @SuppressWarnings("unchecked")
    public static <T> T newInstance(Class<T> type, Object... args) {
        return Sneaky.get(() -> (T) chooseConstructor(type, args).newInstance(args));
    }

    private static <T> Constructor<?> chooseConstructor(Class<T> type, Object[] args) {
        List<Constructor<?>> constructors = Stream.of(type.getConstructors())
                .filter(c -> isProperConstructor(c, args))
                .collect(toList());
        if (constructors.size() != 1)
            throw new NoAppropriateConstructorException(type, args);
        return constructors.get(0);
    }

    private static boolean isProperConstructor(Constructor<?> constructor, Object[] parameters) {
        Class<?>[] parameterTypes = constructor.getParameterTypes();
        return parameterTypes.length == parameters.length && IntStream.range(0, parameterTypes.length)
                .allMatch(i -> parameterTypes[i].isInstance(parameters[i]));
    }

    public static String getClassName(Object object) {
        return object == null ? null : object.getClass().getName();
    }

    @SuppressWarnings("unchecked")
    public static <T> Class<? super T> named(Class<T> type) {
        return type.getInterfaces().length > 0 && (type.isAnonymousClass() && type.getSuperclass() == Object.class
                || type.isSynthetic()) ? (Class<? super T>) type.getInterfaces()[0] : type;
    }
}

1	package com.github.leeonky.util;
2
3	import java.io.BufferedReader;
4	import java.io.InputStream;
5	import java.io.InputStreamReader;
6	import java.lang.reflect.Constructor;
7	import java.net.JarURLConnection;
8	import java.net.URL;
9	import java.util.*;
10	import java.util.function.Supplier;
11	import java.util.stream.IntStream;
12	import java.util.stream.Stream;
13
14	import static com.github.leeonky.util.function.Extension.getFirstPresent;
15	import static java.util.Collections.emptyList;
16	import static java.util.stream.Collectors.toList;
17
UNCOV 18	public class Classes {	×
19	public static List<Class<?>> allTypesIn(String packageName) {
20	return new ArrayList<>(new HashSet<Class<?>>() {{	1✔
21	try {
22	Enumeration<URL> resources = getClassLoader().getResources(packageName.replaceAll("[.]", "/"));	1✔
23	while (resources.hasMoreElements())	1✔
24	addAll(getClasses(packageName, resources.nextElement()));	1✔
UNCOV 25	} catch (Exception ignore) {	×
26	}	1✔
27	}});	1✔
28	}
29
30	private static ClassLoader getClassLoader() {
31	return getFirstPresent(() -> classLoader(Thread.currentThread()::getContextClassLoader),	1✔
UNCOV 32	() -> classLoader(Classes.class::getClassLoader),	×
33	() -> classLoader(ClassLoader::getSystemClassLoader))	×
34	.orElseThrow(IllegalStateException::new);	1✔
35	}
36
37	private static Optional<ClassLoader> classLoader(Supplier<ClassLoader> factory) {
38	ClassLoader classLoader = null;	1✔
39	try {
40	classLoader = factory.get();	1✔
UNCOV 41	} catch (Throwable ignore) {	×
42	}	1✔
43	return Optional.ofNullable(classLoader);	1✔
44	}
45
46	private static List<Class<?>> getClasses(String packageName, URL resource) {
47	try {
48	if ("jar".equals(resource.getProtocol()))	1✔
49	return ((JarURLConnection) resource.openConnection()).getJarFile().stream()	1✔
50	.map(jarEntry -> jarEntry.getName().replace('/', '.'))	1✔
51	.filter(name -> name.endsWith(".class") && name.startsWith(packageName))	1✔
52	.map(name -> Sneaky.get(() -> Class.forName(name.substring(0, name.length() - 6))))	1✔
53	.collect(toList());	1✔
54	else {
55	InputStream stream = resource.openStream();	1✔
56	List<String> lines = stream == null ? emptyList()	1✔
57	: new BufferedReader(new InputStreamReader(stream)).lines().collect(toList());	1✔
58	return Stream.concat(lines.stream().filter(line -> !line.endsWith(".class"))	1✔
59	.map(subPackage -> allTypesIn(packageName + "." + subPackage))	1✔
60	.flatMap(List::stream), lines.stream().filter(line -> line.endsWith(".class"))	1✔
61	.map(line -> toClass(line, packageName))).collect(toList());	1✔
62	}
UNCOV 63	} catch (Exception ignore) {	×
64	return emptyList();	×
65	}
66	}
67
68	private static Class<?> toClass(String className, String packageName) {
69	return Sneaky.get(() -> Class.forName(packageName + "." + className.substring(0, className.lastIndexOf('.'))));	1✔
70	}
71
72	public static <T> List<Class<? extends T>> subTypesOf(Class<T> superClass, String packageName) {
73	return assignableTypesOf(superClass, packageName).stream().filter(c -> !superClass.equals(c))	1✔
74	.map(c -> (Class<? extends T>) c)	1✔
75	.collect(toList());	1✔
76	}
77
78	@SuppressWarnings("unchecked")
79	public static <T> List<Class<? extends T>> assignableTypesOf(Class<T> superClass, String packageName) {
80	return allTypesIn(packageName).stream().filter(superClass::isAssignableFrom)	1✔
81	.map(c -> (Class<? extends T>) c)	1✔
82	.collect(toList());	1✔
83	}
84
85	public static int compareByExtends(Class<?> type1, Class<?> type2) {
86	return type1.equals(type2) ? 0 : type1.isAssignableFrom(type2) ? 1 : -1;	1✔
87	}
88
89	@SuppressWarnings("unchecked")
90	public static <T> T newInstance(Class<T> type, Object... args) {
91	return Sneaky.get(() -> (T) chooseConstructor(type, args).newInstance(args));	1✔
92	}
93
94	private static <T> Constructor<?> chooseConstructor(Class<T> type, Object[] args) {
95	List<Constructor<?>> constructors = Stream.of(type.getConstructors())	1✔
96	.filter(c -> isProperConstructor(c, args))	1✔
97	.collect(toList());	1✔
98	if (constructors.size() != 1)	1✔
99	throw new NoAppropriateConstructorException(type, args);	1✔
100	return constructors.get(0);	1✔
101	}
102
103	private static boolean isProperConstructor(Constructor<?> constructor, Object[] parameters) {
104	Class<?>[] parameterTypes = constructor.getParameterTypes();	1✔
105	return parameterTypes.length == parameters.length && IntStream.range(0, parameterTypes.length)	1✔
106	.allMatch(i -> parameterTypes[i].isInstance(parameters[i]));	1✔
107	}
108
109	public static String getClassName(Object object) {
110	return object == null ? null : object.getClass().getName();	1✔
111	}
112
113	@SuppressWarnings("unchecked")
114	public static <T> Class<? super T> named(Class<T> type) {
115	return type.getInterfaces().length > 0 && (type.isAnonymousClass() && type.getSuperclass() == Object.class	1✔
116	\|\| type.isSynthetic()) ? (Class<? super T>) type.getInterfaces()[0] : type;	1✔
117	}
118	}

leeonky / test-charm-java / 156

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