Scala example source code file (t4565_2.scala)
The Scala t4565_2.scala source code
class Class3_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()
}
println("ok")
}
def run { runTest }
}
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()
}
println("ok")
}
def run { runTest }
}
def run { (new Class1_3).run }
}
def run { (new Class2_2).run } // trigger
}
trait Trait5_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()
}
println("ok")
}
def run { runTest }
}
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()
}
println("ok")
}
def run { runTest }
}
def run { (new Class1_3).run } // trigger
}
def run { Object6_2.run } // trigger
}
trait Trait9_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 }
}
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()
}
println("ok")
}
def run { runTest }
}
def run { (new Class1_3).run }
}
def run { (new Trait10_2 {}).run }
}
object Object12_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()
}
println("ok")
}
def run { runTest }
}
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()
}
println("ok")
}
def run { runTest }
}
def run { (new Class1_3).run }
}
def run { (new Trait10_2 {}).run }
}
class Class15_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()
}
println("ok")
}
def run { runTest }
}
(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()
}
println("ok")
}
def run { runTest }
}
(new Class1_3).run // trigger
}
def run { method14_2 } // trigger
}
trait Trait17_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()
}
println("ok")
}
def run { runTest }
}
(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()
}
println("ok")
}
def run { runTest }
}
(new Class1_3).run // trigger
}
def run { fun18_2() }
}
object Object20_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()
}
println("ok")
}
def run { runTest }
}
(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()
}
println("ok")
}
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 { (new Class22_2) } // trigger
}
trait Trait25_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) }
}
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()
}
println("ok")
}
def run { runTest }
}
(new Class1_3).run // trigger
}
def run { lzvalue26_2 }
}
object Object28_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()
}
println("ok")
}
def run { runTest }
}
(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()
}
println("ok")
}
def run { runTest }
}
(new Class1_3).run // trigger
}
def run { lzvalue26_2 }
}
class Class31_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()
}
println("ok")
}
def run { runTest }
}
(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()
}
println("ok")
}
def run { runTest }
}
(new Class1_3).run // trigger
}
def run { value30_2 } // trigger
}
trait Trait33_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()
}
println("ok")
}
def run { runTest }
}
(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()
}
println("ok")
}
def run { runTest } // trigger
}
def run { Object34_3.run }
}
def run { (new Class35_2).run }
}
object Object37_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()
}
println("ok")
}
def run { runTest } // trigger
}
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()
}
println("ok")
}
def run { runTest } // trigger
}
def run { Object34_3.run }
}
def run { (new Class35_2).run }
}
class Class40_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()
}
println("ok")
}
def run { runTest } // trigger
}
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()
}
println("ok")
}
def run { runTest } // trigger
}
def run { Object34_3.run } // trigger
}
def run { Object39_2.run } // trigger
}
trait Trait42_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()
}
println("ok")
}
def run { runTest } // trigger
}
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()
}
println("ok")
}
def run { runTest } // trigger
}
def run { Object34_3.run }
}
def run { (new Trait43_2 {}).run }
}
object Object45_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()
}
println("ok")
}
def run { runTest } // trigger
}
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()
}
println("ok")
}
def run { runTest } // trigger
}
def run { Object34_3.run }
}
def run { (new Trait43_2 {}).run }
}
class Class48_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()
}
println("ok")
}
def run { runTest } // trigger
}
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()
}
println("ok")
}
def run { runTest } // trigger
}
Object34_3.run // trigger
}
def run { method47_2 } // trigger
}
trait Trait50_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()
}
println("ok")
}
def run { runTest } // trigger
}
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()
}
println("ok")
}
def run { runTest } // trigger
}
Object34_3.run // trigger
}
def run { fun51_2() }
}
object Object53_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()
}
println("ok")
}
def run { runTest } // trigger
}
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()
}
println("ok")
}
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
}
}
def run { (new Class55_2) } // trigger
}
trait Trait58_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) }
}
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}
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() }
}
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()
}
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
}
trait Trait104_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 }
}
class Class106_1 {
object Object105_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 } // trigger
}
def run { Object105_2.run }
}
object Object107_1 {
object Object105_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 } // trigger
}
def run { Object105_2.run } // trigger
}
trait Trait108_1 {
object Object105_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 } // trigger
}
def run { Object105_2.run }
}
class Class110_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()
}
println("ok")
}
runTest // trigger
}
def run { method100_3 }
}
def run { (new Trait109_2 {}).run }
}
object Object111_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { method100_3 }
}
def run { (new Trait109_2 {}).run }
}
class Class114_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
method100_3 // trigger
}
def run { method113_2 } // trigger
}
trait Trait116_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
method100_3 // trigger
}
def run { fun117_2() }
}
object Object119_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
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
}
}
def run { (new Class121_2) }
}
object Object123_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) } // 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()
}
println("ok")
}
runTest // trigger
}
method100_3 // trigger
}
def run { lzvalue125_2 }
}
object Object127_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
method100_3 // trigger
}
def run { lzvalue125_2 }
}
class Class130_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
method100_3 // trigger
}
def run { value129_2 } // trigger
}
trait Trait132_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { fun133_3() }
}
def run { (new Class134_2).run }
}
object Object136_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { fun133_3() }
}
def run { (new Class134_2).run }
}
class Class139_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { fun133_3() } // trigger
}
def run { Object138_2.run } // trigger
}
trait Trait141_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { fun133_3() }
}
def run { (new Trait142_2 {}).run }
}
object Object144_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { fun133_3() }
}
def run { (new Trait142_2 {}).run }
}
class Class147_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
fun133_3() // trigger
}
def run { method146_2 } // trigger
}
trait Trait149_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
fun133_3() // trigger
}
def run { fun150_2() }
}
object Object152_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
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 { (new Class154_2) }
}
class Class159_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
fun133_3() // trigger
}
def run { lzvalue158_2 } // trigger
}
trait Trait161_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
fun133_3() // trigger
}
def run { value162_2 }
}
object Object164_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()
}
println("ok")
}
runTest // trigger
}
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()
}
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
}
}
(new Class166_3) // trigger
}
def run { method179_2 }
}
class Class184_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() }
}
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
}
}
(new Class166_3) // trigger
}
def run { lzvalue191_2 } // trigger
}
trait Trait194_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 }
}
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
}
}
(new Class166_3) // trigger
}
def run { value195_2 } // trigger
}
trait Trait198_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 }
}
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()
}
println("ok")
}
runTest // trigger
}
def run { lzvalue199_3 }
}
def run { (new Class200_2).run }
}
object Object202_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { lzvalue199_3 }
}
def run { (new Class200_2).run }
}
class Class205_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { lzvalue199_3 } // trigger
}
def run { Object204_2.run } // trigger
}
trait Trait207_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { lzvalue199_3 }
}
def run { (new Trait208_2 {}).run }
}
object Object210_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { lzvalue199_3 }
}
def run { (new Trait208_2 {}).run }
}
class Class213_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
lzvalue199_3 // trigger
}
def run { method212_2 } // trigger
}
trait Trait215_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
lzvalue199_3 // trigger
}
def run { fun216_2() }
}
object Object218_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
lzvalue199_3 // trigger
}
def run { fun216_2() }
}
class Class221_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) }
}
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()
}
println("ok")
}
runTest // trigger
}
lzvalue199_3 // trigger
}
def run { lzvalue224_2 }
}
object Object226_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
lzvalue199_3 // trigger
}
def run { lzvalue224_2 }
}
class Class234_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { value232_3 }
}
def run { (new Class233_2).run } // trigger
}
trait Trait236_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { value232_3 } // trigger
}
def run { Object237_2.run }
}
object Object239_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
def run { value232_3 } // trigger
}
def run { Object237_2.run }
}
class Class242_1 {
trait Trait241_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()
}
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
}
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 } // trigger
}
trait Trait244_1 {
trait Trait241_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()
}
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
}
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 }
}
object Object247_1 {
def method245_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()
}
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
}
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 }
}
class Class250_1 {
val fun249_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()
}
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
}
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() } // trigger
}
trait Trait252_1 {
val fun249_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()
}
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
}
trait Trait256_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) }
}
class Class258_1 {
lazy val lzvalue257_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()
}
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
}
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 } // trigger
}
trait Trait260_1 {
lazy val lzvalue257_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
value232_3 // trigger
}
def run { value261_2 }
}
object Object263_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()
}
println("ok")
}
runTest // trigger
}
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()
}
println("ok")
}
runTest // trigger
}
value232_3 // trigger
}
def run { value261_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
}
Other Scala examples (source code examples)Here is a short list of links related to this Scala t4565_2.scala source code file: |
The search page
Other Scala source code examples at this package level
Click here to learn more about this project
