java.lang.reflect.Method Java Examples

private static void checkRes(String resName) throws Exception {
    System.out.println("Checking " + resName + "...");
    Class clazz = Class.forName(resName);
    Method m = clazz.getMethod("getContents");
    Object[][] contents = (Object[][])m.invoke(clazz.newInstance());
    Set<String> keys = new HashSet<String>();
    for (Object[] pair: contents) {
        String key = (String)pair[0];
        if (keys.contains(key)) {
            System.out.println("Found dup: " + key);
            throw new Exception();
        }
        checkKey(key);
        keys.add(key);
    }
}
 

private File getClientLib(String discoveryDocString) throws Exception {
  Class<?> clientLibGenerator =
      loader.loadClass("com.google.api.server.spi.tools.CloudClientLibGenerator");
  Method clientLibGeneratorMethod = null;
  clientLibGeneratorMethod = clientLibGenerator.getMethod("generateClientLib",
      String.class, /* discoveryDoc */
      String.class, /* language */
      String.class, /* languageVersion */
      String.class, /* layout */
      File.class /* file */);
  File destFile =
      File.createTempFile("client_lib", ".zip", tmpFolder.getRoot().getAbsoluteFile());
  ArrayList<Object> methodArgs = new ArrayList<Object>();
  methodArgs.add(discoveryDocString);
  methodArgs.add("JAVA");
  methodArgs.add("1.18.0-rc");
  methodArgs.add(null);
  methodArgs.add(destFile);
  Object clientLibGeneratorInstance =
      clientLibGenerator.getMethod("using", String.class).invoke(null, CLIENT_LIB_GENERATOR);
  clientLibGeneratorMethod.invoke(clientLibGeneratorInstance, methodArgs.toArray());
  return destFile;
}
 

/**
 * Processes a method invocation on a proxy instance and returns the
 * result.
 * 
 * @param proxy
 *            the proxy instance that the method was invoked on
 * @param method
 *            the <code>Method</code> instance corresponding to
 *            the interface method invoked on the proxy instance.
 * @param args
 *            an array of objects containing the values of the
 *            arguments passed in the method invocation on the proxy
 *            instance.
 * @return the value to return from the method invocation on the
 *         proxy instance.
 * @throws Throwable
 *             the exception to throw from the method
 *             invocation on the proxy instance.
 * @see InvocationHandler#invoke(Object, Method, Object[])
 */
@Override
public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
    final Class<?> listenerClass = method.getDeclaringClass();
    final List<Object> targets = m_listeners.get(listenerClass);
    if (LengthUtils.isNotEmpty(targets)) {
        final Task task = new Task(targets, method, args);
        switch (m_type) {
            case AsyncUI:
                m_base.runOnUiThread(task);
                break;
            case SeparatedThread:
                new Thread(task).start();
                break;
            case Direct:
            default:
                task.run();
                break;
        }
    }
    return null;
}
 

protected void removeEJBObject(final Method callMethod, final Object[] args, final ThreadContext callContext, final InterfaceType type) throws OpenEJBException {
    callContext.setCurrentOperation(Operation.REMOVE);

    final BeanContext beanContext = callContext.getBeanContext();
    final TransactionPolicy txPolicy = createTransactionPolicy(beanContext.getTransactionType(callMethod, type), callContext);

    EntityBean bean = null;
    try {

        bean = instanceManager.obtainInstance(callContext);

        ejbLoad_If_No_Transaction(callContext, bean);
        bean.ejbRemove();
        didRemove(bean, callContext);
        instanceManager.poolInstance(callContext, bean, callContext.getPrimaryKey());
    } catch (final Throwable e) {
        handleException(txPolicy, e, callContext, bean);
    } finally {
        afterInvoke(txPolicy, callContext);
    }
}
 

/**
 * Calls the {@link TmfAbstractAnalysisModule#executeAnalysis} method of an
 * analysis module. This method does not return until the analysis is
 * completed and it returns the result of the method. It allows to execute
 * the analysis without requiring an Eclipse job and waiting for completion.
 *
 * Note that executing an analysis using this method will not automatically
 * execute the dependent analyses module. The execution of those modules is
 * left to the caller.
 *
 * @param module
 *            The analysis module to execute
 * @return The return value of the
 *         {@link TmfAbstractAnalysisModule#executeAnalysis} method
 */
public static boolean executeAnalysis(IAnalysisModule module) {
    if (module instanceof TmfAbstractAnalysisModule) {
        try {
            Class<?>[] argTypes = new Class[] { IProgressMonitor.class };
            Method method = TmfAbstractAnalysisModule.class.getDeclaredMethod("executeAnalysis", argTypes);
            method.setAccessible(true);
            Boolean result = (Boolean) method.invoke(module, new NullProgressMonitor());
            // Set the module as completed, to avoid another call creating a job
            method = TmfAbstractAnalysisModule.class.getDeclaredMethod("setAnalysisCompleted", new Class[] { } );
            method.setAccessible(true);
            method.invoke(module);
            return result;
        } catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException e) {
            fail(e.toString());
        }
    }
    throw new RuntimeException("This analysis module does not have a protected method to execute. Maybe it can be executed differently? Or it is not supported yet in this method?");
}
 

public void run() {
    for (String name : this.names) {
        Object bean;
        try {
            bean = this.loader.loadClass(name).newInstance();
        } catch (Exception exception) {
            throw new Error("could not instantiate bean: " + name, exception);
        }
        if (this.loader != bean.getClass().getClassLoader()) {
            throw new Error("bean class loader is not equal to default one");
        }
        PropertyDescriptor[] pds = getPropertyDescriptors(bean);
        for (PropertyDescriptor pd : pds) {
            Class type = pd.getPropertyType();
            Method setter = pd.getWriteMethod();
            Method getter = pd.getReadMethod();

            if (type.equals(String.class)) {
                executeMethod(setter, bean, "Foo");
            } else if (type.equals(int.class)) {
                executeMethod(setter, bean, Integer.valueOf(1));
            }
            executeMethod(getter, bean);
        }
    }
}
 

/**
 * 检查方法是否包含一个参数，为StreamObserver
 *
 * @param methodCallProperty 方法
 */
private void checkOneParamHasStreamObServer(MethodCallProperty methodCallProperty) {
    Method method = methodCallProperty.getMethod();
    //判断当前方法是否仅包含一个参数，为StreamObserver。如果不是，抛出异常。
    Type[] types = method.getGenericParameterTypes();
    if (types == null || types.length != 1) {
        throw new GRpcMethodNoMatchException(method.getDeclaringClass().getName(), method.getName(), methodCallProperty.getMethodType().name(),
                "You should use one param [StreamObserver] in your method.Please check it.");
    }
    //检查第一个参数是否为StreamObserver
    Type type = Utils.safeElement(types, 0);
    if (type instanceof ParameterizedType) {
        if (!((ParameterizedType) type).getRawType().getTypeName().equals(StreamObserver.class.getName())) {
            throw new GRpcMethodNoMatchException(method.getDeclaringClass().getName(), method.getName(), methodCallProperty.getMethodType().name(),
                    "You should use one param [StreamObserver] in your method.Please check it.");
        }
    } else {
        if (!type.getTypeName().equals(StreamObserver.class.getName())) {
            throw new GRpcMethodNoMatchException(method.getDeclaringClass().getName(), method.getName(), methodCallProperty.getMethodType().name(),
                    "You should use one param [StreamObserver] in your method.Please check it.");
        }
    }
}
 

@Test
public void testGetPropertySetterMethod() throws Exception {
    Method method = TestReflect.class.getMethod("setS", int.class);
    Assert.assertEquals(method, getPropertySetterMethod(TestReflect.class, "s", int.class));

    method = TestReflect.class.getMethod("setB", boolean.class);
    Assert.assertEquals(method, getPropertySetterMethod(TestReflect.class, "b", boolean.class));

    boolean error = false;
    try {
        getPropertySetterMethod(TestReflect.class, "xxx", String.class);
    } catch (Exception e) {
        error = true;
    }
    Assert.assertTrue(error);
}
 

@RuntimeType
public static List getVertexes(@This final VertexFrame thiz, @Origin final Method method, @RuntimeType @Argument(0) final Class type) {
    assert thiz instanceof CachesReflection;
    final Adjacency annotation = ((CachesReflection) thiz).getReflectionCache().getAnnotation(method, Adjacency.class);
    final Direction direction = annotation.direction();
    final String label = annotation.label();
    final TypeResolver resolver = thiz.getGraph().getTypeResolver();

    return thiz.traverse(input -> {
        switch(direction) {
            case IN:
                return resolver.hasType(input.in(label), type);
            case OUT:
                return resolver.hasType(input.out(label), type);
            case BOTH:
                return resolver.hasType(input.both(label), type);
            default:
                throw new IllegalStateException("Direction not recognized.");
        }
    }).toList(type);
}
 

public static JsonObject getResourceMethodIndexNode(String pathPrefix, Collection<Method> methods, ArgsUriPart args, boolean addPsfQueryParams) throws Exception {
	JsonObject indexNode = new JsonObject();
	if (methods != null) {
		Iterator<Method> it = methods.iterator();
		while (it.hasNext()) {
			Method field = it.next();
			JsonObject methodNode = new JsonObject();
			String resource = joinUri(pathPrefix, args.getMethodTransfilter().transform(field.getName()));
			Set<NamedParameter> queryParams = args.getNamedParameters(field.getName(), true);
			if (addPsfQueryParams) {
				queryParams.addAll(PSFUriPart.SLURPED_NAMED_QUERY_PARAMETERS);
			}
			methodNode.add(JS_QUERY_PARAMS_FIELD, createQueryParameterNode(queryParams));
			methodNode.add(JS_OUT_VO_FIELD, createVOReturnTypeNode(field.getReturnType(), field.getGenericReturnType()));
			indexNode.add(resource, methodNode);
		}
	}
	return indexNode;
}
 

@Test
public void testMatches4() throws Exception {
    Method m1 = I4.class.getMethod("foo");
    Method m2 = C4.class.getMethod("foo");
    Assert.assertTrue(pc.matches(m1, C4.class));
    Assert.assertTrue(pc.matches(m2, C4.class));
    Assert.assertTrue(pc.matches(m1, I4.class));
    Assert.assertTrue(pc.matches(m2, I4.class));

    Assert.assertFalse(map.getByMethodInfo(CachePointcut.getKey(m1, I4.class)).isEnableCacheContext());
    Assert.assertNotNull(map.getByMethodInfo(CachePointcut.getKey(m1, I4.class)).getCachedAnnoConfig());

    Assert.assertTrue(map.getByMethodInfo(CachePointcut.getKey(m1, C4.class)).isEnableCacheContext());
    Assert.assertNotNull(map.getByMethodInfo(CachePointcut.getKey(m1, C4.class)).getCachedAnnoConfig());

    Assert.assertTrue(map.getByMethodInfo(CachePointcut.getKey(m2, I4.class)).isEnableCacheContext());
    Assert.assertNotNull(map.getByMethodInfo(CachePointcut.getKey(m2, I4.class)).getCachedAnnoConfig());

    Assert.assertTrue(map.getByMethodInfo(CachePointcut.getKey(m2, C4.class)).isEnableCacheContext());
    Assert.assertNotNull(map.getByMethodInfo(CachePointcut.getKey(m2, C4.class)).getCachedAnnoConfig());

}
 

private Method getMethod(String name, Class<?>[] parameterTypes, boolean recursivePublicMethods)
        throws NoSuchMethodException {
    if (name == null) {
        throw new NullPointerException("name == null");
    }
    if (parameterTypes == null) {
        parameterTypes = EmptyArray.CLASS;
    }
    for (Class<?> c : parameterTypes) {
        if (c == null) {
            throw new NoSuchMethodException("parameter type is null");
        }
    }
    Method result = recursivePublicMethods ? getPublicMethodRecursive(name, parameterTypes)
                                           : getDeclaredMethodInternal(name, parameterTypes);
    // Fail if we didn't find the method or it was expected to be public.
    if (result == null ||
        (recursivePublicMethods && !Modifier.isPublic(result.getAccessFlags()))) {
        throw new NoSuchMethodException(name + " " + Arrays.toString(parameterTypes));
    }
    return result;
}
 

/** Read resolve to the read object.
 * We give chance to actual instance to do its own resolution as well. It
 * is necessary for achieving back compatability of certain types of settings etc.
 */
private Object readResolve() throws ObjectStreamException {
    SharedClassObject resolved = object;

    Method resolveMethod = findReadResolveMethod(object.getClass());

    if (resolveMethod != null) {
        // invoke resolve method and accept its result
        try {
            // make readResolve accessible (it can have any access modifier)
            resolveMethod.setAccessible(true);

            return resolveMethod.invoke(object);
        } catch (Exception ex) {
            // checked or runtime does not matter - we must survive
            String banner = "Skipping " + object.getClass() + " resolution:"; //NOI18N
            err.log(Level.WARNING, banner, ex);
        } finally {
            resolveMethod.setAccessible(false);
        }
    }

    return resolved;
}
 

private static Method tryFindClientMethod(Object client, String name) {
    // TODO: Cache me.
    for (Method method : client.getClass().getMethods()) {
        if (!method.getName().equals(name)) {
            continue;
        }

        Class<?>[] parameters = method.getParameterTypes();
        if (parameters.length != 1) {
            continue;
        }

        // This is the inverse of the normal approach of findMethod() -
        // we're looking for a method which will accept a specific subtype
        // of AmazonWebServiceRequest, without worrying overmuch about
        // what subtype it is. We'll create an object of the appropriate
        // type and fill it in.
        if (AmazonWebServiceRequest.class.isAssignableFrom(parameters[0])) {
            return method;
        }
    }

    return null;
}
 

/**
 * 引数に存在しないファイルパスを渡した場合_レスポンスボディに空文字列が入ったSC_OKレスポンスが返る.
 */
@Test
public void 引数に存在しないファイルパスを渡した場合_レスポンスボディに空文字列が入ったSC_OKレスポンスが返る() {
    TestLogResource logResource = new TestLogResource();

    try {
        Method method = LogResource.class.getDeclaredMethod("getLog", new Class[] {String.class, String.class });
        method.setAccessible(true);

        String filename = "/non-existing-file-path";
        Object result = method.invoke(logResource, new Object[] {"current", filename });

        assertNotNull(result);
        assertTrue(result instanceof Response);
        assertEquals(HttpStatus.SC_OK, ((Response) result).getStatus());
        assertTrue(((Response) result).getEntity() instanceof String);
        assertEquals(0, ((String) ((Response) result).getEntity()).length());
    } catch (Exception e) {
        e.printStackTrace();
        fail();
    }
}
 

protected Double getProperty(Object bean, String name) {
    try {
        // Get the value of prop
        String prop = "get" + name.substring(0,1).toUpperCase() + name.substring(1);
        Method meth = bean.getClass().getMethod(prop, new Class[0]);
        Object property = meth.invoke(bean, new Object[0]);
        if (meth.getReturnType().equals(Double.TYPE)) {
            return (Double) property;
        } else if (meth.getReturnType().equals(Long.TYPE)) {
            return Double.valueOf(((Long) property).doubleValue());
        } else {
            fail("wrong type: " + meth.getReturnType().getName());
        }
    } catch (NoSuchMethodException nsme) {
        // ignored
    } catch (InvocationTargetException ite) {
        fail(ite.getMessage());
    } catch (IllegalAccessException iae) {
        fail(iae.getMessage());
    }
    return null;
}
 

/**
 * Creates an <TT>EventSetDescriptor</TT> assuming that you are
 * following the most simple standard design pattern where a named
 * event &quot;fred&quot; is (1) delivered as a call on the single method of
 * interface FredListener, (2) has a single argument of type FredEvent,
 * and (3) where the FredListener may be registered with a call on an
 * addFredListener method of the source component and removed with a
 * call on a removeFredListener method.
 *
 * @param sourceClass  The class firing the event.
 * @param eventSetName  The programmatic name of the event.  E.g. &quot;fred&quot;.
 *          Note that this should normally start with a lower-case character.
 * @param listenerType  The target interface that events
 *          will get delivered to.
 * @param listenerMethodName  The method that will get called when the event gets
 *          delivered to its target listener interface.
 * @exception IntrospectionException if an exception occurs during
 *              introspection.
 */
public EventSetDescriptor(Class<?> sourceClass, String eventSetName,
            Class<?> listenerType, String listenerMethodName)
            throws IntrospectionException {
    this(sourceClass, eventSetName, listenerType,
         new String[] { listenerMethodName },
         Introspector.ADD_PREFIX + getListenerClassName(listenerType),
         Introspector.REMOVE_PREFIX + getListenerClassName(listenerType),
         Introspector.GET_PREFIX + getListenerClassName(listenerType) + "s");

    String eventName = NameGenerator.capitalize(eventSetName) + "Event";
    Method[] listenerMethods = getListenerMethods();
    if (listenerMethods.length > 0) {
        Class[] args = getParameterTypes(getClass0(), listenerMethods[0]);
        // Check for EventSet compliance. Special case for vetoableChange. See 4529996
        if (!"vetoableChange".equals(eventSetName) && !args[0].getName().endsWith(eventName)) {
            throw new IntrospectionException("Method \"" + listenerMethodName +
                                             "\" should have argument \"" +
                                             eventName + "\"");
        }
    }
}
 

protected ACC accumulateValues(List<T> values)
		throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
	AggregateFunction<T, ACC> aggregator = getAggregator();
	ACC accumulator = getAggregator().createAccumulator();
	Method accumulateFunc = getAccumulateFunc();
	for (T value : values) {
		if (accumulateFunc.getParameterCount() == 1) {
			accumulateFunc.invoke(aggregator, (Object) accumulator);
		} else if (accumulateFunc.getParameterCount() == 2) {
			accumulateFunc.invoke(aggregator, (Object) accumulator, (Object) value);
		} else {
			throw new TableException("Unsupported now");
		}
	}
	return accumulator;
}
 

@Test
public void allMethodsForwarded() throws Exception {
  ForwardingTestUtil.testMethodsForwarded(
      ManagedChannelBuilder.class,
      mockDelegate,
      testChannelBuilder,
      Collections.<Method>emptyList(),
      new ForwardingTestUtil.ArgumentProvider() {
        @Override
        public Object get(Method method, int argPos, Class<?> clazz) {
          if (method.getName().equals("maxInboundMetadataSize")) {
            assertThat(argPos).isEqualTo(0);
            return 1; // an arbitrary positive number
          }
          return null;
        }
      });
}
 

@Test
public void illegalArgumentException() {
	this.resolvers.add(stubResolver(1));
	Method method = ResolvableMethod.on(TestController.class).mockCall(o -> o.singleArg(null)).method();
	Mono<HandlerResult> mono = invoke(new TestController(), method);

	try {
		mono.block();
		fail("Expected IllegalStateException");
	}
	catch (IllegalStateException ex) {
		assertNotNull("Exception not wrapped", ex.getCause());
		assertTrue(ex.getCause() instanceof IllegalArgumentException);
		assertTrue(ex.getMessage().contains("Controller ["));
		assertTrue(ex.getMessage().contains("Method ["));
		assertTrue(ex.getMessage().contains("with argument values:"));
		assertTrue(ex.getMessage().contains("[0] [type=java.lang.Integer] [value=1]"));
	}
}
 

@Test public void When_Call_OnIllegalMock_Response_With_Custom_Response_Adapter_Adapt_It()
    throws NoSuchMethodException, IOException {
  Method method = Providers.class.getDeclaredMethod("singleResponseMock");
  Rx2Retrofit annotation =
      PlaceholderRetrofitErrorResponseAdapterAnnotation.class.getAnnotation(Rx2Retrofit.class);
  Metadata<Rx2Retrofit> metadata = new Metadata(Providers.class,
      method, null, annotation, method.getGenericReturnType());

  Single single =
      (Single) rx2RetrofitInterceptor.onIllegalMock(new AssertionError("BOOM!"), metadata);
  TestObserver<Response<Mock>> subscriber = single.test();
  subscriber.awaitTerminalEvent();
  subscriber.assertNoErrors();
  subscriber.assertValueCount(1);

  Response<Mock> response = subscriber.values().get(0);
  assertNull(response.body());
  assertThat(response.errorBody().string(), is("{'message':'BOOM!'}"));
}
 

private static Method findMethod(Object instance, String name, Class<?>... parameterTypes)
        throws NoSuchMethodException {
    for (Class<?> clazz = instance.getClass(); clazz != null; clazz = clazz.getSuperclass()) {
        try {
            Method method = clazz.getDeclaredMethod(name, parameterTypes);


            if (!method.isAccessible()) {
                method.setAccessible(true);
            }

            return method;
        } catch (NoSuchMethodException e) {
            // ignore and search next
        }
    }

    throw new NoSuchMethodException("Method " + name + " with parameters " +
            Arrays.asList(parameterTypes) + " not found in " + instance.getClass());
}
 

@Test public void When_Call_Adapt_Type_With_Observable_Response_List_Mock_Then_Unwrap_Its_Value() throws NoSuchMethodException {
  Method method = Providers.class.getDeclaredMethod("observableResponseMocks");

  RxRetrofit annotation = PlaceholderRetrofitAnnotation.class.getAnnotation(RxRetrofit.class);
  Metadata<RxRetrofit> metadata = new Metadata(Providers.class,
      method, null, annotation, method.getGenericReturnType());

  Type methodType = method.getGenericReturnType();
  Type expectedType = Types.newParameterizedType(List.class, Mock.class);

  Type adaptedType = rxRetrofitInterceptor
      .adaptType(methodType, metadata);

  assertEquals(expectedType, adaptedType);
}
 

protected void newWindow(LoggingPreferences lp) {
    try
    {
        Method m = getClass().getMethod("setupDriver"+getSession().browserName, new Class[]{LoggingPreferences.class});
        if(m!=null) {
            m.invoke(this, new Object[]{lp});
        }
        getSession().__wpos__++;
    }
    catch (Exception e)
    {
        throw new RuntimeException("Invalid browser name specified");
    }
}
 

public void testMultiNodeMethodsArg0() throws Exception
{
    runAs("andy");

    Object o = new ClassWithMethods();
    Method method = o.getClass().getMethod("testManyNodeRef",
            new Class[] { NodeRef.class, NodeRef.class, NodeRef.class, NodeRef.class });

    AdvisorAdapterRegistry advisorAdapterRegistry = GlobalAdvisorAdapterRegistry.getInstance();

    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.addAdvisor(advisorAdapterRegistry.wrap(new Interceptor("ACL_NODE.0.sys:base.Read")));
    proxyFactory.setTargetSource(new SingletonTargetSource(o));
    Object proxy = proxyFactory.getProxy();

    method.invoke(proxy, new Object[] { null, null, null, null });

    try
    {
        method.invoke(proxy, new Object[] { rootNodeRef, null, null, null });
        assertNotNull(null);
    }
    catch (InvocationTargetException e)
    {

    }

    permissionService.setPermission(new SimplePermissionEntry(rootNodeRef, getPermission(PermissionService.READ),
            "andy", AccessStatus.ALLOWED));
    method.invoke(proxy, new Object[] { rootNodeRef, null, null, null });
}
 

public boolean matchesMethod(Class<?> clazz, Method method, ScanResult scanResult) {
    if (clazz.getName().equals(className)
            && method.getName().equals(methodName)
            && method.getParameterCount() == parameterTypeSignature.length)
    {
        boolean paramsMatch = true;
        for (int i = 0; i < parameterTypeSignature.length; i++) {
            paramsMatch = paramsMatch && parameterTypeSignature[i].instantiate(scanResult) == method.getParameters()[i].getType();
        }
        return paramsMatch;
    }
    return false;
}
 

private static Map<String, DefaultValueHolder> computeDefaultValues(
		Class<? extends Annotation> annotationType) {

	AttributeMethods methods = AttributeMethods.forAnnotationType(annotationType);
	if (!methods.hasDefaultValueMethod()) {
		return Collections.emptyMap();
	}
	Map<String, DefaultValueHolder> result = new LinkedHashMap<>(methods.size());
	if (!methods.hasNestedAnnotation()) {
		// Use simpler method if there are no nested annotations
		for (int i = 0; i < methods.size(); i++) {
			Method method = methods.get(i);
			Object defaultValue = method.getDefaultValue();
			if (defaultValue != null) {
				result.put(method.getName(), new DefaultValueHolder(defaultValue));
			}
		}
	}
	else {
		// If we have nested annotations, we need them as nested maps
		AnnotationAttributes attributes = MergedAnnotation.of(annotationType)
				.asMap(annotation ->
						new AnnotationAttributes(annotation.getType(), true), Adapt.ANNOTATION_TO_MAP);
		for (Map.Entry<String, Object> element : attributes.entrySet()) {
			result.put(element.getKey(), new DefaultValueHolder(element.getValue()));
		}
	}
	return result;
}
 

/**
 * Registers post condition checks to a method's return value
 *
 * @throws IllegalArgumentException if <code>method == null</code> or <code>checks == null</code> or checks is empty
 * @throws InvalidConfigurationException if the declaring class is not guarded
 */
public void removeChecks(final Method method, final PostCheck... checks) throws InvalidConfigurationException {
   Assert.argumentNotNull("method", method);
   Assert.argumentNotEmpty("checks", checks);

   getClassChecks(method.getDeclaringClass()).removeMethodPostChecks(method, checks);
}
 

private AudioInputStream invokeOpenStream(Synthesizer synthesizer, AudioFormat audioFormat, Map<String, Object> map) throws Throwable {
	Class<?>[] methodSignature = new Class[]{AudioFormat.class,Map.class};
	Object[] methodArguments = new Object[]{audioFormat, map};
	
	Class<?> classInstance = synthesizer.getClass();
	Method method = classInstance.getMethod(SYNTHESIZER_OPEN_STREAM_METHOD, methodSignature);
	Object returnValue = method.invoke(synthesizer, methodArguments);
	
	return (AudioInputStream)returnValue;
}
 

public void click() {
	// cheat to invoke sendSelectionEvent(), which is private
       Class<?>toolItemClass = getClass().getSuperclass().getSuperclass().getSuperclass();	// i.e., Widget class
       Method method;
	try {
		method = toolItemClass.getDeclaredMethod("sendSelectionEvent", int.class, Event.class, boolean.class);
        method.setAccessible(true);
        method.invoke(this, SWT.Selection, new Event(), false);
	} catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
		e.printStackTrace();
	}
}