Move blackBoxFile() testData to box/ directory
Delete all test methods (and empty test classes), since they'll be auto-generated
This commit is contained in:
Alexander Udalov
committed by
Alexander Udalov
Alexander Udalov
parent
ecbb2f10ef
commit
41a416da60
@@ -0,0 +1,11 @@
|
||||
class C() {
|
||||
class object {
|
||||
fun create() = C()
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val c = C.create()
|
||||
return if (c is C) "OK" else "fail"
|
||||
}
|
||||
|
||||
@@ -0,0 +1,7 @@
|
||||
class A() {
|
||||
class object {
|
||||
val value = 10
|
||||
}
|
||||
}
|
||||
|
||||
fun box() = if (A.value == 10) "OK" else "Fail ${A.value}"
|
||||
@@ -0,0 +1,12 @@
|
||||
// EA-38323 - Illegal field modifiers in class: classObject field in C must be static and final
|
||||
|
||||
trait C {
|
||||
class object {
|
||||
public val FOO: String = "OK"
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
return C.FOO
|
||||
}
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
trait Trait1 {
|
||||
fun foo() : String
|
||||
}
|
||||
|
||||
trait Trait2 {
|
||||
fun bar() : String
|
||||
}
|
||||
|
||||
class T1 : Trait1{
|
||||
override fun foo() = "aaa"
|
||||
}
|
||||
|
||||
class T2 : Trait2{
|
||||
override fun bar() = "bbb"
|
||||
}
|
||||
|
||||
class C(a:Trait1, b:Trait2) : Trait1 by a, Trait2 by b
|
||||
|
||||
fun box() : String {
|
||||
val c = C(T1(),T2())
|
||||
if(c.foo() != "aaa") return "fail"
|
||||
if(c.bar() != "bbb") return "fail"
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
trait One {
|
||||
public open fun foo() : Int
|
||||
public open fun faz() : Int = 10
|
||||
}
|
||||
trait Two {
|
||||
public open fun foo() : Int
|
||||
public open fun quux() : Int = 100
|
||||
}
|
||||
|
||||
class OneImpl : One {
|
||||
public override fun foo() = 1
|
||||
}
|
||||
class TwoImpl : Two {
|
||||
public override fun foo() = 2
|
||||
}
|
||||
|
||||
class Test2(a : One, b : Two) : Two by b, One by a {
|
||||
public override fun foo() = 0
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
var t2 = Test2(OneImpl(), TwoImpl())
|
||||
if (t2.foo() != 0)
|
||||
return "Fail #1"
|
||||
if (t2.faz() != 10)
|
||||
return "Fail #2"
|
||||
if (t2.quux() != 100)
|
||||
return "Fail #3"
|
||||
if (t2 !is One)
|
||||
return "Fail #4"
|
||||
if (t2 !is Two)
|
||||
return "Fail #5"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
open trait First {
|
||||
public open fun foo() : Int
|
||||
}
|
||||
|
||||
open trait Second : First {
|
||||
public open fun bar() : Int
|
||||
}
|
||||
|
||||
class Impl : Second {
|
||||
public override fun foo() = 1
|
||||
public override fun bar() = 2
|
||||
}
|
||||
|
||||
class Test(s : Second) : Second by s {}
|
||||
|
||||
fun box() : String {
|
||||
var t = Test(Impl())
|
||||
if (t.foo() != 1)
|
||||
return "Fail #1"
|
||||
if (t.bar() != 2)
|
||||
return "Fail #2"
|
||||
if (t !is First)
|
||||
return "Fail #3"
|
||||
if (t !is Second)
|
||||
return "Fail #4"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
trait A<T> {
|
||||
fun foo(t: T): String
|
||||
}
|
||||
|
||||
class Derived(a: A<Int>) : A<Int> by a
|
||||
|
||||
fun box(): String {
|
||||
val o = object : A<Int> {
|
||||
override fun foo(t: Int) = if (t == 42) "OK" else "Fail $t"
|
||||
}
|
||||
return Derived(o).foo(42)
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
trait A<T: Number> {
|
||||
fun foo(t: T): String
|
||||
}
|
||||
|
||||
class Derived(a: A<Int>) : A<Int> by a
|
||||
|
||||
fun box(): String {
|
||||
val o = object : A<Int> {
|
||||
override fun foo(t: Int) = if (t == 42) "OK" else "Fail $t"
|
||||
}
|
||||
return Derived(o).foo(42)
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
trait A<T, U> {
|
||||
fun foo(t: T, u: U): String
|
||||
}
|
||||
|
||||
class Derived(a: A<Long, Int>) : A<Long, Int> by a
|
||||
|
||||
fun box(): String {
|
||||
val o = object : A<Long, Int> {
|
||||
override fun foo(t: Long, u: Int) = if (t == u.toLong()) "OK" else "Fail $t $u"
|
||||
}
|
||||
return Derived(o).foo(42, 42)
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
class TestJava(r : Runnable) : Runnable by r {}
|
||||
class TestRunnable() : Runnable {
|
||||
public override fun run() = System.out.println("foobar")
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
var del = TestJava(TestRunnable())
|
||||
del.run()
|
||||
if (del !is Runnable)
|
||||
return "Fail #1"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
package test
|
||||
|
||||
trait TextField {
|
||||
fun getText(): String
|
||||
}
|
||||
|
||||
trait InputTextField : TextField {
|
||||
fun setText(text: String)
|
||||
}
|
||||
|
||||
trait MooableTextField : InputTextField {
|
||||
fun moo(a: Int, b: Int, c: Int): Int
|
||||
}
|
||||
|
||||
class SimpleTextField : MooableTextField {
|
||||
private var text = ""
|
||||
override fun getText() = text
|
||||
override fun setText(text: String) {
|
||||
this.text = text
|
||||
}
|
||||
override fun moo(a: Int, b: Int, c: Int) = a + b + c
|
||||
}
|
||||
|
||||
class TextFieldWrapper(textField: MooableTextField) : MooableTextField by textField
|
||||
|
||||
fun box() : String {
|
||||
val textField = TextFieldWrapper(SimpleTextField())
|
||||
textField.setText("hello world!")
|
||||
|
||||
if (!textField.getText().equals("hello world!")) return "FAIL #!1"
|
||||
if (textField.moo(1,2,3) != 6) return "FAIL #2"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
// Changed when traits were introduced. May not make sense any more
|
||||
|
||||
open class Base() {
|
||||
public var v : Int = 0
|
||||
}
|
||||
|
||||
open class Left() : Base() {}
|
||||
trait Right : Base {}
|
||||
|
||||
class D() : Left(), Right
|
||||
|
||||
fun vl(l : Left) : Int = l.v
|
||||
fun vr(r : Right) : Int = r.v
|
||||
|
||||
fun box() : String {
|
||||
val d = D()
|
||||
d.v = 42
|
||||
|
||||
if (d.v != 42) return "Fail #1"
|
||||
if (vl(d) != 42) return "Fail #2"
|
||||
if (vr(d) != 42) return "Fail #3"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
class GameError(msg: String): Exception(msg) {
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val e = GameError("foo")
|
||||
return if (e.getMessage() == "foo") "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
open class Base() {
|
||||
fun n(n : Int) : Int = n + 1
|
||||
}
|
||||
|
||||
trait Abstract {}
|
||||
|
||||
class Derived1() : Base(), Abstract {}
|
||||
class Derived2() : Abstract, Base() {}
|
||||
|
||||
fun test(s : Base) : Boolean = s.n(238) == 239
|
||||
|
||||
fun box() : String {
|
||||
if (!test(Base())) return "Fail #1"
|
||||
if (!test(Derived1())) return "Fail #2"
|
||||
if (!test(Derived2())) return "Fail #3"
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
// Changed when traits were introduced. May not make sense any more
|
||||
|
||||
open class X(val x : Int) {}
|
||||
trait Y {
|
||||
abstract val y : Int
|
||||
}
|
||||
|
||||
class YImpl(override val y : Int) : Y {}
|
||||
|
||||
class Point(x : Int, yy : Int) : X(x) , Y {
|
||||
override val y : Int = yy
|
||||
}
|
||||
|
||||
trait Abstract {}
|
||||
|
||||
class P1(x : Int, yy : Y) : Abstract, X(x), Y by yy {}
|
||||
class P2(x : Int, yy : Y) : X(x), Abstract, Y by yy {}
|
||||
class P3(x : Int, yy : Y) : X(x), Y by yy, Abstract {}
|
||||
class P4(x : Int, yy : Y) : Y by yy, Abstract, X(x) {}
|
||||
|
||||
fun box() : String {
|
||||
if (X(239).x != 239) return "FAIL #1"
|
||||
if (YImpl(239).y != 239) return "FAIL #2"
|
||||
|
||||
val p = Point(240, -1)
|
||||
if (p.x + p.y != 239) return "FAIL #3"
|
||||
|
||||
val y = YImpl(-1)
|
||||
val p1 = P1(240, y)
|
||||
if (p1.x + p1.y != 239) return "FAIL #4"
|
||||
val p2 = P2(240, y)
|
||||
if (p2.x + p2.y != 239) return "FAIL #5"
|
||||
|
||||
val p3 = P3(240, y)
|
||||
if (p3.x + p3.y != 239) return "FAIL #6"
|
||||
|
||||
val p4 = P4(240, y)
|
||||
if (p4.x + p4.y != 239) return "FAIL #7"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
class Outer() {
|
||||
open inner class InnerBase() {
|
||||
}
|
||||
|
||||
inner class InnerDerived(): InnerBase() {
|
||||
}
|
||||
|
||||
public val foo: InnerBase? = InnerDerived()
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val o = Outer()
|
||||
return if (o.foo === null) "fail" else "OK"
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
open class Foo {
|
||||
fun xyzzy(): String = "xyzzy"
|
||||
}
|
||||
|
||||
class Bar(): Foo() {
|
||||
fun test(): String = xyzzy()
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val bar = Bar()
|
||||
val f = bar.test()
|
||||
return if (f == "xyzzy") "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
class C() {
|
||||
public var f: Int
|
||||
|
||||
{
|
||||
$f = 610
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val c = C()
|
||||
if (c.f != 610) return "fail"
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
import java.util.*
|
||||
import java.io.*
|
||||
|
||||
class World() {
|
||||
public val items: ArrayList<Item> = ArrayList<Item>()
|
||||
|
||||
inner class Item() {
|
||||
{
|
||||
items.add(this)
|
||||
}
|
||||
}
|
||||
|
||||
val foo = Item()
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val w = World()
|
||||
if (w.items.size() != 1) return "fail"
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
class Outer(val foo: StringBuilder) {
|
||||
inner class Inner() {
|
||||
fun len() : Int {
|
||||
return foo.length()
|
||||
}
|
||||
}
|
||||
|
||||
fun test() : Inner {
|
||||
return Inner()
|
||||
}
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val sb = StringBuilder("xyzzy")
|
||||
val o = Outer(sb)
|
||||
val i = o.test()
|
||||
val l = i.len()
|
||||
return if (l != 5) "fail" else "OK"
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
public class StockMarketTableModel() {
|
||||
|
||||
public fun getColumnCount() : Int {
|
||||
return COLUMN_TITLES?.size!!
|
||||
}
|
||||
|
||||
class object {
|
||||
private val COLUMN_TITLES : Array<Int?> = arrayOfNulls<Int>(10)
|
||||
}
|
||||
}
|
||||
|
||||
fun box() : String = if(StockMarketTableModel().getColumnCount()==10) "OK" else "fail"
|
||||
@@ -0,0 +1,14 @@
|
||||
object RefreshQueue {
|
||||
val workerThread: Thread = Thread(object : Runnable {
|
||||
override fun run() {
|
||||
val a = workerThread
|
||||
val b = RefreshQueue.workerThread
|
||||
if (a != b) throw AssertionError()
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
RefreshQueue.workerThread.run()
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,7 @@
|
||||
public class SomeClass() : java.lang.Object() {
|
||||
}
|
||||
|
||||
public fun box():String {
|
||||
System.out?.println(SomeClass().getClass())
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
public object SomeClass {
|
||||
var bug: Any = ""
|
||||
|
||||
private val workerThread = object : Thread() {
|
||||
override fun run() {
|
||||
try {
|
||||
foo()
|
||||
bug = "none"
|
||||
}
|
||||
catch(t: Throwable) {
|
||||
bug = t
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
workerThread.start()
|
||||
}
|
||||
|
||||
private fun foo() : Unit {
|
||||
}
|
||||
}
|
||||
|
||||
public fun box():String {
|
||||
if(SomeClass.bug is Throwable)
|
||||
throw SomeClass.bug as Throwable
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
fun f(a : Int?, b : Int.(Int)->Int) = a?.b(1)
|
||||
|
||||
fun box(): String {
|
||||
val x = f(1) { this+it+2 }
|
||||
return if (x == 4) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
trait Creator<T> {
|
||||
fun create() : T
|
||||
}
|
||||
|
||||
class Actor(val code: String = "OK")
|
||||
|
||||
trait Factory : Creator<Actor>
|
||||
|
||||
class MyFactory() : Factory {
|
||||
override fun create(): Actor = Actor()
|
||||
}
|
||||
|
||||
fun box() : String = MyFactory().create().code
|
||||
@@ -0,0 +1,17 @@
|
||||
class MyClass(var fnc : () -> String) {
|
||||
|
||||
fun test(): String {
|
||||
return fnc()
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
fun printtest() : String {
|
||||
return "OK"
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
var c = MyClass({ printtest() })
|
||||
|
||||
return c.test()
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
class Works() : jet.Function0<Object>() {
|
||||
public override fun invoke():Object {
|
||||
return "Works" as Object
|
||||
}
|
||||
}
|
||||
class Broken() : jet.Function0<String>() {
|
||||
public override fun invoke():String {
|
||||
return "Broken"
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val works1: ()->Object = Works();
|
||||
works1()
|
||||
|
||||
val broken1: ()->String = Broken();
|
||||
broken1()
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
import java.util.HashMap
|
||||
|
||||
data class Pair<First, Second>(val first: First, val second: Second)
|
||||
|
||||
fun parseCatalogs(hashMap: Any?) {
|
||||
val r = toHasMap(hashMap)
|
||||
if (!r.first) {
|
||||
return
|
||||
}
|
||||
val nodes = r.second
|
||||
}
|
||||
|
||||
fun toHasMap(value: Any?): Pair<Boolean, HashMap<String, Any?>?> {
|
||||
if(value is HashMap<*, *>) {
|
||||
return Pair(true, value as HashMap<String, Any?>)
|
||||
}
|
||||
return Pair(false, null as HashMap<String, Any?>?)
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
parseCatalogs(null)
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
fun box() : String {
|
||||
var i = 0
|
||||
{
|
||||
i++
|
||||
}()
|
||||
i++ //the problem is here
|
||||
// i = i + 1 //this way it works
|
||||
return if (i == 2) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
fun box(): String {
|
||||
return Foo().doBar("OK")
|
||||
}
|
||||
|
||||
class Foo() {
|
||||
val bar : (str : String) -> String = { it }
|
||||
|
||||
fun doBar(str : String): String {
|
||||
return bar(str);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
class T(val f : () -> Any?) {
|
||||
fun call() : Any? = f()
|
||||
}
|
||||
fun box(): String {
|
||||
return T({ "OK" }).call() as String
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
class Foo(
|
||||
var state : Int,
|
||||
val f : (Int) -> Int){
|
||||
|
||||
fun next() : Int {
|
||||
val nextState = f(state)
|
||||
state = nextState
|
||||
return state
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val f = Foo(23, {x -> 2 * x})
|
||||
return if (f.next() == 46) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
class Greeter(var name : String) {
|
||||
fun greet() {
|
||||
name = name.plus("")
|
||||
System.out?.println("Hello, $name");
|
||||
}
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
Greeter("OK").greet()
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
class MyList<T>() {
|
||||
var value: T? = null
|
||||
|
||||
fun get(index: Int): T = value!!
|
||||
|
||||
fun set(index: Int, value: T) { this.value = value }
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val list = MyList<Int>()
|
||||
list[17] = 1
|
||||
list[17] = list[18]++
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
class Bar {
|
||||
}
|
||||
|
||||
trait Foo {
|
||||
fun xyzzy(x: Any?): String
|
||||
}
|
||||
|
||||
fun buildFoo(bar: Bar.() -> Unit): Foo {
|
||||
return object : Foo {
|
||||
override fun xyzzy(x: Any?): String {
|
||||
(x as? Bar)?.bar()
|
||||
return "OK"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val foo = buildFoo({})
|
||||
return foo.xyzzy(Bar())
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
class A {
|
||||
public val f : ()->String = {"OK"}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val a = A()
|
||||
return a.f() // does not work: (in runtime) ClassCastException: A cannot be cast to jet.Function0
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
import java.util.*
|
||||
|
||||
public inline fun Int.times(body : () -> Unit) {
|
||||
var count = this;
|
||||
while (count > 0) {
|
||||
body()
|
||||
count--
|
||||
}
|
||||
}
|
||||
|
||||
fun calc() : Int {
|
||||
val a = ArrayList<()->Int>()
|
||||
2.times {
|
||||
var j = 1
|
||||
a.add({ j })
|
||||
++j
|
||||
}
|
||||
var sum = 0
|
||||
for (f in a) {
|
||||
val g = f as () -> Int
|
||||
sum += g()
|
||||
}
|
||||
return sum
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val x = calc()
|
||||
return if (x == 4) "OK" else x.toString()
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
trait A {
|
||||
fun foo(): Int
|
||||
}
|
||||
|
||||
class B1 : A {
|
||||
override fun foo() = 10
|
||||
}
|
||||
|
||||
class B2(val z: Int) : A {
|
||||
override fun foo() = z
|
||||
}
|
||||
|
||||
|
||||
|
||||
fun f1(b: B1): Int {
|
||||
val o = object : A by b { }
|
||||
return o.foo()
|
||||
}
|
||||
|
||||
fun f2(b: B2): Int {
|
||||
val o = object : A by B2(b.z) { }
|
||||
return o.foo()
|
||||
}
|
||||
|
||||
fun f3(b: B2, mult: Int): Int {
|
||||
val o = object : A by B2(mult * b.z) { }
|
||||
return o.foo()
|
||||
}
|
||||
|
||||
fun f4(b: B1, x: Int, y: Int, z: Int): Int {
|
||||
val o = object : A by b {
|
||||
fun bar() = x + y + z
|
||||
}
|
||||
return o.foo()
|
||||
}
|
||||
|
||||
|
||||
fun box(): String {
|
||||
if (f1(B1()) != 10) return "fail #1"
|
||||
if (f2(B2(239)) != 239) return "fail #2"
|
||||
if (f3(B2(239), 2) != 239*2) return "fail #3"
|
||||
if (f4(B1(), 1, 2, 3) != 10) return "fail #4"
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
public open class Test(): java.util.RandomAccess, Cloneable, java.io.Serializable
|
||||
{
|
||||
public override fun clone(): Test = Test() // Override 'clone()' with more precise type 'Test'
|
||||
|
||||
public override fun toString() = "OK"
|
||||
}
|
||||
|
||||
fun box() = Test().clone().toString()
|
||||
@@ -0,0 +1,15 @@
|
||||
class A {
|
||||
class object {
|
||||
val b = 0
|
||||
val c = b
|
||||
|
||||
{
|
||||
val d = b
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
A()
|
||||
return if (A.c == A.b) "OK" else "Fail"
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
|
||||
class JsonObject() {
|
||||
}
|
||||
|
||||
class JsonArray() {
|
||||
}
|
||||
|
||||
public trait Formatter<in IN: Any, out OUT: Any> {
|
||||
public fun format(source: IN?): OUT
|
||||
}
|
||||
|
||||
public trait MultiFormatter <in IN: Any, out OUT: Any> {
|
||||
public fun format(source: Collection<IN>): OUT
|
||||
}
|
||||
|
||||
public class Project() {
|
||||
}
|
||||
|
||||
public trait JsonFormatter<in IN: Any>: Formatter<IN, JsonObject>, MultiFormatter<IN, JsonArray> {
|
||||
public override fun format(source: Collection<IN>): JsonArray {
|
||||
return JsonArray();
|
||||
}
|
||||
}
|
||||
|
||||
public class ProjectJsonFormatter(): JsonFormatter<Project> {
|
||||
public override fun format(source: Project?): JsonObject {
|
||||
return JsonObject()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fun box(): String {
|
||||
val formatter = ProjectJsonFormatter()
|
||||
return if (formatter.format(Project()) != null) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
public trait LoggerAware {
|
||||
public val logger: StringBuilder
|
||||
}
|
||||
|
||||
public abstract class HttpServer(): LoggerAware {
|
||||
public fun start() {
|
||||
logger.append("OK")
|
||||
}
|
||||
}
|
||||
|
||||
public class MyHttpServer(): HttpServer() {
|
||||
public override val logger = StringBuilder()
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val server = MyHttpServer()
|
||||
server.start()
|
||||
return server.logger.toString()!!
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
import java.util.AbstractList
|
||||
|
||||
class MyList(): AbstractList<String>() {
|
||||
public fun getModificationCount(): Int = modCount
|
||||
public override fun get(index: Int): String = ""
|
||||
public override fun size(): Int = 0
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
return if (MyList().getModificationCount() == 0) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
import java.util.HashSet
|
||||
|
||||
fun box() : String{
|
||||
val set = HashSet<String>()
|
||||
set.add("foo")
|
||||
val t1 = "foo" in set // returns true, valid
|
||||
if(!t1) return "fail1"
|
||||
val t2 = "foo" !in set // returns true, invalid
|
||||
if(t2) return "fail2"
|
||||
val t3 = "bar" in set // returns false, valid
|
||||
if(t3) return "fail3"
|
||||
val t4 = "bar" !in set // return false, invalid
|
||||
if(!t4) return "fail4"
|
||||
val t5 = when("foo") {
|
||||
in set -> true
|
||||
else -> false
|
||||
}
|
||||
if(!t5) return "fail5"
|
||||
val t6 = when("foo") {
|
||||
!in set -> true
|
||||
else -> false
|
||||
}
|
||||
if(t6) return "fail6"
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package test
|
||||
|
||||
trait A {
|
||||
public val c: String
|
||||
get() = "OK"
|
||||
}
|
||||
|
||||
trait B {
|
||||
protected val c: String
|
||||
}
|
||||
|
||||
open class C {
|
||||
private val c: String = "FAIL"
|
||||
}
|
||||
|
||||
open class D: C(), A, B {
|
||||
val b = c
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
return D().c
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
fun box() = Class().printSome()
|
||||
|
||||
public abstract class AbstractClass<T> {
|
||||
public fun printSome() : T = some
|
||||
|
||||
public abstract val some: T
|
||||
}
|
||||
|
||||
public class Class: AbstractClass<String>() {
|
||||
public override val some: String
|
||||
get() = "OK"
|
||||
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
public fun box() : String {
|
||||
if ( 0 == 0 ) { // Does not crash if either this...
|
||||
if ( 0 == 0 ) { // ...or this is changed to if ( true )
|
||||
// Does not crash if the following is uncommented.
|
||||
//println("foo")
|
||||
}
|
||||
}
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
fun f1(a : Any?) {}
|
||||
fun f2(a : Boolean?) {}
|
||||
fun f3(a : Any) {}
|
||||
fun f4(a : Boolean) {}
|
||||
|
||||
fun box() : String {
|
||||
f1(1 == 1)
|
||||
f2(1 == 1)
|
||||
f3(1 == 1)
|
||||
f4(1 == 1)
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
package x
|
||||
|
||||
class Outer() {
|
||||
class object {
|
||||
class Inner() {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun box (): String {
|
||||
val inner = Outer.Inner()
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package foo
|
||||
|
||||
trait B {
|
||||
val c: Int
|
||||
get() = 2
|
||||
}
|
||||
|
||||
class A(val b: B) : B by b {
|
||||
override val c: Int = 3
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val c = A(object: B {}).c
|
||||
return if (c == 3) "OK" else "fail: $c"
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
open class A {
|
||||
open fun foo() = "OK"
|
||||
}
|
||||
|
||||
open class B : A() {
|
||||
override fun foo() = super.foo()
|
||||
}
|
||||
|
||||
trait I
|
||||
|
||||
class C : I, B() {
|
||||
override fun foo() = super<B>.foo()
|
||||
}
|
||||
|
||||
fun box() = C().foo()
|
||||
@@ -0,0 +1,17 @@
|
||||
open class A {
|
||||
open val foo: String = "OK"
|
||||
}
|
||||
|
||||
open class B : A() {
|
||||
inner class E {
|
||||
val foo: String = super<A>@B.foo
|
||||
}
|
||||
}
|
||||
|
||||
class C : B() {
|
||||
inner class D {
|
||||
val foo: String = super<B>@C.foo
|
||||
}
|
||||
}
|
||||
|
||||
fun box() = C().foo
|
||||
@@ -0,0 +1,9 @@
|
||||
fun box() : String {
|
||||
val o = object {
|
||||
|
||||
inner class C {
|
||||
fun foo() = "OK"
|
||||
}
|
||||
}
|
||||
return o.C().foo()
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
package example2
|
||||
|
||||
fun box() = Context.OsType.OK.toString()
|
||||
|
||||
object Context
|
||||
{
|
||||
public enum class OsType {
|
||||
WIN2000; WINDOWS; MACOSX; LINUX; OTHER; OK
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
class IntRange {
|
||||
fun contains(a: Int) = (1..2).contains(a)
|
||||
}
|
||||
|
||||
class C() {
|
||||
fun rangeTo(i: Int) = IntRange()
|
||||
}
|
||||
|
||||
|
||||
fun box(): String {
|
||||
if (2 in C()..2) {
|
||||
2 == 2
|
||||
}
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
trait Trait {
|
||||
fun foo() = "O"
|
||||
fun toString() = "K"
|
||||
}
|
||||
|
||||
class SimpleClass : Trait
|
||||
|
||||
class ComplexClass : Trait by SimpleClass() {
|
||||
override fun toString() = foo() + super.toString()
|
||||
}
|
||||
|
||||
fun box() = ComplexClass().toString()
|
||||
@@ -0,0 +1,24 @@
|
||||
import java.util.ArrayList
|
||||
|
||||
fun launch(f : () -> Unit) {
|
||||
f()
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val list = ArrayList<Int>()
|
||||
val foo : () -> Unit = {
|
||||
list.add(2) //first exception
|
||||
}
|
||||
foo()
|
||||
|
||||
launch({
|
||||
list.add(3)
|
||||
})
|
||||
|
||||
val bar = {
|
||||
val x = 1 //second exception
|
||||
}
|
||||
bar()
|
||||
|
||||
return if (list.size() == 2 && list.get(0) == 2 && list.get(1) == 3) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
fun box(): String {
|
||||
var s1 = (@l1 "s")
|
||||
val s2 = (@l2 if (@l3 true) s1 else null)
|
||||
return if (s2 == "s") "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
class MyNumber(val i: Int) {
|
||||
fun inc(): MyNumber = MyNumber(i+1)
|
||||
}
|
||||
|
||||
class MNR(var ref: MyNumber) {}
|
||||
|
||||
fun test1() : Boolean {
|
||||
var m = MyNumber(42)
|
||||
|
||||
m++
|
||||
if (m.i != 43) return false
|
||||
return true
|
||||
}
|
||||
|
||||
fun test2() : Boolean {
|
||||
var m = MyNumber(44)
|
||||
|
||||
var m2 = m++
|
||||
if (m2.i != 44) return false
|
||||
if (m.i != 45) return false
|
||||
return true
|
||||
}
|
||||
|
||||
fun test3() : Boolean {
|
||||
var mnr = MNR(MyNumber(42))
|
||||
mnr.ref++
|
||||
if (mnr.ref.i != 43) return false
|
||||
return true
|
||||
}
|
||||
|
||||
fun test4() : Boolean {
|
||||
var mnr = MNR(MyNumber(42))
|
||||
val m3 = mnr.ref++
|
||||
if (m3.i != 42) return false
|
||||
return true
|
||||
}
|
||||
|
||||
fun test5() : Boolean {
|
||||
var mnr = Array<MyNumber>(2,{MyNumber(42)})
|
||||
mnr[0]++
|
||||
if (mnr[0].i != 43) return false
|
||||
return true
|
||||
}
|
||||
|
||||
fun test6() : Boolean {
|
||||
var mnr = Array<MyNumber>(2,{it -> MyNumber(42-it)})
|
||||
mnr[1] = mnr[0]++
|
||||
if (mnr[0].i != 43) return false
|
||||
if (mnr[1].i != 42) return false
|
||||
return true
|
||||
}
|
||||
|
||||
// ArrayList without jdk-annotations cannot be used in these tests
|
||||
class MyArrayList<T>() {
|
||||
private var value17: T? = null
|
||||
private var value39: T? = null
|
||||
fun get(index: Int): T {
|
||||
if (index == 17) return value17!!
|
||||
if (index == 39) return value39!!
|
||||
throw Exception()
|
||||
}
|
||||
fun set(index: Int, value: T): T? {
|
||||
if (index == 17) value17 = value
|
||||
else if (index == 39) value39 = value
|
||||
else throw Exception()
|
||||
return null
|
||||
}
|
||||
}
|
||||
|
||||
fun test7() : Boolean {
|
||||
var mnr = MyArrayList<MyNumber>()
|
||||
mnr[17] = MyNumber(42)
|
||||
mnr[17]++
|
||||
if (mnr[17].i != 43) return false
|
||||
return true
|
||||
}
|
||||
|
||||
fun test8() : Boolean {
|
||||
var mnr = MyArrayList<MyNumber>()
|
||||
mnr[17] = MyNumber(42)
|
||||
mnr[39] = mnr[17]++
|
||||
if (mnr[17].i != 43) return false
|
||||
if (mnr[39].i != 42) return false
|
||||
return true
|
||||
}
|
||||
|
||||
|
||||
fun box() : String {
|
||||
var m = MyNumber(42)
|
||||
|
||||
if (!test1()) return "fail test 1"
|
||||
if (!test2()) return "fail test 2"
|
||||
if (!test3()) return "fail test 3"
|
||||
if (!test4()) return "fail test 4"
|
||||
|
||||
if (!test5()) return "fail test 5"
|
||||
if (!test6()) return "fail test 6"
|
||||
if (!test7()) return "fail test 7"
|
||||
if (!test8()) return "fail test 8"
|
||||
|
||||
|
||||
++m
|
||||
if (m.i != 43) return "fail 0"
|
||||
|
||||
var m1 = ++m
|
||||
if (m1.i != 44) return "fail 3"
|
||||
if (m.i != 44) return "fail 4"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
class A() {
|
||||
var xi = 0
|
||||
var xin : Int? = 0
|
||||
var xinn : Int? = null
|
||||
|
||||
var xl = 0.toLong()
|
||||
var xln : Long? = 0.toLong()
|
||||
var xlnn : Long? = null
|
||||
|
||||
var xb = 0.toByte()
|
||||
var xbn : Byte? = 0.toByte()
|
||||
var xbnn : Byte? = null
|
||||
|
||||
var xf = 0.toFloat()
|
||||
var xfn : Float? = 0.toFloat()
|
||||
var xfnn : Float? = null
|
||||
|
||||
var xd = 0.toDouble()
|
||||
var xdn : Double? = 0.toDouble()
|
||||
var xdnn : Double? = null
|
||||
|
||||
var xs = 0.toShort()
|
||||
var xsn : Short? = 0.toShort()
|
||||
var xsnn : Short? = null
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
fun test1() : Boolean {
|
||||
try {
|
||||
return true
|
||||
} finally {
|
||||
if(true) // otherwise we wisely have unreachable code
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
var x = true
|
||||
fun test2() : Boolean {
|
||||
try {
|
||||
} finally {
|
||||
x = false;
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
fun test3() : Int {
|
||||
var y = 0
|
||||
try {
|
||||
++y
|
||||
} finally {
|
||||
++y
|
||||
}
|
||||
return y
|
||||
}
|
||||
|
||||
var z = 0
|
||||
fun test4() : Int {
|
||||
z = 0
|
||||
return try {
|
||||
try {
|
||||
z++
|
||||
}
|
||||
finally {
|
||||
z++
|
||||
}
|
||||
} finally {
|
||||
++z
|
||||
}
|
||||
}
|
||||
|
||||
fun test5() : Int {
|
||||
var x = 0
|
||||
System.out?.println("test 5")
|
||||
while(true) {
|
||||
System.out?.println(x)
|
||||
try {
|
||||
if(x < 10)
|
||||
x++
|
||||
else
|
||||
break
|
||||
}
|
||||
finally {
|
||||
x++
|
||||
}
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
fun test6() : Int {
|
||||
var x = 0
|
||||
System.out?.println("test 6")
|
||||
while(x < 10) {
|
||||
System.out?.println(x)
|
||||
try {
|
||||
x++
|
||||
continue
|
||||
}
|
||||
finally {
|
||||
x++
|
||||
}
|
||||
}
|
||||
return x
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
if(test1()) return "test1 failed"
|
||||
if(test2()) return "test2 failed"
|
||||
if(test3() != 2) return "test3 failed"
|
||||
System.out?.println(test4())
|
||||
if(test4() != 0) return "test4 failed"
|
||||
if(test5() != 11) return "test5 failed"
|
||||
if(test6() != 10) return "test6 failed"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
var GUEST_USER_ID = 3
|
||||
val USER_ID =
|
||||
try {
|
||||
getUserIdFromEnvironment()
|
||||
}
|
||||
catch (e : UnsupportedOperationException) {
|
||||
++GUEST_USER_ID
|
||||
}
|
||||
|
||||
val USER_ID_2 =
|
||||
try {
|
||||
getUserIdFromEnvironment()
|
||||
}
|
||||
catch (e : UnsupportedOperationException) {
|
||||
GUEST_USER_ID
|
||||
}
|
||||
finally {
|
||||
GUEST_USER_ID++
|
||||
}
|
||||
|
||||
fun getUserIdFromEnvironment() : Int = throw UnsupportedOperationException()
|
||||
|
||||
fun box() : String {
|
||||
System.out?.println("G: " + GUEST_USER_ID + " U1:" + USER_ID + " U2: " + USER_ID_2)
|
||||
if(USER_ID != 4) return "test0 failed"
|
||||
if(USER_ID_2 != 4) return "test2 failed"
|
||||
if(GUEST_USER_ID != 5) return "test3 failed"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
class Reluctant() {
|
||||
{
|
||||
throw Exception("I'm not coming out")
|
||||
}
|
||||
}
|
||||
|
||||
fun p(o : Any?) = System.out?.println(o)
|
||||
|
||||
fun test1() : String {
|
||||
try {
|
||||
val b = Reluctant()
|
||||
return "Surprise!"
|
||||
}
|
||||
catch (ex : Exception) {
|
||||
return "I told you so"
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fun box() : String {
|
||||
if(test1() != "I told you so") return "test1 failed"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
import java.util.HashMap
|
||||
import java.io.*
|
||||
|
||||
fun <K, V> MutableMap<K, V>.set(key : K, value : V) = put(key, value)
|
||||
|
||||
fun box() : String {
|
||||
|
||||
val commands : MutableMap<String, String> = HashMap()
|
||||
|
||||
commands["c1"] = "239"
|
||||
if(commands["c1"] != "239") return "fail"
|
||||
|
||||
commands["c1"] += "932"
|
||||
return if(commands["c1"] == "239932") "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package mult_constructors_3_bug
|
||||
|
||||
public open class Identifier() {
|
||||
private var myNullable : Boolean = true
|
||||
class object {
|
||||
open public fun init(isNullable : Boolean) : Identifier {
|
||||
val __ = Identifier()
|
||||
__.myNullable = isNullable
|
||||
return __
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
Identifier.init(true)
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
class mInt(val i : Int) {
|
||||
fun toString() : String = "mint: $i"
|
||||
fun plus(i : Int) = mInt(this.i + i)
|
||||
fun inc() = mInt(i + 1)
|
||||
}
|
||||
|
||||
class MyArray() {
|
||||
val a = Array<mInt>(10, {mInt(0)})
|
||||
fun get(i : mInt) : mInt = a[i.i]
|
||||
fun set(i : mInt, v : mInt) {
|
||||
a[i.i] = v
|
||||
}
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val a = MyArray()
|
||||
var i = mInt(0)
|
||||
System.out?.println(i)
|
||||
a[i++]// = mInt(1)
|
||||
System.out?.println(i)
|
||||
a[i++] = mInt(1)
|
||||
System.out?.println(i)
|
||||
for (i in 0..9)
|
||||
System.out?.println("ar: ${a[mInt(i)]}")
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
class List<T>(val head: T, val tail: List<T>? = null)
|
||||
|
||||
fun <T> List<T>.mapHead(f: (T)-> T): List<T> = List<T>(f(head), null)
|
||||
|
||||
fun box() : String {
|
||||
val a: Int = List<Int>(1).mapHead{it * 2}.head
|
||||
System.out?.println(a)
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
fun Int?.inc() : Int { if (this != null) return this.inc() else throw NullPointerException() }
|
||||
|
||||
public fun box() : String {
|
||||
var i : Int? = 10
|
||||
val j = i++
|
||||
|
||||
return if(j==10 && 11 == i) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
fun Int?.inc() = this!!.inc()
|
||||
|
||||
public fun box() : String {
|
||||
var i : Int? = 10
|
||||
val j = i++
|
||||
|
||||
return if(j==10 && 11 == i) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
import java.util.ArrayList
|
||||
|
||||
fun Int.plus(a: Int?) = this + a!!
|
||||
|
||||
public open class PerfectNumberFinder() {
|
||||
open public fun isPerfect(number : Int) : Boolean {
|
||||
var factors : MutableList<Int?> = ArrayList<Int?>()
|
||||
factors?.add(1)
|
||||
factors?.add(number)
|
||||
for (i in 2..(Math.sqrt((number).toDouble()) - 1).toInt())
|
||||
if (((number % i) == 0)) {
|
||||
factors?.add(i)
|
||||
if (((number / i) != i))
|
||||
factors?.add((number / i))
|
||||
|
||||
}
|
||||
|
||||
var sum : Int = 0
|
||||
for (i : Int? in factors)
|
||||
sum += i
|
||||
return ((sum - number) == number)
|
||||
}
|
||||
}
|
||||
|
||||
fun box () = if (PerfectNumberFinder().isPerfect(28)) "OK" else "fail"
|
||||
@@ -0,0 +1,17 @@
|
||||
import java.util.*
|
||||
|
||||
fun box() : String {
|
||||
val w = object : Comparator<String?> {
|
||||
|
||||
override fun compare(o1 : String?, o2 : String?) : Int {
|
||||
val l1 : Int = o1?.length ?: 0
|
||||
val l2 = o2?.length ?: 0
|
||||
return l1 - l2
|
||||
}
|
||||
|
||||
override fun equals(obj: Any?): Boolean = obj === this
|
||||
}
|
||||
|
||||
w.compare("aaa", "bbb")
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
class Outer() {
|
||||
inner class Inner() {
|
||||
val outer: Outer get() = this@Outer
|
||||
}
|
||||
|
||||
public val x : Inner = Inner()
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val o = Outer()
|
||||
return if (o === o.x.outer) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
import java.util.*
|
||||
|
||||
class ArrayWrapper<T>() {
|
||||
val contents = ArrayList<T>()
|
||||
|
||||
fun add(item: T) {
|
||||
contents.add(item)
|
||||
}
|
||||
|
||||
fun plus(b: ArrayWrapper<T>): ArrayWrapper<T> {
|
||||
val result = ArrayWrapper<T>()
|
||||
result.contents.addAll(contents)
|
||||
result.contents.addAll(b.contents)
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val v1 = ArrayWrapper<String>()
|
||||
val v2 = ArrayWrapper<String>()
|
||||
v1.add("foo")
|
||||
v2.add("bar")
|
||||
val v3 = v1 + v2
|
||||
return if (v3.contents.size() == 2) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
import java.util.*
|
||||
|
||||
class ArrayWrapper<T>() {
|
||||
val contents = ArrayList<T>()
|
||||
|
||||
fun add(item: T) {
|
||||
contents.add(item)
|
||||
}
|
||||
|
||||
fun plusAssign(rhs: ArrayWrapper<T>) {
|
||||
contents.addAll(rhs.contents)
|
||||
}
|
||||
|
||||
fun get(index: Int): T {
|
||||
return contents.get(index)!!
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
var v1 = ArrayWrapper<String>()
|
||||
val v2 = ArrayWrapper<String>()
|
||||
v1.add("foo")
|
||||
v2.add("bar")
|
||||
v1 += v2
|
||||
return if (v1.contents.size() == 2) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
import java.util.*
|
||||
|
||||
class ArrayWrapper<T>() {
|
||||
val contents = ArrayList<T>()
|
||||
|
||||
fun add(item: T) {
|
||||
contents.add(item)
|
||||
}
|
||||
|
||||
fun plus(rhs: ArrayWrapper<T>): ArrayWrapper<T> {
|
||||
val result = ArrayWrapper<T>()
|
||||
result.contents.addAll(contents)
|
||||
result.contents.addAll(rhs.contents)
|
||||
return result
|
||||
}
|
||||
|
||||
fun get(index: Int): T {
|
||||
return contents.get(index)!!
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
var v1 = ArrayWrapper<String>()
|
||||
val v2 = ArrayWrapper<String>()
|
||||
v1.add("foo")
|
||||
val v3 = v1
|
||||
v2.add("bar")
|
||||
v1 += v2
|
||||
return if (v1.contents.size() == 2 && v3.contents.size() == 1) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,30 @@
|
||||
import java.util.*
|
||||
|
||||
class ArrayWrapper<T>() {
|
||||
val contents = ArrayList<T>()
|
||||
|
||||
fun add(item: T) {
|
||||
contents.add(item)
|
||||
}
|
||||
|
||||
fun plus(rhs: ArrayWrapper<T>): ArrayWrapper<T> {
|
||||
val result = ArrayWrapper<T>()
|
||||
result.contents.addAll(contents)
|
||||
result.contents.addAll(rhs.contents)
|
||||
return result
|
||||
}
|
||||
|
||||
fun get(index: Int): T {
|
||||
return contents.get(index)!!
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
var v1 = ArrayWrapper<String>()
|
||||
val v2 = ArrayWrapper<String>()
|
||||
v1.add("foo")
|
||||
val v3 = v1
|
||||
v2.add("bar")
|
||||
v1 += v2
|
||||
return if (v1.contents.size() == 2 && v3.contents.size() == 1) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
import java.util.*
|
||||
|
||||
class ArrayWrapper<T>() {
|
||||
val contents = ArrayList<T>()
|
||||
|
||||
fun add(item: T) {
|
||||
contents.add(item)
|
||||
}
|
||||
|
||||
fun minus(): ArrayWrapper<T> {
|
||||
val result = ArrayWrapper<T>()
|
||||
result.contents.addAll(contents)
|
||||
Collections.reverse(result.contents)
|
||||
return result
|
||||
}
|
||||
|
||||
fun get(index: Int): T {
|
||||
return contents.get(index)!!
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val v1 = ArrayWrapper<String>()
|
||||
v1.add("foo")
|
||||
v1.add("bar")
|
||||
val v2 = -v1
|
||||
return if (v2[0] == "bar" && v2[1] == "foo") "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
class C {
|
||||
private fun String.ext() : String = ""
|
||||
private fun f() {}
|
||||
|
||||
public fun foo() : String {
|
||||
{
|
||||
"".ext()
|
||||
f()
|
||||
}.invoke()
|
||||
|
||||
object : Runnable {
|
||||
public override fun run() {
|
||||
"".ext()
|
||||
f()
|
||||
}
|
||||
}.run()
|
||||
|
||||
Inner().innerFun()
|
||||
|
||||
return "OK"
|
||||
}
|
||||
|
||||
private inner class Inner() {
|
||||
fun innerFun() {
|
||||
"".ext()
|
||||
f()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun box() = C().foo()
|
||||
@@ -0,0 +1,27 @@
|
||||
class C{
|
||||
private var v : Int = 0
|
||||
|
||||
public fun foo() : Int {
|
||||
{
|
||||
v = v + 1
|
||||
}.invoke()
|
||||
|
||||
object : Runnable {
|
||||
public override fun run() {
|
||||
v = v + 1
|
||||
}
|
||||
}.run()
|
||||
|
||||
Inner().innerFun()
|
||||
|
||||
return v
|
||||
}
|
||||
|
||||
private inner class Inner() {
|
||||
fun innerFun() {
|
||||
v = v + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun box() = if (C().foo() == 3) "OK" else "NOT OK"
|
||||
@@ -0,0 +1,33 @@
|
||||
open class Base() {
|
||||
val plain = 239
|
||||
public val read : Int
|
||||
get() = 239
|
||||
|
||||
public var readwrite : Int = 0
|
||||
get() = $readwrite + 1
|
||||
set(n : Int) {
|
||||
$readwrite = n
|
||||
}
|
||||
}
|
||||
|
||||
trait Abstract {}
|
||||
|
||||
class Derived1() : Base(), Abstract {}
|
||||
class Derived2() : Abstract, Base() {}
|
||||
|
||||
fun code(s : Base) : Int {
|
||||
if (s.plain != 239) return 1
|
||||
if (s.read != 239) return 2
|
||||
s.readwrite = 238
|
||||
if (s.readwrite != 239) return 3
|
||||
return 0
|
||||
}
|
||||
|
||||
fun test(s : Base) : Boolean = code(s) == 0
|
||||
|
||||
fun box() : String {
|
||||
if (!test(Base())) return "Fail #1"
|
||||
if (!test(Derived1())) return "Fail #2"
|
||||
if (!test(Derived2())) return "Fail #3"
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
class Outer() {
|
||||
val s = "xyzzy"
|
||||
|
||||
open inner class InnerBase(public val name: String) {
|
||||
}
|
||||
|
||||
inner class InnerDerived(): InnerBase(s) {
|
||||
}
|
||||
|
||||
val x = InnerDerived()
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val o = Outer()
|
||||
return if (o.x.name != "xyzzy") "fail" else "OK"
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
fun box() : String {
|
||||
if (!B().test()) return "fail 1";
|
||||
if (!D().test()) return "fail 2"
|
||||
if (!F().test()) return "fail 3"
|
||||
if (!L().test()) return "fail 4"
|
||||
if (!H().test()) return "fail 5"
|
||||
if (!N().test()) return "fail 6"
|
||||
return "OK"
|
||||
}
|
||||
|
||||
class A {
|
||||
fun foo() = 1
|
||||
}
|
||||
|
||||
class B {
|
||||
fun foo() = 2
|
||||
|
||||
fun A.bar() = foo()
|
||||
|
||||
fun test() = A().bar() == 1
|
||||
}
|
||||
|
||||
|
||||
class C {
|
||||
fun D.foo() = 2
|
||||
}
|
||||
|
||||
class D {
|
||||
fun C.foo() = 1
|
||||
|
||||
fun C.bar() = foo()
|
||||
|
||||
fun test() = C().bar() == 1
|
||||
}
|
||||
|
||||
class E
|
||||
fun E.foo() = 2
|
||||
|
||||
class F {
|
||||
fun foo() = 1
|
||||
|
||||
fun E.bar() = foo()
|
||||
|
||||
fun test() = E().bar() == 1
|
||||
}
|
||||
|
||||
class G
|
||||
fun G.foo() = 2
|
||||
|
||||
class H {
|
||||
fun G.foo() = 1
|
||||
|
||||
fun G.bar() = foo()
|
||||
|
||||
fun test() = G().bar() == 1
|
||||
}
|
||||
|
||||
class K
|
||||
class L {
|
||||
fun K.bar() = foo()
|
||||
|
||||
fun test() = K().bar() == 1
|
||||
}
|
||||
fun K.foo() = 1
|
||||
fun L.foo() = 2
|
||||
|
||||
class M
|
||||
class N {
|
||||
fun foo() = 1
|
||||
fun M.foo() = 2
|
||||
|
||||
fun M.bar() = foo()
|
||||
|
||||
fun test() = M().bar() == 1
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
// Changed when traits were introduced. May not make sense any more
|
||||
|
||||
trait Left {}
|
||||
open class Right() {
|
||||
open fun f() = 42
|
||||
}
|
||||
|
||||
class D() : Left, Right() {
|
||||
override fun f() = 239
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
val r : Right = Right()
|
||||
val d : D = D()
|
||||
|
||||
if (r.f() != 42) return "Fail #1"
|
||||
if (d.f() != 239) return "Fail #2"
|
||||
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
class B () {}
|
||||
|
||||
open class A(val b : B) {
|
||||
fun a() = object: A(b) {}
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
A(B()).a()
|
||||
return "OK"
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
class Box<T>(t: T) {
|
||||
var value = t
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val box: Box<Int> = Box<Int>(1)
|
||||
return if (box.value == 1) "OK" else "fail"
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
trait A<T> {
|
||||
var zzzValue : T
|
||||
fun zzz() : T
|
||||
}
|
||||
|
||||
class Base<T> : A<T?> {
|
||||
override var zzzValue : T? = null
|
||||
|
||||
override fun zzz() : T? = zzzValue
|
||||
}
|
||||
|
||||
class X : A<String?> by Base<String?>()
|
||||
|
||||
fun box() : String {
|
||||
(Base<String?>() as A<String?>).zzz()
|
||||
|
||||
if (X().zzz() != null) {
|
||||
return "Fail"
|
||||
}
|
||||
|
||||
val x = X()
|
||||
x.zzzValue = "aa"
|
||||
if (x.zzzValue != "aa") {
|
||||
return "Fail 2";
|
||||
}
|
||||
if (x.zzz() != "aa") {
|
||||
return "Fail 3";
|
||||
}
|
||||
|
||||
return "OK"
|
||||
}
|
||||
Reference in New Issue
Block a user