Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2010 itemis AG (http://www.itemis.eu) 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 /
   
   package org.eclipse.xtext.xbase.junit.evaluation;
   
  import static com.google.common.collect.Lists.newArrayList;
  import static com.google.common.collect.Sets.newHashSet;
  import static com.google.common.collect.Sets.newTreeSet;
  import static com.google.common.collect.Maps.newHashMap;
  import static java.util.Collections.emptyList;
  
  import java.util.HashMap;
  import java.util.Map;
  import java.util.Stack;
  
  import  org.eclipse.xtext.junit4.TemporaryFolder;
  import  org.eclipse.xtext.xbase.lib.Pair;
  import  org.junit.Assert;
  import  org.junit.Ignore;
  import  org.junit.Rule;
  import  org.junit.Test;
  
  
  import  com.google.inject.Inject;

Author(s):
Sebastian Zarnekow - Initial contribution and API
Sven Efftinge
  
  public abstract class AbstractXbaseEvaluationTest extends Assert {
  	
  	@Rule
  	@Inject public TemporaryFolder temporaryFolder = new TemporaryFolder();
  	
  	@Test public void testReservedWordEnum() throws Exception {
  		assertEvaluatesTo(."typeof(java.lang.annotation.RetentionPolicy).enum");
  	}
  	
  	@Test public void testReservedWordEnum_02() throws Exception {
  		assertEvaluatesTo(."java.lang.annotation.RetentionPolicy.enum");
  	}
  	
  	@Test public void testReservedWordEnum_03() throws Exception {
  		assertEvaluatesTo(."java.lang.annotation.RetentionPolicy.SOURCE");
  	}
  	
  	@Test public void testReservedWordInterface() throws Exception {
  		assertEvaluatesTo(."typeof(Iterable).interface");
  	}
  	
  	@Test public void testReservedWordInterface_02() throws Exception {
  		assertEvaluatesTo(."Iterable.interface");
  	}
  	
  	@Test public void testReservedWordAnnotation() throws Exception {
  		assertEvaluatesTo(."typeof(Override).annotation");
  	}
  	
  	@Test public void testReservedWordClass() throws Exception {
  		assertEvaluatesTo(Class.class"typeof(Override).class");
  	}
  	
  	@Test public void testDoubleSwitch() throws Exception {
  		assertEvaluatesTo("foo","{ val x = 'foo' switch x.length { case 2 : 'bla'.toString } switch x.length { case 3 : 'foo'.toString } }");
  	}
  
  	@Test public void testIntLiteral_0() throws Exception {
  		assertEvaluatesTo(1, "1");
  	}
  
  	@Test public void testIntLiteral_2() throws Exception {
  		assertEvaluatesTo(0x17, "0x17");
  	}
  	
  	@Test public void testIntLiteral_2a() throws Exception {
  		assertEvaluatesTo(0x17, "0X17");
  	}
  	
  	@Test public void testIntLiteral_4() throws Exception {
  		assertEvaluatesTo(123456789, "123_456_789");
  	}
  	
  	@Test public void testIntLiteral_5() throws Exception {
  		assertEvaluatesTo(0xffffeeee, "0xffff_eeee");
  	}
 	
 	@Test public void testLongLiteral_0() throws Exception {
 		assertEvaluatesTo(1l, "1l");
 	}
 
 	@Test public void testLongLiteral_2() throws Exception {
 		assertEvaluatesTo(0x17l, "0x17#L");
 	}
 	
 	@Test public void testLongLiteral_4() throws Exception {
 		assertEvaluatesTo(123456789123456789L, "123_456_789_123_456_789L");
 	}
 	
 	@Test public void testLongLiteral_5() throws Exception {
 		assertEvaluatesTo(0xffffeeeeddddccccl, "0xffff_eeee_dddd_cccc#L");
 	}
 	
 	@Test public void testFloatLiteral_0() throws Exception {
 		assertEvaluatesTo(1f, "1f");
 	}
 
 	@Test public void testFloatLiteral_1() throws Exception {
 		assertEvaluatesTo(17f, "017f");
 	}
 	
 	@Test public void testFloatLiteral_2() throws Exception {
 		assertEvaluatesTo(1.0f, "1.0f");
 	}
 	
 	@Test public void testFloatLiteral_3() throws Exception {
 		assertEvaluatesTo(1.0e-10f, "1.0e-10f");
 	}
 	
 	@Test public void testFloatLiteral_4() throws Exception {
 		assertEvaluatesTo(1.0e+10f, "1.0e+10f");
 	}
 	
 	@Test public void testFloatLiteral_5() throws Exception {
 		assertEvaluatesTo(1.0E10f, "1.0E10f");
 	}
 	
 	@Test public void testFloatLiteral_6() throws Exception {
 		assertEvaluatesTo(1E10f, "1E10f");
 	}
 	
 	@Test public void testDoubleLiteral_0() throws Exception {
 		assertEvaluatesTo(1d, "1d");
 	}
 
 	@Test public void testDoubleLiteral_2() throws Exception {
 		assertEvaluatesTo(1.0, "1.0");
 	}
 	
 	@Test public void testDoubleLiteral_3() throws Exception {
 		assertEvaluatesTo(1.0e-10, "1.0e-10");
 	}
 	
 	@Test public void testDoubleLiteral_4() throws Exception {
 		assertEvaluatesTo(1.0E+10, "1.0E+10");
 	}
 	
 	@Test public void testDoubleLiteral_5() throws Exception {
 		assertEvaluatesTo(1.0E10, "1.0E10");
 	}
 
 	@Test public void testDoubleLiteral_6() throws Exception {
 		assertEvaluatesTo(1e10, "1e10");
 	}
 
 	@Test public void testDoubleLiteral_7() throws Exception {
 		assertEvaluatesTo(1.0d, "1.0d");
 	}
 	
 	@Test public void testDoubleLiteral_8() throws Exception {
 		assertEvaluatesTo(1.0e-10d, "1.0e-10d");
 	}
 	
 	@Test public void testDoubleLiteral_9() throws Exception {
 		assertEvaluatesTo(1.0E+10d, "1.0E+10d");
 	}
 	
 	@Test public void testDoubleLiteral_10() throws Exception {
 		assertEvaluatesTo(1.0E10d, "1.0E10d");
 	}
 
 	@Test public void testDoubleLiteral_11() throws Exception {
 		assertEvaluatesTo(1e10d, "1e10d");
 	}
 
 	@Test public void testDoubleLiteral_12() throws Exception {
 		assertEvaluatesTo(1.123456789e10d, "1.123_456_789e1_0d");
 	}
 
 	@Test public void testDoubleLiteral_13() throws Exception {
 		assertEvaluatesTo(123456789d, "123_456_789d");
 	}
 
 	@Test public void testBigInteger_0() throws Exception {
 		assertEvaluatesTo(new BigInteger("1"), "1bi");
 	}
 
 	@Test public void testBigInteger_1() throws Exception {
 		assertEvaluatesTo(new BigInteger("12345678901234567890123456789012345678901234567890"), 
 				"1234567890_12345678901234567890_1234567890_1234567890_Bi");
 	}
 
 	@Test public void testBigInteger_3() throws Exception {
 		assertEvaluatesTo(new BigInteger("77", 16), "0x77#bI");
 	}
 	
 	@Test public void testBigInteger_4() throws Exception {
 		assertEvaluatesTo(new BigInteger("1000000"), "10e+5bI");
 	}
 	
 	@Test public void testBigInteger_5() throws Exception {
 		assertEvaluatesTo(new BigDecimal("10e+12345").toBigInteger(), "10e+12345bI");
 	}
 	
 	@Test public void testBigInteger_6() throws Exception {
 		assertEvaluatesTo(new BigInteger("beefbeefbeefbeefbeef", 16), "0xbeef_beef_beef_beef_beef#BI");
 	}
 
 	@Test public void testBigDecimal_0() throws Exception {
 		assertEvaluatesTo(new BigDecimal("1.0"), "1.0bd");
 	}
 
 	@Test public void testBigDecimal_1() throws Exception {
 		assertEvaluatesTo(new BigDecimal("1.0e500"), "1.0e500Bd");
 	}
 
 	@Test public void testBigDecimal_2() throws Exception {
 		assertEvaluatesTo(new BigDecimal("123456789012345678901234567890.123456789012345678901234567890"), 
 				"1234567890_1234567890_1234567890.1234567890_1234567890_1234567890bD");
 	}
 
 	@Test public void testBigDecimal_3() throws Exception {
 		assertEvaluatesTo(new BigDecimal("1e500"), "1e500BD");
 	}
 
 	@Test public void testBug372408() throws Exception {
 		assertEvaluatesTo(new BigInteger("0"), "0BI");
 		assertEvaluatesTo(0l, "0l");
 	}
 	
 	@Test public void testImplicitOneArgClosure() throws Exception {
 		assertEvaluatesTo("foo","[it].apply('foo')");
 	}
 	
 	@Ignore("To be implemented later")
 	@Test public void testImplicitOneArgClosure_01() throws Exception {
 		assertEvaluatesTo(3,"[length].apply('foo')");
 	}
 	
 	@Test public void testImplicitOneArgClosure_02() throws Exception {
 		assertEvaluatesTo(newArrayList("a","bb","ccc"), "newArrayList('bb','a','ccc').sortBy([length])");
 	}
 	
 	@Test public void testBug362725() throws Exception {
 		assertEvaluatesTo(."{ val =>int closure = null closure == null }");
 	}
 	
 	@Test public void testBuilderSyntax_01() throws Exception {
 		assertEvaluatesTo(newArrayList("a","bb","ccc"), "newArrayList('a','bb','ccc').sortBy [length]");
 	}
 	
 	@Test public void testBuilderSyntax_02() throws Exception {
 		assertEvaluatesTo(newArrayList("a","bb","ccc"), "newArrayList('a','bb','ccc').sortBy [it.length]");
 	}
 	
 	@Test public void testBuilderSyntax_03() throws Exception {
 		assertEvaluatesTo(newArrayList("a","bb","ccc"), "newArrayList('a','bb','ccc').sortBy [x | x.length]");
 	}
 	
 	@Test public void testBuilderSyntax_04() throws Exception {
 		assertEvaluatesTo(newArrayList(), "<String>newArrayList.sortBy [length]");
 	}
 	
 	@Test public void testNestedClosures_01() throws Exception {
 		String expr = 
 				"{ " +
 				" val x = 'foo' " +
 				" [String s | x + [ String s1 | s1 + s + x].apply(s) ].apply(x)" +
 				"}";
 		assertEvaluatesTo("foofoofoofoo"expr);
 	}
 	
 	@Test public void testNestedClosures_02() throws Exception {
 		String expr = 
 				"{ " +
 				" val x = 'foo' " +
 				" [ s | x + [ s1 | s1 + s + x].apply(s) ].apply(x)" +
 				"}";
 		assertEvaluatesTo("foofoofoofoo"expr);
 	}
 	
 	@Test public void testEscapeCharacter() throws Exception {
 		String expr = "'foo'.^class";
 		assertEvaluatesTo(String.classexpr);
 	}
 	
 	@Test public void testShortCircuitBooleanExpression_00() throws Exception {
 		String expr = "true || {if (true) throw new NullPointerException() else false}";
 		assertEvaluatesTo(trueexpr);
 	}
 	
 	@Test public void testShortCircuitBooleanExpression_01() throws Exception {
 		String expr = "false && {if (true) throw new NullPointerException() else false}";
 		assertEvaluatesTo(falseexpr);
 	}
 	
 	@Test public void testShortCircuitBooleanExpression_02() throws Exception {
 		String expr = "true || {if (true) throw new NullPointerException else false}";
 		assertEvaluatesTo(trueexpr);
 	}
 	
 	@Test public void testShortCircuitBooleanExpression_03() throws Exception {
 		String expr = 
 				"{ val i = newArrayList(false,true).iterator" +
 				"  if (i.next && i.next)" +
 				"    throw new NullPointerException()" +
 				"  else" +
 				"    i.next" +
 				"}";
 		assertEvaluatesTo(trueexpr);
 	}
 	
 	@Test public void testShortCircuitBooleanExpression_04() throws Exception {
 		String expr = 
 				"{ val i = newArrayList(true,false).iterator" +
 				"  if (i.next || i.next)" +
 				"     i.next" +
 				"}";
 		assertEvaluatesTo(falseexpr);
 	}
 	
 	@Test public void testShortCircuitBooleanExpression_05() throws Exception {
 		String expr = 
 				"{ " +
 				"  val i = newArrayList(true, true, true).iterator" +
 				"  if (i.next && i.next && i.next)" +
 				"     i.hasNext" +
 				"}";
 		assertEvaluatesTo(falseexpr);
 	}
 	
 	@Test public void testShortCircuitBooleanExpression_06() throws Exception {
 		String expr = 
 				"{ " +
 				"  val i = newArrayList(false, true).iterator" +
 				"  if (i.next && i.next || i.next)" +
 				"     i.hasNext" +
 				"}";
 		assertEvaluatesTo(falseexpr);
 	}
 	
 	@Test public void testReferenceInnerClasses_01() throws Exception {
 		assertEvaluatesTo(.."testdata::OuterClass$InnerClass::SINGLETON");
 	}
 	
 	@Test public void testReferenceInnerClasses_02() throws Exception {
 		assertEvaluatesTo("FOO""[testdata.OuterClass$InnerClass param| param.toUpperCase('foo')].apply(new testdata.OuterClass$InnerClass())");
 	}
 	
 	@Test public void testReferenceInnerClasses_03() throws Exception {
 		assertEvaluatesTo(null"{for (x : newArrayList(new testdata.OuterClass$InnerClass())) { x.toString } null}");
 	}
 	
 	@Test public void testReferenceInnerClasses_04() throws Exception {
 		assertEvaluatesTo("FOO""[testdata.OuterClass$InnerClass param| param.toUpperCase('foo')].apply(new testdata.OuterClass$InnerClass)");
 	}
 	
 	@Test public void testReferenceInnerClasses_05() throws Exception {
 		assertEvaluatesTo(.."testdata::OuterClass::InnerClass::SINGLETON");
 	}
 	
 	@Test public void testReferenceInnerClasses_06() throws Exception {
 		assertEvaluatesTo("FOO""[testdata.OuterClass.InnerClass param| param.toUpperCase('foo')].apply(new testdata.OuterClass.InnerClass())");
 	}
 	
 	@Test public void testReferenceInnerClasses_07() throws Exception {
 		assertEvaluatesTo(null"{for (x : newArrayList(new testdata.OuterClass.InnerClass())) { x.toString } null}");
 	}
 	
 	@Test public void testReferenceInnerClasses_08() throws Exception {
 		assertEvaluatesTo("FOO""[testdata.OuterClass.InnerClass param| param.toUpperCase('foo')].apply(new testdata.OuterClass.InnerClass)");
 	}
 	
 	@Test public void testReferenceInnerClasses_09() throws Exception {
 		assertEvaluatesTo(.."testdata.OuterClass$InnerClass::SINGLETON");
 	}
 	
 	@Test public void testReferenceInnerClasses_10() throws Exception {
 		assertEvaluatesTo(.."testdata.OuterClass.InnerClass::SINGLETON");
 	}
 	
 	/*
 	 * see https://bugs.eclipse.org/bugs/show_bug.cgi?id=341642
 	 */
 	@Test public void testBug341642() throws Exception {
 		assertEvaluatesTo("a""newArrayList('a', 'b', 'c').filter(a|a == 'a' || a == 'b').iterator.next");
 	}
 	
 	@Test public void testBug341775() throws Exception {
 		assertEvaluatesTo(."'a'.charAt(0) == 'a'");
 		assertEvaluatesTo(."'a'.charAt(0) == 'a'.charAt(0)");
 		assertEvaluatesTo(."'a' == 'a'");
 	}
 	
 	@Test public void testCurrying_01() throws Exception {
 		assertEvaluatesTo("123456""[String p1, String p2, String p3, String p4, String p5, String p6| p1+p2+p3+p4+p5+p6].curry('1').curry('2').curry('3').curry('4').curry('5').curry('6').apply()");
 	}
 	
 	@Test public void testCurrying_02() throws Exception {
 		assertEvaluatesTo("1""[String p1| p1].curry('1').apply()");
 	}
 	
 	@Test public void testCurrying_03() throws Exception {
 		assertEvaluatesTo("12""[String p1, String p2| p1 + p2].curry('1').curry('2').apply()");
 	}
 	
 	@Test public void testCurrying_04() throws Exception {
 		assertEvaluatesTo(newArrayList("1","2","3","4","5","6"), 
 				"{\n" +
 				"  val result = <String>newArrayList\n" +
 				"  var (String,String,String,String,String,String)=>void proc = [ p1, p2, p3, p4, p5, p6 |\n" +
 				"      result.add(p1)\n" +
 				"      result.add(p2)\n" +
 				"      result.add(p3)\n" +
 				"      result.add(p4)\n" +
 				"      result.add(p5)\n" +
 				"      result.add(p6)\n" +
 				"  ]" +
 				"  proc.curry('1').curry('2').curry('3').curry('4').curry('5').curry('6').apply()\n" +
 				"  result\n" +
 				"}");
 	}
 	
 	@Test public void testCurrying_05() throws Exception {
 				"{\n" +
 						"  val result = <String>newArrayList\n" +
 						"  var (String,String)=>void proc = [ p1, p2 |\n" +
 						"      result.add(p1)\n" +
 						"      result.add(p2)\n" +
 						"  ]" +
 						"  proc.curry('1').curry('2').apply()\n" +
 						"  result\n" +
 				"}");
 	}
 	
 	@Test public void testCurrying_06() throws Exception {
 		assertEvaluatesTo(newArrayList("1","2","3","4","5","6"), 
 				"{\n" +
 				"  val result = <String>newArrayList\n" +
 				"  val (String,String,String,String,String,String)=>void proc6 = [ p1, p2, p3, p4, p5, p6 |\n" +
 				"      result.add(p1)\n" +
 				"      result.add(p2)\n" +
 				"      result.add(p3)\n" +
 				"      result.add(p4)\n" +
 				"      result.add(p5)\n" +
 				"      result.add(p6)\n" +
 				"  ]\n" +
 				"  val (String,String,String,String,String)=>void proc5 = proc6.curry('1')\n" +
 				"  val (String,String,String,String)=>void proc4 = proc5.curry('2')\n" +
 				"  val (String,String,String)=>void proc3 = proc4.curry('3')\n" +
 				"  val (String,String)=>void proc2 = proc3.curry('4')\n" +
 				"  val (String)=>void proc1 = proc2.curry('5')\n" +
 				"  val =>void proc0 = proc1.curry('6')\n" +
 				"  proc0.apply()\n" +
 				"  result\n" +
 				"}");
 	}
 	
 	/*
 	 * https://bugs.eclipse.org/bugs/show_bug.cgi?id=341550
 	 */
 	@Test public void testBug341550() throws Exception {
 		assertEvaluatesTo(emptyList(),"switch emptyList() { case emptyList() : emptyList() }");
 	}
 	
 	@Test public void testGenerics_00() throws Exception {
 		assertEvaluatesTo("""try {typeof(String).newInstance} catch(Exception e) {}");
 	}
 	
 	@Test public void testGenerics_00_b() throws Exception {
 		assertEvaluatesTo("""try {String.newInstance} catch(Exception e) {}");
 	}
 	
 	@Test public void testGenerics_01() throws Exception {
 				"{" +
 				" val x = newArrayList('y',23,true)" +
 				" return x.head" +
 				"}");
 	}
 
 	@Test public void testGenerics_02() throws Exception {
 				"new java.util.ArrayList<Object>().addAll(typeof(String).declaredFields)");
 	}
 	
 	@Test public void testGenerics_02_b() throws Exception {
 				"new java.util.ArrayList<Object>().addAll(String.declaredFields)");
 	}
 	
 	@Test public void testGenerics_03() throws Exception {
 				"{" +
 				" val x = <Object>newArrayList('y',23,true)" +
 				" return x.head" +
 				"}");
 	}
 
 	@Test public void testGenerics_04() throws Exception {
 				"new java.util.ArrayList<Object>.addAll(typeof(String).declaredFields)");
 	}
 	
 	@Test public void testGenerics_04_b() throws Exception {
 				"new java.util.ArrayList<Object>.addAll(String.declaredFields)");
 	}
 
 	@Test public void testGenerics_05() throws Exception {
 				"{" +
 				" val x = newArrayList('y',23,true)" +
 				" x.head" +
 				"}");
 	}
 	
 	@Test public void testGenerics_06() throws Exception {
 				"{" +
 				" val x = <Object>newArrayList('y',23,true)" +
 				" x.head" +
 				"}");
 	}
 	
 	@Test public void testGenerics_07() throws Exception {
 				"{" +
 						" val x = newArrayList(23, 23d)" +
 						" x.head" +
 				"}");
 	}

see https://bugs.eclipse.org/bugs/show_bug.cgi?id=341246
 
 	@Test public void testUnreferencedConstructorInBlock_01() throws Exception {
 		assertEvaluatesTo(false"{ new String() false}");
 	}
 	
 	@Test public void testUnreferencedConstructorInBlock_02() throws Exception {
 		assertEvaluatesTo(false"{ new String false}");
 	}
 	
 	@Test public void testStaticFeatureCall_01() throws Exception {
 		assertEvaluatesTo("false""String::valueOf(false)");
 	}
 	
 	@Test public void testStaticFeatureCall_02() throws Exception {
 		assertEvaluatesTo(."Boolean::FALSE");
 	}
 	
 	@Test public void testStaticFeatureCall_03() throws Exception {
 		assertEvaluatesTo("false""String.valueOf(false)");
 	}
 	
 	@Test public void testStaticFeatureCall_04() throws Exception {
 		assertEvaluatesTo(."Boolean.FALSE");
 	}
 	
 	@Test public void testStaticFeatureCall_05() throws Exception {
 		assertEvaluatesTo("false""java.lang.String.valueOf(false)");
 	}
 	
 	@Test public void testPrimitiveConversion_01() throws Exception {
 		assertEvaluatesTo("2","'ab'.length.toString");
 	}
 	
 	@Test public void testPrimitiveConversion_02() throws Exception {
 		assertEvaluatesTo("123","123.toString");
 	}
 	
 	@Test public void testPrimitiveConversion_03() throws Exception {
 		assertEvaluatesTo("123","return 123.toString");
 	}
 	
 	@Test public void testPrimitiveConversion_04() throws Exception {
 		assertEvaluatesTo("123","123L.intValue.toString");
 	}
 	
 	@Test public void testReturnExpression_01() throws Exception {
 		assertEvaluatesTo(."return true");
 	}
 	
 	@Test public void testReturnExpression_02() throws Exception {
 		assertEvaluatesTo("xx""return if ('x'=='x') 'xx'");
 	}
 	
 	@Test public void testReturnExpression_03() throws Exception {
 		assertEvaluatesTo(null"return if ('x'!='x') 'xx'");
 	}
 	
 	@Test public void testReturnExpression_04() throws Exception {
 		assertEvaluatesTo(null"return null");
 	}
 	
 	@Test public void testReturnExpression_05() throws Exception {
 		assertEvaluatesTo("yy""if ('x'!='x') return 'xx' else return 'yy'");
 		assertEvaluatesTo("xx""if ('x'=='x') return 'xx' else return 'yy'");
 	}
 	
 	@Test public void testReturnExpression_06() throws Exception {
 				"{" +
 				" val closure = [Integer i| return i]" +
 				" for (x : 1..100) " +
 				"    closure.apply(x)" +
 				" return null" +
 				"}");
 	}
 	
 	@Ignore("Wrong type")
 	@Test public void testReturnExpression_07() throws Exception {
 		assertEvaluatesTo(null"return if (true) while(false) ('foo'+'bar').length else null");
 		assertEvaluatesTo(null"return if (false) while(false) ('foo'+'bar').length else null");
 	}
 	
 	@Ignore("Wrong type")
 	@Test public void testReturnExpression_08() throws Exception {
 		assertEvaluatesTo(null"return if (true) while(false) ('foo'+'bar').length else 'zonk'");
 		assertEvaluatesTo("zonk""return if (false) while(false) ('foo'+'bar').length else 'zonk'");
 	}
 	
 	@Test public void testReturnExpression_09() throws Exception {
 		assertEvaluatesTo(null"{ return null }");
 	}
 	
 	@Test public void testReturnExpression_10() throws Exception {
 		assertEvaluatesTo(null"{ { println }; null }");
 	}
 
 	@Test public void testUnaryOperator_00() throws Exception {
 		assertEvaluatesTo(new Integer(-19),"-19");
 	}
 	
 	@Test public void testUnaryOperator_01() throws Exception {
 		assertEvaluatesTo(false,"!true");
 	}
 	
 	@Test public void testUnaryOperator_02() throws Exception {
 		assertEvaluatesTo("-1","(-1).toString()");
 	}
 	
 	@Test public void testUnaryOperator_03() throws Exception {
 		assertEvaluatesTo(1,"- -1");
 	}
 	
 	@Test public void testUnaryOperator_04() throws Exception {
 		assertEvaluatesTo(true,"!!true");
 	}
 	
 	@Test public void testUpToOperator() throws Exception {
 		assertEvaluatesTo(new Integer(9),"(9..13).iterator().next()");
 	}
 	
 	@Test public void testExclusiveRangeOperator_0() throws Exception {
 		assertEvaluatesTo("0,1,2,3""(0..<4).join(',')");
 	}
 	
 	@Test public void testExclusiveRangeOperator_1() throws Exception {
 		assertEvaluatesTo("3,2,1,0""(4>..0).join(',')");
 	}
 	
 	@Test public void testExclusiveRangeOperator_2() throws Exception {
 		assertEvaluatesTo("""(0..<0).join(',')");
 	}
 	
 	@Test public void testExclusiveRangeOperator_3() throws Exception {
 		assertEvaluatesTo("""(0>..0).join(',')");
 	}
 	
 	@Test public void testExclusiveRangeOperator_4() throws Exception {
 		assertEvaluatesTo("""(0..<-1).join(',')");
 	}
 	
 	@Test public void testExclusiveRangeOperator_5() throws Exception {
 		assertEvaluatesTo("""(-1>..0).join(',')");
 	}
 	
 	@Test public void testElvisOperator() throws Exception {
 		assertEvaluatesTo("foo","null as String?:'foo'");
 	}
 	
 	@Test public void testElvisOperator_01() throws Exception {
 		assertEvaluatesTo("bar","'bar' ?: 'foo'");
 	}
 	
 	@Test public void testElvisOperator_02() throws Exception {
 		assertEvaluatesTo(null,"null ?: null");
 	}
 	
 	@Test public void testElvisOperator_03() throws Exception {
 		assertEvaluatesTo(null,"null as String ?: null as String");
 	}
 	
 	@Test public void testElvisOperator_04() throws Exception {
 		assertEvaluatesTo("foo","{var foo='foo' val x=foo?:{foo='bar' foo} foo}");
 	}
 	
 	@Test public void testElvisOperator_05() throws Exception {
 		assertEvaluatesTo("bar","{var String foo=null val x=foo?:{foo='bar' foo} foo}");
 	}
 	
 	@Test public void testStringConcatenation_00() throws Exception {
 		assertEvaluatesTo("foobar""'foo'+ ('bar' as Object)");
 	}
 	@Test public void testStringConcatenation_01() throws Exception {
 		assertEvaluatesTo("foo3""'foo'+3");
 	}
 	@Test public void testStringConcatenation_2() throws Exception {
 		assertEvaluatesTo("footrue""'foo'+true");
 	}
 	
 	@Test public void testStringConcatenation_3() throws Exception {
 		assertEvaluatesTo("42footrue""42 +'foo'+true");
 	}
 	
 	@Test public void testStringConcatenation_4() throws Exception {
 		assertEvaluatesTo("truefootrue""true + 'foo'+true");
 	}
 	
 	@Test public void testAddOnIntegers() throws Exception {
 		assertEvaluatesTo(new Integer(3), "1+2");
 	}
 
 	@Test public void testSubtractionOnIntegers() throws Exception {
 		assertEvaluatesTo(new Integer(1), "2-1");
 	}
 
 	@Test public void testMultiplicationOnIntegers() throws Exception {
 		assertEvaluatesTo(new Integer(42), "6*7");
 	}
 
 	@Test public void testDivisionOnIntegers_01() throws Exception {
 		assertEvaluatesTo(new Integer(2), "6/3");
 	}
 
 	@Test public void testDivisionOnIntegers_02() throws Exception {
 		assertEvaluatesTo(new Integer(2), "7/3");
 	}
 
 	@Test public void testModuloOnIntegers() throws Exception {
 		assertEvaluatesTo(new Integer(1), "7%3");
 	}
 
 	@Test public void testPowerOnIntegers() throws Exception {
 		assertEvaluatesTo(new Double(8), "2**3");
 	}
 
 	@Test public void testLessThanOnIntegers_01() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "3<4");
 	}
 
 	@Test public void testLessThanOnIntegers_02() throws Exception {
 		assertEvaluatesTo(new Boolean(false), "4<3");
 	}
 
 	@Test public void testGreaterThanOnIntegers_01() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "4>3");
 	}
 
 	@Test public void testGreaterThanOnIntegers_02() throws Exception {
 		assertEvaluatesTo(new Boolean(false), "3>4");
 	}
 
 	@Test public void testLessEqualsThanOnIntegers_01() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "3<=3");
 	}
 
 	@Test public void testLessEqualsThanOnIntegers_02() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "3<=4");
 	}
 
 	@Test public void testLessEqualsThanOnIntegers_03() throws Exception {
 		assertEvaluatesTo(new Boolean(false), "4<=3");
 	}
 
 	@Test public void testGreaterEqualsThanOnIntegers_01() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "3>=3");
 	}
 
 	@Test public void testGreaterEqualsThanOnIntegers_02() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "4>=3");
 	}
 
 	@Test public void testGreaterEqualsThanOnIntegers_03() throws Exception {
 		assertEvaluatesTo(new Boolean(false), "3>=4");
 	}
 
 	@Test public void testOrOnBooleans_01() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "true||false");
 	}
 
 	@Test public void testOrOnBooleans_02() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "false||true");
 	}
 
 	@Test public void testOrOnBooleans_03() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "true||true");
 	}
 
 	@Test public void testOrOnBooleans_04() throws Exception {
 		assertEvaluatesTo(new Boolean(false), "false||false");
 	}
 
 	@Test public void testAndOnBooleans_01() throws Exception {
 		assertEvaluatesTo(new Boolean(true), "true&&true");
 	}
 
 	@Test public void testAndOnBooleans_02() throws Exception {
 		assertEvaluatesTo(new Boolean(false), "false&&true");
 	}
 
 	@Test public void testAndOnBooleans_03() throws Exception {
 		assertEvaluatesTo(new Boolean(false), "true&&false");
 	}
 
 	@Test public void testAndOnBooleans_04() throws Exception {
 		assertEvaluatesTo(new Boolean(false), "false&&false");
 	}
 
 	@Test public void testNull() throws Exception {
 		assertEvaluatesTo(null"null");
 	}
 	
 	@Test public void testNullBlockResult_01() throws Exception {
 		assertEvaluatesTo(null"{ null; }");
 	}
 	
 	@Test public void testNullBlockResult_02() throws Exception {
 		assertEvaluatesTo(null"{ 'literal'.length; null; }");
 	}
 	
 	@Test public void testBlock_01() throws Exception {
 				"{\n" + 
 				"  val (Integer, Double, Boolean) => void fun1 = null\n" + 
 				"  val (byte[], Object) => double[] fun2 = null\n" + 
 				"  val test = newArrayList.map[1 -> org::eclipse::xtext::xbase::lib::Pair::of(fun1, fun2)]\n" + 
 				"  val test2 = newArrayList.map[2 -> org::eclipse::xtext::xbase::lib::Pair::of(fun1, fun2)]\n" + 
 				"  val test3 = com::google::common::collect::Iterables::concat(test, test2).toMap[key].entrySet.map[value].toList\n" +
 				"  test3 != null" + 
 				"}");
 	}
 	
 	@Test public void testBlock_02() throws Exception {
 		assertEvaluatesTo("Length: 3"
 				"{\n" + 
 				"  val map = newHashMap\n" + 
 				"  map.put(1, 'abc')\n" + 
 				"  val x = map.get(1)\n" + 
 				"  'Length: ' + x.length" + 
 				"}");
 	}
 	
 	@Test public void testSynchronizedBlock_01() throws Exception {
 				"synchronized(new Object) {\n" + 
 				"  val (Integer, Double, Boolean) => void fun1 = null\n" + 
 				"  val (byte[], Object) => double[] fun2 = null\n" + 
 				"  val test = newArrayList.map[1 -> org::eclipse::xtext::xbase::lib::Pair::of(fun1, fun2)]\n" + 
 				"  val test2 = newArrayList.map[2 -> org::eclipse::xtext::xbase::lib::Pair::of(fun1, fun2)]\n" + 
 				"  val test3 = com::google::common::collect::Iterables::concat(test, test2).toMap[key].entrySet.map[value].toList\n" +
 				"  test3 != null" + 
 				"}");
 	}
 	
 	@Test public void testSynchronizedBlock_02() throws Exception {
 		assertEvaluatesTo("Length: 3"
 				"synchronized(new Object) {\n" + 
 				"  val map = newHashMap\n" + 
 				"  map.put(1, 'abc')\n" + 
 				"  val x = map.get(1)\n" + 
 				"  'Length: ' + x.length" + 
 				"}");
 	}
 	
 	@Test public void testSynchronizedBlock_03() throws Exception {
 				"{\n" +
 				"  val list = <String>newArrayList\n" +
 				"  val ()=>int x = [|{ list += 'foo'; 1 }]\n" +
 				"  synchronized(x.apply) {\n" + 
 				"   list.head\n" + 
 				"  }\n" +
 				"}\n");
 	}
 	
 	@Test public void testStringLiteral_01() throws Exception {
 		assertEvaluatesTo("""''");
 	}
 	
 	@Test public void testStringLiteral_02() throws Exception {
 		assertEvaluatesTo("literal""'literal'");
 	}
 	
 	@Test public void testStringLiteral_03() throws Exception {
 		assertEvaluatesTo("lite\r\nr\\al""'lite\r\nr\\\\al'");
 	}
 	
 	@Test public void testStringLiteral_04() throws Exception {
 		assertEvaluatesTo('\n'"{ val char x = '\n' x}");
 	}
 	@Test public void testStringLiteral_05() throws Exception {
 		assertEvaluatesTo(' '"{ val char x = ' ' x}");
 	}
 	@Test public void testStringLiteral_06() throws Exception {
 		assertEvaluatesTo('�'"{ val char x = '�' x}");
 	}
 	
 	@Test public void testStringLiteral_07() throws Exception {
 		assertEvaluatesTo('�'"{ val Character x = '�' x}");
 	}
 	
 	@Test public void testBooleanLiteral_01() throws Exception {
 	}
 	
 	@Test public void testBooleanLiteral_02() throws Exception {
 	}
 	
 	@Test public void testIntLiteral_01() throws Exception {
 		assertEvaluatesTo(53, "53");
 	}
 	
 	@Test public void testIntLiteral_02() throws Exception {
 	}
 	
 	@Test public void testTypeLiteral_01() throws Exception {
 		assertEvaluatesTo(Void.class"typeof(Void)");
 	}
 
 	@Test public void testTypeLiteral_02() throws Exception {
 		assertEvaluatesTo(void.class"typeof(void)");
 	}
 	
 	@Test public void testTypeLiteral_03() throws Exception {
 		assertEvaluatesTo(String[].class"typeof(String[])");
 	}
 	
 	@Test public void testTypeLiteral_04() throws Exception {
 		assertEvaluatesTo(int[][].class"typeof(int[][])");
 	}
 	
 	@Test public void testTypeLiteral_05() throws Exception {
 		assertEvaluatesTo(Void.class"Void");
 	}
 
 	@Test public void testTypeLiteral_06() throws Exception {
 		assertEvaluatesTo(void.class"void");
 	}
 	
 	@Test public void testTypeLiteral_07() throws Exception {
 		assertEvaluatesTo(void.class"void");
 	}
 	
 	@Test public void testTypeLiteral_08() throws Exception {
 		assertEvaluatesTo(Map.Entry.class"typeof(java.util.Map$Entry)");
 	}
 	
 	@Test public void testTypeLiteral_09() throws Exception {
 		assertEvaluatesTo(Map.Entry.class"typeof(java.util.Map.Entry)");
 	}
 	
 	@Test public void testTypeLiteral_10() throws Exception {
 		assertEvaluatesTo(Map.Entry.class"java.util.Map$Entry");
 	}
 	
 	@Test public void testTypeLiteral_11() throws Exception {
 		assertEvaluatesTo(Map.Entry.class"java.util.Map.Entry");
 	}
 
 	
 	@Test public void testIdentityEquals_0() throws Exception {
 		assertEvaluatesTo(true"1===1");
 	}
 	
 	@Test public void testIdentityEquals_1() throws Exception {
 		assertEvaluatesTo(false"new Object===new Object");
 	}
 	
 	@Test public void testIdentityEquals_2() throws Exception {
 		assertEvaluatesTo(true"130L===130L");
	@Test public void testIdentityNotEquals_0() throws Exception {
		assertEvaluatesTo(false"130L!==130L");
	@Test public void testSpaceship_0() throws Exception {
		assertEvaluatesTo(1, "2<=>1");
	@Test public void testSpaceship_1() throws Exception {
		assertEvaluatesTo(-1, "1<=>2");
	@Test public void testSpaceship_2() throws Exception {
		assertEvaluatesTo(0, "'bar'<=>'bar'");
	@Test public void testIfExpression_00() throws Exception {
		assertEvaluatesTo(null"if (0==1) 'literal'");
	@Test public void testIfExpression_01() throws Exception {
		assertEvaluatesTo(null"if (false) 'literal'");
	@Test public void testIfExpression_02() throws Exception {
		assertEvaluatesTo("literal""if (true) 'literal'");
	@Test public void testIfExpression_03() throws Exception {
		assertEvaluatesTo("then""if (true) 'then' else 'else'");
	@Test public void testIfExpression_04() throws Exception {
		assertEvaluatesTo("else""if (false) 'then' else 'else'");
	@Test public void testIfExpression_05() throws Exception {
		assertEvaluatesTo(null"if (false) return 'fail'");
	}

Since:
2.5
	@Test public void testIfExpression_06() throws Exception {
		// this is compiled without expectation thus nothing is inserted during type compilation
		// e.g. the if expression has type 'void' but the compiler / interpreter returns 'void' since
		// the evaluation expects a hardcoded 'Object'
				"if (false) return 1");
	}

Since:
2.5
	@Test public void testIfExpression_07() throws Exception {
				"if (false) return 1L");
	}

Since:
2.5
	@Test public void testIfExpression_08() throws Exception {
				"if (false) 1");
	}

Since:
2.5
	@Test public void testIfExpression_09() throws Exception {
				"if (false) 1L");
	@Test public void testBug342021_01() throws Exception {
				"{\n" +
				"  val Iterable<Object> branch = \n" + 
				"  if (true) \n" + 
				"    [|<Object>newArrayList().iterator]\n" + 
				"  else\n" + 
				"    newArrayList('a').toArray\n" +
				"  branch.iterator.hasNext\n" +
				"}");
	@Test public void testBug342021_02() throws Exception {
				"{\n" +
				"  val Iterable<Object> branch = \n" + 
				"  if (true) \n" + 
				"    { [|<Object>newArrayList().iterator] }\n" + 
				"  else\n" + 
				"    { ''.toString { newArrayList('a').toArray } }\n" +
				"  branch.iterator.hasNext\n" +
				"}");
	@Test public void testBug342021_03() throws Exception {
				"{\n" +
				"  val Iterable<Object> branch = \n" + 
				"  switch '' as Object {\n" + 
				"    Boolean: [|<Object>newArrayList().iterator]\n" + 
				"    String: newArrayList('a').toArray\n" +
				"  }\n" +
				"  branch.iterator.hasNext\n" +
				"}");
	@Test public void testIfExpression_withThrowExpression_00() throws Exception {
		assertEvaluatesWithException(NullPointerException.class"if (false) throw new NullPointerException() else throw new NullPointerException()");
	@Test public void testIfExpression_withThrowExpression_01() throws Exception {
		assertEvaluatesWithException(NullPointerException.class"if (false) 'then' else throw new NullPointerException()");
	@Test public void testIfExpression_withThrowExpression_02() throws Exception {
		assertEvaluatesTo("then""if (true) 'then' else throw new NullPointerException()");
	@Test public void testIfExpression_withThrowExpression_03() throws Exception {
		assertEvaluatesWithException(NullPointerException.class"if (false) 'then' else throw new NullPointerException");
	@Test public void testVariableDeclaration_01() throws Exception {
		assertEvaluatesTo("literal""{var x = 'literal' x = x}");
	@Test public void testVariableDeclaration_03() throws Exception {
		assertEvaluatesTo("literal""{var String x x = 'literal' x}");
	@Test public void testVariableDeclaration_04() throws Exception {
		assertEvaluatesTo("literal""{var String x; x = 'literal'}");
	@Test public void testVariableDeclaration_06() throws Exception {
		assertEvaluatesTo(Short.valueOf((short)0), "{var short s s}");
	@Test public void testVariableDeclaration_07() throws Exception {