Java Statement.execute方法代码示例

import java.beans.Statement; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static <E> void setMethodValue(E obj, Method method, Object... args) {
	try {
		method.setAccessible(true);

		method.invoke(obj, args);

	} catch (InvocationTargetException | IllegalAccessException | IllegalArgumentException e) {
		// e.printStackTrace();
		try {
			if (obj != null) {
				Statement stmt = new Statement(obj, method.getName(), args);
				stmt.execute();
			}

		} catch (Exception e1) {
			// e1.printStackTrace();
		}
	}
}
 

import java.beans.Statement; //导入方法依赖的package包/类
@Override
public void itemStateChanged(ItemEvent evt) {
    Statement statement = (evt.getStateChange() == ItemEvent.DESELECTED) ? falseStatement
            : trueStatement;

    try {
        statement.execute();
    } catch (Exception ex) {
        LOG.log(Level.FINE,
                "Couldn't execute boolean method via Statement "
                        + statement, ex);
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void itemStateChanged(ItemEvent evt) {
    Statement statement = (evt.getStateChange() == ItemEvent.DESELECTED) ? falseStatement
            : trueStatement;

    try {
        statement.execute();
    } catch (Exception ex) {
        LOG.log(Level.FINE,
                "Couldn't execute boolean method via Statement "
                        + statement, ex);
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
/**
 * The test checks the method execute() for setter
 */
public void testSetter() throws Exception {
    Bean bean = new Bean();
    Statement s = new Statement(bean, "setText", new Object[] { "hello" });
    s.execute();
    assertEquals("hello", bean.getText());
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void testExecute_ProtectedMethodWithPackage() throws Exception {
    DefaultPersistenceDelegate dpd = new DefaultPersistenceDelegate();
    Object[] arguments = new Object[] { "test", "test" };
    Statement t = new Statement(dpd, "mutatesTo", arguments);
    try {
        t.execute();
        fail("Should throw NoSuchMethodException!");
    } catch (NoSuchMethodException e) {
        // expected
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
/**
 * The test checks the method execute() for array setter
 */
public void testArraySetter() throws Exception {
    int[] a = { 1, 2, 3 };
    Statement s = new Statement(a, "set", new Object[] { new Integer(1),
            new Integer(7) });
    s.execute();
    assertEquals(7, a[1]);
}
 

import java.beans.Statement; //导入方法依赖的package包/类
/**
 * The test checks the method execute() for static method
 */
public void testStatic() throws Exception {
    int currentId = getTestId();
    Statement s = new Statement(StatementTest.class, "nextTestId",
            new Object[] {});
    s.execute();
    assertEquals(++currentId, getTestId());
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void testExecute_ArrayInvalidName() throws Exception {
    Object[] array = new Object[] { "test" };
    Statement t = new Statement(array, "gets", new Object[] {
            new Integer(0), new Object() });
    try {
        t.execute();
        fail("Should throw NoSuchMethodException!");
    } catch (NoSuchMethodException ex) {
        // expected
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
/**
 * The test checks the method execute() if exception is thrown on static
 * method call
 */
public void testExceptionThrownOnStaticMethodCall() throws Exception {
    Statement s = new Statement(StatementTest.class, "methodWithException",
            new Object[] {});

    try {
        s.execute();
        fail("Exception must be thrown with methodWithException call");
    } catch (SampleException se) {
        // SampleException is thrown as expected
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void testExecute_ApplicableViaTypeConversion() throws Exception {
    MockObject mo = new MockObject(false);
    // mo.methodB('c');
    Object[] arguments = new Object[] { new Character((char) 1) };
    Statement t = new Statement(mo, "methodB", arguments);
    try {
        t.execute();
        fail("Should throw NoSuchMethodException!");
    } catch (NoSuchMethodException e) {
        // expected
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void testExecute_ExceptionalMethod() throws Exception {
    MockObject mo = new MockObject(false);
    Statement t = new Statement(mo, "method", new Object[] { null, null });
    try {
        t.execute();
        fail("Should throw NullPointerException!");
    } catch (NullPointerException ex) {
        // expected
    }
    MockObject.assertCalled("method4", new Object[] { null, null });
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void testExecute_NonExistingMethod() throws Exception {
    MockObject mo = new MockObject(false);
    Statement t = new Statement(mo, "method_not_existing", new Object[] {
            null, null });
    try {
        t.execute();
        fail("Should throw NoSuchMethodException!");
    } catch (NoSuchMethodException ex) {
        // expected
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void testExecute_NullTarget() throws Exception {
    Statement t = new Statement(null, "method_not_existing", new Object[] {
            null, null });
    try {
        t.execute();
        fail("Should throw NullPointerException!");
    } catch (NullPointerException ex) {
        // expected
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void testExecute_InvalidArguments() throws Exception {
    MockObject mo = new MockObject(false);
    Statement t = new Statement(mo, "method", new Object[] { new Object(),
            new Object(), new Object() });
    try {
        t.execute();
        fail("Should throw NoSuchMethodException!");
    } catch (NoSuchMethodException ex) {
        // expected
    }
}
 

import java.beans.Statement; //导入方法依赖的package包/类
public void testExecute_NormalConstructorNull() throws Exception {
    Object[] arguments = new Object[] { null, null };
    Statement t = new Statement(MockObject.class, "new", arguments);

    try {
        t.execute();
        fail("Should throw NullPointerException!");
    } catch (NullPointerException ex) {
        // expected
    }
    MockObject.assertCalled("new4", arguments);
}