Java GroovyRuntimeException类代码示例

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
@Override
protected Object handleEvaluationException(JRExpression expression, Throwable e) throws JRExpressionEvalException
{
	if (ignoreNPE && e instanceof GroovyRuntimeException && e.getMessage() != null)
	{
		//in Groovy 2.0.1, 1 + null (and other e.g. BigDecimal * null) was throwing NPE
		//in 2.4.3, it fails with "Ambiguous method overloading..."
		//we're catching this exception (by message) and treating it like a NPE
		Matcher matcher = GROOVY_EXCEPTION_PATTERN_AMBIGUOUS_NULL.matcher(e.getMessage());
		if (matcher.matches())
		{
			//evaluating the expression to null to match Groovy 2.0.1 behaviour
			return null;
		}
	}
	
	//throw the exception
	return super.handleEvaluationException(expression, e);
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
private void processException(Throwable exception, String prefix) {
  if (exception instanceof GroovyRuntimeException) {
    addErrorMessage((GroovyRuntimeException) exception);
    return;
  }

  if (forStubs) {
    collector.add(new CompilerMessage(GroovyCompilerMessageCategories.INFORMATION,
                                      GroovyRtConstants.GROOVYC_STUB_GENERATION_FAILED, null, -1, -1));
  }

  final StringWriter writer = new StringWriter();
  writer.append(prefix);
  if (!prefix.endsWith("\n")) {
    writer.append("\n\n");
  }
  //noinspection IOResourceOpenedButNotSafelyClosed
  exception.printStackTrace(new PrintWriter(writer));
  collector.add(new CompilerMessage(forStubs ? GroovyCompilerMessageCategories.INFORMATION : GroovyCompilerMessageCategories.ERROR, writer.toString(), null, -1, -1));
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
private void testFileNameInStackTrace(final String target, final String fileNamePattern) {
    try {
        project.executeTarget(target);
        fail();
    }
    catch (final BuildException e) {
        assertEquals(BuildException.class, e.getClass());
        final Throwable cause = e.getCause();
        assertTrue(cause instanceof GroovyRuntimeException);

        final Writer sw = new StringBuilderWriter();
        cause.printStackTrace(new PrintWriter(sw));
        
        final String stackTrace = sw.toString();
        final Pattern pattern = Pattern.compile(fileNamePattern);
        assertTrue("Does >" + stackTrace + "< contain >" + fileNamePattern + "<?", 
                pattern.matcher(stackTrace).find());
    }
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
/**
 * Asserts that the given code closure fails when it is evaluated
 *
 * @param code the code expected to throw the exception
 * @return the message of the thrown Throwable
 */
public static Throwable shouldFail(Closure code) {
    boolean failed = false;
    Throwable th = null;
    try {
        code.call();
    } catch (GroovyRuntimeException gre) {
        failed = true;
        th = ScriptBytecodeAdapter.unwrap(gre);
    } catch (Throwable e) {
        failed = true;
        th = e;
    }
    assertTrue("Closure " + code + " should have failed", failed);
    return th;
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
/**
 * Asserts that the given code closure fails when it is evaluated
 *
 * @param code the code expected to fail
 * @return the caught exception
 */
public static Throwable shouldFail(Closure code) {
    boolean failed = false;
    Throwable th = null;
    try {
        code.call();
    } catch (GroovyRuntimeException gre) {
        failed = true;
        th = ScriptBytecodeAdapter.unwrap(gre);
    } catch (Throwable e) {
        failed = true;
        th = e;
    }
    assertTrue("Closure " + code + " should have failed", failed);
    return th;
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
private static void visit(Closure closure, CodeVisitorSupport visitor) {
    if (closure != null) {
        ClassNode classNode = closure.getMetaClass().getClassNode();
        if (classNode == null) {
            throw new GroovyRuntimeException(
                    "DataSet unable to evaluate expression. AST not available for closure: " + closure.getMetaClass().getTheClass().getName() +
                            ". Is the source code on the classpath?");
        }
        List methods = classNode.getDeclaredMethods("doCall");
        if (!methods.isEmpty()) {
            MethodNode method = (MethodNode) methods.get(0);
            if (method != null) {
                Statement statement = method.getCode();
                if (statement != null) {
                    statement.visit(visitor);
                }
            }
        }
    }
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
/**
 * Utility method to run a TestNG test.
 *
 * @param scriptClass the class we want to run as a test
 * @param loader the class loader to use
 * @return the result of running the test
 */
@Override
public Object run(Class<?> scriptClass, GroovyClassLoader loader) {
    try {
        Class<?> testNGClass = loader.loadClass("org.testng.TestNG");
        Object testng = InvokerHelper.invokeConstructorOf(testNGClass, new Object[]{});
        InvokerHelper.invokeMethod(testng, "setTestClasses", new Object[]{scriptClass});
        Class<?> listenerClass = loader.loadClass("org.testng.TestListenerAdapter");
        Object listener = InvokerHelper.invokeConstructorOf(listenerClass, new Object[]{});
        InvokerHelper.invokeMethod(testng, "addListener", new Object[]{listener});
        if (OUTPUT_DIRECTORY != null) {
            InvokerHelper.invokeMethod(testng, "setOutputDirectory", new Object[]{OUTPUT_DIRECTORY});
        }
        return InvokerHelper.invokeMethod(testng, "run", new Object[]{});
    } catch (ClassNotFoundException e) {
        throw new GroovyRuntimeException("Error running TestNG test.", e);
    }
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
/**
 * Run the specified class extending TestCase as a unit test.
 * This is done through reflection, to avoid adding a dependency to the JUnit framework.
 * Otherwise, developers embedding Groovy and using GroovyShell to load/parse/compile
 * groovy scripts and classes would have to add another dependency on their classpath.
 *
 * @param scriptClass the class to be run as a unit test
 * @param loader the class loader
 */
@Override
public Object run(Class<?> scriptClass, GroovyClassLoader loader) {
    try {
        Class<?> junitCoreClass = loader.loadClass("org.junit.runner.JUnitCore");
        Object result = InvokerHelper.invokeStaticMethod(junitCoreClass,
                "runClasses", new Object[]{scriptClass});
        System.out.print("JUnit 4 Runner, Tests: " + InvokerHelper.getProperty(result, "runCount"));
        System.out.print(", Failures: " + InvokerHelper.getProperty(result, "failureCount"));
        System.out.println(", Time: " + InvokerHelper.getProperty(result, "runTime"));
        List<?> failures = (List<?>) InvokerHelper.getProperty(result, "failures");
        for (Object f : failures) {
            System.out.println("Test Failure: " + InvokerHelper.getProperty(f, "description"));
            System.out.println(InvokerHelper.getProperty(f, "trace"));
        }
        return result;
    } catch (ClassNotFoundException e) {
        throw new GroovyRuntimeException("Error running JUnit 4 test.", e);
    }
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
/**
*  Runs the report once all initialization is complete.
*/

protected void dispatch( Throwable object, boolean child )
{
    if( object instanceof CompilationFailedException )
    {
        report( (CompilationFailedException)object, child );
    }
    else if( object instanceof GroovyExceptionInterface )
    {
        report( (GroovyExceptionInterface)object, child );
    }
    else if( object instanceof GroovyRuntimeException )
    {
        report( (GroovyRuntimeException)object, child );
    }
    else if( object instanceof Exception )
    {
        report( (Exception)object, child );
    }
    else
    {
        report( object, child );
    }

}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
/**
 * Loads the URL contents and parses them with ASM, producing a {@link ClassStub} object representing the structure of
 * the corresponding class file. Stubs are cached and reused if queried several times with equal URLs.
 *
 * @param url an URL from a class loader, most likely a file system file or a JAR entry.
 * @return the class stub
 * @throws IOException if reading from this URL is impossible
 */
public static ClassStub parseClass(URL url) throws IOException {
    URI uri;
    try {
        uri = url.toURI();
    } catch (URISyntaxException e) {
        throw new GroovyRuntimeException(e);
    }

    SoftReference<ClassStub> ref = StubCache.map.get(uri);
    ClassStub stub = ref == null ? null : ref.get();
    if (stub == null) {
        DecompilingVisitor visitor = new DecompilingVisitor();
        InputStream stream = url.openStream();
        try {
            new ClassReader(new BufferedInputStream(stream)).accept(visitor, ClassReader.SKIP_FRAMES);
        } finally {
            stream.close();
        }
        stub = visitor.result;
        StubCache.map.put(uri, new SoftReference<ClassStub>(stub));
    }
    return stub;
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
/**
 * Utility method to run a JUnit4 test.
 *
 * @param scriptClass the class we want to run as a test
 * @return the result of running the test
 */
static Object realRunJUnit4Test(Class scriptClass, GroovyClassLoader loader) {
    // invoke through reflection to eliminate mandatory JUnit 4 jar dependency

    try {
        Class junitCoreClass = loader.loadClass("org.junit.runner.JUnitCore");
        Object result = InvokerHelper.invokeStaticMethod(junitCoreClass,
                "runClasses", new Object[]{scriptClass});
        System.out.print("JUnit 4 Runner, Tests: " + InvokerHelper.getProperty(result, "runCount"));
        System.out.print(", Failures: " + InvokerHelper.getProperty(result, "failureCount"));
        System.out.println(", Time: " + InvokerHelper.getProperty(result, "runTime"));
        List failures = (List) InvokerHelper.getProperty(result, "failures");
        for (int i = 0; i < failures.size(); i++) {
            Object f = failures.get(i);
            System.out.println("Test Failure: " + InvokerHelper.getProperty(f, "description"));
            System.out.println(InvokerHelper.getProperty(f, "trace"));
        }
        return result;
    } catch (ClassNotFoundException e) {
        throw new GroovyRuntimeException("Error running JUnit 4 test.", e);
    }
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
public int compare(T o1, T o2) {
    try {
        return DefaultTypeTransformation.compareTo(o1, o2);
    } catch (ClassCastException cce) {
        /* ignore */
    } catch (GroovyRuntimeException gre) {
        /* ignore */
    } catch (IllegalArgumentException iae) {
        /* ignore */
    }
    // since the object does not have a valid compareTo method
    // we compare using the hashcodes. null cases are handled by
    // DefaultTypeTransformation.compareTo
    // This is not exactly a mathematical valid approach, since we compare object
    // that cannot be compared. To avoid strange side effects we do a pseudo order
    // using hashcodes, but without equality. Since then an x and y with the same
    // hashcodes will behave different depending on if we compare x with y or
    // x with y, the result might be unstable as well. Setting x and y to equal
    // may mean the removal of x or y in a sorting operation, which we don't want.
    int x1 = o1.hashCode();
    int x2 = o2.hashCode();
    if (x1 == x2 && o1.equals(o2)) return 0;
    if (x1 > x2) return 1;
    return -1;
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
public final Object call(Object receiver, Object[] args) throws Throwable {
    if (checkCall(receiver)) {
        try {
            try {
                return metaClass.invokeMethod(receiver, name, args);
            } catch (MissingMethodException e) {
                if (e instanceof MissingMethodExecutionFailed) {
                    throw (MissingMethodException)e.getCause();
                } else if (receiver.getClass() == e.getType() && e.getMethod().equals(name)) {
                    // in case there's nothing else, invoke the object's own invokeMethod()
                    return ((GroovyObject)receiver).invokeMethod(name, args);
                } else {
                    throw e;
                }
            }
        } catch (GroovyRuntimeException gre) {
            throw ScriptBytecodeAdapter.unwrap(gre);
        }
    } else {
      return CallSiteArray.defaultCall(this, receiver, args);
    }
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
public final Object callCurrent(GroovyObject receiver, Object[] args) throws Throwable {
    if (checkCall(receiver)) {
        try {
            try {
                return metaClass.invokeMethod(array.owner, receiver, name, args, false, true);
            } catch (MissingMethodException e) {
                if (e instanceof MissingMethodExecutionFailed) {
                    throw (MissingMethodException)e.getCause();
                } else if (receiver.getClass() == e.getType() && e.getMethod().equals(name)) {
                    // in case there's nothing else, invoke the object's own invokeMethod()
                    return ((GroovyObject)receiver).invokeMethod(name, args);
                } else {
                    throw e;
                }
            }
        } catch (GroovyRuntimeException gre) {
            throw ScriptBytecodeAdapter.unwrap(gre);
        }
    } else {
      return CallSiteArray.defaultCallCurrent(this, receiver, args);
    }
}
 

import groovy.lang.GroovyRuntimeException; //导入依赖的package包/类
/**
 * Coerces this map to the given type, using the map's keys as the public
 * method names, and values as the implementation.  Typically the value
 * would be a closure which behaves like the method implementation.
 *
 * @param map   this map
 * @param clazz the target type
 * @return a Proxy of the given type, which defers calls to this map's elements.
 * @since 1.0
 */
@SuppressWarnings("unchecked")
public static <T> T asType(Map map, Class<T> clazz) {
    if (!(clazz.isInstance(map)) && clazz.isInterface() && !Traits.isTrait(clazz)) {
        return (T) Proxy.newProxyInstance(
                clazz.getClassLoader(),
                new Class[]{clazz},
                new ConvertedMap(map));
    }
    try {
        return asType((Object) map, clazz);
    } catch (GroovyCastException ce) {
        try {
            return (T) ProxyGenerator.INSTANCE.instantiateAggregateFromBaseClass(map, clazz);
        } catch (GroovyRuntimeException cause) {
            throw new GroovyCastException("Error casting map to " + clazz.getName() +
                    ", Reason: " + cause.getMessage());
        }
    }
}