peerigon/alamid-class

2014-03-08 17:38:55
8.0
✓9.0
✓10.0
✓27.0
✓28.0
✓29.0
✓22.0
✓23.0
✓24.0
✓6.0
✓15.0
✓6.0
✓6.0
4.2
android-browser/4.2
timeout waiting to hear back from android-browser/4.2
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 40 # pass 40 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 40 # pass 40 # fail 0
not ok 1 Error: Expected identifier on line 11533
2014-03-08 17:40:55
8.0
✓9.0
✓10.0
✓27.0
✓28.0
✓29.0
✓22.0
✓23.0
✓24.0
✓6.0
✓15.0
✓6.0
✓6.0
4.2
android-browser/4.2
timeout waiting to hear back from android-browser/4.2
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 40 # pass 40 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 40 # pass 40 # fail 0
not ok 1 Error: Expected identifier on line 11533
2014-03-08 17:35:48
8.0
✓9.0
✓10.0
✓27.0
✓28.0
✓29.0
✓22.0
✓23.0
✓24.0
✓6.0
✓15.0
✓6.0
✓6.0
4.2
android-browser/4.2
timeout waiting to hear back from android-browser/4.2
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 43 # pass 43 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 40 # pass 40 # fail 0
1..43 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should be possible to apply the class's constructor on a different context ok 14 Class constructors should provide the possibility to hook into instance constructor by overriding .prototype.constructor ok 15 Class constructors should pass the right context to the constructor ok 16 Class constructors should pass all arguments to the constructor ok 17 Class inheritance should return a function which provides the possibility to inherit from this function ok 18 Class inheritance should call the super constructor automatically if it hasn't been called ok 19 Class inheritance should call the super constructor automatically if the child class has no constructor ok 20 Class inheritance should be possible to call the overridden method via this._super() ok 21 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 22 Class inheritance should be possible to exchange the overridden method on runtime ok 23 Class inheritance should return this when calling this._super() within a constructor ok 24 Class inheritance should not alter the length-attribute of overridden methods ok 25 Class inheritance should be possible to extend existing functions ok 26 Class inheritance should not influence the behaviour of the instanceof operator ok 27 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 28 Class mixins should be possible to mixin a Class into an existing object ok 29 Class mixins should overwrite existing keys ok 30 Class mixins should be chainable ok 31 Class mixins should augment the function object, not the function's prototype ok 32 Class mixins should not call the constructor on the given object ok 33 Class mixins should also mixin all inherited properties ok 34 Class mixins should also be possible to mixin foreign functions ok 35 Class plugins should be possible to override every method of that class ok 36 Class plugins should be possible to override any constructor in the inheritance chain ok 37 Class plugins should be chainable ok 38 Class plugins .use(plugin, config?) should provide a use()-method ok 39 Class plugins .use(plugin, config?) should provide a plugin-interface ok 40 Class plugins .use(plugin, config?) should apply the same plugin only once ok 41 Class plugins .use(plugin, config?) should be usable on other objects too ok 42 Class plugins .use(plugin, config?) should not apply the same plugin on other objects ok 43 Class plugins .use(plugin, config?) should be chainable # tests 40 # pass 40 # fail 0
not ok 1 Error: Expected identifier on line 11533
2014-03-08 14:57:58
8.0
✓9.0
✓10.0
✓27.0
✓28.0
✓29.0
✓22.0
✓23.0
✓24.0
✓6.0
✓15.0
✓6.0
✓6.0
4.2
android-browser/4.2
timeout waiting to hear back from android-browser/4.2
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
not ok 1 Error: Expected identifier on line 11382
2014-03-08 14:31:11
8.0
✓9.0
✓10.0
✓27.0
✓28.0
✓29.0
✓22.0
✓23.0
✓24.0
✓6.0
✓15.0
✓6.0
✓6.0
4.2
android-browser/4.2
timeout waiting to hear back from android-browser/4.2
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
not ok 1 Error: Expected identifier on line 11394
2014-03-08 00:43:10
8.0
✓9.0
✓10.0
✓27.0
✓28.0
✓29.0
✓22.0
✓23.0
✓24.0
✓6.0
✓15.0
✓6.0
✓6.0
4.2
android-browser/4.2
timeout waiting to hear back from android-browser/4.2
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
not ok 1 Error: Expected identifier on line 11394
2014-03-08 00:51:45
7.0
8.0
✓9.0
✓10.0
✓22.0
✓23.0
✓24.0
✓25.0
✓26.0
✓27.0
✓28.0
✓29.0
✓16.0
✓17.0
✓18.0
✓19.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓6.0
✓11.0
11.5
✓11.6
✓12.0
✓15.0
7.0
7.0
4.2
timeout waiting to hear back from iphone/7.0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..0 # tests 0 # pass 0 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
not ok 1 Error: Expected identifier on line 11394
not ok 1 Error: Expected identifier on line 11395
2014-03-08 00:49:35
7.0
8.0
✓9.0
✓10.0
✓22.0
✓23.0
✓24.0
✓25.0
✓26.0
✓27.0
✓28.0
✓29.0
✓16.0
✓17.0
✓18.0
✓19.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓6.0
✓11.0
11.5
✓11.6
✓12.0
✓15.0
7.0
7.0
4.2
timeout waiting to hear back from iphone/7.0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..0 # tests 0 # pass 0 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name # SKIP - ok 2 Class name should be 'MyClass' if specified (in dev mode) # SKIP - ok 3 Class name should always be 'AnonymousClass' when not in dev mode # SKIP - ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 32 # pass 32 # fail 0
not ok 1 Error: Expected identifier on line 11393
not ok 1 Error: Expected identifier on line 11394
2014-03-08 00:40:31
7.0
8.0
9.0
10.0
✓22.0
✓23.0
✓24.0
✓25.0
✓26.0
✓27.0
✓28.0
✓29.0
✓16.0
✓17.0
✓18.0
✓19.0
✓20.0
✓21.0
✓22.0
✓23.0
✓24.0
✓6.0
✓11.0
11.5
✓11.6
✓12.0
✓15.0
7.0
7.0
4.2
timeout waiting to hear back from iphone/7.0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..0 # tests 0 # pass 0 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class constructors should expose a override-able constructor function ok 14 Class inheritance should return a function which provides the possibility to inherit from this function ok 15 Class inheritance should call the super constructor automatically if it hasn't been called ok 16 Class inheritance should call the super constructor automatically if the child class has no constructor ok 17 Class inheritance should be possible to call the overridden method via this._super() ok 18 Class inheritance should execute the superior method of the mixin when the mixin calls this._super() ok 19 Class inheritance should be possible to exchange the overridden method on runtime ok 20 Class inheritance should return this when calling this._super() within a constructor ok 21 Class inheritance should not alter the length-attribute of overridden methods ok 22 Class inheritance should be possible to extend existing functions ok 23 Class inheritance should not influence the behaviour of the instanceof operator ok 24 Class inheritance should apply the ChildClass as read-only 'Class'-reference ok 25 Class mixins should be possible to mixin a Class into an existing object ok 26 Class mixins should overwrite existing keys ok 27 Class mixins should be chainable ok 28 Class mixins should augment the function object, not the function's prototype ok 29 Class mixins should not call the constructor on the given object ok 30 Class mixins should also mixin all inherited properties ok 31 Class mixins should also be possible to mixin foreign functions ok 32 Class plugins should be possible to add plugins to classes via the .use()-method ok 33 Class plugins should be possible to override every method of that class ok 34 Class plugins should be possible to override any constructor in the inheritance chain ok 35 Class plugins should be chainable # tests 35 # pass 35 # fail 0
1..35 ok 1 Class name should be 'AnonymousClass' when passing no class name ok 2 Class name should be 'MyClass' if specified (in dev mode) ok 3 Class name should always be 'AnonymousClass' when not in dev mode ok 4 Class prototype should accept several objects as prototypes ok 5 Class prototype should also accept functions as prototypes ok 6 Class prototype should accept other classes as prototypes ok 7 Class prototype should throw an exception when passing non-objects ok 8 Class prototype should have a read-only reference called 'Class' to the Class-function ok 9 Class constructors should be possible to define a constructor ok 10 Class constructors should not be a problem to have a constructor with several arguments ok 11 Class constructors should return a function with the constructor's length attribute ok 12 Class constructors should execute only the last specified constructor ok 13 Class