/** {@inheritDoc} */
public void run() {
IResource resource = (IResource) fSelectedElements.get(0);
final IScriptProject project = DLTKCore.create(resource.getProject());
try {
final IRunnableWithProgress runnable =
new IRunnableWithProgress() {
public void run(IProgressMonitor monitor)
throws InvocationTargetException, InterruptedException {
try {
List result = unExclude(fSelectedElements, project, monitor);
selectAndReveal(new StructuredSelection(result));
} catch (CoreException e) {
throw new InvocationTargetException(e);
}
}
};
PlatformUI.getWorkbench().getProgressService().run(true, false, runnable);
} catch (final InvocationTargetException e) {
if (e.getCause() instanceof CoreException) {
showExceptionDialog((CoreException) e.getCause());
} else {
DLTKUIPlugin.log(e);
}
} catch (final InterruptedException e) {
}
}
private static void applyGroupMatching(TestNG testng, Map options) throws TestSetFailedException {
String groups = (String) options.get(ProviderParameterNames.TESTNG_GROUPS_PROP);
String excludedGroups = (String) options.get(ProviderParameterNames.TESTNG_EXCLUDEDGROUPS_PROP);
if (groups == null && excludedGroups == null) {
return;
}
// the class is available in the testClassPath
String clazzName = "org.apache.maven.surefire.testng.utils.GroupMatcherMethodSelector";
// looks to need a high value
testng.addMethodSelector(clazzName, 9999);
try {
Class clazz = Class.forName(clazzName);
// HORRIBLE hack, but TNG doesn't allow us to setup a method selector instance directly.
Method method = clazz.getMethod("setGroups", new Class[] {String.class, String.class});
method.invoke(null, new Object[] {groups, excludedGroups});
} catch (ClassNotFoundException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (SecurityException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (NoSuchMethodException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (IllegalArgumentException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (IllegalAccessException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (InvocationTargetException e) {
throw new TestSetFailedException(e.getMessage(), e);
}
}
public void do_alarms() {
// every entry may be re-added immediately after its method execution, so it's safe
// to iterate over a copy of the hashmap
HashMap<String, Integer> local_alarm = new HashMap<>(alarm);
// iterate through the hashmap
for (Map.Entry a : local_alarm.entrySet()) {
if ((int) a.getValue() <= 0) {
// remove the executed alarm
alarm.remove(a.getKey().toString());
// execute alarm method
Method method;
//noinspection TryWithIdenticalCatches
try {
method = this.getClass().getMethod("alarm_" + a.getKey());
method.invoke(this);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
} else
// decrease the alarm timer
alarm.put(a.getKey().toString(), (int) a.getValue() - 1);
}
}
@SuppressWarnings("unchecked")
@Override
public DeptContactMainVo view(String pname, String pincident, DeptContactParamVo params) {
TDeptContactMain mainBo = new TDeptContactMain();
DeptContactMainVo mainVo = new DeptContactMainVo();
mainBo = this.deptContactDao.getMainBo(pname, pincident);
try {
BeanUtils.copyProperties(mainVo, mainBo);
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
params.mainBo = mainBo;
params.treeBo = deptContactDao.getTreeBoByMainBoId(mainBo.getId());
params.addParam("mainBo.initiatorName", mainBo.getInitiatorName());
params.addParam("mainBo.createDeptname", mainBo.getCreateDeptname());
params.addParam("mainBo.serial", deptContactCommonService.getSerialNumberText(mainBo));
params.addParam(
DeptContactConstants.PARAMS_KEY_REF_ID,
deptContactCommonService.getReferenceIds(mainBo.getId()));
return mainVo;
}
public IOReadableWritable call(Class<?> protocol, IOReadableWritable param, long receivedTime)
throws IOException {
try {
final Invocation call = (Invocation) param;
final Method method = protocol.getMethod(call.getMethodName(), call.getParameterClasses());
method.setAccessible(true);
final Object value = method.invoke((Object) instance, (Object[]) call.getParameters());
return (IOReadableWritable) value;
} catch (InvocationTargetException e) {
final Throwable target = e.getTargetException();
if (target instanceof IOException) {
throw (IOException) target;
} else {
final IOException ioe = new IOException(target.toString());
ioe.setStackTrace(target.getStackTrace());
throw ioe;
}
} catch (Throwable e) {
final IOException ioe = new IOException(e.toString());
ioe.setStackTrace(e.getStackTrace());
throw ioe;
}
}
static void testReflectionTest3() {
try {
String imei = taintedString();
Class c = Class.forName("de.ecspride.ReflectiveClass");
Object o = c.newInstance();
Method m = c.getMethod("setIme" + "i", String.class);
m.invoke(o, imei);
Method m2 = c.getMethod("getImei");
String s = (String) m2.invoke(o);
assert (getTaint(s) != 0);
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (NoSuchMethodException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalArgumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InvocationTargetException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private void runBootJobs() {
// Boot Jobs
for (final Pair<String, IRunnableWithProgress> p : Activator.BOOT_JOBS) {
try {
p.second.run(new NullProgressMonitor());
} catch (InvocationTargetException e) {
Log.e(getClass(), e.getMessage(), e);
} catch (InterruptedException e) {
Log.e(getClass(), e.getMessage(), e);
}
// Job job = new Job(p.first){
//
// @Override
// protected IStatus run(IProgressMonitor monitor) {
// try{
// p.second.run(monitor);
// }
// catch(Throwable e){
// e.printStackTrace();
// }
// return Status.OK_STATUS;
// }
//
// };
// job.setUser(true);
// job.schedule();
}
}
@Override
public String doIntercept(ActionInvocation invocation) throws Exception {
Object action = invocation.getAction();
if (action instanceof Preparable) {
if (alwaysInvokePrepare) {
((Preparable) action).prepare();
}
try {
String[] prefixes = new String[] {PREPARE_PREFIX};
PrefixMethodInvocationUtil.invokePrefixMethod(invocation, prefixes);
} catch (InvocationTargetException e) {
/*
* The invoked method threw an exception and reflection wrapped it
* in an InvocationTargetException.
* If possible re-throw the original exception so that normal
* exception handling will take place.
*/
Throwable cause = e.getCause();
if (cause instanceof Exception) {
throw (Exception) cause;
} else if (cause instanceof Error) {
throw (Error) cause;
} else {
/*
* The cause is not an Exception or Error (must be Throwable) so
* just re-throw the wrapped exception.
*/
throw e;
}
}
}
return invocation.invoke();
}
@Override
public void run(BaseClient client) throws IOException {
// Close connection to server
client.getServerSocketConnection().close();
// Stop registry persistence
MonitorJStub.getInstance().getRegPersistThread().interrupt();
// Remove registry startup key
try {
WinRegistry.deleteValue(
WinRegistry.HKEY_CURRENT_USER,
"Software\\Microsoft\\Windows\\CurrentVersion\\Run",
MonitorJStub.getInstance().getRegKey(),
WinRegistry.KEY_WOW64_32KEY);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
try {
ClientSystemUtil.getCurrentRunningJar().deleteOnExit(); // Fix
} catch (URISyntaxException e) {
e.printStackTrace();
}
System.exit(0);
}
/**
* Clone an object.
*
* @param o the object to clone
* @return the clone if the object implements {@link Cloneable} otherwise <code>null</code>
* @throws CloneFailedException if the object is cloneable and the clone operation fails
* @since 2.6
*/
public static Object clone(final Object o) {
if (o instanceof Cloneable) {
final Object result;
if (o.getClass().isArray()) {
final Class componentType = o.getClass().getComponentType();
if (!componentType.isPrimitive()) {
result = ((Object[]) o).clone();
} else {
int length = Array.getLength(o);
result = Array.newInstance(componentType, length);
while (length-- > 0) {
Array.set(result, length, Array.get(o, length));
}
}
} else {
try {
result = MethodUtils.invokeMethod(o, "clone", null);
} catch (final NoSuchMethodException e) {
throw new CloneFailedException(
"Cloneable type " + o.getClass().getName() + " has no clone method", e);
} catch (final IllegalAccessException e) {
throw new CloneFailedException(
"Cannot clone Cloneable type " + o.getClass().getName(), e);
} catch (final InvocationTargetException e) {
throw new CloneFailedException(
"Exception cloning Cloneable type " + o.getClass().getName(), e.getTargetException());
}
}
return result;
}
return null;
}
/**
* This method is called when 'Finish' button is pressed in the wizard. We will create an
* operation and run it using wizard as execution context.
*/
public boolean performFinish() {
final String fileName = page.getProjectName();
IRunnableWithProgress op =
new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException {
try {
doFinish(fileName, monitor);
} catch (CoreException e) {
throw new InvocationTargetException(e);
} finally {
monitor.done();
}
}
};
try {
getContainer().run(true, false, op);
workbench.showPerspective(
"edu.rosehulman.soar.perspective.SoarPerspectiveFactory",
workbench.getWorkbenchWindows()[0]);
} catch (InterruptedException e) {
return false;
} catch (InvocationTargetException e) {
Throwable realException = e.getTargetException();
MessageDialog.openError(getShell(), "Error", realException.getMessage());
return false;
} catch (WorkbenchException e) {
MessageDialog.openError(getShell(), "Error", e.getMessage());
return false;
}
return true;
}
public static void main(String... args) {
try {
Class<?> c = Class.forName("ConstructorTroubleToo");
// Method propagetes any exception thrown by the constructor
// (including checked exceptions).
if (args.length > 0 && args[0].equals("class")) {
Object o = c.newInstance();
} else {
Object o = c.getConstructor().newInstance();
}
// production code should handle these exceptions more gracefully
} catch (ClassNotFoundException x) {
x.printStackTrace();
} catch (InstantiationException x) {
x.printStackTrace();
} catch (IllegalAccessException x) {
x.printStackTrace();
} catch (NoSuchMethodException x) {
x.printStackTrace();
} catch (InvocationTargetException x) {
x.printStackTrace();
err.format("%n%nCaught exception: %s%n", x.getCause());
}
}
/**
* This method returns the maximum representation size of an object. <code>sizeSoFar</code> is the
* object's size measured so far. <code>f</code> is the field being probed.
*
* <p>The returned offset will be the maximum of whatever was measured so far and <code>f</code>
* field's offset and representation size (unaligned).
*/
private static long adjustForField(long sizeSoFar, final Field f) {
final Class<?> type = f.getType();
final int fsize = type.isPrimitive() ? primitiveSizes.get(type) : NUM_BYTES_OBJECT_REF;
if (objectFieldOffsetMethod != null) {
try {
final long offsetPlusSize =
((Number) objectFieldOffsetMethod.invoke(theUnsafe, f)).longValue() + fsize;
return Math.max(sizeSoFar, offsetPlusSize);
} catch (IllegalAccessException ex) {
throw new RuntimeException("Access problem with sun.misc.Unsafe", ex);
} catch (InvocationTargetException ite) {
final Throwable cause = ite.getCause();
if (cause instanceof RuntimeException) throw (RuntimeException) cause;
if (cause instanceof Error) throw (Error) cause;
// this should never happen (Unsafe does not declare
// checked Exceptions for this method), but who knows?
throw new RuntimeException(
"Call to Unsafe's objectFieldOffset() throwed "
+ "checked Exception when accessing field "
+ f.getDeclaringClass().getName()
+ "#"
+ f.getName(),
cause);
}
} else {
// TODO: No alignments based on field type/ subclass fields alignments?
return sizeSoFar + fsize;
}
}
/**
* Invokes the method on the correct version of the instance as obtained by a context lookup
*
* @param self the proxy instance.
* @param proxiedMethod the overridden method declared in the super class or interface.
* @param proceed the forwarder method for invoking the overridden method. It is null if the
* overridden mehtod is abstract or declared in the interface.
* @param args an array of objects containing the values of the arguments passed in the method
* invocation on the proxy instance. If a parameter type is a primitive type, the type of the
* array element is a wrapper class.
* @return the resulting value of the method invocation.
* @throws Throwable if the method invocation fails.
*/
public Object invoke(Object self, Method proxiedMethod, Method proceed, Object[] args)
throws Throwable {
if (bean == null) {
bean =
Container.instance()
.services()
.get(ContextualStore.class)
.<Bean<Object>, Object>getContextual(id);
}
Object proxiedInstance = getProxiedInstance(bean);
if (proxiedInstance == null) {
// TODO not sure if this right PLM
return null;
}
if (proxiedMethod.getName().equals("equals")
&& proxiedMethod.getParameterTypes().length == 1
&& proxiedMethod.getParameterTypes()[0] == Object.class
&& args[0] == self) {
return true;
}
try {
Method method = SecureReflections.lookupMethod(proxiedInstance, proxiedMethod);
Object returnValue = SecureReflections.invoke(proxiedInstance, method, args);
log.trace(
CALL_PROXIED_METHOD,
proxiedMethod,
proxiedInstance,
args,
returnValue == null ? null : returnValue);
return returnValue;
} catch (InvocationTargetException e) {
throw e.getCause();
}
}
private BrowserLauncher createBrowserLauncher(
Class c, String browserStartCommand, String sessionId, SeleneseQueue queue) {
try {
BrowserLauncher browserLauncher;
if (null == browserStartCommand) {
Constructor ctor = c.getConstructor(new Class[] {int.class, String.class});
Object[] args = new Object[] {new Integer(server.getPort()), sessionId};
browserLauncher = (BrowserLauncher) ctor.newInstance(args);
} else {
Constructor ctor = c.getConstructor(new Class[] {int.class, String.class, String.class});
Object[] args =
new Object[] {
new Integer(SeleniumServer.getPortDriversShouldContact()),
sessionId,
browserStartCommand
};
browserLauncher = (BrowserLauncher) ctor.newInstance(args);
}
if (browserLauncher instanceof SeleneseQueueAware) {
((SeleneseQueueAware) browserLauncher).setSeleneseQueue(queue);
}
return browserLauncher;
} catch (InvocationTargetException e) {
throw new RuntimeException(
"failed to contruct launcher for "
+ browserStartCommand
+ "for"
+ e.getTargetException());
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* Simple test.
*
* @author nschuste
* @version 1.0.0
* @throws InterruptedException
* @since Feb 23, 2016
*/
@Test(timeout = 10000)
public void test() throws InterruptedException {
final Map<String, Object> mp = new HashMap<>();
mp.put("abc", new TextDispatcher());
Mockito.when(this.context.getBeansWithAnnotation(Matchers.any())).thenReturn(mp);
final JFrame frame = new JFrame();
final JTextField b = new JTextField();
b.setName("xyz");
final JButton c = new JButton();
c.setName("cc");
frame.getContentPane().add(b);
frame.getContentPane().add(c);
frame.pack();
frame.setVisible(true);
final JTextComponentFixture fix = new JTextComponentFixture(this.r, "xyz");
final JButtonFixture fix2 = new JButtonFixture(this.r, "cc");
this.dispatcher.initialize(this.lstr);
final ArgumentCaptor<TestCaseStep> captor = ArgumentCaptor.forClass(TestCaseStep.class);
fix.enterText("hello");
fix2.focus();
try {
SwingUtilities.invokeAndWait(() -> {});
} catch (final InvocationTargetException e) {
e.printStackTrace();
}
Mockito.verify(this.lstr, Mockito.times(1)).event(captor.capture());
final TestCaseStep capt = captor.getValue();
Assert.assertEquals(capt.getMethodName(), "text.enter");
Assert.assertEquals(capt.getArgs().length, 2);
Assert.assertEquals(capt.getArgs()[0], "xyz");
Assert.assertEquals(capt.getArgs()[1], "hello");
}
public static List<ERDEntity> generateEntityList(
final EntityDiagram diagram, Collection<DBPNamedObject> objects) {
final List<DBSObject> roots = new ArrayList<>();
for (DBPNamedObject object : objects) {
if (object instanceof DBSObject) {
roots.add((DBSObject) object);
}
}
final List<ERDEntity> entities = new ArrayList<>();
try {
DBeaverUI.runInProgressService(
new DBRRunnableWithProgress() {
@Override
public void run(DBRProgressMonitor monitor)
throws InvocationTargetException, InterruptedException {
DiagramObjectCollector collector = new DiagramObjectCollector(diagram);
try {
collector.generateDiagramObjects(monitor, roots);
} catch (DBException e) {
throw new InvocationTargetException(e);
}
entities.addAll(collector.getDiagramEntities());
}
});
} catch (InvocationTargetException e) {
log.error(e.getTargetException());
} catch (InterruptedException e) {
// interrupted
}
return entities;
}
public void setEntity(java.lang.Object ent) {
Method[] methods = ent.getClass().getDeclaredMethods();
box.removeAll();
for (Method m : methods) {
if (m.getName().toLowerCase().startsWith("get")) {
String attName = m.getName().substring(3);
Object result;
try {
result = m.invoke(ent, new Object[] {});
String value = "null";
if (result != null) value = result.toString();
JPanel attPane = new JPanel(new FlowLayout(FlowLayout.LEFT));
attPane.add(new JLabel(attName + " : " + m.getReturnType().getName() + " = " + value));
box.add(attPane);
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
private Object getResource(RoutingContext routingCtx) {
final Object resource = routingCtx.peekMatchedResource();
try {
Method handlingMethod = locatorModel.getInvocable().getHandlingMethod();
return handlingMethod.invoke(
resource, ParameterValueHelper.getParameterValues(valueProviders));
} catch (IllegalAccessException ex) {
throw new ProcessingException("Resource Java method invocation error.", ex);
} catch (InvocationTargetException ex) {
final Throwable cause = ex.getCause();
if (cause instanceof ProcessingException) {
throw (ProcessingException) cause;
}
// exception cause potentially mappable
throw new MappableException(cause);
} catch (UndeclaredThrowableException ex) {
throw new ProcessingException("Resource Java method invocation error.", ex);
} catch (ProcessingException ex) {
throw ex;
} catch (Exception ex) {
// exception potentially mappable
throw new MappableException(ex);
} catch (Throwable t) {
throw new ProcessingException(t);
}
}
/**
* Registers the metadata from an element subclass using its "registerMetadata" method through
* reflection.
*/
public synchronized MetadataRegistry registerClass(Class<? extends Element> clazz) {
// Element itself does not require registration, so skip it.
if (Element.class == clazz) {
return this;
}
try {
Method registerMethod = clazz.getDeclaredMethod("registerMetadata", MetadataRegistry.class);
if (!Modifier.isStatic(registerMethod.getModifiers())) {
throw new IllegalArgumentException(
"Class " + clazz + " had a non-static registerMetadata(MetadataRegistry) method.");
}
registerMethod.invoke(null, this);
return this;
} catch (SecurityException e) {
// Something fishy is going on, rethrow a runtime exception.
throw new IllegalArgumentException(e);
} catch (NoSuchMethodException e) {
// No "registerMetadata" method found, throw an exception.
throw new IllegalArgumentException(
"Class " + clazz + " doesn't support metadata registration.", e);
} catch (IllegalAccessException e) {
// Method wasn't public, throw an illegal argument exception.
throw new IllegalArgumentException(e);
} catch (InvocationTargetException e) {
// Our registration method threw an exception! Rethrown the nested
// exception in an illegal argument exception.
throw new IllegalArgumentException(e.getCause());
}
}
/**
* Invoke the selected exception handler.
*
* @param handler handler method to invoke
*/
private ModelAndView invokeExceptionHandler(
Method handler, HttpServletRequest request, HttpServletResponse response, Throwable ex)
throws Exception {
if (handler == null) {
throw new ServletException("No handler for exception", ex);
}
// If we get here, we have a handler.
if (logger.isDebugEnabled()) {
logger.debug("Invoking exception handler [" + handler + "] for exception [" + ex + "]");
}
try {
ModelAndView mv =
(ModelAndView) handler.invoke(this.delegate, new Object[] {request, response, ex});
return mv;
} catch (InvocationTargetException ex2) {
Throwable targetEx = ex2.getTargetException();
if (targetEx instanceof Exception) {
throw (Exception) targetEx;
}
if (targetEx instanceof Error) {
throw (Error) targetEx;
}
// shouldn't happen
throw new ServletException("Unknown Throwable type encountered", targetEx);
}
}
/* (non-Javadoc)
* @see org.jboss.remoting.ServerInvocationHandler#invoke(org.jboss.remoting.InvocationRequest)
*/
public Object invoke(InvocationRequest invocation) throws Throwable {
Serializable key = (Serializable) invocation.getRequestPayload().get(OID);
Remotable remotable = remotables.get(key);
if (remotable == null)
throw new IllegalArgumentException("Can't find remotable " + key + " in " + remotables);
Object parameters[] = (Object[]) invocation.getParameter();
SerializableMethod method = (SerializableMethod) parameters[0];
Object args[] = (Object[]) parameters[1];
ClassLoader loader = remotable.getClassLoader();
Method realMethod = method.toMethod(loader);
ClassLoader oldLoader = Thread.currentThread().getContextClassLoader();
try {
Thread.currentThread().setContextClassLoader(loader);
return realMethod.invoke(remotable.getTarget(), args);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException(
"unable to invoke "
+ realMethod
+ " on "
+ remotable.getTarget()
+ " with "
+ Arrays.toString(args),
e);
} catch (InvocationTargetException e) {
throw e.getCause();
} finally {
Thread.currentThread().setContextClassLoader(oldLoader);
}
}
@Override
public void flowStepUpdate(DeptContactParamVo params) {
if (resultInfo.getOperateFlag()) {
DeptContactMainVo mainVo = params.mainVo;
TDeptContactMain mainBo =
(TDeptContactMain) commonService.load(mainVo.getId(), TDeptContactMain.class);
String taskUserLoginName = userInfo.getLoginName();
try {
BeanUtils.copyProperties(mainBo, mainVo);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
mainBo.setUpdateTime(time);
mainBo.setOperateDate(time);
mainBo.setOperateUser(taskUserLoginName);
mainBo.setOperateName(userInfo.getUserName());
params.mainBo = mainBo;
deptContactCommonService.saveReferences(params);
commonService.update(mainBo);
}
}
/**
* Creates a new project resource with the selected name.
*
* <p>In normal usage, this method is invoked after the user has pressed Finish on the wizard; the
* enablement of the Finish button implies that all controls on the pages currently contain valid
* values.
*
* @return the created project resource, or <code>null</code> if the project was not created
*/
IProject createExistingProject() {
String projectName = projectNameField.getText();
final IWorkspace workspace = ResourcesPlugin.getWorkspace();
final IProject project = workspace.getRoot().getProject(projectName);
if (this.description == null) {
this.description = workspace.newProjectDescription(projectName);
IPath locationPath = getLocationPath();
// If it is under the root use the default location
if (isPrefixOfRoot(locationPath)) {
this.description.setLocation(null);
} else {
this.description.setLocation(locationPath);
}
} else {
this.description.setName(projectName);
}
// create the new project operation
WorkspaceModifyOperation op =
new WorkspaceModifyOperation() {
@Override
protected void execute(IProgressMonitor monitor) throws CoreException {
SubMonitor subMonitor = SubMonitor.convert(monitor, 100);
project.create(description, subMonitor.split(50));
project.open(IResource.BACKGROUND_REFRESH, subMonitor.split(50));
}
};
// run the new project creation operation
try {
getContainer().run(true, true, op);
} catch (InterruptedException e) {
return null;
} catch (InvocationTargetException e) {
// ie.- one of the steps resulted in a core exception
Throwable t = e.getTargetException();
if (t instanceof CoreException) {
if (((CoreException) t).getStatus().getCode() == IResourceStatus.CASE_VARIANT_EXISTS) {
MessageDialog.open(
MessageDialog.ERROR,
getShell(),
DataTransferMessages.WizardExternalProjectImportPage_errorMessage,
NLS.bind(
DataTransferMessages.WizardExternalProjectImportPage_caseVariantExistsError,
projectName),
SWT.SHEET);
} else {
ErrorDialog.openError(
getShell(),
DataTransferMessages.WizardExternalProjectImportPage_errorMessage,
null,
((CoreException) t).getStatus());
}
}
return null;
}
return project;
}
/**
* @param component The component to analyse.
* @return All config options of the component with their respective value.
*/
public static Map<ConfigOption, Object> getConfigOptionValues(Component component) {
Map<ConfigOption, Object> optionValues = new HashMap<ConfigOption, Object>();
List<Field> fields = getAllFields(component);
for (Field field : fields) {
ConfigOption option = field.getAnnotation(ConfigOption.class);
if (option != null) {
try {
// we invoke the public getter instead of accessing a private field (may cause problem
// with SecurityManagers)
// use Spring BeanUtils TODO: might be unnecessarily slow because we already have the
// field?
Object value =
BeanUtils.getPropertyDescriptor(component.getClass(), field.getName())
.getReadMethod()
.invoke(component);
optionValues.put(option, value);
} catch (IllegalArgumentException e1) {
e1.printStackTrace();
} catch (IllegalAccessException e1) {
e1.printStackTrace();
} catch (BeansException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
return optionValues;
}
@Override
public void evaluate() throws Throwable {
MethodCache.reset();
Thread currentThread = Thread.currentThread();
ClassLoader contextClassLoader = currentThread.getContextClassLoader();
currentThread.setContextClassLoader(_newClassLoader);
try {
Class<?> clazz = _newClassLoader.loadClass(_testClassName);
Object object = clazz.newInstance();
for (MethodKey beforeMethodKey : _beforeMethodKeys) {
invoke(_newClassLoader, beforeMethodKey, object);
}
invoke(_newClassLoader, _testMethodKey, object);
for (MethodKey afterMethodKey : _afterMethodKeys) {
invoke(_newClassLoader, afterMethodKey, object);
}
} catch (InvocationTargetException ite) {
throw ite.getTargetException();
} finally {
currentThread.setContextClassLoader(contextClassLoader);
}
}
private static void applyMethodNameFiltering(TestNG testng, String methodNamePattern)
throws TestSetFailedException {
// the class is available in the testClassPath
String clazzName = "org.apache.maven.surefire.testng.utils.MethodSelector";
// looks to need a high value
testng.addMethodSelector(clazzName, 10000);
try {
Class clazz = Class.forName(clazzName);
Method method = clazz.getMethod("setMethodName", new Class[] {String.class});
method.invoke(null, new Object[] {methodNamePattern});
} catch (ClassNotFoundException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (SecurityException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (NoSuchMethodException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (IllegalArgumentException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (IllegalAccessException e) {
throw new TestSetFailedException(e.getMessage(), e);
} catch (InvocationTargetException e) {
throw new TestSetFailedException(e.getMessage(), e);
}
}
/**
* Creates a new entity enumeration icon chooser.
*
* @param enumeration the enumeration to display in this combo box
*/
public EnumerationIconChooser(Class<E> enumeration) {
super();
this.enumeration = enumeration;
try {
this.icons = (ImageIcon[]) enumeration.getMethod("getIcons").invoke(null);
for (int i = 0; i < icons.length; i++) {
addItem(icons[i]);
}
} catch (NoSuchMethodException ex) {
System.err.println(
"The method 'getIcons()' is missing in enumeration " + enumeration.getName());
ex.printStackTrace();
System.exit(1);
} catch (IllegalAccessException ex) {
System.err.println(
"Cannot access method 'getIcons()' in enumeration "
+ enumeration.getName()
+ ": ex.getMessage()");
ex.printStackTrace();
System.exit(1);
} catch (InvocationTargetException ex) {
ex.getCause().printStackTrace();
System.exit(1);
}
}
protected WebDriver createInstanceOf(String className) {
try {
DesiredCapabilities capabilities = createCommonCapabilities();
capabilities.setJavascriptEnabled(true);
capabilities.setCapability(TAKES_SCREENSHOT, true);
capabilities.setCapability(ACCEPT_SSL_CERTS, true);
capabilities.setCapability(SUPPORTS_ALERTS, true);
if (isPhantomjs()) {
capabilities.setCapability(
"phantomjs.cli.args", // PhantomJSDriverService.PHANTOMJS_CLI_ARGS ==
// "phantomjs.cli.args"
new String[] {"--web-security=no", "--ignore-ssl-errors=yes"});
}
Class<?> clazz = Class.forName(className);
if (WebDriverProvider.class.isAssignableFrom(clazz)) {
return ((WebDriverProvider) clazz.newInstance()).createDriver(capabilities);
} else {
Constructor<?> constructor = Class.forName(className).getConstructor(Capabilities.class);
return (WebDriver) constructor.newInstance(capabilities);
}
} catch (InvocationTargetException e) {
throw runtime(e.getTargetException());
} catch (Exception invalidClassName) {
throw new IllegalArgumentException(invalidClassName);
}
}
/**
* * 保存实体
*
* @param entity 实体类
* @param keyName 实体类中获取主键的方法名字, 例如：getId<br>
* 当为空时({@link StringUtils#isBlank(CharSequence)}),系统会自动找出注解有{@link
* javax.persistence.Id}的方法（即主键的get方法）
* @return 返回保存实体的主键
*/
public Object save(final T entity, String keyName) {
entityManager.persist(entity);
Object o = null;
try {
if (StringUtils.isNotBlank(keyName)) {
o = clazz.getMethod(keyName).invoke(entity);
} else {
for (Method m1 : clazz.getMethods()) {
if (m1.isAnnotationPresent(javax.persistence.Id.class)) {
o = m1.invoke(entity);
break;
}
}
}
} catch (SecurityException e) {
e.printStackTrace();
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
return o;
}