diff options
| -rw-r--r-- | src/build/InnerObjectTestGen.scala | 308 | ||||
| -rw-r--r-- | test/files/run/inner-obj-auto.check | 124 | ||||
| -rw-r--r-- | test/files/run/inner-obj-auto.scala | 6731 |
3 files changed, 1361 insertions, 5802 deletions
diff --git a/src/build/InnerObjectTestGen.scala b/src/build/InnerObjectTestGen.scala new file mode 100644 index 0000000000..5945bc17c7 --- /dev/null +++ b/src/build/InnerObjectTestGen.scala @@ -0,0 +1,308 @@ +import collection.mutable + +/** All contexts where objects can be embedded. */ +object Contexts extends Enumeration { + val Class, Object, Trait, Method, PrivateMethod, Anonfun, ClassConstructor, TraitConstructor, LazyVal, Val = Value + + val topLevel = List(Class, Object, Trait) +} + + +/** Test generation of inner objects, trying to cover as many cases as possible. It proceeds + * by progressively adding nesting layers around a 'payload body'. + * + * There are three scenarios (each generating a full combinatorial search): + * - plain object with single-threaded access + * - private object with single-threaded access + * - plain object with multi-threaded access. + * + * Special care is taken to skip problematic cases (or known bugs). For instance, + * it won't generate objects inside lazy vals (leads to deadlock), or objects that + * are initialized in the static constructors (meaning inside 'val' inside a top-level + * object, or equivalent). + * + * Usage: TestGen <nr of levels> + * - by default it's 2 leves. Currently, 3-level deep uncovers bugs in the type checker. + * + * @author Iulian Dragos + */ +object TestGen { + val testFile = "object-testers-automated.scala" + + val payload = +""" var ObjCounter = 0 + + object Obj { ObjCounter += 1} + Obj // one + + def singleThreadedAccess(x: Any) = { + x == Obj + } + + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") + } catch { + case e => print("failed "); e.printStackTrace() + } + } +""" + + val payloadPrivate = +""" var ObjCounter = 0 + + private object Obj { ObjCounter += 1} + Obj // one + + def singleThreadedAccess(x: Any) = { + x == Obj + } + + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") + } catch { + case e => print("failed "); e.printStackTrace() + } + } +""" + + val payloadMT = +""" @volatile var ObjCounter = 0 + + object Obj { ObjCounter += 1} + + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) + + threads foreach (_.start()) + threads foreach (_.join()) + } + + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() + } + } +""" + + + import Contexts._ + + val template = +""" +%s + +%s + +object Test { + def main(args: Array[String]) { + %s + } +} +""" + + var counter = 0 + def freshName(name: String) = { + counter += 1 + name + counter + } + + val bodies = new mutable.ListBuffer[String] + val triggers = new mutable.ListBuffer[String] + + /** Generate the nesting code. */ + def generate(depth: Int, // how many levels we still need to 'add' around the current body + body: String, // the body of one test, so far + trigger: String, // the code that needs to be invoked to run the test so far + nested: List[Contexts.Value], // the path from the innermost to the outermost context + p: List[Contexts.Value] => Boolean, // a predicate for filtering problematic cases + privateObj: Boolean = false) { // are we using a private object? + + def shouldBeTopLevel = + ((depth == 1) + || (nested.headOption == Some(PrivateMethod)) + || (nested.isEmpty && privateObj)) + + val enums = + if (shouldBeTopLevel) Contexts.topLevel else Contexts.values.toList + + if (depth == 0) { + if (p(nested)) {bodies += body; triggers += trigger } + } else { + for (ctx <- enums) { + val (body1, trigger1) = ctx match { + case Class => + val name = freshName("Class") + "_" + depth + (""" + class %s { + %s + def run { %s } + } + """.format(name, body, trigger), "(new %s).run".format(name)) + + case Trait => + val name = freshName("Trait") + "_" + depth + (""" + trait %s { + %s + def run { %s } + } + """.format(name, body, trigger), "(new %s {}).run".format(name)) + + case Object => + val name = freshName("Object") + "_" + depth + (""" + object %s { + %s + def run { %s } // trigger + } + """.format(name, body, trigger), "%s.run".format(name)) + + case Method => + val name = freshName("method") + "_" + depth + (""" + def %s { + %s + %s // trigger + } + """.format(name, body, trigger), name) + + case PrivateMethod => + val name = freshName("method") + "_" + depth + (""" + private def %s { + %s + %s // trigger + } + """.format(name, body, trigger), name) + + case Val => + val name = freshName("value") + "_" + depth + (""" + val %s = { + %s + %s // trigger + } + """.format(name, body, trigger), name) + + case LazyVal => + val name = freshName("lzvalue") + "_" + depth + (""" + lazy val %s = { + %s + %s // trigger + } + """.format(name, body, trigger), name) + + case Anonfun => + val name = freshName("fun") + "_" + depth + (""" + val %s = () => { + %s + %s // trigger + } + """.format(name, body, trigger), name + "()") + + case ClassConstructor => + val name = freshName("Class") + "_" + depth + (""" + class %s { + { // in primary constructor + %s + %s // trigger + } + } + """.format(name, body, trigger), "(new %s)".format(name)) + + case TraitConstructor => + val name = freshName("Trait") + "_" + depth + (""" + trait %s { + { // in primary constructor + %s + %s // trigger + } + } + """.format(name, body, trigger), "(new %s {})".format(name)) + + } + generate(depth - 1, body1, trigger1, ctx :: nested, p) + } + } + } + + /** Only allow multithreaded tests if not inside a static initializer. */ + private def allowMT(structure: List[Contexts.Value]): Boolean = { + var nesting = structure + while ((nesting ne Nil) && nesting.head == Object) { + nesting = nesting.tail + } + if (nesting ne Nil) + !(nesting.head == Val) + else + true + } && !objectInsideLazyVal(structure) + + /** Known bug: object inside lazyval leads to deadlock. */ + private def objectInsideLazyVal(structure: List[Contexts.Value]): Boolean = + structure.contains(LazyVal) + + + def usage() { + val help = +""" + Usage: TestGen <nr of levels> + + <nr of levels> - how deeply nested should the objects be? default is 2. + (Currently, 3-level deep uncovers bugs in the type checker). + + Test generation of inner objects, trying to cover as many cases as possible. It proceeds + by progressively adding nesting layers around a 'payload body'. + + There are three scenarios (each generating a full combinatorial search): + - plain object with single-threaded access + - private object with single-threaded access + - plain object with multi-threaded access. + + Special care is taken to skip problematic cases (or known bugs). For instance, + it won't generate objects inside lazy vals (leads to deadlock), or objects that + are initialized in the static constructors (meaning inside 'val' inside a top-level + object, or equivalent). +""" + + println(help) + System.exit(1) + } + + def main(args: Array[String]) { + if (args.isEmpty || args.contains("-help")) usage() + + val depth = if (args.length < 1) 2 else args(0).toInt + + val header = +""" +/* ================================================================================ + Automatically generated on %tF. Do Not Edit (unless you have to). + (%d-level nesting) + ================================================================================ */ +""".format(new java.util.Date, depth) + + generate(depth, payload, "runTest", List(), x => true) + // private + generate(depth, payloadPrivate, "runTest", List(), x => true, true) + generate(depth, payloadMT, "runTest", List(), allowMT) + + println(template.format(header, bodies.mkString("", "\n", ""), triggers.mkString("", "\n", ""))) + } +} diff --git a/test/files/run/inner-obj-auto.check b/test/files/run/inner-obj-auto.check index 96f3dbc139..90f7e27b98 100644 --- a/test/files/run/inner-obj-auto.check +++ b/test/files/run/inner-obj-auto.check @@ -63,127 +63,3 @@ ok ok ok ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok -ok diff --git a/test/files/run/inner-obj-auto.scala b/test/files/run/inner-obj-auto.scala index 2f72b077d2..98b48b150f 100644 --- a/test/files/run/inner-obj-auto.scala +++ b/test/files/run/inner-obj-auto.scala @@ -1,2062 +1,538 @@ -class Class3_1 { +/* ================================================================================ + Automatically generated on 2011-05-11. Do Not Edit (unless you have to). + (2-level nesting) + ================================================================================ */ - class Class2_2 { - class Class1_3 { - var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one +class Class2_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + class Class1_2 { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} + Obj // one - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { (new Class1_3).run } - } - - def run { (new Class2_2).run } -} - - -object Object4_1 { - - class Class2_2 { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - def run { (new Class1_3).run } + def run { runTest } } - def run { (new Class2_2).run } // trigger + def run { (new Class1_2).run } } -trait Trait5_1 { +object Object3_1 { - class Class2_2 { + class Class1_2 { + var ObjCounter = 0 - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} + Obj // one - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { (new Class1_3).run } - } - - def run { (new Class2_2).run } -} - - -class Class7_1 { - - object Object6_2 { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Class1_3).run } // trigger - } - - def run { Object6_2.run } -} - - -object Object8_1 { - - object Object6_2 { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - def run { (new Class1_3).run } // trigger + def run { runTest } } - def run { Object6_2.run } // trigger + def run { (new Class1_2).run } // trigger } -trait Trait9_1 { - - object Object6_2 { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one +trait Trait4_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + class Class1_2 { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} + Obj // one - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { (new Class1_3).run } // trigger - } - - def run { Object6_2.run } -} - - -class Class11_1 { - - trait Trait10_2 { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - def run { (new Class1_3).run } + def run { runTest } } - def run { (new Trait10_2 {}).run } + def run { (new Class1_2).run } } -object Object12_1 { +class Class6_1 { - trait Trait10_2 { + object Object5_2 { + var ObjCounter = 0 - class Class1_3 { - var ObjCounter = 0 + object Obj { ObjCounter += 1} + Obj // one - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { (new Class1_3).run } - } - - def run { (new Trait10_2 {}).run } // trigger -} - - -trait Trait13_1 { - - trait Trait10_2 { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - def run { (new Class1_3).run } + def run { runTest } // trigger } - def run { (new Trait10_2 {}).run } + def run { Object5_2.run } } -class Class15_1 { +object Object7_1 { - def method14_2 { + object Object5_2 { + var ObjCounter = 0 - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} + Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - (new Class1_3).run // trigger - } - - def run { method14_2 } -} - - -object Object16_1 { - - def method14_2 { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - (new Class1_3).run // trigger + def run { runTest } // trigger } - def run { method14_2 } // trigger + def run { Object5_2.run } // trigger } -trait Trait17_1 { - - def method14_2 { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one +trait Trait8_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Object5_2 { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} + Obj // one - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - (new Class1_3).run // trigger - } - - def run { method14_2 } -} - - -class Class19_1 { - - val fun18_2 = () => { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - (new Class1_3).run // trigger + def run { runTest } // trigger } - def run { fun18_2() } + def run { Object5_2.run } } -object Object20_1 { +class Class10_1 { - val fun18_2 = () => { + trait Trait9_2 { + var ObjCounter = 0 - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} + Obj // one - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - (new Class1_3).run // trigger - } - - def run { fun18_2() } // trigger -} - - -trait Trait21_1 { - - val fun18_2 = () => { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } - } - - (new Class1_3).run // trigger - } - - def run { fun18_2() } -} - - -class Class23_1 { - - class Class22_2 { - { // in primary constructor - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Class1_3).run // trigger } - } - - def run { (new Class22_2) } -} - - -object Object24_1 { - - class Class22_2 { - { // in primary constructor - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - def run { runTest } - } - - (new Class1_3).run // trigger - } + def run { runTest } } - def run { (new Class22_2) } // trigger + def run { (new Trait9_2 {}).run } } -trait Trait25_1 { - - class Class22_2 { - { // in primary constructor - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one +object Object11_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + trait Trait9_2 { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} + Obj // one - def run { runTest } - } - - (new Class1_3).run // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - } - - def run { (new Class22_2) } -} - - -class Class27_1 { - - lazy val lzvalue26_2 = { - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - (new Class1_3).run // trigger + def run { runTest } } - def run { lzvalue26_2 } + def run { (new Trait9_2 {}).run } // trigger } -object Object28_1 { +trait Trait12_1 { - lazy val lzvalue26_2 = { + trait Trait9_2 { + var ObjCounter = 0 - class Class1_3 { - var ObjCounter = 0 + object Obj { ObjCounter += 1} + Obj // one - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - (new Class1_3).run // trigger - } - - def run { lzvalue26_2 } // trigger -} - - -trait Trait29_1 { - - lazy val lzvalue26_2 = { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - (new Class1_3).run // trigger + def run { runTest } } - def run { lzvalue26_2 } + def run { (new Trait9_2 {}).run } } -class Class31_1 { - - val value30_2 = { +class Class14_1 { - class Class1_3 { - var ObjCounter = 0 + def method13_2 { + var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} + Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - (new Class1_3).run // trigger - } - - def run { value30_2 } -} - - -object Object32_1 { - - val value30_2 = { - - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } } - (new Class1_3).run // trigger + runTest // trigger } - def run { value30_2 } // trigger + def run { method13_2 } } -trait Trait33_1 { +object Object15_1 { - val value30_2 = { + def method13_2 { + var ObjCounter = 0 - class Class1_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} + Obj // one - def run { runTest } + def singleThreadedAccess(x: Any) = { + x == Obj } - (new Class1_3).run // trigger - } - - def run { value30_2 } -} - - -class Class36_1 { - - class Class35_2 { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } // trigger } - def run { Object34_3.run } + runTest // trigger } - def run { (new Class35_2).run } + def run { method13_2 } // trigger } -object Object37_1 { +trait Trait16_1 { - class Class35_2 { + def method13_2 { + var ObjCounter = 0 - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} + Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { Object34_3.run } - } - - def run { (new Class35_2).run } // trigger -} - - -trait Trait38_1 { - - class Class35_2 { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } // trigger } - def run { Object34_3.run } + runTest // trigger } - def run { (new Class35_2).run } + def run { method13_2 } } -class Class40_1 { +class Class18_1 { - object Object39_2 { + private def method17_2 { + var ObjCounter = 0 - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} + Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { Object34_3.run } // trigger - } - - def run { Object39_2.run } -} - - -object Object41_1 { - - object Object39_2 { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } // trigger } - def run { Object34_3.run } // trigger + runTest // trigger } - def run { Object39_2.run } // trigger + def run { method17_2 } } -trait Trait42_1 { +object Object19_1 { - object Object39_2 { + private def method17_2 { + var ObjCounter = 0 - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} + Obj // one - def run { runTest } // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { Object34_3.run } // trigger - } - - def run { Object39_2.run } -} - - -class Class44_1 { - - trait Trait43_2 { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } // trigger } - def run { Object34_3.run } + runTest // trigger } - def run { (new Trait43_2 {}).run } + def run { method17_2 } // trigger } -object Object45_1 { +trait Trait20_1 { - trait Trait43_2 { + private def method17_2 { + var ObjCounter = 0 - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} + Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { Object34_3.run } - } - - def run { (new Trait43_2 {}).run } // trigger -} - - -trait Trait46_1 { - - trait Trait43_2 { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } // trigger } - def run { Object34_3.run } + runTest // trigger } - def run { (new Trait43_2 {}).run } + def run { method17_2 } } -class Class48_1 { +class Class22_1 { - def method47_2 { + val fun21_2 = () => { + var ObjCounter = 0 - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} + Obj // one - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - Object34_3.run // trigger - } - - def run { method47_2 } -} - - -object Object49_1 { - - def method47_2 { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } // trigger } - Object34_3.run // trigger + runTest // trigger } - def run { method47_2 } // trigger + def run { fun21_2() } } -trait Trait50_1 { - - def method47_2 { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one +object Object23_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + val fun21_2 = () => { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} + Obj // one - def run { runTest } // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - Object34_3.run // trigger - } - - def run { method47_2 } -} - - -class Class52_1 { - - val fun51_2 = () => { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } // trigger } - Object34_3.run // trigger + runTest // trigger } - def run { fun51_2() } + def run { fun21_2() } // trigger } -object Object53_1 { +trait Trait24_1 { - val fun51_2 = () => { + val fun21_2 = () => { + var ObjCounter = 0 - object Object34_3 { - var ObjCounter = 0 + object Obj { ObjCounter += 1} + Obj // one - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - Object34_3.run // trigger - } - - def run { fun51_2() } // trigger -} - - -trait Trait54_1 { - - val fun51_2 = () => { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } - - def run { fun51_2() } -} - - -class Class56_1 { - - class Class55_2 { - { // in primary constructor - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger } - } - - def run { (new Class55_2) } -} - - -object Object57_1 { - - class Class55_2 { - { // in primary constructor - - object Object34_3 { - var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } + runTest // trigger } - def run { (new Class55_2) } // trigger + def run { fun21_2() } } -trait Trait58_1 { +class Class26_1 { - class Class55_2 { + class Class25_2 { { // in primary constructor - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } - } - - def run { (new Class55_2) } -} - - -class Class60_1 { - - lazy val lzvalue59_2 = { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } - - def run { lzvalue59_2 } -} - - -object Object61_1 { - - lazy val lzvalue59_2 = { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } - - def run { lzvalue59_2 } // trigger -} - - -trait Trait62_1 { - - lazy val lzvalue59_2 = { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } - - def run { lzvalue59_2 } -} - - -class Class64_1 { - - val value63_2 = { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } - - def run { value63_2 } -} - - -object Object65_1 { - - val value63_2 = { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } - - def run { value63_2 } // trigger -} - - -trait Trait66_1 { - - val value63_2 = { - - object Object34_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } // trigger - } - - Object34_3.run // trigger - } - - def run { value63_2 } -} - - -class Class69_1 { - - class Class68_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } - } - - def run { (new Class68_2).run } -} - - -object Object70_1 { - - class Class68_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } - } - - def run { (new Class68_2).run } // trigger -} - - -trait Trait71_1 { - - class Class68_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } - } - - def run { (new Class68_2).run } -} - - -class Class73_1 { - - object Object72_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } // trigger - } - - def run { Object72_2.run } -} - - -object Object74_1 { - - object Object72_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } // trigger - } - - def run { Object72_2.run } // trigger -} - - -trait Trait75_1 { - - object Object72_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } // trigger - } - - def run { Object72_2.run } -} - - -class Class77_1 { - - trait Trait76_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } - } - - def run { (new Trait76_2 {}).run } -} - - -object Object78_1 { - - trait Trait76_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } - } - - def run { (new Trait76_2 {}).run } // trigger -} - - -trait Trait79_1 { - - trait Trait76_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - def run { (new Trait67_3 {}).run } - } - - def run { (new Trait76_2 {}).run } -} - - -class Class81_1 { - - def method80_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { method80_2 } -} - - -object Object82_1 { - - def method80_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { method80_2 } // trigger -} - - -trait Trait83_1 { - - def method80_2 { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { method80_2 } -} - - -class Class85_1 { - - val fun84_2 = () => { - - trait Trait67_3 { var ObjCounter = 0 object Obj { ObjCounter += 1} @@ -2069,476 +545,25 @@ class Class85_1 { def runTest { try { assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { fun84_2() } -} - - -object Object86_1 { - - val fun84_2 = () => { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { fun84_2() } // trigger -} - - -trait Trait87_1 { - - val fun84_2 = () => { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { fun84_2() } -} - - -class Class89_1 { - - class Class88_2 { - { // in primary constructor - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - } - - def run { (new Class88_2) } -} - - -object Object90_1 { - - class Class88_2 { - { // in primary constructor - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - } - - def run { (new Class88_2) } // trigger -} - - -trait Trait91_1 { - - class Class88_2 { - { // in primary constructor - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - } - - def run { (new Class88_2) } -} - - -class Class93_1 { - - lazy val lzvalue92_2 = { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { lzvalue92_2 } -} - - -object Object94_1 { - - lazy val lzvalue92_2 = { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { lzvalue92_2 } // trigger -} - - -trait Trait95_1 { - - lazy val lzvalue92_2 = { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { lzvalue92_2 } -} - - -class Class97_1 { - - val value96_2 = { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) } catch { case e => print("failed "); e.printStackTrace() } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { value96_2 } -} - - -object Object98_1 { - - val value96_2 = { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { value96_2 } // trigger -} - - -trait Trait99_1 { - - val value96_2 = { - - trait Trait67_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - def run { runTest } - } - - (new Trait67_3 {}).run // trigger - } - - def run { value96_2 } -} - - -class Class102_1 { - - class Class101_2 { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - def run { method100_3 } - } - - def run { (new Class101_2).run } -} - - -object Object103_1 { - - class Class101_2 { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") } runTest // trigger } - - def run { method100_3 } } - def run { (new Class101_2).run } // trigger + def run { (new Class25_2) } } -trait Trait104_1 { - - class Class101_2 { +object Object27_1 { - def method100_3 { + class Class25_2 { + { // in primary constructor var ObjCounter = 0 object Obj { ObjCounter += 1} @@ -2551,28 +576,25 @@ trait Trait104_1 { def runTest { try { assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { case e => print("failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - def run { method100_3 } } - def run { (new Class101_2).run } + def run { (new Class25_2) } // trigger } -class Class106_1 { +trait Trait28_1 { - object Object105_2 { - - def method100_3 { + class Class25_2 { + { // in primary constructor var ObjCounter = 0 object Obj { ObjCounter += 1} @@ -2585,28 +607,25 @@ class Class106_1 { def runTest { try { assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { case e => print("failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - def run { method100_3 } // trigger } - def run { Object105_2.run } + def run { (new Class25_2) } } -object Object107_1 { - - object Object105_2 { +class Class30_1 { - def method100_3 { + trait Trait29_2 { + { // in primary constructor var ObjCounter = 0 object Obj { ObjCounter += 1} @@ -2619,28 +638,25 @@ object Object107_1 { def runTest { try { assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { case e => print("failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - def run { method100_3 } // trigger } - def run { Object105_2.run } // trigger + def run { (new Trait29_2 {}) } } -trait Trait108_1 { - - object Object105_2 { +object Object31_1 { - def method100_3 { + trait Trait29_2 { + { // in primary constructor var ObjCounter = 0 object Obj { ObjCounter += 1} @@ -2653,28 +669,25 @@ trait Trait108_1 { def runTest { try { assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { case e => print("failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - def run { method100_3 } // trigger } - def run { Object105_2.run } + def run { (new Trait29_2 {}) } // trigger } -class Class110_1 { +trait Trait32_1 { - trait Trait109_2 { - - def method100_3 { + trait Trait29_2 { + { // in primary constructor var ObjCounter = 0 object Obj { ObjCounter += 1} @@ -2687,4031 +700,1393 @@ class Class110_1 { def runTest { try { assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { case e => print("failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - def run { method100_3 } } - def run { (new Trait109_2 {}).run } + def run { (new Trait29_2 {}) } } -object Object111_1 { +class Class34_1 { - trait Trait109_2 { + lazy val lzvalue33_2 = { + var ObjCounter = 0 - def method100_3 { - var ObjCounter = 0 + object Obj { ObjCounter += 1} + Obj // one - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { method100_3 } - } - - def run { (new Trait109_2 {}).run } // trigger -} - - -trait Trait112_1 { - - trait Trait109_2 { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - def run { method100_3 } + runTest // trigger } - def run { (new Trait109_2 {}).run } + def run { lzvalue33_2 } } -class Class114_1 { +object Object35_1 { - def method113_2 { + lazy val lzvalue33_2 = { + var ObjCounter = 0 - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} + Obj // one - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - method100_3 // trigger - } - - def run { method113_2 } -} - - -object Object115_1 { - - def method113_2 { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - method100_3 // trigger + runTest // trigger } - def run { method113_2 } // trigger + def run { lzvalue33_2 } // trigger } -trait Trait116_1 { - - def method113_2 { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one +trait Trait36_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + lazy val lzvalue33_2 = { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} + Obj // one - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - method100_3 // trigger - } - - def run { method113_2 } -} - - -class Class118_1 { - - val fun117_2 = () => { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - method100_3 // trigger + runTest // trigger } - def run { fun117_2() } + def run { lzvalue33_2 } } -object Object119_1 { - - val fun117_2 = () => { +class Class38_1 { - def method100_3 { - var ObjCounter = 0 + val value37_2 = { + var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} + Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - method100_3 // trigger - } - - def run { fun117_2() } // trigger -} - - -trait Trait120_1 { - - val fun117_2 = () => { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - method100_3 // trigger - } - - def run { fun117_2() } -} - - -class Class122_1 { - - class Class121_2 { - { // in primary constructor - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - method100_3 // trigger - } + runTest // trigger } - def run { (new Class121_2) } + def run { value37_2 } } -object Object123_1 { - - class Class121_2 { - { // in primary constructor +object Object39_1 { - def method100_3 { - var ObjCounter = 0 + val value37_2 = { + var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} + Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - method100_3 // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - } - def run { (new Class121_2) } // trigger -} - - -trait Trait124_1 { - - class Class121_2 { - { // in primary constructor - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - method100_3 // trigger - } - } - - def run { (new Class121_2) } -} - - -class Class126_1 { - - lazy val lzvalue125_2 = { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - method100_3 // trigger + runTest // trigger } - def run { lzvalue125_2 } + def run { value37_2 } // trigger } -object Object127_1 { +trait Trait40_1 { - lazy val lzvalue125_2 = { + val value37_2 = { + var ObjCounter = 0 - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} + Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - method100_3 // trigger - } - - def run { lzvalue125_2 } // trigger -} - - -trait Trait128_1 { - - lazy val lzvalue125_2 = { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - method100_3 // trigger + runTest // trigger } - def run { lzvalue125_2 } + def run { value37_2 } } -class Class130_1 { +class Class42_1 { - val value129_2 = { + class Class41_2 { + var ObjCounter = 0 - def method100_3 { - var ObjCounter = 0 + private object Obj { ObjCounter += 1} + Obj // one - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - method100_3 // trigger - } - - def run { value129_2 } -} - - -object Object131_1 { - - val value129_2 = { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - method100_3 // trigger + def run { runTest } } - def run { value129_2 } // trigger + def run { (new Class41_2).run } } -trait Trait132_1 { +object Object43_1 { - val value129_2 = { - - def method100_3 { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + class Class41_2 { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + private object Obj { ObjCounter += 1} + Obj // one - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - method100_3 // trigger - } - - def run { value129_2 } -} - - -class Class135_1 { - - class Class134_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - def run { fun133_3() } + def run { runTest } } - def run { (new Class134_2).run } + def run { (new Class41_2).run } // trigger } -object Object136_1 { +trait Trait44_1 { - class Class134_2 { + class Class41_2 { + var ObjCounter = 0 - val fun133_3 = () => { - var ObjCounter = 0 + private object Obj { ObjCounter += 1} + Obj // one - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { fun133_3() } - } - - def run { (new Class134_2).run } // trigger -} - - -trait Trait137_1 { - - class Class134_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - def run { fun133_3() } + def run { runTest } } - def run { (new Class134_2).run } + def run { (new Class41_2).run } } -class Class139_1 { - - object Object138_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one +class Class46_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Object45_2 { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + private object Obj { ObjCounter += 1} + Obj // one - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { fun133_3() } // trigger - } - - def run { Object138_2.run } -} - - -object Object140_1 { - - object Object138_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - def run { fun133_3() } // trigger + def run { runTest } // trigger } - def run { Object138_2.run } // trigger + def run { Object45_2.run } } -trait Trait141_1 { - - object Object138_2 { - - val fun133_3 = () => { - var ObjCounter = 0 +object Object47_1 { - object Obj { ObjCounter += 1} - Obj // one + object Object45_2 { + var ObjCounter = 0 - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + private object Obj { ObjCounter += 1} + Obj // one - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { fun133_3() } // trigger - } - - def run { Object138_2.run } -} - - -class Class143_1 { - - trait Trait142_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - def run { fun133_3() } + def run { runTest } // trigger } - def run { (new Trait142_2 {}).run } + def run { Object45_2.run } // trigger } -object Object144_1 { +trait Trait48_1 { - trait Trait142_2 { + object Object45_2 { + var ObjCounter = 0 - val fun133_3 = () => { - var ObjCounter = 0 + private object Obj { ObjCounter += 1} + Obj // one - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - def run { fun133_3() } - } - - def run { (new Trait142_2 {}).run } // trigger -} - - -trait Trait145_1 { - - trait Trait142_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - def run { fun133_3() } + def run { runTest } // trigger } - def run { (new Trait142_2 {}).run } + def run { Object45_2.run } } -class Class147_1 { - - def method146_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one +class Class50_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + trait Trait49_2 { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + private object Obj { ObjCounter += 1} + Obj // one - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - fun133_3() // trigger - } - - def run { method146_2 } -} - - -object Object148_1 { - - def method146_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - fun133_3() // trigger + def run { runTest } } - def run { method146_2 } // trigger + def run { (new Trait49_2 {}).run } } -trait Trait149_1 { - - def method146_2 { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one +object Object51_1 { - def singleThreadedAccess(x: Any) = { - x == Obj - } + trait Trait49_2 { + var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + private object Obj { ObjCounter += 1} + Obj // one - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - fun133_3() // trigger - } - - def run { method146_2 } -} - - -class Class151_1 { - - val fun150_2 = () => { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger } - fun133_3() // trigger + def run { runTest } } - def run { fun150_2() } + def run { (new Trait49_2 {}).run } // trigger } -object Object152_1 { +trait Trait52_1 { - val fun150_2 = () => { + trait Trait49_2 { + var ObjCounter = 0 - val fun133_3 = () => { - var ObjCounter = 0 + private object Obj { ObjCounter += 1} + Obj // one - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def singleThreadedAccess(x: Any) = { + x == Obj } - fun133_3() // trigger - } - - def run { fun150_2() } // trigger -} - - -trait Trait153_1 { - - val fun150_2 = () => { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + assert(singleThreadedAccess(Obj)) + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("failed "); e.printStackTrace() } - - runTest // trigger - } - - fun133_3() // trigger - } - - def run { fun150_2() } -} - - -class Class155_1 { - - class Class154_2 { - { // in primary constructor - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - fun133_3() // trigger - } - } - - def run { (new Class154_2) } -} - - -object Object156_1 { - - class Class154_2 { - { // in primary constructor - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - fun133_3() // trigger } - } - - def run { (new Class154_2) } // trigger -} - - -trait Trait157_1 { - - class Class154_2 { - { // in primary constructor - - val fun133_3 = () => { - var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - fun133_3() // trigger - } + def run { runTest } } - def run { (new Class154_2) } + def run { (new Trait49_2 {}).run } } -class Class159_1 { +class Class54_1 { - lazy val lzvalue158_2 = { + class Class53_2 { + @volatile var ObjCounter = 0 - val fun133_3 = () => { - var ObjCounter = 0 + object Obj { ObjCounter += 1} - object Obj { ObjCounter += 1} - Obj // one + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - fun133_3() // trigger - } - - def run { lzvalue158_2 } -} - - -object Object160_1 { - - lazy val lzvalue158_2 = { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - fun133_3() // trigger + def run { runTest } } - def run { lzvalue158_2 } // trigger + def run { (new Class53_2).run } } -trait Trait161_1 { +object Object55_1 { - lazy val lzvalue158_2 = { + class Class53_2 { + @volatile var ObjCounter = 0 - val fun133_3 = () => { - var ObjCounter = 0 + object Obj { ObjCounter += 1} - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - fun133_3() // trigger - } - - def run { lzvalue158_2 } -} - - -class Class163_1 { - - val value162_2 = { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - fun133_3() // trigger + def run { runTest } } - def run { value162_2 } + def run { (new Class53_2).run } // trigger } -object Object164_1 { - - val value162_2 = { - - val fun133_3 = () => { - var ObjCounter = 0 +trait Trait56_1 { - object Obj { ObjCounter += 1} - Obj // one + class Class53_2 { + @volatile var ObjCounter = 0 - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - fun133_3() // trigger - } - - def run { value162_2 } // trigger -} - - -trait Trait165_1 { - - val value162_2 = { - - val fun133_3 = () => { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") - } - - runTest // trigger - } - - fun133_3() // trigger - } - - def run { value162_2 } -} - - -class Class168_1 { - - class Class167_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } - } - - def run { (new Class167_2).run } -} - - -object Object169_1 { - - class Class167_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } - } - - def run { (new Class167_2).run } // trigger -} - - -trait Trait170_1 { - - class Class167_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } - } - - def run { (new Class167_2).run } -} - - -class Class172_1 { - - object Object171_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } // trigger - } - - def run { Object171_2.run } -} - - -object Object173_1 { - - object Object171_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } // trigger - } - - def run { Object171_2.run } // trigger -} - - -trait Trait174_1 { - - object Object171_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } // trigger - } - - def run { Object171_2.run } -} - - -class Class176_1 { - - trait Trait175_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } - } - - def run { (new Trait175_2 {}).run } -} - - -object Object177_1 { - - trait Trait175_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } - } - - def run { (new Trait175_2 {}).run } // trigger -} - - -trait Trait178_1 { - - trait Trait175_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - def run { (new Class166_3) } - } - - def run { (new Trait175_2 {}).run } -} - - -class Class180_1 { - - def method179_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - - def run { method179_2 } -} - - -object Object181_1 { - - def method179_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - - def run { method179_2 } // trigger -} - - -trait Trait182_1 { - - def method179_2 { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } } - (new Class166_3) // trigger + def run { runTest } } - def run { method179_2 } + def run { (new Class53_2).run } } -class Class184_1 { +class Class58_1 { - val fun183_2 = () => { + object Object57_2 { + @volatile var ObjCounter = 0 - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 + object Obj { ObjCounter += 1} - object Obj { ObjCounter += 1} - Obj // one + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } + threads foreach (_.start()) + threads foreach (_.join()) } - (new Class166_3) // trigger - } - - def run { fun183_2() } -} - - -object Object185_1 { - - val fun183_2 = () => { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - - def run { fun183_2() } // trigger -} - - -trait Trait186_1 { - - val fun183_2 = () => { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - - def run { fun183_2() } -} - - -class Class188_1 { - - class Class187_2 { - { // in primary constructor - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - } - - def run { (new Class187_2) } -} - - -object Object189_1 { - - class Class187_2 { - { // in primary constructor - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - } - - def run { (new Class187_2) } // trigger -} - - -trait Trait190_1 { - - class Class187_2 { - { // in primary constructor - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - } - - def run { (new Class187_2) } -} - - -class Class192_1 { - - lazy val lzvalue191_2 = { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - - def run { lzvalue191_2 } -} - - -object Object193_1 { - - lazy val lzvalue191_2 = { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } } - (new Class166_3) // trigger + def run { runTest } // trigger } - def run { lzvalue191_2 } // trigger + def run { Object57_2.run } } -trait Trait194_1 { - - lazy val lzvalue191_2 = { +object Object59_1 { - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 + object Object57_2 { + @volatile var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger - } + threads foreach (_.start()) + threads foreach (_.join()) } - (new Class166_3) // trigger - } - - def run { lzvalue191_2 } -} - - -class Class196_1 { - - val value195_2 = { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - } - - (new Class166_3) // trigger - } - - def run { value195_2 } -} - - -object Object197_1 { - - val value195_2 = { - - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } } - (new Class166_3) // trigger + def run { runTest } // trigger } - def run { value195_2 } // trigger + def run { Object57_2.run } // trigger } -trait Trait198_1 { +trait Trait60_1 { - val value195_2 = { + object Object57_2 { + @volatile var ObjCounter = 0 - class Class166_3 { - { // in primary constructor - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger - } + threads foreach (_.start()) + threads foreach (_.join()) } - (new Class166_3) // trigger - } - - def run { value195_2 } -} - - -class Class201_1 { - - class Class200_2 { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - def run { lzvalue199_3 } + def run { runTest } // trigger } - def run { (new Class200_2).run } + def run { Object57_2.run } } -object Object202_1 { - - class Class200_2 { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 +class Class62_1 { - object Obj { ObjCounter += 1} - Obj // one + trait Trait61_2 { + @volatile var ObjCounter = 0 - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - def run { lzvalue199_3 } - } - - def run { (new Class200_2).run } // trigger -} - - -trait Trait203_1 { - - class Class200_2 { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - def run { lzvalue199_3 } + def run { runTest } } - def run { (new Class200_2).run } + def run { (new Trait61_2 {}).run } } -class Class205_1 { - - object Object204_2 { +object Object63_1 { - lazy val lzvalue199_3 = { - var ObjCounter = 0 + trait Trait61_2 { + @volatile var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - def run { lzvalue199_3 } // trigger - } - - def run { Object204_2.run } -} - - -object Object206_1 { - - object Object204_2 { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - def run { lzvalue199_3 } // trigger + def run { runTest } } - def run { Object204_2.run } // trigger + def run { (new Trait61_2 {}).run } // trigger } -trait Trait207_1 { +trait Trait64_1 { - object Object204_2 { + trait Trait61_2 { + @volatile var ObjCounter = 0 - lazy val lzvalue199_3 = { - var ObjCounter = 0 + object Obj { ObjCounter += 1} - object Obj { ObjCounter += 1} - Obj // one + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - def run { lzvalue199_3 } // trigger - } - - def run { Object204_2.run } -} - - -class Class209_1 { - - trait Trait208_2 { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - def run { lzvalue199_3 } + def run { runTest } } - def run { (new Trait208_2 {}).run } + def run { (new Trait61_2 {}).run } } -object Object210_1 { - - trait Trait208_2 { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 +class Class66_1 { - object Obj { ObjCounter += 1} - Obj // one + def method65_2 { + @volatile var ObjCounter = 0 - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - def run { lzvalue199_3 } - } - - def run { (new Trait208_2 {}).run } // trigger -} - - -trait Trait211_1 { - - trait Trait208_2 { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - def run { lzvalue199_3 } + runTest // trigger } - def run { (new Trait208_2 {}).run } + def run { method65_2 } } -class Class213_1 { - - def method212_2 { +object Object67_1 { - lazy val lzvalue199_3 = { - var ObjCounter = 0 + def method65_2 { + @volatile var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - lzvalue199_3 // trigger - } - - def run { method212_2 } -} - - -object Object214_1 { - - def method212_2 { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - lzvalue199_3 // trigger + runTest // trigger } - def run { method212_2 } // trigger + def run { method65_2 } // trigger } -trait Trait215_1 { - - def method212_2 { +trait Trait68_1 { - lazy val lzvalue199_3 = { - var ObjCounter = 0 + def method65_2 { + @volatile var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} - def singleThreadedAccess(x: Any) = { - x == Obj - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - lzvalue199_3 // trigger - } - - def run { method212_2 } -} - - -class Class217_1 { - - val fun216_2 = () => { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - lzvalue199_3 // trigger + runTest // trigger } - def run { fun216_2() } + def run { method65_2 } } -object Object218_1 { +class Class70_1 { - val fun216_2 = () => { + private def method69_2 { + @volatile var ObjCounter = 0 - lazy val lzvalue199_3 = { - var ObjCounter = 0 + object Obj { ObjCounter += 1} - object Obj { ObjCounter += 1} - Obj // one + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - lzvalue199_3 // trigger - } - - def run { fun216_2() } // trigger -} - - -trait Trait219_1 { - - val fun216_2 = () => { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - lzvalue199_3 // trigger + runTest // trigger } - def run { fun216_2() } + def run { method69_2 } } -class Class221_1 { +object Object71_1 { - class Class220_2 { - { // in primary constructor - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + private def method69_2 { + @volatile var ObjCounter = 0 - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + object Obj { ObjCounter += 1} - runTest // trigger - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - lzvalue199_3 // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - } - - def run { (new Class220_2) } -} - - -object Object222_1 { - - class Class220_2 { - { // in primary constructor - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - lzvalue199_3 // trigger - } - } - - def run { (new Class220_2) } // trigger -} - - -trait Trait223_1 { - - class Class220_2 { - { // in primary constructor - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - lzvalue199_3 // trigger - } - } - - def run { (new Class220_2) } -} - - -class Class225_1 { - - lazy val lzvalue224_2 = { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - lzvalue199_3 // trigger + runTest // trigger } - def run { lzvalue224_2 } + def run { method69_2 } // trigger } -object Object226_1 { - - lazy val lzvalue224_2 = { +trait Trait72_1 { - lazy val lzvalue199_3 = { - var ObjCounter = 0 + private def method69_2 { + @volatile var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - lzvalue199_3 // trigger - } - - def run { lzvalue224_2 } // trigger -} - - -trait Trait227_1 { - - lazy val lzvalue224_2 = { - - lazy val lzvalue199_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - lzvalue199_3 // trigger + runTest // trigger } - def run { lzvalue224_2 } + def run { method69_2 } } +class Class74_1 { -class Class234_1 { + val fun73_2 = () => { + @volatile var ObjCounter = 0 - class Class233_2 { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - def run { value232_3 } - } - - def run { (new Class233_2).run } -} - - -object Object235_1 { - - class Class233_2 { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - def run { value232_3 } + runTest // trigger } - def run { (new Class233_2).run } // trigger + def run { fun73_2() } } -trait Trait236_1 { +object Object75_1 { - class Class233_2 { + val fun73_2 = () => { + @volatile var ObjCounter = 0 - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} - def singleThreadedAccess(x: Any) = { - x == Obj - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - def run { value232_3 } - } - - def run { (new Class233_2).run } -} - - -class Class238_1 { - - object Object237_2 { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - def run { value232_3 } // trigger + runTest // trigger } - def run { Object237_2.run } + def run { fun73_2() } // trigger } -object Object239_1 { - - object Object237_2 { +trait Trait76_1 { - val value232_3 = { - var ObjCounter = 0 + val fun73_2 = () => { + @volatile var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one + object Obj { ObjCounter += 1} - def singleThreadedAccess(x: Any) = { - x == Obj - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - def run { value232_3 } // trigger - } - - def run { Object237_2.run } // trigger -} - - -trait Trait240_1 { - - object Object237_2 { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - def run { value232_3 } // trigger + runTest // trigger } - def run { Object237_2.run } + def run { fun73_2() } } -class Class242_1 { - - trait Trait241_2 { +class Class78_1 { - val value232_3 = { - var ObjCounter = 0 + class Class77_2 { + { // in primary constructor + @volatile var ObjCounter = 0 object Obj { ObjCounter += 1} - Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - def run { value232_3 } - } - - def run { (new Trait241_2 {}).run } -} - - -object Object243_1 { - - trait Trait241_2 { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj + threads foreach (_.start()) + threads foreach (_.join()) } def runTest { try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { - case e => print("failed "); e.printStackTrace() + case e => print("multi-threaded failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - def run { value232_3 } } - def run { (new Trait241_2 {}).run } // trigger + def run { (new Class77_2) } } -trait Trait244_1 { - - trait Trait241_2 { +object Object79_1 { - val value232_3 = { - var ObjCounter = 0 + class Class77_2 { + { // in primary constructor + @volatile var ObjCounter = 0 object Obj { ObjCounter += 1} - Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - def run { value232_3 } - } - - def run { (new Trait241_2 {}).run } -} - - -class Class246_1 { - - def method245_2 { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj + threads foreach (_.start()) + threads foreach (_.join()) } def runTest { try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { - case e => print("failed "); e.printStackTrace() + case e => print("multi-threaded failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - value232_3 // trigger } - def run { method245_2 } + def run { (new Class77_2) } // trigger } -object Object247_1 { - - def method245_2 { +trait Trait80_1 { - val value232_3 = { - var ObjCounter = 0 + class Class77_2 { + { // in primary constructor + @volatile var ObjCounter = 0 object Obj { ObjCounter += 1} - Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - value232_3 // trigger - } - - def run { method245_2 } // trigger -} - - -trait Trait248_1 { - - def method245_2 { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj + threads foreach (_.start()) + threads foreach (_.join()) } def runTest { try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { - case e => print("failed "); e.printStackTrace() + case e => print("multi-threaded failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - value232_3 // trigger } - def run { method245_2 } + def run { (new Class77_2) } } -class Class250_1 { +class Class82_1 { - val fun249_2 = () => { - - val value232_3 = { - var ObjCounter = 0 + trait Trait81_2 { + { // in primary constructor + @volatile var ObjCounter = 0 object Obj { ObjCounter += 1} - Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - value232_3 // trigger - } - - def run { fun249_2() } -} - - -object Object251_1 { - - val fun249_2 = () => { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj + threads foreach (_.start()) + threads foreach (_.join()) } def runTest { try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { - case e => print("failed "); e.printStackTrace() + case e => print("multi-threaded failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - value232_3 // trigger } - def run { fun249_2() } // trigger + def run { (new Trait81_2 {}) } } -trait Trait252_1 { - - val fun249_2 = () => { +object Object83_1 { - val value232_3 = { - var ObjCounter = 0 + trait Trait81_2 { + { // in primary constructor + @volatile var ObjCounter = 0 object Obj { ObjCounter += 1} - Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) + + threads foreach (_.start()) + threads foreach (_.join()) } def runTest { try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { - case e => print("failed "); e.printStackTrace() + case e => print("multi-threaded failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - value232_3 // trigger - } - - def run { fun249_2() } -} - - -class Class254_1 { - - class Class253_2 { - { // in primary constructor - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - value232_3 // trigger - } - } - - def run { (new Class253_2) } -} - - -object Object255_1 { - - class Class253_2 { - { // in primary constructor - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - value232_3 // trigger - } } - def run { (new Class253_2) } // trigger + def run { (new Trait81_2 {}) } // trigger } -trait Trait256_1 { +trait Trait84_1 { - class Class253_2 { + trait Trait81_2 { { // in primary constructor - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - value232_3 // trigger - } - } - - def run { (new Class253_2) } -} - - -class Class258_1 { - - lazy val lzvalue257_2 = { - - val value232_3 = { - var ObjCounter = 0 + @volatile var ObjCounter = 0 object Obj { ObjCounter += 1} - Obj // one - def singleThreadedAccess(x: Any) = { - x == Obj - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger - } - - value232_3 // trigger - } - - def run { lzvalue257_2 } -} - - -object Object259_1 { - - lazy val lzvalue257_2 = { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj + threads foreach (_.start()) + threads foreach (_.join()) } def runTest { try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) + println("ok") } catch { - case e => print("failed "); e.printStackTrace() + case e => print("multi-threaded failed "); e.printStackTrace() } - println("ok") } runTest // trigger } - - value232_3 // trigger } - def run { lzvalue257_2 } // trigger + def run { (new Trait81_2 {}) } } -trait Trait260_1 { +class Class90_1 { - lazy val lzvalue257_2 = { + val value89_2 = { + @volatile var ObjCounter = 0 - val value232_3 = { - var ObjCounter = 0 + object Obj { ObjCounter += 1} - object Obj { ObjCounter += 1} - Obj // one + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } - - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - value232_3 // trigger - } - - def run { lzvalue257_2 } -} - - -class Class262_1 { - - val value261_2 = { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - value232_3 // trigger + runTest // trigger } - def run { value261_2 } + def run { value89_2 } } -object Object263_1 { - - val value261_2 = { +trait Trait92_1 { - val value232_3 = { - var ObjCounter = 0 + val value89_2 = { + @volatile var ObjCounter = 0 - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } + object Obj { ObjCounter += 1} - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } - println("ok") - } + def multiThreadedAccess() { + val threads = for (i <- 1 to 5) yield new Thread(new Runnable { + def run = Obj + }) - runTest // trigger + threads foreach (_.start()) + threads foreach (_.join()) } - value232_3 // trigger - } - - def run { value261_2 } // trigger -} - - -trait Trait264_1 { - - val value261_2 = { - - val value232_3 = { - var ObjCounter = 0 - - object Obj { ObjCounter += 1} - Obj // one - - def singleThreadedAccess(x: Any) = { - x == Obj - } - - def runTest { - try { - assert(singleThreadedAccess(Obj)) - assert(ObjCounter == 1) - } catch { - case e => print("failed "); e.printStackTrace() - } + def runTest { + try { + multiThreadedAccess() + assert(ObjCounter == 1, "multiple instances: " + ObjCounter) println("ok") + } catch { + case e => print("multi-threaded failed "); e.printStackTrace() } - - runTest // trigger } - value232_3 // trigger + runTest // trigger } - def run { value261_2 } + def run { value89_2 } } -object Test extends App { - (new Class3_1).run - Object4_1.run - (new Trait5_1 {}).run - (new Class7_1).run - Object8_1.run - (new Trait9_1 {}).run - (new Class11_1).run - Object12_1.run - (new Trait13_1 {}).run - (new Class15_1).run - Object16_1.run - (new Trait17_1 {}).run - (new Class19_1).run - Object20_1.run - (new Trait21_1 {}).run - (new Class23_1).run - Object24_1.run - (new Trait25_1 {}).run - (new Class27_1).run - Object28_1.run - (new Trait29_1 {}).run - (new Class31_1).run - Object32_1.run - (new Trait33_1 {}).run - (new Class36_1).run - Object37_1.run - (new Trait38_1 {}).run - (new Class40_1).run - Object41_1.run - (new Trait42_1 {}).run - (new Class44_1).run - Object45_1.run - (new Trait46_1 {}).run - (new Class48_1).run - Object49_1.run - (new Trait50_1 {}).run - (new Class52_1).run - Object53_1.run - (new Trait54_1 {}).run - (new Class56_1).run - Object57_1.run - (new Trait58_1 {}).run - (new Class60_1).run - Object61_1.run - (new Trait62_1 {}).run - (new Class64_1).run - Object65_1.run - (new Trait66_1 {}).run - (new Class69_1).run - Object70_1.run - (new Trait71_1 {}).run - (new Class73_1).run - Object74_1.run - (new Trait75_1 {}).run - (new Class77_1).run - Object78_1.run - (new Trait79_1 {}).run - (new Class81_1).run - Object82_1.run - (new Trait83_1 {}).run - (new Class85_1).run - Object86_1.run - (new Trait87_1 {}).run - (new Class89_1).run - Object90_1.run - (new Trait91_1 {}).run - (new Class93_1).run - Object94_1.run - (new Trait95_1 {}).run - (new Class97_1).run - Object98_1.run - (new Trait99_1 {}).run - (new Class102_1).run - Object103_1.run - (new Trait104_1 {}).run - (new Class106_1).run - Object107_1.run - (new Trait108_1 {}).run - (new Class110_1).run - Object111_1.run - (new Trait112_1 {}).run - (new Class114_1).run - Object115_1.run - (new Trait116_1 {}).run - (new Class118_1).run - Object119_1.run - (new Trait120_1 {}).run - (new Class122_1).run - Object123_1.run - (new Trait124_1 {}).run - (new Class126_1).run - Object127_1.run - (new Trait128_1 {}).run - (new Class130_1).run - Object131_1.run - (new Trait132_1 {}).run - (new Class135_1).run - Object136_1.run - (new Trait137_1 {}).run - (new Class139_1).run - Object140_1.run - (new Trait141_1 {}).run - (new Class143_1).run - Object144_1.run - (new Trait145_1 {}).run - (new Class147_1).run - Object148_1.run - (new Trait149_1 {}).run - (new Class151_1).run - Object152_1.run - (new Trait153_1 {}).run - (new Class155_1).run - Object156_1.run - (new Trait157_1 {}).run - (new Class159_1).run - Object160_1.run - (new Trait161_1 {}).run - (new Class163_1).run - Object164_1.run - (new Trait165_1 {}).run - (new Class168_1).run - Object169_1.run - (new Trait170_1 {}).run - (new Class172_1).run - Object173_1.run - (new Trait174_1 {}).run - (new Class176_1).run - Object177_1.run - (new Trait178_1 {}).run - (new Class180_1).run - Object181_1.run - (new Trait182_1 {}).run - (new Class184_1).run - Object185_1.run - (new Trait186_1 {}).run - (new Class188_1).run - Object189_1.run - (new Trait190_1 {}).run - (new Class192_1).run - Object193_1.run - (new Trait194_1 {}).run - (new Class196_1).run - Object197_1.run - (new Trait198_1 {}).run - (new Class201_1).run - Object202_1.run - (new Trait203_1 {}).run - (new Class205_1).run - Object206_1.run - (new Trait207_1 {}).run - (new Class209_1).run - Object210_1.run - (new Trait211_1 {}).run - (new Class213_1).run - Object214_1.run - (new Trait215_1 {}).run - (new Class217_1).run - Object218_1.run - (new Trait219_1 {}).run - (new Class221_1).run - Object222_1.run - (new Trait223_1 {}).run - (new Class225_1).run - Object226_1.run - (new Trait227_1 {}).run - (new Class234_1).run - Object235_1.run - (new Trait236_1 {}).run - (new Class238_1).run - Object239_1.run - (new Trait240_1 {}).run - (new Class242_1).run - Object243_1.run - (new Trait244_1 {}).run - (new Class246_1).run - Object247_1.run - (new Trait248_1 {}).run - (new Class250_1).run - Object251_1.run - (new Trait252_1 {}).run - (new Class254_1).run - Object255_1.run - (new Trait256_1 {}).run - (new Class258_1).run - Object259_1.run - (new Trait260_1 {}).run - (new Class262_1).run - Object263_1.run - (new Trait264_1 {}).run +object Test { + def main(args: Array[String]) { + (new Class2_1).run + Object3_1.run + (new Trait4_1 {}).run + (new Class6_1).run + Object7_1.run + (new Trait8_1 {}).run + (new Class10_1).run + Object11_1.run + (new Trait12_1 {}).run + (new Class14_1).run + Object15_1.run + (new Trait16_1 {}).run + (new Class18_1).run + Object19_1.run + (new Trait20_1 {}).run + (new Class22_1).run + Object23_1.run + (new Trait24_1 {}).run + (new Class26_1).run + Object27_1.run + (new Trait28_1 {}).run + (new Class30_1).run + Object31_1.run + (new Trait32_1 {}).run + (new Class34_1).run + Object35_1.run + (new Trait36_1 {}).run + (new Class38_1).run + Object39_1.run + (new Trait40_1 {}).run + (new Class42_1).run + Object43_1.run + (new Trait44_1 {}).run + (new Class46_1).run + Object47_1.run + (new Trait48_1 {}).run + (new Class50_1).run + Object51_1.run + (new Trait52_1 {}).run + (new Class54_1).run + Object55_1.run + (new Trait56_1 {}).run + (new Class58_1).run + Object59_1.run + (new Trait60_1 {}).run + (new Class62_1).run + Object63_1.run + (new Trait64_1 {}).run + (new Class66_1).run + Object67_1.run + (new Trait68_1 {}).run + (new Class70_1).run + Object71_1.run + (new Trait72_1 {}).run + (new Class74_1).run + Object75_1.run + (new Trait76_1 {}).run + (new Class78_1).run + Object79_1.run + (new Trait80_1 {}).run + (new Class82_1).run + Object83_1.run + (new Trait84_1 {}).run + (new Class90_1).run + (new Trait92_1 {}).run + } } |