diff options
author | Dmitry Petrashko <dmitry.petrashko@gmail.com> | 2015-06-25 09:45:27 +0200 |
---|---|---|
committer | Dmitry Petrashko <dmitry.petrashko@gmail.com> | 2015-07-13 15:31:16 +0200 |
commit | ef536f00d9d480f28db3093b9dc09a90041cfb74 (patch) | |
tree | ca82afa7a37ce866978b0b66904941672f2dacc3 /tests/run/exceptions-2.scala | |
parent | 9185428b63b138f8c05ade5592e59956296b5128 (diff) | |
download | dotty-ef536f00d9d480f28db3093b9dc09a90041cfb74.tar.gz dotty-ef536f00d9d480f28db3093b9dc09a90041cfb74.tar.bz2 dotty-ef536f00d9d480f28db3093b9dc09a90041cfb74.zip |
Enable 61 tests that succeed.
Diffstat (limited to 'tests/run/exceptions-2.scala')
-rw-r--r-- | tests/run/exceptions-2.scala | 349 |
1 files changed, 349 insertions, 0 deletions
diff --git a/tests/run/exceptions-2.scala b/tests/run/exceptions-2.scala new file mode 100644 index 000000000..8d755c380 --- /dev/null +++ b/tests/run/exceptions-2.scala @@ -0,0 +1,349 @@ +/* + * Try exception handling and finally blocks. + */ + +trait Tree extends Exception; + +case class Node(a: Tree, b: Tree) extends Tree; +case class Leaf(x: Int) extends Tree; + + +object NoExcep { + def a = true; + def b = false; + def c = true; + + def method1(t: Tree) = try { + Console.println(t); + } catch { + case Node(Leaf(_), Leaf(_)) => a; + case Leaf(_) => b; + } + + def method2 = try { + Console.println("Hello, world"); + } catch { + case _: Error => Console.println("File error"); + case t: Throwable => Console.println("Unknown error"); + } + + def method3 = try { + try { + Console.println("method3"); + } catch { + case Node(Leaf(_), Leaf(_)) => Console.println("First one"); + case Leaf(_) => Console.println("Second one"); + } + } catch { + case _: Error => Console.println("File error"); + case t: Exception => Console.println("Unknown error"); + } + + def method4 = try { + Console.println(".."); + } catch { + case _: Throwable => sys.error(".."); + } +} + +object Test { + def nested1: Unit = try { + try { + sys.error("nnnnoooo"); + } finally { + Console.println("Innermost finally"); + } + } finally { + Console.println("Outermost finally"); + } + + def nested2 = try { + try { + sys.error("nnnnoooo"); + } finally { + Console.println("Innermost finally"); + } + Console.println("Intermediary step"); + } finally { + Console.println("Outermost finally"); + } + + def mixed = + try { + if (10 > 0) + throw Leaf(10); + Console.println("nooo oneeee can priiiint meee"); + } catch { + case Leaf(a) => Console.println(a); + case _: Exception => Console.println("Exception occurred"); + } finally { + Console.println("Finally!"); + } + + def method2: Unit = { + try { + if (10 > 0) + throw Leaf(10); + Console.println("nooo oneeee can priiiint meee"); + } catch { + case Leaf(a) => Console.println(a); + case _: Exception => Console.println("Exception occurred"); + } + + try { + val a: Leaf = null; + println(a.x); + } catch { + case Leaf(a) => Console.println(a); + case _: NullPointerException => Console.println("Exception occurred"); + } + } + + def method3: Unit = try { + try { + val a: Leaf = null; + println(a.x); + } catch { + case Leaf(a) => Console.println(a); + } + } catch { + case npe: NullPointerException => + Console.println("Caught an NPE"); + } + + def withValue1: Unit = { + val x = try { + 10 + } finally { + Console.println("Oh, oh"); + }; + Console.println(x); + } + + def withValue2: Unit = { + val x = try { + null + } finally { + Console.println("droped a null"); + }; + Console.println(x); + } + + def tryFinallyTry: Unit = { + try { + () + } finally { + try { + sys.error("a"); + } catch { + case _: Throwable => Console.println("Silently ignore exception in finally"); + } + } + } + + def valInFinally: Unit = + try { + } finally { + val fin = "Abc"; + Console.println(fin); + } + + def tryAndValInFinally: Unit = + try { + } finally { + val fin = "Abc"; + try { + Console.println(fin); + } catch { case _: Throwable => () } + } + + def returnInBody: Unit = try { + try { + Console.println("Normal execution..."); + return + Console.println("non reachable code"); + } finally { + Console.println("inner finally"); + } + } finally { + Console.println("Outer finally"); + } + + def returnInBodySynch: Unit = try { + synchronized { + try { + Console.println("Synchronized normal execution..."); + return + Console.println("non reachable code"); + } finally { + Console.println("inner finally"); + } + } + } finally { + Console.println("Outer finally"); + } + + + def returnInBodyAndInFinally: Unit = try { + try { + Console.println("Normal execution..."); + return + Console.println("non reachable code"); + } finally { + Console.println("inner finally"); + return + } + } finally { + Console.println("Outer finally"); + return + } + + def returnInBodyAndInFinally2: Unit = try { + try { + Console.println("Normal execution..."); + return + Console.println("non reachable code"); + } finally { + try { + Console.println("inner finally"); + return + } finally { + Console.println("finally inside finally"); + } + } + } finally { + Console.println("Outer finally"); + return + } + + /** bug #1020, no crash at compile time */ + def tryCatchInFinally: Unit = { + try { + Console.println("Try") + } catch { + case e:java.io.IOException => + throw e + } finally { + val x = 10 + // Always make sure result sets and statements are closed, + // and the connection is returned to the pool + if (x != 10) { + try { Console.println("Fin"); } catch { case e:java.io.IOException => ; } + } + } + } + + def tryThrowFinally: Unit = { + try { + print("A") + throw new Exception + } catch { + case e : Exception => + print("B") + throw e + } finally { + println("C") + } + } + + def execute(f: => Unit) = try { + f; + } catch { + case _: Throwable => () + } + + + def returnWithFinallyClean: Int = try { + try { + Console.println("Normal execution..."); + return 10 + Console.println("non reachable code"); + 11 + } finally { + Console.println("inner finally"); + } + } finally { + Console.println("Outer finally"); + try { 1 } catch { case e: java.io.IOException => () } + } + + /** Test that empty finally clauses containing while are correctly emitted. + */ + class Issue { + var b = 0 + try { + // println("abc") + } finally { + while (b == -1) {b = 0} + } + } + + /* Tests that class Issue passes verification. */ + def whileInFinally = { + new Issue + } + + + + def main(args: Array[String]): Unit = { + Console.println("nested1: "); + execute(nested1); + + Console.println("nested2: "); + execute(nested2); + + Console.println("mixed: "); + execute(mixed); + + Console.println("withValue1:"); + execute(withValue1); + + Console.println("withValue2:"); + execute(withValue2); + + Console.println("method2:"); + execute(method2); + + Console.println("method3:"); + execute(method3); + + Console.println("tryFinallyTry:"); + execute(tryFinallyTry); + + Console.println("valInFinally:"); + execute(valInFinally); + Console.println("tryAndValInFinally"); + execute(tryAndValInFinally); + + Console.println("================="); + + Console.println("NoExcep.method2:"); + execute(NoExcep.method2); + + Console.println("NoExcep.method3:"); + execute(NoExcep.method3); + + Console.println("NoExcep.method4:"); + execute(NoExcep.method4); + + Console.println("Return inside body:"); + execute(returnInBody); + + Console.println("Return inside synchronized body:"); + execute(returnInBodySynch); + + Console.println("Return inside body and return in finally:"); + execute(returnInBodyAndInFinally); + + Console.println("Return inside body and return in finally inside finally:"); + execute(returnInBodyAndInFinally2); + + Console.println("Throw in catch and finally:"); + execute(tryThrowFinally); + + Console.println("Return with finally clause that cleans the stack") + returnWithFinallyClean + + whileInFinally + } +} |