path: root/test/files/run/inner-obj-auto.scala

/* ================================================================================
         Automatically generated on 2011-05-11. Do Not Edit (unless you have to).
         (2-level nesting)
   ================================================================================ */ 



class Class2_1 {
  
  class Class1_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class1_2).run }
}


object Object3_1 {
  
  class Class1_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class1_2).run } // trigger
}


trait Trait4_1 {
  
  class Class1_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class1_2).run }
}


class Class6_1 {
  
  object Object5_2 {
    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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object5_2.run }
}


object Object7_1 {
  
  object Object5_2 {
    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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object5_2.run } // trigger
}


trait Trait8_1 {
  
  object Object5_2 {
    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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object5_2.run }
}


class Class10_1 {
  
  trait Trait9_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait9_2 {}).run }
}


object Object11_1 {
  
  trait Trait9_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait9_2 {}).run } // trigger
}


trait Trait12_1 {
  
  trait Trait9_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait9_2 {}).run }
}


class Class14_1 {
  
  def method13_2 {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { method13_2 }
}


object Object15_1 {
  
  def method13_2 {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { method13_2 } // trigger
}


trait Trait16_1 {
  
  def method13_2 {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { method13_2 }
}


class Class18_1 {
  
  private def method17_2 {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { method17_2 }
}


object Object19_1 {
  
  private def method17_2 {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { method17_2 } // trigger
}


trait Trait20_1 {
  
  private def method17_2 {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { method17_2 }
}


class Class22_1 {
  
  val fun21_2 = () => {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { fun21_2() }
}


object Object23_1 {
  
  val fun21_2 = () => {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { fun21_2() } // trigger
}


trait Trait24_1 {
  
  val fun21_2 = () => {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { fun21_2() }
}


class Class26_1 {
  
  class Class25_2 {
    { // 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, "multiple instances: " + ObjCounter)
          println("ok")
        } catch {
          case e =>  print("failed "); e.printStackTrace()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Class25_2) }
}


object Object27_1 {
  
  class Class25_2 {
    { // 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, "multiple instances: " + ObjCounter)
          println("ok")
        } catch {
          case e =>  print("failed "); e.printStackTrace()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Class25_2) } // trigger
}


trait Trait28_1 {
  
  class Class25_2 {
    { // 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, "multiple instances: " + ObjCounter)
          println("ok")
        } catch {
          case e =>  print("failed "); e.printStackTrace()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Class25_2) }
}


class Class30_1 {
  
  trait Trait29_2 {
    { // 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, "multiple instances: " + ObjCounter)
          println("ok")
        } catch {
          case e =>  print("failed "); e.printStackTrace()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Trait29_2 {}) }
}


object Object31_1 {
  
  trait Trait29_2 {
    { // 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, "multiple instances: " + ObjCounter)
          println("ok")
        } catch {
          case e =>  print("failed "); e.printStackTrace()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Trait29_2 {}) } // trigger
}


trait Trait32_1 {
  
  trait Trait29_2 {
    { // 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, "multiple instances: " + ObjCounter)
          println("ok")
        } catch {
          case e =>  print("failed "); e.printStackTrace()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Trait29_2 {}) }
}


class Class34_1 {
  
  lazy val lzvalue33_2 = {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { lzvalue33_2 }
}


object Object35_1 {
  
  lazy val lzvalue33_2 = {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { lzvalue33_2 } // trigger
}


trait Trait36_1 {
  
  lazy val lzvalue33_2 = {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { lzvalue33_2 }
}


class Class38_1 {
  
  val value37_2 = {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { value37_2 }
}


object Object39_1 {
  
  val value37_2 = {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { value37_2 } // trigger
}


trait Trait40_1 {
  
  val value37_2 = {
    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()
      }
    }

    runTest // trigger
  }
  
  def run { value37_2 }
}


class Class42_1 {
  
  class Class41_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class41_2).run }
}


object Object43_1 {
  
  class Class41_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class41_2).run } // trigger
}


trait Trait44_1 {
  
  class Class41_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class41_2).run }
}


class Class46_1 {
  
  object Object45_2 {
    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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object45_2.run }
}


object Object47_1 {
  
  object Object45_2 {
    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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object45_2.run } // trigger
}


trait Trait48_1 {
  
  object Object45_2 {
    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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object45_2.run }
}


class Class50_1 {
  
  trait Trait49_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait49_2 {}).run }
}


object Object51_1 {
  
  trait Trait49_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait49_2 {}).run } // trigger
}


trait Trait52_1 {
  
  trait Trait49_2 {
    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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait49_2 {}).run }
}


class Class54_1 {
  
  class Class53_2 {
    @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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class53_2).run }
}


object Object55_1 {
  
  class Class53_2 {
    @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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class53_2).run } // trigger
}


trait Trait56_1 {
  
  class Class53_2 {
    @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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Class53_2).run }
}


class Class58_1 {
  
  object Object57_2 {
    @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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object57_2.run }
}


object Object59_1 {
  
  object Object57_2 {
    @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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object57_2.run } // trigger
}


trait Trait60_1 {
  
  object Object57_2 {
    @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()
      }
    }

    def run { runTest } // trigger
  }
  
  def run { Object57_2.run }
}


class Class62_1 {
  
  trait Trait61_2 {
    @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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait61_2 {}).run }
}


object Object63_1 {
  
  trait Trait61_2 {
    @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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait61_2 {}).run } // trigger
}


trait Trait64_1 {
  
  trait Trait61_2 {
    @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()
      }
    }

    def run { runTest }
  }
  
  def run { (new Trait61_2 {}).run }
}


class Class66_1 {
  
  def method65_2 {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { method65_2 }
}


object Object67_1 {
  
  def method65_2 {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { method65_2 } // trigger
}


trait Trait68_1 {
  
  def method65_2 {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { method65_2 }
}


class Class70_1 {
  
  private def method69_2 {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { method69_2 }
}


object Object71_1 {
  
  private def method69_2 {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { method69_2 } // trigger
}


trait Trait72_1 {
  
  private def method69_2 {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { method69_2 }
}


class Class74_1 {
  
  val fun73_2 = () => {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { fun73_2() }
}


object Object75_1 {
  
  val fun73_2 = () => {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { fun73_2() } // trigger
}


trait Trait76_1 {
  
  val fun73_2 = () => {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { fun73_2() }
}


class Class78_1 {
  
  class Class77_2 {
    { // in primary constructor 
      @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()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Class77_2) }
}


object Object79_1 {
  
  class Class77_2 {
    { // in primary constructor 
      @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()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Class77_2) } // trigger
}


trait Trait80_1 {
  
  class Class77_2 {
    { // in primary constructor 
      @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()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Class77_2) }
}


class Class82_1 {
  
  trait Trait81_2 {
    { // in primary constructor 
      @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()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Trait81_2 {}) }
}


object Object83_1 {
  
  trait Trait81_2 {
    { // in primary constructor 
      @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()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Trait81_2 {}) } // trigger
}


trait Trait84_1 {
  
  trait Trait81_2 {
    { // in primary constructor 
      @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()
        }
      }

      runTest // trigger
    } 
  }
  
  def run { (new Trait81_2 {}) }
}


class Class90_1 {
  
  val value89_2 = {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { value89_2 }
}


trait Trait92_1 {
  
  val value89_2 = {
    @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()
      }
    }

    runTest // trigger
  }
  
  def run { value89_2 }
}


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
  }
}