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; }
/** * Appends the class name to a non-null value. * @param o the object * @return the string representation */ public static String valueAndClass(Object o) { if (o != null) { return o + " (class: " + o.getClass().getSimpleName() + ")"; } return "null"; }
@Override public void configureTlsExtensions( SSLSocket sslSocket, String hostname, List<Protocol> protocols) { List<String> names = alpnProtocolNames(protocols); try { Object alpnProvider = Proxy.newProxyInstance(Platform.class.getClassLoader(), new Class[] {clientProviderClass, serverProviderClass}, new AlpnProvider(names)); putMethod.invoke(null, sslSocket, alpnProvider); } catch (InvocationTargetException | IllegalAccessException e) { throw new AssertionError("failed to set ALPN", e); } }
private static boolean isPresent(String className) { try { Class.forName(className, false, LogAdapter.class.getClassLoader()); return true; } catch (ClassNotFoundException ex) { return false; } }
private static <T> T newProxy(Class<T> interfaceType, InvocationHandler handler) { Object object = Proxy.newProxyInstance( interfaceType.getClassLoader(), new Class<?>[] {interfaceType}, handler); return interfaceType.cast(object); }
private Object readResolve() { try { Class c = Class.forName("java.time.Duration"); Method m = c.getDeclaredMethod("ofSeconds", long.class, long.class); return m.invoke(null, seconds, nanos); } catch (Throwable t) { // ignore } return null; } }
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 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); }
@Test public void testManualProxyJavaWithStaticPointcutAndTwoClassLoaders() throws Exception { LogUserAdvice logAdvice = new LogUserAdvice(); AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut(); pointcut.setExpression(String.format("execution(* %s.TestService.*(..))", getClass().getName())); // Test with default class loader first... testAdvice(new DefaultPointcutAdvisor(pointcut, logAdvice), logAdvice, new TestServiceImpl(), "TestServiceImpl"); // Then try again with a different class loader on the target... SimpleThrowawayClassLoader loader = new SimpleThrowawayClassLoader(new TestServiceImpl().getClass().getClassLoader()); // Make sure the interface is loaded from the parent class loader loader.excludeClass(TestService.class.getName()); loader.excludeClass(TestException.class.getName()); TestService other = (TestService) loader.loadClass(TestServiceImpl.class.getName()).newInstance(); testAdvice(new DefaultPointcutAdvisor(pointcut, logAdvice), logAdvice, other, "TestServiceImpl"); }
private static void ensureSpringRulesAreNotPresent(Class<?> testClass) { for (Field field : testClass.getFields()) { Assert.state(!SpringClassRule.class.isAssignableFrom(field.getType()), () -> String.format( "Detected SpringClassRule field in test class [%s], " + "but SpringClassRule cannot be used with the SpringJUnit4ClassRunner.", testClass.getName())); Assert.state(!SpringMethodRule.class.isAssignableFrom(field.getType()), () -> String.format( "Detected SpringMethodRule field in test class [%s], " + "but SpringMethodRule cannot be used with the SpringJUnit4ClassRunner.", testClass.getName())); } }
protected Object instantiate() throws Exception { try { if (_constructor != null) return _constructor.newInstance(_constructorArgs); else return _type.newInstance(); } catch (Exception e) { throw new HessianProtocolException("'" + _type.getName() + "' could not be instantiated", e); } }
@Override public boolean matches(Method method, Class<?> targetClass) { if (TransactionalProxy.class.isAssignableFrom(targetClass) || PlatformTransactionManager.class.isAssignableFrom(targetClass) || PersistenceExceptionTranslator.class.isAssignableFrom(targetClass)) { return false; } TransactionAttributeSource tas = getTransactionAttributeSource(); return (tas == null || tas.getTransactionAttribute(method, targetClass) != null); }
private static ResourceInfo resourceInfo(Class<?> cls) { String resource = cls.getName().replace('.', '/') + ".class"; ClassLoader loader = cls.getClassLoader(); return ResourceInfo.of(resource, loader); }
private static Class<?> getCommandClass(String request) { Class<?> result; try { result = Class.forName("com.iluwatar.front.controller." + request + "Command"); } catch (ClassNotFoundException e) { result = UnknownCommand.class; } return result; } }
public CertificateChainCleaner buildCertificateChainCleaner(X509TrustManager trustManager) { try { Class<?> extensionsClass = Class.forName("android.net.http.X509TrustManagerExtensions"); Constructor<?> constructor = extensionsClass.getConstructor(X509TrustManager.class); Object extensions = constructor.newInstance(trustManager); Method checkServerTrusted = extensionsClass.getMethod( "checkServerTrusted", X509Certificate[].class, String.class, String.class); return new AndroidCertificateChainCleaner(extensions, checkServerTrusted); } catch (Exception e) { throw new AssertionError(e); } }
public void setStatLoggerClassName(String className) { Class<?> clazz; try { clazz = Class.forName(className); DruidDataSourceStatLogger statLogger = (DruidDataSourceStatLogger) clazz.newInstance(); this.setStatLogger(statLogger); } catch (Exception e) { throw new IllegalArgumentException(className, e); } }
@Override public SubscriberInfo getSuperSubscriberInfo() { if(superSubscriberInfoClass == null) { return null; } try { return superSubscriberInfoClass.newInstance(); } catch (InstantiationException e) { throw new RuntimeException(e); } catch (IllegalAccessException e) { throw new RuntimeException(e); } }
private static boolean isZoneId(Class cl) { try { return isJava8() && Class.forName("java.time.ZoneId").isAssignableFrom(cl); } catch (ClassNotFoundException e) { // ignore } return false; }
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)); }
@Override public boolean isCleartextTrafficPermitted(String hostname) { try { Class<?> networkPolicyClass = Class.forName("android.security.NetworkSecurityPolicy"); Method getInstanceMethod = networkPolicyClass.getMethod("getInstance"); Object networkSecurityPolicy = getInstanceMethod.invoke(null); return api24IsCleartextTrafficPermitted(hostname, networkPolicyClass, networkSecurityPolicy); } catch (ClassNotFoundException | NoSuchMethodException e) { return super.isCleartextTrafficPermitted(hostname); } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { throw new AssertionError("unable to determine cleartext support", e); } }