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:
committed by
Alexander Udalov
parent
ecbb2f10ef
commit
41a416da60
@@ -1,11 +0,0 @@
|
||||
class C() {
|
||||
class object {
|
||||
fun create() = C()
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val c = C.create()
|
||||
return if (c is C) "OK" else "fail"
|
||||
}
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
class A() {
|
||||
class object {
|
||||
val value = 10
|
||||
}
|
||||
}
|
||||
|
||||
fun box() = if (A.value == 10) "OK" else "Fail ${A.value}"
|
||||
@@ -1,12 +0,0 @@
|
||||
// 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
|
||||
}
|
||||
|
||||
@@ -1,7 +0,0 @@
|
||||
fun box() : String {
|
||||
return apply( "OK", {(arg: String) -> arg } )
|
||||
}
|
||||
|
||||
fun apply(arg : String, f : (p:String) -> String) : String {
|
||||
return f(arg)
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
fun box() : String {
|
||||
return if (apply( 5, {(arg: Int) -> arg + 13 } ) == 18) "OK" else "fail"
|
||||
}
|
||||
|
||||
fun apply(arg : Int, f : (p:Int) -> Int) : Int {
|
||||
return f(arg)
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,35 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
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)
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
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)
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
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)
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
// 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"
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
fun box() : String {
|
||||
val cl = 39
|
||||
return if (sum(200, { val ff = {cl}; ff() }) == 239) "OK" else "FAIL"
|
||||
}
|
||||
|
||||
fun sum(arg:Int, f : () -> Int) : Int {
|
||||
return arg + f()
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
fun box() : String {
|
||||
val cl = 39
|
||||
return if (sum(200, { val m = { val r = { cl }; r() }; m() }) == 239) "OK" else "FAIL"
|
||||
}
|
||||
|
||||
fun sum(arg:Int, f : () -> Int) : Int {
|
||||
return arg + f()
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
class Point(val x:Int, val y:Int) {
|
||||
fun mul() : (scalar:Int)->Point {
|
||||
return { (scalar:Int):Point -> Point(x * scalar, y * scalar) }
|
||||
}
|
||||
}
|
||||
|
||||
val m = Point(2, 3).mul() : (scalar:Int)->Point
|
||||
|
||||
fun box() : String {
|
||||
val answer = m(5)
|
||||
return if (answer.x == 10 && answer.y == 15) "OK" else "FAIL"
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
class GameError(msg: String): Exception(msg) {
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val e = GameError("foo")
|
||||
return if (e.getMessage() == "foo") "OK" else "fail"
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
class Point(val x : Int, val y : Int)
|
||||
|
||||
fun box() : String {
|
||||
val answer = apply(Point(3, 5), { Point.(scalar : Int) : Point ->
|
||||
Point(x * scalar, y * scalar)
|
||||
})
|
||||
|
||||
return if (answer.x == 6 && answer.y == 10) "OK" else "FAIL"
|
||||
}
|
||||
|
||||
fun apply(arg:Point, f : Point.(scalar : Int) -> Point) : Point {
|
||||
return arg.f(2)
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
// 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"
|
||||
}
|
||||
@@ -1,14 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,13 +0,0 @@
|
||||
class C() {
|
||||
public var f: Int
|
||||
|
||||
{
|
||||
$f = 610
|
||||
}
|
||||
}
|
||||
|
||||
fun box(): String {
|
||||
val c = C()
|
||||
if (c.f != 610) return "fail"
|
||||
return "OK"
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,19 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,15 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,25 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
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()
|
||||
@@ -1,27 +0,0 @@
|
||||
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"
|
||||
@@ -1,33 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,16 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
fun foo(s: String): String {
|
||||
fun bar(count: Int): String =
|
||||
if (count == 0) s else bar(count - 1)
|
||||
return bar(10)
|
||||
}
|
||||
|
||||
fun box(): String = foo("OK")
|
||||
@@ -1,75 +0,0 @@
|
||||
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
|
||||
}
|
||||
@@ -1,20 +0,0 @@
|
||||
// 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"
|
||||
}
|
||||
@@ -1,10 +0,0 @@
|
||||
class B () {}
|
||||
|
||||
open class A(val b : B) {
|
||||
fun a() = object: A(b) {}
|
||||
}
|
||||
|
||||
fun box() : String {
|
||||
A(B()).a()
|
||||
return "OK"
|
||||
}
|
||||
@@ -1,8 +0,0 @@
|
||||
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"
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
fun box() : String {
|
||||
return invoker( {"OK"} )
|
||||
}
|
||||
|
||||
fun invoker(gen : () -> String) : String {
|
||||
return gen()
|
||||
}
|
||||
@@ -1,7 +0,0 @@
|
||||
fun box() : String {
|
||||
return if (int_invoker( { 7 } ) == 7) "OK" else "fail"
|
||||
}
|
||||
|
||||
fun int_invoker(gen : () -> Int) : Int {
|
||||
return gen()
|
||||
}
|
||||
@@ -1,31 +0,0 @@
|
||||
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