private boolean isMyServiceRunning(Class<?> serviceClass) { ActivityManager manager = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE); for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE)) { if (serviceClass.getName().equals(service.service.getClassName())) { return true; } } return false; }
/** * Returns human readable string representation of {@code type}. * * <p>The format is subject to change. */ static String toString(Type type) { return (type instanceof Class) ? ((Class<?>) type).getName() : type.toString(); }
@Override public String toString() { return String.format("%s.%s() %s", method.getDeclaringClass().getName(), method.getName(), arguments); } }
@Override public String toString() { return clazz.getName() + " " + name; } }
@Override public String toString() { return clazz.getName() + " " + name; } }
/** * Returns the package name of {@code clazz} according to the Java Language Specification (section * 6.7). Unlike {@link Class#getPackage}, this method only parses the class name, without * attempting to define the {@link Package} and hence load files. */ public static String getPackageName(Class<?> clazz) { return getPackageName(clazz.getName()); }
@SuppressWarnings("unchecked") static Class<? extends Annotation> getAnnotationType(AnnotationFormatterFactory<? extends Annotation> factory) { Class<? extends Annotation> annotationType = (Class<? extends Annotation>) GenericTypeResolver.resolveTypeArgument(factory.getClass(), AnnotationFormatterFactory.class); if (annotationType == null) { throw new IllegalArgumentException("Unable to extract parameterized Annotation type argument from " + "AnnotationFormatterFactory [" + factory.getClass().getName() + "]; does the factory parameterize the <A extends Annotation> generic type?"); } return annotationType; }
@Override public void destroy() { if (this.loadTimeWeaver instanceof InstrumentationLoadTimeWeaver) { if (logger.isDebugEnabled()) { logger.debug("Removing all registered transformers for class loader: " + this.loadTimeWeaver.getInstrumentableClassLoader().getClass().getName()); } ((InstrumentationLoadTimeWeaver) this.loadTimeWeaver).removeTransformers(); } }
@Override public boolean apply(StackTraceElement element) { return element.getClassName().equals(clazz.getName()); } };
/** * Report a ProtocolViolationException with a personalized message referencing * the simple type name of the consumer class and report it via * RxJavaPlugins.onError. * @param consumer the class of the consumer */ public static void reportDoubleSubscription(Class<?> consumer) { RxJavaPlugins.onError(new ProtocolViolationException(composeMessage(consumer.getName()))); } }
private void runTestMethod(ClassLoader classLoader) throws Exception { Class<?> test = classLoader.loadClass(FuturesTest.class.getName()); Object testInstance = test.newInstance(); test.getMethod("setUp").invoke(testInstance); test.getMethod(getName()).invoke(testInstance); test.getMethod("tearDown").invoke(testInstance); }
private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName) throws Exception { // Make sure we are actually running with the expected helper implementation Class<?> abstractFutureClass = classLoader.loadClass(AbstractFuture.class.getName()); Field helperField = abstractFutureClass.getDeclaredField("ATOMIC_HELPER"); helperField.setAccessible(true); assertEquals(expectedHelperClassName, helperField.get(null).getClass().getSimpleName()); }
private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName) throws Exception { // Make sure we are actually running with the expected helper implementation Class<?> abstractFutureClass = classLoader.loadClass(AggregateFutureState.class.getName()); Field helperField = abstractFutureClass.getDeclaredField("ATOMIC_HELPER"); helperField.setAccessible(true); assertEquals(expectedHelperClassName, helperField.get(null).getClass().getSimpleName()); }
private static ResourceInfo resourceInfo(Class<?> cls) { String resource = cls.getName().replace('.', '/') + ".class"; ClassLoader loader = cls.getClassLoader(); return ResourceInfo.of(resource, loader); }
private static ClassPath.ClassInfo findClass( Iterable<ClassPath.ClassInfo> classes, Class<?> cls) { for (ClassPath.ClassInfo classInfo : classes) { if (classInfo.getName().equals(cls.getName())) { return classInfo; } } throw new AssertionError("failed to find " + cls); }
private void checkStackTrace(ExecutionException e) { // Our call site for get() should be in the trace. int index = findStackFrame(e, getClass().getName(), "getExpectingExecutionException"); assertThat(index).isNotEqualTo(0); // Above our method should be the call to get(). Don't assert on the class // because it could be some superclass. assertThat(e.getStackTrace()[index - 1].getMethodName()).isEqualTo("get"); }
public void testToString() { assertEquals(int[].class.getName(), Types.toString(int[].class)); assertEquals(int[][].class.getName(), Types.toString(int[][].class)); assertEquals(String[].class.getName(), Types.toString(String[].class)); Type elementType = List.class.getTypeParameters()[0]; assertEquals(elementType.toString(), Types.toString(elementType)); }
public <T> void testToString() { assertEquals(String.class.getName(), new TypeToken<String>() {}.toString()); assertEquals("T", TypeToken.of(new TypeCapture<T>() {}.capture()).toString()); assertEquals("java.lang.String", new Entry<String, Integer>() {}.keyType().toString()); }
public void testGetPackageName() throws Exception { assertEquals("java.lang", Reflection.getPackageName(Iterable.class)); assertEquals("java", Reflection.getPackageName("java.MyType")); assertEquals("java.lang", Reflection.getPackageName(Iterable.class.getName())); assertEquals("", Reflection.getPackageName("NoPackage")); assertEquals("java.util", Reflection.getPackageName(Map.Entry.class)); }