leeonky / test-charm-java / 117

Committed 26 Feb 2025 03:01AM UTC coverage: 74.16% (+0.9%) from 73.251%

Build # 117

Build Type

push

circleci

Committed by

leeonky

Commit Message

Update version

Run Details

7838 of 10569 relevant lines covered (74.16%)

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

leeonky / test-charm-java / 117

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