| /******************************************************************************* |
| * Copyright (c) 2004, 2005 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| *******************************************************************************/ |
| /* |
| * $RCSfile: ExpressionTest.java,v $ |
| * $Revision: 1.13 $ $Date: 2005/08/24 20:58:54 $ |
| */ |
| package org.eclipse.jem.tests.proxy; |
| |
| import org.eclipse.core.runtime.CoreException; |
| |
| import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException; |
| import org.eclipse.jem.internal.proxy.core.*; |
| import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent; |
| import org.eclipse.jem.internal.proxy.ide.IDEStandardBeanProxyFactory; |
| import org.eclipse.jem.internal.proxy.initParser.tree.*; |
| |
| /** |
| * |
| * @since 1.0.0 |
| */ |
| public class ExpressionTest extends AbstractTestProxy { |
| |
| /** |
| * |
| * |
| * @since 1.0.0 |
| */ |
| public ExpressionTest() { |
| super(); |
| } |
| |
| /** |
| * @param name |
| * |
| * @since 1.0.0 |
| */ |
| public ExpressionTest(String name) { |
| super(name); |
| } |
| |
| public void testIProxyBeanTypeProxy() throws CoreException, IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // Test that proxy bean type is first an expression proxy and after expression evaluation does it become a real proxy. |
| // Can't test that it doesn't become a real proxy before evaluation because it may become resolved under the covers. For |
| // example IDE expression immediately resolves it. |
| // |
| // First we must make sure we have a clean registry because it could of been resolved from a previous test. |
| recreateRegistry(); |
| |
| // Now do an expression and get a proxy. |
| IExpression exp = proxyFactory.createExpression(); |
| IProxyBeanType beanTypeProxy = proxyTypeFactory.getBeanTypeProxy(exp, "testPackage.TestAccess"); |
| assertNotNull(beanTypeProxy); |
| assertTrue(beanTypeProxy.isExpressionProxy()); |
| final IBeanTypeProxy[] resolution = new IBeanTypeProxy[1]; |
| ((ExpressionProxy) beanTypeProxy).addProxyListener(new ExpressionProxy.ProxyListener() { |
| public void proxyResolved(ProxyEvent event) { |
| resolution[0] = (IBeanTypeProxy) event.getProxy(); |
| } |
| public void proxyVoid(ProxyEvent event) { |
| fail("Proxy should not be void."); |
| } |
| public void proxyNotResolved(ProxyEvent event) { |
| fail("Proxy should of resolved."); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| assertNotNull(resolution[0]); |
| IBeanTypeProxy beanTypeProxy2 = proxyTypeFactory.getBeanTypeProxy("testPackage.TestAccess"); |
| assertNotNull(beanTypeProxy2); |
| assertTrue(beanTypeProxy2.isBeanProxy()); |
| assertTrue(beanTypeProxy2.isValid()); |
| assertSame(beanTypeProxy2, resolution[0]); // In case of beantypes we will get identical ones back (identity not just equals). |
| } |
| |
| public void testIProxyMethodProxy() throws CoreException, IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // Test that proxy methode is first an expression proxy and after expression evaluation does it become a real proxy. |
| // Can't test that it doesn't become a real proxy before evaluation because it may become resolved under the covers. For |
| // example IDE expression immediately resolves it. |
| // |
| // First we must make sure we have a clean registry because it could of been resolved from a previous test. |
| recreateRegistry(); |
| |
| // Now do an expression and get a proxy. |
| IExpression exp = proxyFactory.createExpression(); |
| IProxyBeanType beanTypeProxy = proxyTypeFactory.getBeanTypeProxy(exp, "testPackage.TestAccess"); |
| IProxyMethod methodProxy = beanTypeProxy.getMethodProxy(exp, "xyz"); |
| assertNotNull(methodProxy); |
| assertTrue(methodProxy.isExpressionProxy()); |
| final IMethodProxy[] resolution = new IMethodProxy[1]; |
| final boolean[] wasVoid = new boolean[1]; |
| ((ExpressionProxy) methodProxy).addProxyListener(new ExpressionProxy.ProxyListener() { |
| public void proxyResolved(ProxyEvent event) { |
| resolution[0] = (IMethodProxy) event.getProxy(); |
| } |
| public void proxyVoid(ProxyEvent event) { |
| wasVoid[0] = true; |
| } |
| public void proxyNotResolved(ProxyEvent event) { |
| } |
| }); |
| IProxyMethod methodProxy2 = beanTypeProxy.getMethodProxy(exp, "xyz"); |
| assertSame(methodProxy, methodProxy2); // It should return same expression proxy each time. |
| |
| exp.createMethodInvocation(ForExpression.ROOTEXPRESSION, methodProxy, true, 0); |
| exp.createClassInstanceCreation(ForExpression.METHOD_RECEIVER, beanTypeProxy, 0); |
| exp.invokeExpression(); |
| |
| assertFalse(wasVoid[0]); |
| assertNotNull(resolution[0]); |
| IMethodProxy methodProxy3 = proxyTypeFactory.getBeanTypeProxy("testPackage.TestAccess").getMethodProxy("xyz"); |
| assertNotNull(methodProxy3); |
| assertTrue(methodProxy3.isBeanProxy()); |
| assertTrue(methodProxy3.isValid()); |
| // Can't test identity of methodproxies because some registries (IDE for example) create a new method proxy each time. |
| } |
| |
| public void testIProxyFieldProxy() throws CoreException, IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // Test that proxy field is first an expression proxy and after expression evaluation does it become a real proxy. |
| // Can't test that it doesn't become a real proxy before evaluation because it may become resolved under the covers. For |
| // example IDE expression immediately resolves it. |
| // |
| // First we must make sure we have a clean registry because it could of been resolved from a previous test. |
| recreateRegistry(); |
| |
| // Now do an expression and get a proxy. |
| IExpression exp = proxyFactory.createExpression(); |
| IProxyBeanType beanTypeProxy = proxyTypeFactory.getBeanTypeProxy(exp, "testPackage.TestAccess"); |
| IProxyField fieldProxy = beanTypeProxy.getFieldProxy(exp, "STATIC_FIELD"); |
| assertNotNull(fieldProxy); |
| assertTrue(fieldProxy.isExpressionProxy()); |
| final IFieldProxy[] resolution = new IFieldProxy[1]; |
| final boolean[] wasVoid = new boolean[1]; |
| ((ExpressionProxy) fieldProxy).addProxyListener(new ExpressionProxy.ProxyListener() { |
| public void proxyResolved(ProxyEvent event) { |
| resolution[0] = (IFieldProxy) event.getProxy(); |
| } |
| public void proxyVoid(ProxyEvent event) { |
| wasVoid[0] = true; |
| } |
| public void proxyNotResolved(ProxyEvent event) { |
| } |
| }); |
| |
| IProxyField fieldProxy2 = beanTypeProxy.getFieldProxy(exp, "STATIC_FIELD"); |
| assertSame(fieldProxy, fieldProxy2); // It should return same expression proxy each time. |
| |
| exp.createFieldAccess(ForExpression.ROOTEXPRESSION, fieldProxy, true); |
| exp.createClassInstanceCreation(ForExpression.FIELD_RECEIVER, beanTypeProxy, 0); |
| IBeanProxy v = exp.getExpressionValue(); |
| assertNotNull(v); |
| assertEquals(3, ((IIntegerBeanProxy) v).intValue()); |
| |
| assertFalse(wasVoid[0]); |
| assertNotNull(resolution[0]); |
| IFieldProxy fieldProxy3 = proxyTypeFactory.getBeanTypeProxy("testPackage.TestAccess").getFieldProxy("STATIC_FIELD"); |
| assertNotNull(fieldProxy3); |
| assertTrue(fieldProxy3.isBeanProxy()); |
| assertTrue(fieldProxy3.isValid()); |
| // Can't test identity of methodproxies because some registries (IDE for example) create a new method proxy each time. |
| } |
| |
| public void testCastStringType() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createCastExpression(ForExpression.ROOTEXPRESSION, "short"); |
| exp.createPrimitiveLiteral(ForExpression.CAST_EXPRESSION, 10l); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("short", result.getTypeProxy().getTypeName()); |
| assertEquals((short) 10, ((INumberBeanProxy) result).shortValue()); |
| } |
| |
| public void testCastProxyType() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createCastExpression(ForExpression.ROOTEXPRESSION, proxyTypeFactory.getBeanTypeProxy("short")); |
| exp.createPrimitiveLiteral(ForExpression.CAST_EXPRESSION, 'a'); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("short", result.getTypeProxy().getTypeName()); |
| assertEquals((short) 'a', ((INumberBeanProxy) result).shortValue()); |
| } |
| |
| public void testCastError() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createCastExpression(ForExpression.ROOTEXPRESSION, proxyTypeFactory.getBeanTypeProxy("short")); |
| try { |
| exp.createProxyExpression(ForExpression.CAST_EXPRESSION, proxyFactory.createBeanProxyWith(Boolean.TRUE)); |
| exp.getExpressionValue(); |
| fail("Should of thrown ClassCastException"); |
| } catch (ThrowableProxy e) { |
| if (!e.getTypeProxy().getFormalTypeName().equals("java.lang.ClassCastException")) |
| throw e; // Some other exception, rethrow it. |
| } |
| } |
| |
| public void testCastFailed() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createCastExpression(ForExpression.ROOTEXPRESSION, proxyTypeFactory.getBeanTypeProxy("short")); |
| try { |
| exp.getExpressionValue(); |
| fail("Should of gotton IllegalStateException"); |
| } catch (IllegalStateException e) { |
| System.out.println("From testCastFailed (This is successful): "+e.getLocalizedMessage()); |
| } |
| } |
| |
| public void testInstanceofStringType() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInstanceofExpression(ForExpression.ROOTEXPRESSION, "java.lang.String"); |
| exp.createStringLiteral(ForExpression.INSTANCEOF_VALUE, "asdf"); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(true, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testInstanceofProxyType() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInstanceofExpression(ForExpression.ROOTEXPRESSION, proxyTypeFactory.getBeanTypeProxy("java.lang.String")); |
| exp.createStringLiteral(ForExpression.INSTANCEOF_VALUE, "asdf"); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(true, ((IBooleanBeanProxy) result).booleanValue()); |
| |
| } |
| |
| public void testInstanceofFailed() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInstanceofExpression(ForExpression.ROOTEXPRESSION, proxyTypeFactory.getBeanTypeProxy("java.lang.String")); |
| try { |
| exp.getExpressionValue(); |
| fail("Should of gotton IllegalStateException"); |
| } catch (IllegalStateException e) { |
| System.out.println("From testInstanceofFailed (This is successful): "+e.getLocalizedMessage()); |
| } |
| } |
| |
| public void testTypeLiteral() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTypeLiteral(ForExpression.ROOTEXPRESSION, "java.lang.String"); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertTrue("Not a bean type proxy.", result instanceof IBeanTypeProxy); |
| IBeanTypeProxy type = (IBeanTypeProxy) result; |
| assertTrue("Not valid.", type.isValid()); |
| assertEquals("java.lang.String", type.getFormalTypeName()); |
| } |
| |
| public void testTypeFails() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| try { |
| exp.createTypeLiteral(ForExpression.ROOTEXPRESSION, "java.lang.Stng"); |
| exp.getExpressionValue(); |
| fail("Should not of gotton a result."); |
| } catch (ThrowableProxy e) { |
| assertEquals("java.lang.ClassNotFoundException", e.getTypeProxy().getFormalTypeName()); |
| } |
| } |
| |
| public void testNesting() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInstanceofExpression(ForExpression.ROOTEXPRESSION, "short"); |
| exp.createCastExpression(ForExpression.INSTANCEOF_VALUE, "short"); |
| exp.createPrimitiveLiteral(ForExpression.CAST_EXPRESSION, (short) 10); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(true, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testPrefixPlus() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createPrefixExpression(ForExpression.ROOTEXPRESSION, PrefixOperator.PRE_PLUS); |
| exp.createPrimitiveLiteral(ForExpression.PREFIX_OPERAND, 10); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(10, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testPrefixMinus() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createPrefixExpression(ForExpression.ROOTEXPRESSION, PrefixOperator.PRE_MINUS); |
| exp.createPrimitiveLiteral(ForExpression.PREFIX_OPERAND, 10); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(-10, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testPrefixMinusChar() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createPrefixExpression(ForExpression.ROOTEXPRESSION, PrefixOperator.PRE_MINUS); |
| exp.createPrimitiveLiteral(ForExpression.PREFIX_OPERAND, 'a'); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(-'a', ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testPrefixComplement() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createPrefixExpression(ForExpression.ROOTEXPRESSION, PrefixOperator.PRE_COMPLEMENT); |
| exp.createPrimitiveLiteral(ForExpression.PREFIX_OPERAND, (short) 10); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(~10, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testPrefixNot() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createPrefixExpression(ForExpression.ROOTEXPRESSION, PrefixOperator.PRE_NOT); |
| exp.createPrimitiveLiteral(ForExpression.PREFIX_OPERAND, true); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(false, ((IBooleanBeanProxy) result).booleanValue()); |
| |
| } |
| |
| public void testPrefixFail() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createPrefixExpression(ForExpression.ROOTEXPRESSION, PrefixOperator.PRE_NOT); |
| try { |
| exp.createPrimitiveLiteral(ForExpression.PREFIX_OPERAND, 10); |
| exp.getExpressionValue(); |
| fail("Should of failed."); |
| } catch (ThrowableProxy e) { |
| System.out.println("Test was successful: "+e.getProxyLocalizedMessage()); |
| } |
| |
| } |
| |
| public void testTimes() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_TIMES, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 4); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(3*4, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testTimesExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_TIMES, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 5d); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("double", result.getTypeProxy().getTypeName()); |
| assertEquals((3*4*5d), ((INumberBeanProxy) result).doubleValue(), 0); |
| |
| } |
| |
| public void testTimesExtendedNested() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_TIMES, 1); |
| exp.createInfixExpression(ForExpression.INFIX_LEFT, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 10); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 5); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 5d); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("double", result.getTypeProxy().getTypeName()); |
| assertEquals(((10-5)*4*5d), ((INumberBeanProxy) result).doubleValue(), 0); |
| |
| } |
| |
| public void testDivide() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_DIVIDE, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(4/2, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testDivideExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_DIVIDE, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 12); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2d); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("double", result.getTypeProxy().getTypeName()); |
| assertEquals((12/3/2d), ((INumberBeanProxy) result).doubleValue(), 0); |
| |
| } |
| |
| public void testRemainder() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_REMAINDER, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(4%3, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testRemainderExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_REMAINDER, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 12); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 9); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2d); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("double", result.getTypeProxy().getTypeName()); |
| assertEquals((12%9%2d), ((INumberBeanProxy) result).doubleValue(), 0); |
| |
| } |
| |
| public void testMinus() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(4-3, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testMinusExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_MINUS, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 12); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 9); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2d); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("double", result.getTypeProxy().getTypeName()); |
| assertEquals((12-9-2d), ((INumberBeanProxy) result).doubleValue(), 0); |
| |
| } |
| |
| public void testLeftShift() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_LEFT_SHIFT, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(4<<3, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testLeftShiftExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_LEFT_SHIFT, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 12); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 9); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals((12<<9<<2), ((INumberBeanProxy) result).intValue(), 0); |
| } |
| |
| public void testRightShiftSigned() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_RIGHT_SHIFT_SIGNED, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, -10000000); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(-10000000>>3, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testRightShiftSignedExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_RIGHT_SHIFT_SIGNED, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, -10000000); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals((-10000000>>4>>2), ((INumberBeanProxy) result).intValue(), 0); |
| } |
| public void testRightShiftUnSigned() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_RIGHT_SHIFT_UNSIGNED, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, -10000000); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(-10000000>>>3, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testRightShiftUnSignedExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_RIGHT_SHIFT_UNSIGNED, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, -10000000); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals((-10000000>>>4>>>2), ((INumberBeanProxy) result).intValue(), 0); |
| } |
| |
| public void testLess() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_LESS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, -10000000); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(-10000000<3, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testLessEquals() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_LESS_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(3<=3, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testGreater() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_GREATER, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, -10000000); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(-10000000>3, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testGreaterEquals() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_GREATER_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 2); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(2>=3, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testEqualsPrimitives() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3d); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(3d==3, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testEqualsObjects() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_EQUALS, 0); |
| exp.createTypeLiteral(ForExpression.INFIX_LEFT, "java.lang.String"); |
| exp.createTypeLiteral(ForExpression.INFIX_RIGHT, "java.lang.String"); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(String.class == String.class, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testNotEqualsPrimitives() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_NOT_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3d); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(3d!=3, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testNotEqualsObjects() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_NOT_EQUALS, 0); |
| exp.createTypeLiteral(ForExpression.INFIX_LEFT, "java.lang.String"); |
| exp.createTypeLiteral(ForExpression.INFIX_RIGHT, "java.lang.String"); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(String.class != String.class, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testXOR() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_XOR, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 5); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(5^3, ((INumberBeanProxy) result).intValue()); |
| |
| } |
| |
| public void testXORExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_XOR, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 23); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 9); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals((23^9^2), ((INumberBeanProxy) result).intValue(), 0); |
| |
| } |
| |
| public void testAnd() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_AND, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 5); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(5&3, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testAndExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_AND, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 13); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 15); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 1); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals((13&5&1), ((INumberBeanProxy) result).intValue(), 0); |
| } |
| |
| public void testOr() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_OR, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 5); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(5|2, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testOrExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_OR, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 13); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 6); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals((13|6|2), ((INumberBeanProxy) result).intValue(), 0); |
| } |
| |
| public void testPlus() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 5); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getTypeName()); |
| assertEquals(5+2, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testPlusExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 5); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 2); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_EXTENDED, 2l); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("long", result.getTypeProxy().getTypeName()); |
| assertEquals(5+2+2l, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testPlusStringLeft() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createProxyExpression(ForExpression.INFIX_LEFT, proxyFactory.createBeanProxyWith("abc")); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.String", result.getTypeProxy().getTypeName()); |
| assertEquals("abc"+2, ((IStringBeanProxy) result).stringValue()); |
| } |
| |
| public void testPlusStringRight() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 2); |
| exp.createProxyExpression(ForExpression.INFIX_RIGHT, proxyFactory.createBeanProxyWith("abc")); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.String", result.getTypeProxy().getTypeName()); |
| assertEquals(2+"abc", ((IStringBeanProxy) result).stringValue()); |
| } |
| |
| public void testPlusStringLeftNull() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createProxyExpression(ForExpression.INFIX_LEFT, proxyFactory.createBeanProxyWith("abc")); |
| exp.createNull(ForExpression.INFIX_RIGHT); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.String", result.getTypeProxy().getTypeName()); |
| assertEquals("abc"+null, ((IStringBeanProxy) result).stringValue()); |
| } |
| |
| public void testPlusStringRightNull() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createNull(ForExpression.INFIX_LEFT); |
| exp.createProxyExpression(ForExpression.INFIX_RIGHT, proxyFactory.createBeanProxyWith("abc")); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.String", result.getTypeProxy().getTypeName()); |
| assertEquals(null+"abc", ((IStringBeanProxy) result).stringValue()); |
| } |
| |
| public void testPlusStringLeftChar() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createProxyExpression(ForExpression.INFIX_LEFT, proxyFactory.createBeanProxyWith("abc")); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 'a'); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.String", result.getTypeProxy().getTypeName()); |
| assertEquals("abc"+'a', ((IStringBeanProxy) result).stringValue()); |
| } |
| |
| public void testPlusStringRightChar() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 'a'); |
| exp.createProxyExpression(ForExpression.INFIX_RIGHT, proxyFactory.createBeanProxyWith("abc")); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.String", result.getTypeProxy().getTypeName()); |
| assertEquals('a'+"abc", ((IStringBeanProxy) result).stringValue()); |
| } |
| |
| public void testConditionalAnd() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_AND, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, true); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, true); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(true && true, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testConditionalAndExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_AND, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, true); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, true); |
| exp.createInfixExpression(ForExpression.INFIX_EXTENDED, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(true && true && (3 == 3), ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testConditionalAndFalseLast() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_AND, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, true); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, false); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(true && false, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testConditionalAndFalseFirst() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_AND, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, false); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, true); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(false && true, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testConditionalAndExtendedAndFalseFirst() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_AND, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, false); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, true); |
| exp.createInfixExpression(ForExpression.INFIX_EXTENDED, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(false && true && (3 == 3), ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testConditionalOr() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_OR, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, false); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, true); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(false || true, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testConditionalOrExtended() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_OR, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, false); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, false); |
| exp.createInfixExpression(ForExpression.INFIX_EXTENDED, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(false || false || (3 == 3), ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testConditionalOrTrueFirst() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_OR, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, true); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, false); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(true || false, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testConditionalOrExtendedAndTrueMiddle() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_CONDITIONAL_OR, 1); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, false); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, true); |
| exp.createInfixExpression(ForExpression.INFIX_EXTENDED, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(false || true || (3 == 3), ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| |
| public void testArrayAccess() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IArrayBeanProxy array = proxyFactory.createBeanProxyWith(proxyTypeFactory.getBeanTypeProxy("short"), 1); |
| array.set(proxyFactory.createBeanProxyWith((short) 3), 0); |
| |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayAccess(ForExpression.ROOTEXPRESSION, 1); |
| exp.createProxyExpression(ForExpression.ARRAYACCESS_ARRAY, array); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYACCESS_INDEX, 0); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("short", result.getTypeProxy().getTypeName()); |
| assertEquals(((INumberBeanProxy) result).shortValue(), (short) 3); |
| } |
| |
| public void testArrayAccessSet() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IArrayBeanProxy array = proxyFactory.createBeanProxyWith(proxyTypeFactory.getBeanTypeProxy("short"), 1); |
| array.set(proxyFactory.createBeanProxyWith((short) 3), 0); |
| |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createArrayAccess(ForExpression.ASSIGNMENT_LEFT, 1); |
| exp.createProxyExpression(ForExpression.ARRAYACCESS_ARRAY, array); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYACCESS_INDEX, 0); |
| exp.createPrimitiveLiteral(ForExpression.ASSIGNMENT_RIGHT, (short) 33); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("short", result.getTypeProxy().getTypeName()); |
| assertEquals(((INumberBeanProxy) result).shortValue(), (short) 33); |
| } |
| |
| |
| public void testMultiArrayAccess() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IArrayBeanProxy array = proxyFactory.createBeanProxyWith(proxyTypeFactory.getBeanTypeProxy("short"), new int[] {2,1}); |
| array.set(proxyFactory.createBeanProxyWith((short) 3), new int[]{1,0}); |
| |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayAccess(ForExpression.ROOTEXPRESSION, 1); |
| exp.createProxyExpression(ForExpression.ARRAYACCESS_ARRAY, array); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYACCESS_INDEX, 1); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("short[]", result.getTypeProxy().getFormalTypeName()); |
| } |
| |
| public void testMultiArrayAccessSet() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IArrayBeanProxy array = proxyFactory.createBeanProxyWith(proxyTypeFactory.getBeanTypeProxy("short"), new int[] {2,1}); |
| array.set(proxyFactory.createBeanProxyWith((short) 3), new int[]{1,0}); |
| |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createArrayAccess(ForExpression.ASSIGNMENT_LEFT, 1); |
| exp.createProxyExpression(ForExpression.ARRAYACCESS_ARRAY, array); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYACCESS_INDEX, 1); |
| IArrayBeanProxy newArray = proxyFactory.createBeanProxyWith(proxyTypeFactory.getBeanTypeProxy("short"), new int[] {3}); |
| exp.createProxyExpression(ForExpression.ASSIGNMENT_RIGHT, newArray); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("short[]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(3, ((IArrayBeanProxy) result).getLength()); |
| } |
| |
| public void testMultiArrayAccess1() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IArrayBeanProxy array = proxyFactory.createBeanProxyWith(proxyTypeFactory.getBeanTypeProxy("short"), new int[] {2,1}); |
| array.set(proxyFactory.createBeanProxyWith((short) 3), new int[]{1,0}); |
| |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayAccess(ForExpression.ROOTEXPRESSION, 2); |
| exp.createProxyExpression(ForExpression.ARRAYACCESS_ARRAY, array); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYACCESS_INDEX, 1); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYACCESS_INDEX, 0); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("short", result.getTypeProxy().getFormalTypeName()); |
| assertEquals((short) 3, ((INumberBeanProxy) result).shortValue()); |
| } |
| |
| public void testArrayCreation() throws IllegalStateException, IllegalArgumentException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[]", 1); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYCREATION_DIMENSION, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(2, ((IArrayBeanProxy) result).getLength()); |
| } |
| |
| public void testMultiArrayCreation() throws IllegalStateException, IllegalArgumentException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[][]", 2); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYCREATION_DIMENSION, 2); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYCREATION_DIMENSION, 4); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[][]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(2, ((IArrayBeanProxy) result).getLength()); |
| assertEquals(4, ((IArrayBeanProxy)((IArrayBeanProxy) result).get(0)).getLength()); |
| } |
| |
| public void testMultiPartialArrayCreation() throws IllegalStateException, IllegalArgumentException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[][][]", 2); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYCREATION_DIMENSION, 2); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYCREATION_DIMENSION, 4); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[][][]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(2, ((IArrayBeanProxy) result).getLength()); |
| assertEquals(4, ((IArrayBeanProxy)((IArrayBeanProxy) result).get(0)).getLength()); |
| assertNull(((IArrayBeanProxy)((IArrayBeanProxy) result).get(0)).get(0)); |
| } |
| |
| public void testArrayInitializerEmpty() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[]", 0); |
| exp.createArrayInitializer(0); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(0, ((IArrayBeanProxy) result).getLength()); |
| } |
| |
| public void testArrayInitializerOneDim() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[]", 0); |
| exp.createArrayInitializer(1); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYINITIALIZER_EXPRESSION, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(1, ((IArrayBeanProxy) result).getLength()); |
| assertEquals(3, ((INumberBeanProxy) ((IArrayBeanProxy) result).get(0)).intValue()); |
| } |
| |
| public void testArrayInitializerTwoDimEmpty() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[][]", 0); |
| exp.createArrayInitializer(0); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[][]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(0, ((IArrayBeanProxy) result).getLength()); |
| } |
| |
| public void testArrayInitializerTwoDim() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[][]", 0); |
| exp.createArrayInitializer(1); |
| exp.createArrayInitializer(0); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[][]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(1, ((IArrayBeanProxy) result).getLength()); |
| assertEquals(0, ((IArrayBeanProxy) ((IArrayBeanProxy) result).get(0)).getLength()); |
| } |
| |
| public void testArrayInitializerTwoDimNotEmpty() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[][]", 0); |
| exp.createArrayInitializer(2); |
| exp.createNull(ForExpression.ARRAYINITIALIZER_EXPRESSION); |
| exp.createArrayInitializer(2); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYINITIALIZER_EXPRESSION, 3); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYINITIALIZER_EXPRESSION, 4); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[][]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(2, ((IArrayBeanProxy) result).getLength()); |
| assertNull(((IArrayBeanProxy) result).get(0)); |
| assertEquals(2, ((IArrayBeanProxy) ((IArrayBeanProxy) result).get(1)).getLength()); |
| assertEquals(4, ((INumberBeanProxy)((IArrayBeanProxy) ((IArrayBeanProxy) result).get(1)).get(1)).intValue()); |
| } |
| |
| public void testArrayInitializerShortInt() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "short[]", 0); |
| exp.createArrayInitializer(1); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYINITIALIZER_EXPRESSION, 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("short[]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(1, ((IArrayBeanProxy) result).getLength()); |
| assertEquals(3, ((INumberBeanProxy) ((IArrayBeanProxy) result).get(0)).intValue()); |
| } |
| |
| public void testClassInstanceCreationDefault() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createClassInstanceCreation(ForExpression.ROOTEXPRESSION, "java.lang.Object", 0); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.Object", result.getTypeProxy().getFormalTypeName()); |
| } |
| |
| public void testClassInstanceCreationDefaultWithBeanTypeProxy() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createClassInstanceCreation(ForExpression.ROOTEXPRESSION, proxyTypeFactory.getBeanTypeProxy("java.lang.Object"), 0); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.Object", result.getTypeProxy().getFormalTypeName()); |
| } |
| |
| public void testClassInstanceCreationOneArg() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createClassInstanceCreation(ForExpression.ROOTEXPRESSION, "java.lang.Integer", 1); |
| exp.createStringLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, "3"); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.Integer", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(3, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testClassInstanceCreationOneArgWithPrimWidening() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createClassInstanceCreation(ForExpression.ROOTEXPRESSION, "java.lang.Short", 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, (byte)3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.Short", result.getTypeProxy().getFormalTypeName()); |
| assertEquals((short)3, ((INumberBeanProxy) result).shortValue()); |
| } |
| |
| public void testClassInstanceCreationNullArg() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createClassInstanceCreation(ForExpression.ROOTEXPRESSION, "testPackage.TestCtorWithNull", 1); |
| exp.createNull(ForExpression.CLASSINSTANCECREATION_ARGUMENT); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("testPackage.TestCtorWithNull", result.getTypeProxy().getFormalTypeName()); |
| } |
| |
| public void testClassInstanceCreationMismatchArg() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createClassInstanceCreation(ForExpression.ROOTEXPRESSION, "testPackage.TestCtorWithNull", 1); |
| try { |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 1); |
| exp.getExpressionValue(); |
| fail("Exception should of been thrown."); |
| } catch (ThrowableProxy e) { |
| assertEquals("java.lang.NoSuchMethodException", e.getTypeProxy().getFormalTypeName()); |
| } |
| } |
| |
| public void testFieldAccessStatic() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createFieldAccess(ForExpression.ROOTEXPRESSION, "RED", true); |
| exp.createTypeReceiver("java.awt.Color"); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.awt.Color", result.getTypeProxy().getFormalTypeName()); |
| IBeanTypeProxy colorType = result.getTypeProxy(); |
| IMethodProxy red = colorType.getMethodProxy("getRed"); |
| IMethodProxy green = colorType.getMethodProxy("getGreen"); |
| IMethodProxy blue = colorType.getMethodProxy("getBlue"); |
| assertEquals(255, ((INumberBeanProxy) red.invoke(result)).intValue()); |
| assertEquals(0, ((INumberBeanProxy) green.invoke(result)).intValue()); |
| assertEquals(0, ((INumberBeanProxy) blue.invoke(result)).intValue()); |
| } |
| |
| public void testFieldAccessSetStatic() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createFieldAccess(ForExpression.ASSIGNMENT_LEFT, "STATIC_FIELD", true); |
| exp.createTypeReceiver("testPackage.TestAccess"); |
| exp.createPrimitiveLiteral(ForExpression.ASSIGNMENT_RIGHT, 23); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(23, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| |
| public void testFieldAccessNonStatic() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createFieldAccess(ForExpression.ROOTEXPRESSION, "x", true); |
| exp.createClassInstanceCreation(ForExpression.FIELD_RECEIVER, "java.awt.Point", 2); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(1, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testFieldAccessSetNonStatic() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createFieldAccess(ForExpression.ASSIGNMENT_LEFT, "x", true); |
| exp.createClassInstanceCreation(ForExpression.FIELD_RECEIVER, "java.awt.Point", 2); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 2); |
| exp.createPrimitiveLiteral(ForExpression.ASSIGNMENT_RIGHT, 23); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(23, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testFieldAccessSetNonStaticSimple() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // First create using normal proxy stuff, then test the expression processor. |
| IBeanTypeProxy pointType = proxyTypeFactory.getBeanTypeProxy("java.awt.Point"); |
| IFieldProxy xFieldProxy = pointType.getFieldProxy("x"); |
| IBeanProxy pointProxy = pointType.getConstructorProxy(new String[] {"int", "int"}).newInstance(new IBeanProxy[] {proxyFactory.createBeanProxyWith(1), proxyFactory.createBeanProxyWith(2)}); |
| |
| IExpression exp = proxyFactory.createExpression(); |
| ExpressionProxy ep = exp.createSimpleFieldSet(xFieldProxy, pointProxy, proxyFactory.createBeanProxyWith(23), true); |
| ep.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy result = event.getProxy(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(23, ((INumberBeanProxy) result).intValue()); |
| } |
| }); |
| exp.invokeExpression(); |
| } |
| |
| public void testFieldAccessNonStaticSimple() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // First create using normal proxy stuff, then test the expression processor. |
| IBeanTypeProxy pointType = proxyTypeFactory.getBeanTypeProxy("java.awt.Point"); |
| IFieldProxy xFieldProxy = pointType.getFieldProxy("x"); |
| IBeanProxy pointProxy = pointType.getConstructorProxy(new String[] {"int", "int"}).newInstance(new IBeanProxy[] {proxyFactory.createBeanProxyWith(1), proxyFactory.createBeanProxyWith(2)}); |
| |
| IExpression exp = proxyFactory.createExpression(); |
| ExpressionProxy ep = exp.createSimpleFieldAccess(xFieldProxy, pointProxy); |
| ep.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy result = event.getProxy(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(1, ((INumberBeanProxy) result).intValue()); |
| } |
| }); |
| exp.invokeExpression(); |
| } |
| |
| public void testFieldAccessNonStaticWithProxy() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IBeanTypeProxy pointType = proxyTypeFactory.getBeanTypeProxy("java.awt.Point"); |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createFieldAccess(ForExpression.ROOTEXPRESSION, pointType.getFieldProxy("x"), true); |
| exp.createClassInstanceCreation(ForExpression.FIELD_RECEIVER, "java.awt.Point", 2); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 2); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(1, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testFieldAccessFailWithExpressionProxy() throws IllegalStateException, NoExpressionValueException { |
| IBeanTypeProxy pointType = proxyTypeFactory.getBeanTypeProxy("java.awt.Point"); |
| IExpression exp = proxyFactory.createExpression(); |
| try { |
| exp.createFieldAccess(ForExpression.ROOTEXPRESSION, pointType.getFieldProxy(exp, "z"), true); |
| exp.createClassInstanceCreation(ForExpression.FIELD_RECEIVER, "java.awt.Point", 2); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 2); |
| exp.getExpressionValue(); |
| fail("Should of had exception"); |
| } catch (ThrowableProxy e) { |
| assertEquals("java.lang.NoSuchFieldException", e.getTypeProxy().getFormalTypeName()); |
| } |
| } |
| |
| public void testMethodInvokeStatic() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createMethodInvocation(ForExpression.ROOTEXPRESSION, "valueOf", true, 1); |
| exp.createTypeReceiver("java.lang.String"); |
| exp.createPrimitiveLiteral(ForExpression.METHOD_ARGUMENT, true); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("java.lang.String", result.getTypeProxy().getFormalTypeName()); |
| assertEquals("true", ((IStringBeanProxy) result).stringValue()); |
| } |
| |
| public void testMethodInvokeProxyFail() throws IllegalStateException, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| IBeanTypeProxy intType = proxyTypeFactory.getBeanTypeProxy("java.lang.Integer"); |
| try { |
| exp.createMethodInvocation(ForExpression.ROOTEXPRESSION, intType.getMethodProxy(exp, "goobldy-gook"), true, 1); |
| exp.createClassInstanceCreation(ForExpression.METHOD_RECEIVER, intType, 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 3); |
| exp.createClassInstanceCreation(ForExpression.METHOD_ARGUMENT, "java.lang.Integer", 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 4); |
| exp.getExpressionValue(); |
| fail("Should of gotten exception"); |
| } catch (ThrowableProxy e) { |
| assertEquals("java.lang.NoSuchMethodException", e.getTypeProxy().getFormalTypeName()); |
| } |
| } |
| |
| public void testMethodInvokeNonStatic() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createMethodInvocation(ForExpression.ROOTEXPRESSION, "compareTo", true, 1); |
| exp.createClassInstanceCreation(ForExpression.METHOD_RECEIVER, "java.lang.Integer", 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 3); |
| exp.createClassInstanceCreation(ForExpression.METHOD_ARGUMENT, "java.lang.Integer", 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 4); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertTrue("CompareTo wasn't less than 0.", ((INumberBeanProxy) result).intValue() < 0); |
| } |
| |
| public void testMethodInvokeNonStaticWithProxy() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IBeanTypeProxy integerType = proxyTypeFactory.getBeanTypeProxy("java.lang.Integer"); |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createMethodInvocation(ForExpression.ROOTEXPRESSION, integerType.getMethodProxy("compareTo", new IBeanTypeProxy[] {integerType}), true, 1); |
| exp.createClassInstanceCreation(ForExpression.METHOD_RECEIVER, "java.lang.Integer", 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 3); |
| exp.createClassInstanceCreation(ForExpression.METHOD_ARGUMENT, "java.lang.Integer", 1); |
| exp.createPrimitiveLiteral(ForExpression.CLASSINSTANCECREATION_ARGUMENT, 4); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertTrue("CompareTo wasn't less than 0.", ((INumberBeanProxy) result).intValue() < 0); |
| } |
| |
| public void testConditionalTrue() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createConditionalExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_TRUE, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_FALSE, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(6, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testConditionalFalse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createConditionalExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_TRUE, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_FALSE, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(0, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testNestedConditionalTrueTrue() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createConditionalExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createConditionalExpression(ForExpression.CONDITIONAL_TRUE); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_TRUE, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 4); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_FALSE, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_FALSE, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 5); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(8, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testNestedConditionalFalseFalse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createConditionalExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 2); |
| exp.createConditionalExpression(ForExpression.CONDITIONAL_TRUE); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 2); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_TRUE, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 4); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_FALSE, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createInfixExpression(ForExpression.CONDITIONAL_FALSE, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 5); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(2, ((INumberBeanProxy) result).intValue()); |
| } |
| |
| public void testVoidReturnType() throws IllegalStateException, ThrowableProxy { |
| IExpression exp = proxyFactory.createExpression(); |
| try { |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createMethodInvocation(ForExpression.INFIX_RIGHT, "gc", true, 0); |
| exp.createTypeReceiver("java.lang.System"); |
| exp.getExpressionValue(); |
| fail("Should of received no expression value exception."); |
| } catch (NoExpressionValueException e) { |
| if (e.getLocalizedMessage() != null) |
| System.out.println("Test was successful: "+e.getLocalizedMessage()); |
| } |
| } |
| |
| public void testWrongReturnType() throws ThrowableProxy, IllegalStateException, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| try { |
| exp.createInfixExpression(ForExpression.ROOTEXPRESSION, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, 3); |
| exp.createMethodInvocation(ForExpression.INFIX_RIGHT, "getSecurityManager", true, 0); |
| exp.createTypeReceiver("java.lang.System"); |
| exp.getExpressionValue(); |
| fail("Should of received class cast proxy exception."); |
| } catch (ThrowableProxy e) { |
| if (!e.getTypeProxy().getFormalTypeName().equals("java.lang.IllegalArgumentException")) |
| throw e; // Some other exception, rethrow it. |
| } |
| } |
| |
| public void testInvoke() throws ThrowableProxy, IllegalStateException, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createMethodInvocation(ForExpression.ROOTEXPRESSION, "getSecurityManager", true, 0); |
| exp.createTypeReceiver("java.lang.System"); |
| exp.invokeExpression(); |
| } |
| |
| public void testInvokeFail() throws ThrowableProxy, IllegalStateException, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| try { |
| exp.createMethodInvocation(ForExpression.ROOTEXPRESSION, "getenv", true, 1); |
| exp.createTypeReceiver("java.lang.System"); |
| exp.createStringLiteral(ForExpression.METHOD_ARGUMENT, "xyz"); |
| exp.invokeExpression(); |
| } catch (ThrowableProxy e) { |
| if (!e.getTypeProxy().getFormalTypeName().equals("java.lang.Error")) |
| throw e; // Some other exception, rethrow it. |
| } |
| } |
| |
| public void testAssignment() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| ExpressionProxy ep = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| final long[] time = new long[1]; |
| ep.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyAdapter#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| time[0] = ((INumberBeanProxy) event.getProxy()).longValue(); |
| } |
| }); |
| exp.createMethodInvocation(ForExpression.ASSIGNMENT_RIGHT, "currentTimeMillis", true, 0); |
| exp.createTypeReceiver("java.lang.System"); |
| exp.invokeExpression(); |
| assertTrue(0L != time[0]); |
| } |
| |
| public void testReassignment() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| ExpressionProxy ep = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| final long[] time = new long[1]; |
| ep.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyAdapter#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| time[0] = ((INumberBeanProxy) event.getProxy()).longValue(); |
| } |
| }); |
| exp.createMethodInvocation(ForExpression.ASSIGNMENT_RIGHT, "currentTimeMillis", true, 0); |
| exp.createTypeReceiver("java.lang.System"); |
| exp.createProxyReassignmentExpression(ForExpression.ROOTEXPRESSION, ep); |
| exp.createPrimitiveLiteral(ForExpression.ASSIGNMENT_RIGHT, -23L); |
| exp.invokeExpression(); |
| assertEquals(-23L, time[0]); |
| } |
| |
| public void testAssignmentVoid() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| ExpressionProxy ep = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| ExpressionVoid epl = new ExpressionVoid(); |
| ep.addProxyListener(epl); |
| exp.createMethodInvocation(ForExpression.ASSIGNMENT_RIGHT, "testVoid", true, 0); |
| exp.createTypeReceiver("testPackage.TestAccess"); |
| exp.invokeExpression(); |
| assertTrue(epl.voidCalled); |
| } |
| |
| public void testAssignmentNot() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createConditionalExpression(ForExpression.ROOTEXPRESSION); |
| exp.createPrimitiveLiteral(ForExpression.CONDITIONAL_CONDITION, true); |
| exp.createPrimitiveLiteral(ForExpression.CONDITIONAL_TRUE, true); |
| ExpressionProxy ep = exp.createProxyAssignmentExpression(ForExpression.CONDITIONAL_FALSE); |
| exp.createPrimitiveLiteral(ForExpression.ASSIGNMENT_RIGHT, false); |
| ExpressionNotResolved epl = new ExpressionNotResolved(); |
| ep.addProxyListener(epl); |
| exp.invokeExpression(); |
| assertTrue(epl.notResolvedCalled); |
| } |
| |
| public void testAssignmentLaterUsage() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // eparg = 3; |
| // epInteger = new Integer(eparg+1); |
| IExpression exp = proxyFactory.createExpression(); |
| ExpressionProxy epArg = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createPrimitiveLiteral(ForExpression.ASSIGNMENT_RIGHT, 3); |
| ExpressionProxy epInteger = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createClassInstanceCreation(ForExpression.ASSIGNMENT_RIGHT, proxyTypeFactory.getBeanTypeProxy("java.lang.Integer"), 1); |
| exp.createInfixExpression(ForExpression.CLASSINSTANCECREATION_ARGUMENT, InfixOperator.IN_PLUS, 0); |
| exp.createProxyExpression(ForExpression.INFIX_LEFT, epArg); // Use literal 3+1 as the argument to this. |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 1); |
| epInteger.addProxyListener(new ExpressionResolved() { |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyAdapter#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals(((INumberBeanProxy) event.getProxy()).intValue(), 4); |
| } |
| }); |
| exp.invokeExpression(); |
| } |
| |
| // TODO - for some unknown reason this test continues to fail in the build on the jvelinux machine. It seems to have |
| // very very poor performance on jvelinux. |
| // If we can get it working, put "test" on the front of the method name again to get it running as a test. |
| public void ExpressionPerformanceSmall() throws IllegalStateException, NoExpressionValueException, ThrowableProxy, AmbiguousMethodException, NoSuchMethodException { |
| // Small performance test. We are testing a small batch of expressions on each run. We then avg. the runs. This tests many small |
| // expression processing performance. |
| |
| // Prime the proxies so they don't become part of the timings. |
| IBeanTypeProxy pointType = proxyTypeFactory.getBeanTypeProxy("java.awt.Point"); |
| IMethodProxy setLocation = pointType.getMethodProxy("setLocation", new String[] {"int", "int"}); |
| IMethodProxy getLocation = pointType.getMethodProxy("getLocation"); |
| // |
| // Now for just a simple one method invocation using method proxies (and not method lookup each time) the standard proxy calls |
| // will beat out expression processing for Remote. Note that is not true of IDE vm. In that case the standard proxy calls |
| // will ALWAYS out perform greatly the expression processer because there is no latency in the communications. It is basically |
| // straight direct calls. While expression processing is also direct calls, the call path is much larger because it needs to |
| // build/maintain/execute the processing stack, rather than just execute the command. |
| // |
| |
| // Try to prime the communication pump. This sends about 36,000 bytes of data. |
| // Doing it here means later when needed the communications costs are drastically reduced. |
| IExpression exp = proxyFactory.createExpression(); |
| int i =1000; |
| while (i-->0) { |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, registry.getBeanTypeProxyFactory() |
| .getBeanTypeProxy(exp, "java.lang.Object", 1), 0); |
| exp.createArrayInitializer(0); |
| } |
| exp.invokeExpression(); |
| |
| int times = 100; // Number of times to run the test. |
| int batchSize = 10; // Size of batch for each test. |
| // Now do the actual test. |
| long start = System.currentTimeMillis(); |
| i = times; |
| while(i-->0) { |
| expressionSetting(pointType, setLocation, getLocation, batchSize); |
| } |
| |
| long expressionTime = System.currentTimeMillis()-start; |
| long startNormal = System.currentTimeMillis(); |
| i = times; |
| while(i-->0) { |
| normalSetting(pointType, setLocation, getLocation, batchSize); |
| } |
| long normalTime = System.currentTimeMillis()-startNormal; |
| System.out.println("Small Batch results: Batch size="+batchSize+" Number of runs="+times); |
| System.out.println("Expression Time: " + expressionTime + " Avg: " + (expressionTime/((double) times))); |
| System.out.println("Normal Time: " + normalTime+ " Avg: " + (normalTime/((double) times))); |
| if (normalTime == 0) |
| normalTime = 1; // So no divide by zero. |
| int improvement = (int) ((1-((double) expressionTime)/normalTime)*100); |
| System.out.println("Improvement of expression over normal time: "+improvement+'%'); |
| // Note that this test is not valid for IDE because the IDE will always be other way around because |
| // there is no latency delay there. |
| |
| if (!(proxyFactory instanceof IDEStandardBeanProxyFactory)) |
| assertTrue("Less than 30% improvement: "+improvement+'%', improvement>=30); // We like this %. |
| } |
| |
| // TODO - for some unknown reason this test continues to fail in the build on the jvelinux machine. It seems to have |
| // very very poor performance on jvelinux. |
| // If we can get it working, put "test" on the front of the method name again to get it running as a test. |
| public void ExpressionPerformanceLarge() throws IllegalStateException, NoExpressionValueException, ThrowableProxy, AmbiguousMethodException, NoSuchMethodException { |
| // Small performance test. We are testing a large batch of expressions on each run. We then avg. the runs. This tests many large |
| // expression processing performance. |
| |
| // Prime the proxies so they don't become part of the timings. |
| IBeanTypeProxy pointType = proxyTypeFactory.getBeanTypeProxy("java.awt.Point"); |
| IMethodProxy setLocation = pointType.getMethodProxy("setLocation", new String[] {"int", "int"}); |
| IMethodProxy getLocation = pointType.getMethodProxy("getLocation"); |
| // |
| // Now for just a simple one method invocation using method proxies (and not method lookup each time) the standard proxy calls |
| // will beat out expression processing for Remote. Note that is not true of IDE vm. In that case the standard proxy calls |
| // will ALWAYS out perform greatly the expression processer because there is no latency in the communications. It is basically |
| // straight direct calls. While expression processing is also direct calls, the call path is much larger because it needs to |
| // build/maintain/execute the processing stack, rather than just execute the command. |
| // |
| |
| // Try to prime the communication pump. This sends about 36,000 bytes of data. |
| // Doing it here means later when needed the communications costs are drastically reduced. |
| IExpression exp = proxyFactory.createExpression(); |
| int i =1000; |
| while (i-->0) { |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, registry.getBeanTypeProxyFactory() |
| .getBeanTypeProxy(exp, "java.lang.Object", 1), 0); |
| exp.createArrayInitializer(0); |
| } |
| exp.invokeExpression(); |
| |
| int times = 25; // Number of times to run the test. |
| int batchSize = 100; // Size of batch for each test. |
| |
| // Now do the actual test. |
| long start = System.currentTimeMillis(); |
| i = times; |
| while(i-->0) { |
| expressionSetting(pointType, setLocation, getLocation, batchSize); |
| } |
| long expressionTime = System.currentTimeMillis()-start; |
| long startNormal = System.currentTimeMillis(); |
| i = times; |
| while(i-->0) { |
| normalSetting(pointType, setLocation, getLocation, batchSize); |
| } |
| long normalTime = System.currentTimeMillis()-startNormal; |
| System.out.println("Large Batch results: Batch size="+batchSize+" Number of runs="+times); |
| System.out.println("Expression Time: " + expressionTime + " Avg: " + (expressionTime/((double) times))); |
| System.out.println("Normal Time: " + normalTime+ " Avg: " + (normalTime/((double) times))); |
| if (normalTime == 0) |
| normalTime = 1; // So no divide by zero. |
| int improvement = (int) ((1-((double) expressionTime)/normalTime)*100); |
| System.out.println("Improvement of expression over normal time: "+improvement+'%'); |
| // Note that this test is not valid for IDE because the IDE will always be other way around because |
| // there is no latency delay there. |
| if (!(proxyFactory instanceof IDEStandardBeanProxyFactory)) |
| assertTrue("Less than 75% improvement: "+improvement+'%', improvement>=75); // We like this %. |
| } |
| |
| private void expressionSetting(IBeanTypeProxy pointType, IMethodProxy setLocation, IMethodProxy getLocation, int times) throws ThrowableProxy, NoExpressionValueException { |
| // This is the same as expressionSetting except it uses regular proxy access instead of expressions. It should be |
| // slower because it requires a round trip for each access. For remote only. |
| // To factor out the overhead of the initialization of the expression processing, we will do the create/set/get 10 times. |
| // Point p = new Point(); |
| // p.setLocation(3,4); |
| // p.getLocation(); |
| IExpression exp = proxyFactory.createExpression(); |
| for (int i = 0; i < times; i++) { |
| ExpressionProxy epPoint = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createClassInstanceCreation(ForExpression.ASSIGNMENT_RIGHT, pointType, 0); |
| exp.createSimpleMethodInvoke(setLocation, epPoint, new IProxy[] {proxyFactory.createBeanProxyWith(3), proxyFactory.createBeanProxyWith(4)}, false); |
| ExpressionProxy epLoc = exp.createSimpleMethodInvoke(getLocation, epPoint, null, true); |
| epLoc.addProxyListener(new ExpressionProxy.ProxyAdapter()); // Just have a listener, we want the callback overhead added in. |
| } |
| exp.invokeExpression(); |
| } |
| |
| private void normalSetting(IBeanTypeProxy pointType, IMethodProxy setLocation, IMethodProxy getLocation, int times) throws ThrowableProxy, AmbiguousMethodException, NoSuchMethodException { |
| // This is the same as expressionSetting except it uses regular proxy access instead of expressions. It should be |
| // slower because it requires a round trip for each access. |
| // To factor out the overhead of the initialization of the expression processing, we will do the create/set/get 10 times. This here matches that. |
| // Point p = new Point(); |
| // p.setLocation(3,4); |
| for (int i = 0; i < times; i++) { |
| IBeanProxy epPoint = pointType.newInstance(); |
| setLocation.invokeCatchThrowableExceptions(epPoint, new IBeanProxy[] {proxyFactory.createBeanProxyWith(3), proxyFactory.createBeanProxyWith(4)}); |
| getLocation.invokeCatchThrowableExceptions(epPoint); |
| } |
| } |
| |
| public void testBlock() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| int blocknum = exp.createBlockBegin(); |
| ExpressionProxy epArg = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createPrimitiveLiteral(ForExpression.ASSIGNMENT_RIGHT, true); |
| exp.createBlockBreak(blocknum); |
| ExpressionProxy epBoolean = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createClassInstanceCreation(ForExpression.ASSIGNMENT_RIGHT, proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), 1); |
| exp.createInfixExpression(ForExpression.CLASSINSTANCECREATION_ARGUMENT, InfixOperator.IN_CONDITIONAL_AND, 0); |
| exp.createProxyExpression(ForExpression.INFIX_LEFT, epArg); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, true); |
| exp.createBlockEnd(); |
| ExpressionNotResolved epBooleanl = new ExpressionNotResolved(); |
| epBoolean.addProxyListener(epBooleanl); |
| exp.invokeExpression(); |
| assertTrue(epBooleanl.notResolvedCalled); |
| } |
| |
| /* |
| * A proxy listener class for test purposes that requires resolved but |
| * won't allow not resolved or void resolution. Impliment the resolved |
| * method to test for valid values. |
| * |
| * @since 1.1.0 |
| */ |
| protected abstract class ExpressionResolved implements ExpressionProxy.ProxyListener { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyNotResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyNotResolved(ProxyEvent event) { |
| fail("Proxy must not be unresolved."); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyVoid(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyVoid(ProxyEvent event) { |
| fail("Proxy must not be void assignment."); |
| } |
| } |
| |
| protected class ExpressionNotResolved implements ExpressionProxy.ProxyListener { |
| public boolean notResolvedCalled = false; |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyNotResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyNotResolved(ProxyEvent event) { |
| notResolvedCalled = true; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| fail("Proxy should not of been resolved. It should be unresolved."); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyVoid(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyVoid(ProxyEvent event) { |
| fail("Proxy must not be void assignment. It should be unresolved."); |
| } |
| }; |
| |
| protected class ExpressionVoid implements ExpressionProxy.ProxyListener { |
| public boolean voidCalled = false; |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyNotResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyNotResolved(ProxyEvent event) { |
| fail("Proxy should of been void and not unresolved."); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| fail("Proxy should not of been resolved, it should of been void.."); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyVoid(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyVoid(ProxyEvent event) { |
| voidCalled = true; |
| } |
| }; |
| |
| public void testTryCatchNoThrow() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = Boolean.valueOf(true); |
| * } catch (RuntimeException e) { |
| * y = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| xProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertTrue(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy.addProxyListener(runtimeCatchExceptionProxyResolver); |
| exp.invokeExpression(); |
| |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTry2CatchNoThrow() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * try { |
| * x = Boolean.valueOf(true); |
| * } catch (RuntimeException e) { |
| * y = Boolean.valueOf(false); |
| * } |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionProxy runtimeCatchExceptionProxy2 = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| |
| xProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertTrue(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy.addProxyListener(runtimeCatchExceptionProxyResolver); |
| ExpressionNotResolved zProxyResolver = new ExpressionNotResolved(); |
| zProxy.addProxyListener(zProxyResolver); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver2 = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy2.addProxyListener(runtimeCatchExceptionProxyResolver2); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver.notResolvedCalled); |
| assertTrue(zProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver2.notResolvedCalled); |
| |
| } |
| |
| public void testTry2CatchThrowTry1() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * w = (null).booleanValue(); |
| * try { |
| * x = Boolean.valueOf(true); |
| * } catch (RuntimeException e) { |
| * y = Boolean.valueOf(false); |
| * } |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy wProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionProxy runtimeCatchExceptionProxy2 = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| |
| ExpressionNotResolved wProxyResolver = new ExpressionNotResolved(); |
| wProxy.addProxyListener(wProxyResolver); |
| |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy.addProxyListener(runtimeCatchExceptionProxyResolver); |
| zProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| runtimeCatchExceptionProxy2.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(wProxyResolver.notResolvedCalled); |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTry2CatchThrowTry2Catch() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (RuntimeException e) { |
| * y = Boolean.valueOf(false); |
| * } |
| * w = Boolean.valueOf(true); |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionProxy wProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy2 = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| runtimeCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| |
| yProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| wProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertTrue(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver2 = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy2.addProxyListener(runtimeCatchExceptionProxyResolver2); |
| ExpressionNotResolved zProxyResolver = new ExpressionNotResolved(); |
| zProxy.addProxyListener(zProxyResolver); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver2.notResolvedCalled); |
| assertTrue(zProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTry2CatchThrowTry2Catch1() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (IllegalArgumentException e) { |
| * y = Boolean.valueOf(false); |
| * } |
| * w = Boolean.valueOf(true); |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy illegalArgumentCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.IllegalArgumentException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionProxy wProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy2 = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| ExpressionNotResolved illegalArgumentCatchProxyResolver = new ExpressionNotResolved(); |
| illegalArgumentCatchExceptionProxy.addProxyListener(illegalArgumentCatchProxyResolver); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| ExpressionNotResolved wProxyResolver = new ExpressionNotResolved(); |
| wProxy.addProxyListener(wProxyResolver); |
| |
| runtimeCatchExceptionProxy2.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| zProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(illegalArgumentCatchProxyResolver.notResolvedCalled); |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(wProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTry2CatchThrowTry2Finally2Catch1() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (IllegalArgumentException e) { |
| * y = Boolean.valueOf(false); |
| * } finally { |
| * v = Boolean.valueOf(false); |
| * } |
| * w = Boolean.valueOf(true); |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy illegalArgumentCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.IllegalArgumentException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryFinallyClause(); |
| ExpressionProxy vProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionProxy wProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy2 = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| ExpressionNotResolved illegalArgumentCatchProxyResolver = new ExpressionNotResolved(); |
| illegalArgumentCatchExceptionProxy.addProxyListener(illegalArgumentCatchProxyResolver); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| vProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| ExpressionNotResolved wProxyResolver = new ExpressionNotResolved(); |
| wProxy.addProxyListener(wProxyResolver); |
| |
| runtimeCatchExceptionProxy2.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| zProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(illegalArgumentCatchProxyResolver.notResolvedCalled); |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(wProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTry2CatchThrowTry2Finally2NoCatch() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (IllegalArgumentException e) { |
| * y = Boolean.valueOf(false); |
| * } finally { |
| * v = Boolean.valueOf(false); |
| * } |
| * w = Boolean.valueOf(true); |
| * } catch (IllegalArgumentException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy illegalArgumentCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.IllegalArgumentException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryFinallyClause(); |
| ExpressionProxy vProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionProxy wProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy illegalArgumentCatchExceptionProxy2 = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.IllegalArgumentException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| ExpressionNotResolved illegalArgumentCatchProxyResolver = new ExpressionNotResolved(); |
| illegalArgumentCatchExceptionProxy.addProxyListener(illegalArgumentCatchProxyResolver); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| vProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| ExpressionNotResolved wProxyResolver = new ExpressionNotResolved(); |
| wProxy.addProxyListener(wProxyResolver); |
| |
| ExpressionNotResolved illegalArgumentCatchExceptionProxyResolver2 = new ExpressionNotResolved(); |
| illegalArgumentCatchExceptionProxy2.addProxyListener(illegalArgumentCatchExceptionProxyResolver2); |
| ExpressionNotResolved zProxyResolver = new ExpressionNotResolved(); |
| zProxy.addProxyListener(zProxyResolver); |
| |
| boolean didit = false; |
| try { |
| exp.invokeExpression(); |
| } catch (ThrowableProxy e) { |
| assertEquals(proxyTypeFactory.getBeanTypeProxy("java.lang.NullPointerException"), e.getTypeProxy()); |
| didit = true; |
| } |
| |
| assertTrue(didit); |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(illegalArgumentCatchProxyResolver.notResolvedCalled); |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(wProxyResolver.notResolvedCalled); |
| assertTrue(illegalArgumentCatchExceptionProxyResolver2.notResolvedCalled); |
| assertTrue(zProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTryCatchThrow() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (NullPointerException e) { |
| * y = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy nullCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| yProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| nullCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| exp.invokeExpression(); |
| assertTrue(xProxyResolver.notResolvedCalled); |
| } |
| |
| public void testTryCatchRethrow() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (NullPointerException e) { |
| * y = Boolean.valueOf(false); |
| * throw e; // As a rethrow. |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy nullCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createRethrow(); |
| exp.createTryEnd(); |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| yProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| nullCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| try { |
| exp.invokeExpression(); |
| fail("Should of thrown NPE."); |
| } catch (ThrowableProxy e) { |
| assertEquals("java.lang.NullPointerException", e.getTypeProxy().getTypeName()); |
| } |
| assertTrue(xProxyResolver.notResolvedCalled); |
| } |
| |
| |
| public void testTryCatchExplicitThrow() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = Boolean.valueOf(true); |
| * throw new NullPointerException(); |
| * y = Boolean.valueOf(false); |
| * } catch (NullPointerException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| exp.createThrow(); |
| exp.createClassInstanceCreation(ForExpression.THROW_OPERAND, proxyTypeFactory.getBeanTypeProxy("java.lang.NullPointerException"), 0); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| ExpressionProxy nullCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.NullPointerException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| xProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertTrue(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| |
| zProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| nullCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| exp.invokeExpression(); |
| assertTrue(yProxyResolver.notResolvedCalled); |
| } |
| |
| public void testTryCatch2NoThrow() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = Boolean.valueOf(true); |
| * } catch (IllegalArgumentException e) { |
| * y = Boolean.valueOf(false); |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy illegalCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.IllegalArgumentException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| xProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertTrue(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| ExpressionNotResolved illegalCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| illegalCatchExceptionProxy.addProxyListener(illegalCatchExceptionProxyResolver); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy.addProxyListener(runtimeCatchExceptionProxyResolver); |
| ExpressionNotResolved zProxyResolver = new ExpressionNotResolved(); |
| zProxy.addProxyListener(zProxyResolver); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(illegalCatchExceptionProxyResolver.notResolvedCalled); |
| assertTrue(zProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTryCatch2Throw1() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (NullPointerException e) { |
| * y = Boolean.valueOf(false); |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy nullCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.NullPointerException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| |
| yProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| nullCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy.addProxyListener(runtimeCatchExceptionProxyResolver); |
| ExpressionNotResolved zProxyResolver = new ExpressionNotResolved(); |
| zProxy.addProxyListener(zProxyResolver); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(zProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTryCatch2Throw2() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (IllegalArgumentException e) { |
| * y = Boolean.valueOf(false); |
| * } catch (NullPointerException e) { |
| * z = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy illegalCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.IllegalArgumentException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| ExpressionProxy nullCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.NullPointerException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| ExpressionNotResolved illegalCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| illegalCatchExceptionProxy.addProxyListener(illegalCatchExceptionProxyResolver); |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| |
| zProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| nullCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| exp.invokeExpression(); |
| |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(illegalCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTryCatchThrowFinally() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (NullPointerException e) { |
| * y = Boolean.valueOf(false); |
| * } finally { |
| * f = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy nullCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryFinallyClause(); |
| ExpressionProxy fProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| |
| exp.createTryEnd(); |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| yProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| nullCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| |
| fProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| assertTrue(xProxyResolver.notResolvedCalled); |
| } |
| |
| public void testTryCatch2Throw1Finally() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (NullPointerException e) { |
| * y = Boolean.valueOf(false); |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } finally { |
| * f = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy nullCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.NullPointerException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryFinallyClause(); |
| ExpressionProxy fProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| |
| yProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| nullCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy.addProxyListener(runtimeCatchExceptionProxyResolver); |
| ExpressionNotResolved zProxyResolver = new ExpressionNotResolved(); |
| zProxy.addProxyListener(zProxyResolver); |
| fProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| |
| |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(zProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTryCatch2Throw2Finally() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = (null).booleanValue(); |
| * } catch (IllegalArgumentException e) { |
| * y = Boolean.valueOf(false); |
| * } catch (NullPointerException e) { |
| * z = Boolean.valueOf(false); |
| * } finally { |
| * f = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("booleanValue"), null, null, true); |
| ExpressionProxy illegalCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.IllegalArgumentException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| ExpressionProxy nullCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.NullPointerException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryFinallyClause(); |
| ExpressionProxy fProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| ExpressionNotResolved xProxyResolver = new ExpressionNotResolved(); |
| xProxy.addProxyListener(xProxyResolver); |
| ExpressionNotResolved illegalCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| illegalCatchExceptionProxy.addProxyListener(illegalCatchExceptionProxyResolver); |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| |
| zProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| nullCatchExceptionProxy.addProxyListener(new ExpressionResolved() { |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| assertEquals("java.lang.NullPointerException", event.getProxy().getTypeProxy().getTypeName()); |
| } |
| }); |
| |
| fProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| exp.invokeExpression(); |
| |
| assertTrue(xProxyResolver.notResolvedCalled); |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(illegalCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| |
| public void testTryCatchNoThrowFinally() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = Boolean.valueOf(true); |
| * } catch (RuntimeException e) { |
| * y = Boolean.valueOf(false); |
| * } finally { |
| * f = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryFinallyClause(); |
| ExpressionProxy fProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| xProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertTrue(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy.addProxyListener(runtimeCatchExceptionProxyResolver); |
| fProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| public void testTryCatch2NoThrowFinally() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| /* |
| * try { |
| * x = Boolean.valueOf(true); |
| * } catch (IllegalArgumentException e) { |
| * y = Boolean.valueOf(false); |
| * } catch (RuntimeException e) { |
| * z = Boolean.valueOf(false); |
| * } finally { |
| * f = Boolean.valueOf(false); |
| * } |
| */ |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createTry(); |
| ExpressionProxy xProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(true)}, true); |
| ExpressionProxy illegalCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.IllegalArgumentException"), true); |
| ExpressionProxy yProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| ExpressionProxy runtimeCatchExceptionProxy = exp.createTryCatchClause(proxyTypeFactory.getBeanTypeProxy("java.lang.RuntimeException"), true); |
| ExpressionProxy zProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryFinallyClause(); |
| ExpressionProxy fProxy = exp.createSimpleMethodInvoke(proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean").getMethodProxy("valueOf", new String[] {"boolean"}), null, new IProxy[] {proxyFactory.createBeanProxyWith(false)}, true); |
| exp.createTryEnd(); |
| xProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertTrue(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| ExpressionNotResolved yProxyResolver = new ExpressionNotResolved(); |
| yProxy.addProxyListener(yProxyResolver); |
| ExpressionNotResolved illegalCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| illegalCatchExceptionProxy.addProxyListener(illegalCatchExceptionProxyResolver); |
| ExpressionNotResolved runtimeCatchExceptionProxyResolver = new ExpressionNotResolved(); |
| runtimeCatchExceptionProxy.addProxyListener(runtimeCatchExceptionProxyResolver); |
| ExpressionNotResolved zProxyResolver = new ExpressionNotResolved(); |
| zProxy.addProxyListener(zProxyResolver); |
| fProxy.addProxyListener(new ExpressionResolved() { |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyListener#proxyResolved(org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent) |
| */ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy proxy = event.getProxy(); |
| assertEquals("Not a Boolean proxy:"+proxy.getTypeProxy().getTypeName(), proxyTypeFactory.getBeanTypeProxy("java.lang.Boolean"), proxy.getTypeProxy()); |
| assertFalse(((IBooleanBeanProxy) event.getProxy()).booleanValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| |
| assertTrue(yProxyResolver.notResolvedCalled); |
| assertTrue(illegalCatchExceptionProxyResolver.notResolvedCalled); |
| assertTrue(zProxyResolver.notResolvedCalled); |
| assertTrue(runtimeCatchExceptionProxyResolver.notResolvedCalled); |
| |
| } |
| |
| |
| public void testIfElseTrueWithElse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createIfElse(true); |
| exp.createInfixExpression(ForExpression.IF_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| ExpressionProxy trueProxy = exp.createProxyAssignmentExpression(ForExpression.IF_TRUE); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| ExpressionProxy falseProxy = exp.createProxyAssignmentExpression(ForExpression.IF_ELSE); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| |
| trueProxy.addProxyListener(new ExpressionResolved() { |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("int", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(6, ((INumberBeanProxy) value).intValue()); |
| } |
| }); |
| |
| falseProxy.addProxyListener(new ExpressionNotResolved()); |
| exp.invokeExpression(); |
| } |
| |
| public void testIfElseFalseWithElse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createIfElse(true); |
| exp.createInfixExpression(ForExpression.IF_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| ExpressionProxy trueProxy = exp.createProxyAssignmentExpression(ForExpression.IF_TRUE); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| ExpressionProxy falseProxy = exp.createProxyAssignmentExpression(ForExpression.IF_ELSE); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| |
| trueProxy.addProxyListener(new ExpressionNotResolved()); |
| |
| falseProxy.addProxyListener(new ExpressionResolved() { |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("int", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(0, ((INumberBeanProxy) value).intValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| } |
| |
| public void testIfElseTrueWithoutElse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createIfElse(false); |
| exp.createInfixExpression(ForExpression.IF_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| ExpressionProxy trueProxy = exp.createProxyAssignmentExpression(ForExpression.IF_TRUE); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| |
| trueProxy.addProxyListener(new ExpressionResolved() { |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("int", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(6, ((INumberBeanProxy) value).intValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| } |
| |
| public void testIfElseFalseWithoutElse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createIfElse(false); |
| exp.createInfixExpression(ForExpression.IF_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| ExpressionProxy trueProxy = exp.createProxyAssignmentExpression(ForExpression.IF_TRUE); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| |
| trueProxy.addProxyListener(new ExpressionNotResolved()); |
| |
| exp.invokeExpression(); |
| } |
| |
| public void testIfElseBlocksTrueWithElse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createIfElse(true); |
| exp.createInfixExpression(ForExpression.IF_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockBegin(); |
| ExpressionProxy trueProxy = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockEnd(); |
| exp.createBlockBegin(); |
| ExpressionProxy falseProxy = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockEnd(); |
| |
| trueProxy.addProxyListener(new ExpressionResolved() { |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("int", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(6, ((INumberBeanProxy) value).intValue()); |
| } |
| }); |
| |
| falseProxy.addProxyListener(new ExpressionNotResolved()); |
| exp.invokeExpression(); |
| } |
| |
| public void testIfElseBlocksFalseWithElse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createIfElse(true); |
| exp.createInfixExpression(ForExpression.IF_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockBegin(); |
| ExpressionProxy trueProxy = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockEnd(); |
| exp.createBlockBegin(); |
| ExpressionProxy falseProxy = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_MINUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockEnd(); |
| |
| trueProxy.addProxyListener(new ExpressionNotResolved()); |
| |
| falseProxy.addProxyListener(new ExpressionResolved() { |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("int", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(0, ((INumberBeanProxy) value).intValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| } |
| |
| public void testIfElseBlockTrueWithoutElse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createIfElse(false); |
| exp.createInfixExpression(ForExpression.IF_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockBegin(); |
| ExpressionProxy trueProxy = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockEnd(); |
| |
| trueProxy.addProxyListener(new ExpressionResolved() { |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("int", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(6, ((INumberBeanProxy) value).intValue()); |
| } |
| }); |
| |
| exp.invokeExpression(); |
| } |
| |
| public void testIfElseBlockFalseWithoutElse() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createIfElse(false); |
| exp.createInfixExpression(ForExpression.IF_CONDITION, InfixOperator.IN_EQUALS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 4); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockBegin(); |
| ExpressionProxy trueProxy = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_PLUS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, (byte) 3); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, (short) 3); |
| exp.createBlockEnd(); |
| |
| trueProxy.addProxyListener(new ExpressionNotResolved()); |
| |
| exp.invokeExpression(); |
| } |
| |
| public void testNewInitStringPrimitive() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // Use internal expression class so we can test the special method. |
| Expression exp = (Expression) proxyFactory.createExpression(); |
| ExpressionProxy result = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_RIGHT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| result.addProxyListener(new ExpressionResolved(){ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("boolean", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(false, ((IBooleanBeanProxy) value).booleanValue()); |
| } |
| |
| }); |
| |
| exp.invokeExpression(); |
| } |
| |
| public void testMark() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // Just test having a mark and no errors. |
| Expression exp = (Expression) proxyFactory.createExpression(); |
| int mark = exp.mark(); |
| try { |
| ExpressionProxy result = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_RIGHT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| result.addProxyListener(new ExpressionResolved(){ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("boolean", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(false, ((IBooleanBeanProxy) value).booleanValue()); |
| } |
| |
| }); |
| } finally { |
| exp.endMark(mark); |
| } |
| exp.invokeExpression(); |
| |
| } |
| |
| public void testMark2() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // Just test having a mark errors, but expressions before the mark and after the mark are successful. |
| Expression exp = (Expression) proxyFactory.createExpression(); |
| int mark0 = exp.mark(); |
| final boolean[] resultResolved = new boolean[1]; |
| ExpressionNotResolved ep1 = null; |
| final boolean[] resultResolved2 = new boolean[1]; |
| try { |
| ExpressionProxy result = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| result.addProxyListener(new ExpressionResolved() { |
| |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("boolean", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(false, ((IBooleanBeanProxy) value).booleanValue()); |
| resultResolved[0] = true; |
| } |
| |
| }); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_RIGHT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| exp.createTry(); |
| int mark = exp.mark(); |
| try { |
| ExpressionProxy result1 = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| result1.addProxyListener(ep1 = new ExpressionNotResolved()); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_LEFT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| } catch (IllegalStateException e) { |
| // This is ok, should of got this. |
| } finally { |
| exp.endMark(mark); |
| } |
| exp.createTryEnd(); |
| ExpressionProxy result2 = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| result2.addProxyListener(new ExpressionResolved() { |
| |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("boolean", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(false, ((IBooleanBeanProxy) value).booleanValue()); |
| resultResolved2[0] = true; |
| } |
| |
| }); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_RIGHT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| } finally { |
| exp.endMark(mark0); |
| } |
| |
| exp.invokeExpression(); |
| |
| assertNotNull(ep1); |
| assertTrue(ep1.notResolvedCalled); |
| assertTrue(resultResolved[0]); |
| assertTrue(resultResolved2[0]); |
| |
| } |
| |
| |
| public void testMarkError() throws IllegalStateException, ThrowableProxy, NoExpressionValueException { |
| // Test with one error and see if it restores correctly. |
| Expression exp = (Expression) proxyFactory.createExpression(); |
| int mark = exp.mark(); |
| ExpressionNotResolved epl = null; |
| try { |
| ExpressionProxy result = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| result.addProxyListener(epl = new ExpressionNotResolved()); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_LEFT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| } catch (IllegalStateException e) { |
| // This is good. We should get here. |
| } finally { |
| exp.endMark(mark); |
| } |
| |
| // Now we should be able to continue and get good answer. |
| ExpressionProxy result = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_RIGHT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| result.addProxyListener(new ExpressionResolved(){ |
| public void proxyResolved(ProxyEvent event) { |
| IBeanProxy value = event.getProxy(); |
| assertNotNull(value); |
| assertEquals("boolean", value.getTypeProxy().getFormalTypeName()); |
| assertEquals(false, ((IBooleanBeanProxy) value).booleanValue()); |
| } |
| |
| }); |
| |
| exp.invokeExpression(); |
| assertNotNull(epl); |
| assertTrue(epl.notResolvedCalled); |
| } |
| |
| public void testMarkNestError() { |
| // Test mark nest error. |
| // mark |
| // try { |
| // endmark |
| // } finally <-- this should cause an exception. |
| Expression exp = (Expression) proxyFactory.createExpression(); |
| int mark = exp.mark(); |
| ExpressionNotResolved epl = null; |
| try { |
| exp.createTry(); |
| ExpressionProxy result = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| result.addProxyListener(epl = new ExpressionNotResolved()); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_RIGHT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| exp.endMark(mark); |
| exp.createTryFinallyClause(); |
| exp.createTryEnd(); |
| } catch (IllegalStateException e) { |
| // This is good. We should get here. |
| exp.close(); |
| assertNotNull(epl); |
| assertTrue(epl.notResolvedCalled); |
| return; |
| } |
| |
| exp.close(); |
| fail("Should not of gotten here."); |
| } |
| |
| public void testMarkNestError2() { |
| // Test mark nest error. |
| // try { |
| // mark |
| // } finally <-- this should cause an exception. |
| // endmark |
| Expression exp = (Expression) proxyFactory.createExpression(); |
| ExpressionNotResolved epl = null; |
| try { |
| exp.createTry(); |
| int mark = exp.mark(); |
| ExpressionProxy result = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| result.addProxyListener(epl = new ExpressionNotResolved()); |
| exp.createNewInstance(ForExpression.ASSIGNMENT_RIGHT, "false", proxyTypeFactory.getBeanTypeProxy("boolean")); |
| exp.createTryFinallyClause(); |
| exp.createTryEnd(); |
| exp.endMark(mark); |
| } catch (IllegalStateException e) { |
| // This is good. We should get here. |
| exp.close(); |
| assertNotNull(epl); |
| assertTrue(epl.notResolvedCalled); |
| return; |
| } |
| |
| exp.close(); |
| fail("Should not of gotten here."); |
| } |
| |
| public void testExpressionTransfer() throws Throwable { |
| // Test that thread transfer works. We will do part of the expression in one thread, more in the next, and |
| // then come back and complete it. |
| IExpression exp = proxyFactory.createExpression(); |
| ExpressionProxy epInfix = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createInfixExpression(ForExpression.ASSIGNMENT_RIGHT, InfixOperator.IN_LESS, 0); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_LEFT, -10000000); |
| exp.createPrimitiveLiteral(ForExpression.INFIX_RIGHT, 3); |
| |
| // Now transfer to another thread. |
| Expression expression = (Expression) exp; |
| expression.beginTransferThread(); // Begin the transfer. |
| |
| IBeanTypeProxy callbackType = proxyTypeFactory.getBeanTypeProxy("org.eclipse.jem.tests.proxy.vm.TestExpressionThreadTransfer"); //$NON-NLS-1$ |
| assertNotNull(callbackType); |
| IBeanProxy callbackProxy = callbackType.newInstance(); |
| |
| ExpressionThreadTransferCallBack cb = new ExpressionThreadTransferCallBack(expression); |
| registry.getCallbackRegistry().registerCallback(callbackProxy, cb); |
| IInvokable start = callbackType.getInvokable("start"); //$NON-NLS-1$ |
| start.invokeCatchThrowableExceptions(callbackProxy); // Start the thread on the remote vm and wait for it to finish. |
| |
| epInfix.addProxyListener(new ExpressionResolved() { |
| public void proxyResolved(ExpressionProxy.ProxyEvent event) { |
| IBeanProxy result = event.getProxy(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(-10000000<3, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| }); |
| |
| if (cb.error != null) { |
| throw cb.error; |
| } |
| |
| cb.ep.addProxyListener(new ExpressionResolved(){ |
| public void proxyResolved(ExpressionProxy.ProxyEvent event) { |
| IBeanProxy result = event.getProxy(); |
| assertNotNull(result); |
| assertEquals("boolean", result.getTypeProxy().getTypeName()); |
| assertEquals(String.class == String.class, ((IBooleanBeanProxy) result).booleanValue()); |
| } |
| }); |
| |
| expression.transferThread(); |
| exp.invokeExpression(); |
| } |
| |
| public void testSubexpression() throws IllegalStateException, IllegalArgumentException, ThrowableProxy, NoExpressionValueException { |
| IExpression exp = proxyFactory.createExpression(); |
| exp.createArrayCreation(ForExpression.ROOTEXPRESSION, "int[][][]", 2); |
| exp.createPrimitiveLiteral(ForExpression.ARRAYCREATION_DIMENSION, 2); |
| ExpressionProxy secondDimensionProxy = null; |
| // This tests that we can put an expression right in the middle of another expression and |
| // pick it where it left off. |
| exp.createSubexpression(); |
| exp.createTry(); |
| secondDimensionProxy = exp.createProxyAssignmentExpression(ForExpression.ROOTEXPRESSION); |
| exp.createPrimitiveLiteral(ForExpression.ASSIGNMENT_RIGHT, 4); |
| exp.createTryEnd(); |
| exp.createSubexpressionEnd(); |
| exp.createProxyExpression(ForExpression.ARRAYCREATION_DIMENSION, secondDimensionProxy); |
| IBeanProxy result = exp.getExpressionValue(); |
| assertNotNull(result); |
| assertEquals("int[][][]", result.getTypeProxy().getFormalTypeName()); |
| assertEquals(2, ((IArrayBeanProxy) result).getLength()); |
| assertEquals(4, ((IArrayBeanProxy)((IArrayBeanProxy) result).get(0)).getLength()); |
| assertNull(((IArrayBeanProxy)((IArrayBeanProxy) result).get(0)).get(0)); |
| } |
| } |