added tests

tests/cases/conformance/classes/classDeclarations/classAbstractConstructor.ts

@@ -0,0 +1,3 @@
+abstract class A {
+    abstract constructor() {}
+}

tests/cases/conformance/classes/classDeclarations/classAbstractDeclarations.d.ts

@@ -0,0 +1,25 @@
+declare abstract class A {
+    abstract constructor() {}
+}
+
+declare abstract class AA {
+    abstract foo();
+}
+
+declare abstract class BB extends AA {}
+
+declare class CC extends AA {}
+
+declare class DD extends BB {}
+
+declare abstract class EE extends BB {}
+
+declare class FF extends CC {}
+
+declare abstract class GG extends CC {}
+
+declare abstract class AAA {}
+
+declare abstract class BBB extends AAA {}
+
+declare class CCC extends AAA {}

tests/cases/conformance/classes/classDeclarations/classAbstractInheritance.ts

@@ -0,0 +1,21 @@
+abstract class A {}
+
+abstract class B extends A {}
+
+class C extends A {}
+
+abstract class AA {
+    abstract foo();
+}
+
+abstract class BB extends AA {}
+
+class CC extends AA {}
+
+class DD extends BB {}
+
+abstract class EE extends BB {}
+
+class FF extends CC {}
+
+abstract class GG extends CC {}

tests/cases/conformance/classes/classDeclarations/classAbstractMethodWithImplementation.ts

@@ -0,0 +1,3 @@
+abstract class A {
+    abstract foo() {}
+}

tests/cases/conformance/classes/classDeclarations/classAbstractMixedWithModifiers.ts

@@ -0,0 +1,15 @@
+abstract class A {
+    abstract foo_a();
+    
+    public abstract foo_b();
+    protected abstract foo_c();
+    private abstract foo_d();
+    
+    abstract public foo_bb();
+    abstract protected foo_cc();
+    abstract private foo_dd();
+    
+    abstract static foo_d();
+    
+    static abstract foo_e();
+}

tests/cases/conformance/classes/classDeclarations/classAbstractOverloads.ts

@@ -0,0 +1,24 @@
+abstract class A {
+    abstract foo();
+    abstract foo() : number;
+    abstract foo();
+    
+    abstract bar();
+    bar();
+    abstract bar();
+    
+    abstract baz();
+    baz();
+    abstract baz();
+    baz() {}
+    
+    qux();
+}
+
+abstract class B {
+    abstract foo() : number;
+    abstract foo();
+    x : number;
+    abstract foo();
+    abstract foo();
+}

tests/cases/conformance/classes/classDeclarations/classAbstractProperties.ts

@@ -0,0 +1,11 @@
+abstract class A {
+    abstract x : number;
+    public abstract y : number;
+    protected abstract z : number;
+    private abstract w : number;
+    
+    abstract foo_x() : number;
+    public abstract foo_y() : number;
+    protected abstract foo_z() : number;
+    private abstract foo_w() : number;
+}

tests/cases/conformance/classes/classDeclarations/classAbstractSuperCalls.ts

@@ -0,0 +1,26 @@
+
+class A {
+    foo() { return 1; }
+}
+
+abstract class B extends A {
+    abstract foo();
+    bar() { super.foo(); }
+    baz() { return this.foo; }
+}
+
+class C extends B {
+    foo() { return 2; }
+    qux() { return super.foo(); } // error, super is abstract
+    norf() { return super.bar(); }
+}
+
+class AA {
+    foo() { return 1; }
+    bar() { return this.foo(); }
+}
+
+abstract class BB extends AA {
+    abstract foo();
+    // inherits bar. But BB is abstract, so this is OK.
+}

tests/cases/conformance/classes/classDeclarations/classInstantiatingAbstractClass.ts

@@ -0,0 +1,18 @@
+
+abstract class A {}
+
+class B extends A {}
+
+abstract class C extends B {}
+
+new A;
+new B;
+new C;
+
+var a : A;
+var b : B;
+var c : C;
+
+a = new B;
+b = new B;
+c = new B;

tests/cases/conformance/classes/classDeclarations/classWithAbstractMethods.ts

@@ -0,0 +1,27 @@
+class A {
+    abstract foo();
+}
+
+class B extends A  {}
+
+abstract class C extends A {}
+
+class D extends A {
+    foo() {}
+}
+
+abstract class E extends A {
+    foo() {}
+}
+
+abstract class AA {
+    abstract foo();
+}
+
+class BB extends AA  {}
+
+abstract class CC extends AA {}
+
+class DD extends AA {
+    foo() {}
+}