The following example pages are good showcases for the Uize.Test module...

SEARCH FOR EXAMPLES

Use the link below to search for example pages on the UIZE Web site that reference the Uize.Test module...

SEARCH

The Uize.Test module defines the Uize.Test class, which is a subclass of Uize.Class.

INHERITANCE CHAIN

Uize.Class -> Uize.Test

1.2.1. Features Introduced in This Module

1.2.2. Features Overridden in This Module

1.2.3. Features Inherited From Other Modules

1.2.4. Modules Directly Under This Namespace

1.2.5. Unit Tests

Returns a boolean value, indicating whether or not the specified actual value is identical to the specified expected value.

SYNTAX

resultBOOL = myTest.expect (expectedValueANYTYPE,valueANYTYPE);

2.1.1. Identical, Not Same

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is an instance of JavaScript's built-in Array object.

SYNTAX

resultBOOL = myTest.expectArray (valueANYTYPE);

2.2.1. Array, Not Array-like

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is array-like.

SYNTAX

resultBOOL = myTest.expectArrayLike (valueANYTYPE);

A value is regarded as array-like when the following conditions are met...

2.3.1. Array-like Includes Array

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a boolean primitive (ie. of type 'boolean').

SYNTAX

resultBOOL = myTest.expectBoolean (valueANYTYPE);

2.4.1. Boolean Type, Not Boolean Object Instance

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a function (ie. of type 'function').

SYNTAX

resultBOOL = myTest.expectFunction (valueANYTYPE);

Examples of things that would test true as functions include...

EXAMPLE

myTest.expectFunction (Uize.copyInto);                           // returns true
myTest.expectFunction (myTest.expectFunction);                   // returns true
myTest.expectFunction (function (value) {alert (value)});        // returns true
myTest.expectFunction (new Function ('value','alert (value')));  // returns true
myTest.expectFunction (Date);                                    // returns true
myTest.expectFunction (Uize.Util);                               // returns true
myTest.expectFunction (Uize.Node);                               // returns true
myTest.expectFunction (Uize.Widget);                             // returns true

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is in the specified range.

SYNTAX

resultBOOL = myTest.expectInRange (minValueANYTYPE,maxValueANYTYPE,valueANYTYPE);

2.6.1. Multiple Types Supported

// range boundaries and value are strings

  myTest.expectInRange ('betty','samantha','annette');  // returns false
  myTest.expectInRange ('betty','samantha','kelly');    // returns true
  myTest.expectInRange ('betty','samantha','wynona');   // returns false


// range boundaries are boolean, value is number

  myTest.expectInRange (false,true,-1);   // returns false
  myTest.expectInRange (false,true,0);    // returns true
  myTest.expectInRange (false,true,.5);   // returns true
  myTest.expectInRange (false,true,1);    // returns true
  myTest.expectInRange (false,true,1.5);  // returns false


// range boundaries and value are date objects

  myTest.expectInRange (       // returns false
    new Date ('2010-01-31'),
    new Date ('2010-12-01'),
    new Date ('2010-01-15')
  );
  myTest.expectInRange (       // returns true
    new Date ('2010-01-31'),
    new Date ('2010-12-01'),
    new Date ('2010-05-13')
  );
  myTest.expectInRange (       // returns false
    new Date ('2010-01-31'),
    new Date ('2010-12-01'),
    new Date ('2010-12-22')
  );


// range boundaries and value are class instances

  myTest.expectInRange (    // returns false
    Uize.Class ({value:0}),
    Uize.Class ({value:1}),
    Uize.Class ({value:-1})
  );
  myTest.expectInRange (    // returns true
    Uize.Class ({value:0}),
    Uize.Class ({value:1}),
    Uize.Class ({value:.5})
  );
  myTest.expectInRange (    // returns false
    Uize.Class ({value:0}),
    Uize.Class ({value:1}),
    Uize.Class ({value:1.5})
  );

2.6.2. Range Boundary Order Unimportant

myTest.expectInRange (100,0,50);  // returns true

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is an instance of the specified class.

SYNTAX

resultBOOL = myTest.expectInstanceOf (classOBJorSTR,valueANYTYPE);

The value of the classOBJorSTR parameter can be an object, being a reference to the expected class, or a string representing the globally accessible name of the class' constructor ('Function', 'String', 'RegExp', 'Uize.Widget.Bar.Slider', etc.).

2.7.1. What Qualifies as an Instance Of?

2.7.2. Built-in Objects Supported

2.7.3. Uize Subclasses Supported

2.7.4. Instances of Subclasses Don't Qualify

2.7.5. Expecting Arrays or Regular Expressions

2.7.6. Null Is Not An Instance of Object

2.7.7. Primitives Are Instances, Too

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is an integer.

SYNTAX

resultBOOL = myTest.expectInteger (valueANYTYPE);

A value specified for the valueANYTYPE parameter will be considered to be an integer when the following conditions are met...

EXAMPLES

myTest.expectInteger (10);                       // returns true
myTest.expectInteger (0);                        // returns true
myTest.expectInteger (-10);                      // returns true
myTest.expectInteger (Infinity);                 // returns true

myTest.expectInteger (10.5);                     // returns false
myTest.expectInteger ('10');                     // returns false
myTest.expectInteger (new Number (10));          // returns false
myTest.expectInteger (Uize.Class ({value:10}));  // returns false
myTest.expectInteger (NaN);                      // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is an integer that falls within the specified range.

SYNTAX

resultBOOL = myTest.expectIntegerInRange (minValueNUM,maxValueNUM,valueANYTYPE);

The expectIntegerInRange method uses the expectInteger and expectInRange methods in its implementation. The statement myTest.expectIntegerInRange (0,100,value) would be equivalent to the statement myTest.expectInteger (value) && myTest.expectInRange (0,100,value).

2.9.1. Range Boundary Order Unimportant

2.9.2. Range Boundaries Can Be Floating Point

EXAMPLES

myTest.expectIntegerInRange (0,100,0);                 // returns true
myTest.expectIntegerInRange (0,100,100);               // returns true
myTest.expectIntegerInRange (0,100,50);                // returns true
myTest.expectIntegerInRange (100,0,50);                // returns true
myTest.expectIntegerInRange (0,100.25,100);            // returns true

myTest.expectIntegerInRange (100,0,.5);                // returns false
myTest.expectIntegerInRange (0,100,-1);                // returns false
myTest.expectIntegerInRange (0,100,101);               // returns false
myTest.expectIntegerInRange (0,100,'.5');              // returns false
myTest.expectIntegerInRange (0,100,true);              // returns false
myTest.expectIntegerInRange (0,100,new Number (.5));   // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the length of the specified value falls into the specified length range.

SYNTAX

resultBOOL = myTest.expectLengthInRange (minLengthNUM,maxLengthNUM,valueANYTYPE);

2.10.1. Multiple Types Supported

// value with length property is string

  myTest.expectLengthInRange (1,10,'Cleopatra');    // returns true
  myTest.expectLengthInRange (1,10,'Amanda');       // returns true
  myTest.expectLengthInRange (1,10,'Margueritta');  // returns false
  myTest.expectLengthInRange (1,10,'');             // returns false


// value with length property is array

  myTest.expectLengthInRange (1,5,[1,2,3,4,5]);     // returns true
  myTest.expectLengthInRange (1,5,[1,2,3]);         // returns true
  myTest.expectLengthInRange (1,5,[1]);             // returns true
  myTest.expectLengthInRange (1,5,[1,2,3,4,5,6]);   // returns false
  myTest.expectLengthInRange (1,5,[]);              // returns false


// value with length property is object

  myTest.expectLengthInRange (5,10,{length:10});    // returns true
  myTest.expectLengthInRange (5,10,{length:5});     // returns true
  myTest.expectLengthInRange (5,10,{length:11});    // returns false
  myTest.expectLengthInRange (5,10,{length:4});     // returns false

2.10.2. Range Boundary Order Unimportant

myTest.expectLengthInRange (10,1,'Amanda');  // returns true

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a negative integer.

SYNTAX

resultBOOL = myTest.expectNegativeInteger (valueANYTYPE);

A value will be considered to be a negative integer when the following conditions are met...

The expectNegativeInteger method uses the expectIntegerInRange method in its implementation. The statement myTest.expectNegativeInteger (value) would be equivalent to the statement myTest.expectIntegerInRange (-Infinity,0,value).

EXAMPLE

myTest.expectNegativeInteger (0);                        // returns true
myTest.expectNegativeInteger (-1);                       // returns true
myTest.expectNegativeInteger (-Infinity);                // returns true

myTest.expectNegativeInteger (-1.5);                     // returns false
myTest.expectNegativeInteger ('-1');                     // returns false
myTest.expectNegativeInteger (Uize.Class ({value:-1}));  // returns false
myTest.expectNegativeInteger (1);                        // returns false
myTest.expectNegativeInteger (1.5);                      // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a negative number.

SYNTAX

resultBOOL = myTest.expectNegativeNumber (valueANYTYPE);

A value will be considered to be a negative number when the following conditions are met...

The expectNegativeNumber method uses the expectNumberInRange method in its implementation. The statement myTest.expectNegativeNumber (value) would be equivalent to the statement myTest.expectNumberInRange (-Infinity,0,value).

EXAMPLE

myTest.expectNegativeNumber (0);                        // returns true
myTest.expectNegativeNumber (-.5);                      // returns true
myTest.expectNegativeNumber (-Infinity);                // returns true

myTest.expectNegativeNumber (1.333);                    // returns false
myTest.expectNegativeNumber ('-5');                     // returns false
myTest.expectNegativeNumber (Uize.Class ({value:-5}));  // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not there are no repeated values in the specified array.

SYNTAX

resultBOOL = myTest.expectNoRepeats (valueANYTYPE);

EXAMPLES

myTest.expectNoRepeats ([1,2,3,4,5]);    // returns true
myTest.expectNoRepeats ([1,2,3,4,5,2]);  // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is regarded as being empty.

SYNTAX

resultBOOL = myTest.expectNonEmpty (valueANYTYPE);

A value specified for the valueANYTYPE parameter will be considered empty if it is any of the following...

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is an instance of JavaScript's built-in Array object and has a non-zero length.

SYNTAX

resultBOOL = myTest.expectNonEmptyArray (valueANYTYPE);

This method uses the expectArray and expectNonEmpty methods in its implementation. The statement myTest.expectNonEmptyArray (value) is equivalent to the statement this.expectArray (value) && this.expectNonEmpty (value).

EXAMPLES

myTest.expectNonEmptyArray (['foo','bar']);                 // returns true
myTest.expectNonEmptyArray (new Array ('foo','bar'));       // returns true
myTest.expectNonEmptyArray (new Array (5));                 // returns true

myTest.expectNonEmptyArray ([]);                            // returns false
myTest.expectNonEmptyArray (new Array);                     // returns false
myTest.expectNonEmptyArray (Uize.Class ({value:['foo']}));  // returns false
myTest.expectNonEmptyArray ({foo:'bar'});                   // returns false
myTest.expectNonEmptyArray (1.2345);                        // returns false
myTest.expectNonEmptyArray (true);                          // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is of type 'object' and has at least one enumerable property.

SYNTAX

resultBOOL = myTest.expectNonEmptyObject (valueANYTYPE);

This method uses the expectObject and expectNonEmpty methods in its implementation. The statement myTest.expectNonEmptyObject (value) is equivalent to the statement this.expectObject (value) && this.expectNonEmpty (value).

EXAMPLES

myTest.expectNonEmptyObject ({foo:'bar'});                 // returns true
myTest.expectNonEmptyObject (new Object ({foo:'bar'}));    // returns true
myTest.expectNonEmptyObject (['foo','bar']);               // returns true
myTest.expectNonEmptyObject (new Array (5));               // returns true
myTest.expectNonEmptyObject (Uize.Class ({value:'foo'}));  // returns true
myTest.expectNonEmptyObject ({});                          // returns false
myTest.expectNonEmptyObject (new Object);                  // returns false
myTest.expectNonEmptyObject ([]);                          // returns false
myTest.expectNonEmptyObject (new Array);                   // returns false
myTest.expectNonEmptyObject (1.2345);                      // returns false
myTest.expectNonEmptyObject (true);                        // returns false

2.16.1. Not Only Object Instances Are Object Type

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is of type 'string' and contains one or more characters.

SYNTAX

resultBOOL = myTest.expectNonEmptyString (valueANYTYPE);

This method uses the expectString and expectNonEmpty methods in its implementation. The statement myTest.expectNonEmptyString (value) is equivalent to the statement this.expectString (value) && this.expectNonEmpty (value).

EXAMPLES

myTest.expectNonEmptyString ('foo');                       // returns true

myTest.expectNonEmptyString ('');                          // returns false
myTest.expectNonEmptyString (new String ('foo'));          // returns false
myTest.expectNonEmptyString (Uize.Class ({value:'foo'}));  // returns false
myTest.expectNonEmptyString (1.2345);                      // returns false
myTest.expectNonEmptyString (true);                        // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is non-null (ie. not null or undefined.

SYNTAX

resultBOOL = myTest.expectNonNull (valueANYTYPE);

This method tests whether or not a value is non-null. Any value other than null or undefined is considered non-null. So, the boolean value false, the number value 0, the string value '' (empty string), the object value {} (empty object), and the array value [] (empty array) are all considered non-null.

EXAMPLES

// when called with non-null values...

myTest.expectNonNull (1);              // returns true
myTest.expectNonNull (0);              // returns true
myTest.expectNonNull ('blah');         // returns true
myTest.expectNonNull ('');             // returns true
myTest.expectNonNull (true);           // returns true
myTest.expectNonNull (false);          // returns true
myTest.expectNonNull ({foo:'bar'});    // returns true
myTest.expectNonNull ({});             // returns true
myTest.expectNonNull (['foo','bar']);  // returns true
myTest.expectNonNull ([]);             // returns true

// when called with null values...

myTest.expectNonNull (null);           // returns false
myTest.expectNonNull (undefined);      // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a number primitive (ie. of type 'number').

SYNTAX

resultBOOL = myTest.expectNumber (valueANYTYPE);

2.19.1. Number Type, Not Number Object Instance

EXAMPLES

myTest.expectNumber (1);               // returns true
myTest.expectNumber (0);               // returns true
myTest.expectNumber (NaN);             // returns true
myTest.expectNumber (Infinity);        // returns true
myTest.expectNumber (new Number (5));  // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a number that falls within the specified range.

SYNTAX

resultBOOL = myTest.expectNumberInRange (minValueNUM,maxValueNUM,valueANYTYPE);

The expectNumberInRange method uses the expectNumber and expectInRange methods in its implementation. The statement myTest.expectNumberInRange (value,0,100) would be equivalent to the statement myTest.expectNumber (value) && myTest.expectInRange (0,100,value).

2.20.1. Range Boundary Order Unimportant

EXAMPLES

myTest.expectNumberInRange (0,100,0);                // returns true
myTest.expectNumberInRange (0,100,100);              // returns true
myTest.expectNumberInRange (0,100,50);               // returns true
myTest.expectNumberInRange (100,0,50);               // returns true

myTest.expectNumberInRange (0,100,-1);               // returns false
myTest.expectNumberInRange (0,100,101);              // returns false
myTest.expectNumberInRange (0,100,'50');             // returns false
myTest.expectNumberInRange (0,100,true);             // returns false
myTest.expectNumberInRange (0,100,new Number (50));  // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is an object (ie. of type 'object').

SYNTAX

resultBOOL = myTest.expectObject (valueANYTYPE);

2.21.1. Not Only Object Instances Are Object Type

EXAMPLES

myTest.expectObject ({});                                     // returns true
myTest.expectObject ({foo:'bar'});                            // returns true
myTest.expectObject (new Object);                             // returns true
myTest.expectObject ([]);                                     // returns true
myTest.expectObject (['foo','bar']);                          // returns true
myTest.expectObject (/^\s+$/);                                // returns true
myTest.expectObject (new Boolean (false));                    // returns true
myTest.expectObject (Uize.Widget.Bar.Slider ());              // returns true
myTest.expectObject (null);                                   // returns true

myTest.expectObject (undefined);                              // returns false
myTest.expectObject (function (value) {alert (value)});       // returns false
myTest.expectObject (new Function ('value','alert (value)');  // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a positive integer.

SYNTAX

resultBOOL = myTest.expectPositiveInteger (valueANYTYPE);

A value will be considered to be a positive integer when the following conditions are met...

The expectPositiveInteger method uses the expectIntegerInRange method in its implementation. The statement myTest.expectPositiveInteger (value) would be equivalent to the statement myTest.expectIntegerInRange (0,Infinity,value).

EXAMPLE

myTest.expectPositiveInteger (0);                       // returns true
myTest.expectPositiveInteger (1);                       // returns true
myTest.expectPositiveInteger (Infinity);                // returns true

myTest.expectPositiveInteger (1.5);                     // returns false
myTest.expectPositiveInteger ('1');                     // returns false
myTest.expectPositiveInteger (Uize.Class ({value:1}));  // returns false
myTest.expectPositiveInteger (-1);                      // returns false
myTest.expectPositiveInteger (-1.5);                    // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a positive number.

SYNTAX

resultBOOL = myTest.expectPositiveNumber (valueANYTYPE);

A value will be considered to be a positive number when the following conditions are met...

The expectPositiveNumber method uses the expectNumberInRange method in its implementation. The statement myTest.expectPositiveNumber (value) would be equivalent to the statement myTest.expectNumberInRange (0,Infinity,value).

EXAMPLE

myTest.expectPositiveNumber (0);                       // returns true
myTest.expectPositiveNumber (5);                       // returns true
myTest.expectPositiveNumber (Infinity);                // returns true

myTest.expectPositiveNumber (-1.333);                  // returns false
myTest.expectPositiveNumber ('5');                     // returns false
myTest.expectPositiveNumber (Uize.Class ({value:5}));  // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is an instance of JavaScript's built-in RegExp object.

SYNTAX

resultBOOL = myTest.expectRegExp (valueANYTYPE);

Because the expectRegExp method tests whether or not the value is an instance of the RegExp object, the statement myTest.expectRegExp (/^\s+$/) would be equivalent to the statement myTest.expectInstanceOf (RegExp,/^\s+$/).

EXAMPLES

myTest.expectObject (/^\s+$/);                // returns true
myTest.expectObject (new RegExp);             // returns true
myTest.expectObject (new RegExp ('^\\s+$'));  // returns true

myTest.expectObject ('^\\s+$');               // returns false

NOTES

IMPLEMENTATION INFO

Returns a boolean value, indicating whether or not the specified actual value is exactly equal to the specified expected value.

SYNTAX

resultBOOL = myTest.expectSameAs (expectedValueANYTYPE,valueANYTYPE);

2.25.1. Same, Not Identical

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is a string primitive (ie. of type 'string').

SYNTAX

resultBOOL = myTest.expectString (valueANYTYPE);

2.26.1. String Type, Not String Object Instance

NOTES

IMPLEMENTATION INFO

Returns a boolean, indicating whether or not the specified value is of the specified type.

SYNTAX

resultBOOL = myTest.expectType (typeSTR,valueANYTYPE);

2.27.1. Primitives Versus Instances

NOTES

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Returns an integer, indicating how deep within the test instance tree the test instance is.

SYNTAX

depthINT = myTest.getDepth ();

The depth of a test instance is determined by traversing up the parent chain, all the way up to the root test. The depth of the root test is reported as 0, the depth of a child test of the root test is reported as 1, the depth of a child test of that child test is reported as 2, and so on.

NOTES

IMPLEMENTATION INFO

Returns a string, providing a synopsis of the test instance's run.

SYNTAX

synopsisSTR = myTest.getSynopsis ();

This method is useful when providing a report for a test, especially if the test fails. The synopsis provides an indication of whether the test passed or failed, breadcrumbs to indicate where the test is in a test tree, when the test started and ended and its duration, and the reason for failure if the test failed.

NOTES

IMPLEMENTATION INFO

Returns an integer, indicating the total number of tests inside the test instance's test tree.

SYNTAX

totalTestsINT = myTest.getTotalTests ();

This method recurses through the entire tree, essentially flattening the tree in order to count the total number of actual tests that would be performed. The method includes parent tests in the tally, along with all child tests. For example, if the test contained two child tests, and each one of those child tests contained two child tests, then the total number of tests in the tree would be 7 - one root test, two child tests, and four grandchild tests.

NOTES

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

IMPLEMENTATION INFO

Adds the specified message, along with a generated timestamp, to the log array for the instance and returns a reference to the instance.

SYNTAX

myTest = myTest.log (messageSTR);

NOTES

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Runs the instance's test(s) and returns the result.

SYNTAX

resultBOOL = myTest.run ();

In the event that running of the instance's test(s) is asynchronous, the run method will return the value Uize.Test.isAsync, and the instance's isAsync state property will be set to the value true. For a more in-depth discussion, see the section Asynchronous Tests in the JavaScript Testing Framework explainer.

2.39.1. Callback Function For Asynchronous Tests

resultBOOL = myTest.run (callbackFUNC);

NOTES

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Stops running of the test instance's test(s).

SYNTAX

myTest.stop ();

Upon calling the stop method, the stop method will first be called on any child tests belonging to the test, after which the inProgress state property for the instance will be set to false. If the instance is not running its test(s) at the time that this method is called, then calling it will have no effect.

NOTES

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

An bubbling instance event that is fired whenever the instance's test completes running.

NOTES

An bubbling instance event that is fired whenever the instance's test is run by calling its run instance method.

NOTES

A read-only special value that is used to indicate that running of a test instance's test(s) is asynchronous.

When a test instance is known to be asynchronous, the instance's result state property will be set to the value Uize.Test.isAsync. In this situation, the instance's isAsync state property will also be set to the value true. For a more in-depth discussion, see the section Asynchronous Tests in the JavaScript Testing Framework explainer.

NOTES

IMPLEMENTATION INFO

IMPLEMENTATION INFO

Adds the specified child test to the test class and returns a reference to the test class.

SYNTAX

Uize.Test.addTest (testOBJ);

IMPLEMENTATION INFO

Returns a Uize.Test subclass, being the specified test object resolved to a test class.

SYNTAX

testCLASS = Uize.Test.declare (testOBJ);

5.2.1. testOBJ

5.2.2. More Concise and Declarative

var My2Plus2Equals4TestClass = Uize.Test.subclass ();
My2Plus2Equals4TestClass.set ({
  title:'Test that 2 + 2 equals 4',
  test:function () {return this.expect (4,2 + 2)}
});

Uize.Test.declare ({
  title:'Test that 2 + 2 equals 4',
  test:function () {return this.expect (4,2 + 2)}
});

5.2.3. Returns a Test Class

5.2.4. Resolving Subtests

5.2.5. Example 1: A Single Test

Uize.Test.declare ({
  title:'Test that 2 + 2 equals 4',
  test:function () {return this.expect (4,2 + 2)}
});

5.2.6. Example 2: A Set of Tests

Uize.Test.declare ({
  title:'Test a whole bunch of things',
  test:[
    {
      title:'Test that 2 + 2 equals 4',
      test:function () {return this.expect (4,2 + 2)}
    },
    Uize.Test.declare ({
      title:'Test that true is equal to 1 in a simple equality test',
      test:function () {return this.expect (true,1 == true)}
    }),
    Uize.Test.staticPropertyTest ('Math.min','function'),
    Uize.Test.staticPropertyTest ('Number.MAX_VALUE','number')
  ]
});

NOTES

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Returns a Uize.Test subclass, for a test that tests whether or not the specified module(s) can be successfully required (and loaded and built, if necessary).

SYNTAX

testCLASS = Uize.Test.requiredModulesTest (modulesSTRorARRAY);

5.7.1. modulesSTRorARRAY

5.7.2. An Example

var testClassForUizeArrayOrder = Uize.Test.declare ({
  title:'Uize.Array.Order Module Test',
  test:[
    Uize.Test.requiredModulesTest ('Uize.Array.Order'),
    Uize.Test.staticMethodsTest ([
      // ...
      // static method tests here, in comma-separated list
      // ...
    ])
  ]
});

NOTES

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Returns an object, containing host and property properties that represent the specified property full path name split into the two parts.

SYNTAX

hostAndPropertyOBJ = Uize.Test.splitHostAndProperty (propertyFullNameSTR);

RETURN VALUE

{
  host     : hostPathSTR,
  property : propertyNameSTR
}

The value of the propertyFullNameSTR parameter should be a string that fully qualifies the path for referencing a property in the global context (eg. 'Uize.Test.declare'). The Uize.Test.splitHostAndProperty method splits this string into host and property strings, and packages these two string values into an object. Supplied our example value of 'Uize.Test.declare', the Uize.Test.splitHostAndProperty method would return the object {host:'Uize.Test',property:'declare'}.

IMPLEMENTATION INFO

Returns a Uize.Test subclass, for a test that tests whether or not the specified static method is defined and all the specified test cases succeed.

SYNTAX

testCLASS = Uize.Test.staticMethodTest (
  methodFullNameSTR,
  casesARRAY,
  supplementalTestPropertiesOBJ,     // optional
  supplementalCaseTestPropertiesOBJ  // optional
);

5.11.1. methodFullNameSTR

5.11.2. casesARRAY

[
  caseARRAYorOBJ,
  caseARRAYorOBJ,
  ...
  caseARRAYorOBJ
]

[
  titleSTR,              // the title of the test case
  argumentsANYTYPE,      // arguments to be used when calling the static method
  expectedResultANYTYPE  // the expected return value for the test case
]

5.11.3. supplementalTestPropertiesOBJ

5.11.4. supplementalCaseTestPropertiesOBJ

5.11.5. An Example

Uize.Test.staticMethodTest (
  'Uize.capFirstChar',
  [
    ['Many letters, first letter is lowercase','hello','Hello'],
    ['Many letters, first letter is uppercase','Hello','Hello'],
    ['Single letter, lowercase','h','H'],
    ['Single letter, uppercase','H','H'],
    ['Empty string','','']
  ]
);

NOTES

IMPLEMENTATION INFO

Returns a Uize.Test subclass, for a test that tests all the specified test cases of all the specified static methods.

SYNTAX

testCLASS = Uize.Test.staticMethodsTest (staticMethodsTestARRAY);

The Uize.Test.staticMethodsTest method is a convenience method that provides a more concise way to declare static methods tests for multiple static methods in a single statement.

5.12.1. staticMethodsTestARRAY

[
  staticMethodTestARRAYorOBJ,
  staticMethodTestARRAYorOBJ,
  ...
  staticMethodTestARRAYorOBJ
]

5.12.2. staticMethodTestARRAYorOBJ

[
  methodFullNameSTR,  // full name of static method, including module path
  casesARRAY          // array of test cases
]

EXAMPLE

Uize.Test.staticMethodsTest ([
  ['Uize.String.trimLeft',[
    ['Test that left-trimming empty string produces empty string',
      '',
      ''
    ],
    ['Test that left-trimming string with no padding returns the same string',
      'hello',
      'hello'
    ],
    ['Test that left-trimming string with leading spaces works',
      '   hello',
      'hello'
    ],
    ['Test that left-trimming string with trailing spaces works',
      'hello   ',
      'hello   '
    ],
    ['Test that left-trimming string with leading and trailing spaces works',
      '   hello   ',
      'hello   '
    ],
    ['Test that left-trimming does not affect inner whitesapce',
      ' hello \t there ',
      'hello \t there '
    ],
    ['Test that left-trimming string with tab padding works',
      '\t\thello\t\t',
      'hello\t\t'
    ]
  ]],
  ['Uize.String.trimRight',[
    ['Test that right-trimming empty string produces empty string',
      '',
      ''
    ],
    ['Test that right-trimming string with no padding returns the same string',
      'hello',
      'hello'
    ],
    ['Test that right-trimming string with leading spaces works',
      '   hello',
      '   hello'
    ],
    ['Test that right-trimming string with trailing spaces works',
      'hello   ',
      'hello'
    ],
    ['Test that right-trimming string with leading and trailing spaces works',
      '   hello   ',
      '   hello'
    ],
    ['Test that right-trimming does not affect inner whitesapce',
      ' hello \t there ',
      ' hello \t there'
    ],
    ['Test that right-trimming string with tab padding works',
      '\t\thello\t\t',
      '\t\thello'
    ]
  ]]
]);

In the above (rather long) example, static method tests are being declared for the Uize.String.trimLeft and Uize.String.trimRight static methods of the Uize.String module.

NOTES

IMPLEMENTATION INFO

Returns a Uize.Test subclass, for a test that tests whether or not the specified static property exists and is of the specified type.

SYNTAX

testCLASS = Uize.Test.staticPropertyTest (propertyFullNameSTR,typeSTR);

5.13.1. propertyFullNameSTR

5.13.2. What Comprises a Static Property Test

5.13.3. An Example

var
  StaticPropertyTestClass = Uize.Test.staticPropertyTest ('Uize.Test.isAsync','object'),
  staticPropertyTest = new StaticPropertyTestClass
;
staticPropertyTest.run (
  function () {
    alert (staticPropertyTest.get ('result'));  // displays true
  }
);

NOTES

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Returns a Uize.Test subclass, for a test that safely tests the loading and running of a test module.

SYNTAX

testCLASS = Uize.Test.testModuleTest (testModuleSTR);

The test class created by this method first tests whether or not the specified test module can be successfully required (and loaded and built, if necessary). It does this using a child test created using the Uize.Test.requiredModulesTest static method. If the test module can be successfully required, then it is run by instantiating it and calling its run instance method.

EXAMPLE

uizeDataTestModuleRunner = Uize.Test.testModuleTest ('Uize.Test.Uize.Data');

NOTES

IMPLEMENTATION INFO

Returns a Uize.Test subclass, for a test that combines multiple separate test modules into a single test suite.

SYNTAX

testCLASS = Uize.Test.testSuite (testSuiteTitleSTR,testSuiteModulesARRAY);

The Uize.Test.testSuite method wraps each of the test modules specified in the testSuiteModulesARRAY parameter in a test module test, using the Uize.Test.testModuleTest static method. This ensures that the many individual test modules that make up a test suite are only loaded dynamically as needed when the test suite is run - they are not directly required by the test suite test, and they do not need to be loaded in just so that the test suite's test class can be built. This is a good thing, because many of the test modules are rather large.

EXAMPLE

var uizeTestSuite = Uize.Test.testSuite (
  'UIZE JavaScript Framework Unit Tests',
  [
    'Uize.Test.Uize.Data',
    'Uize.Test.Uize',
    'Uize.Test.Uize.Array',
    'Uize.Test.Uize.Array.Order',
    'Uize.Test.Uize.Array.Sort',
    'Uize.Test.Uize.Data.Csv',
    'Uize.Test.Uize.Date',
    // ... ... ... ... ... ...
    // more test modules here
    // ... ... ... ... ... ...
  ]
);

In the above example, a test suite test class is being created to sequence execution of a series of test modules that test various modules of the UIZE JavaScript Framework.

NOTES

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

Inherited from Uize.Class.

IMPLEMENTATION INFO

A number, representing how long it took for the test instance to run, measured in milliseconds.

Before a test instance has been run for the first time, the value of this property will be undefined. The value will also be reset to undefined each time the test is started, and will remain undefined while the test is in progress.

NOTES

IMPLEMENTATION INFO

An instance of JavaScript's Date object, that is set to the time at which running of the test instance ended.

Before a test instance has been run for the first time, the value of this property will be undefined. The value will also be reset to undefined each time the test is started, and will remain undefined while the test is in progress. The value will be reset to the current time each time the test ends running.

NOTES

IMPLEMENTATION INFO

A boolean, indicating whether or not the test instance is busy running its test(s).

The value of this property is set to true each time the test is started, and is set back to false each time the test ends running.

NOTES

IMPLEMENTATION INFO

A boolean, indicating whether or not running the test instance's test(s) is asynchronous.

The value undefined is equivalent to the boolean value false. When a test is run in the browser context, the value of this property is coerced to true. For a more in-depth discussion, see the section Asynchronous Tests in the JavaScript Testing Framework explainer.

NOTES

IMPLEMENTATION INFO

An array, containing all of the messages logged using the log Instance Method.

Before a test instance has been run for the first time, the value of this property will be undefined. The value will also be reset to [] (an empty array) each time the test is started. Each element of the log array is an object with the following structure...

LOG MESSAGE OBJECT

{
  message   : messageSTR,  // the text of the log message
  timestamp : dataOBJ      // the time at which the message was added to the log
}

NOTES

IMPLEMENTATION INFO

A floating point number in the range of 0 to 1, indicating how far the test instance is in running its test(s).

Before a test instance has been run for the first time, the value of this property will be 0. The value will also be reset to 0 each time the test is started. The value will be set to the 1 when the test ends running. During running of the test, the value will be updated periodically to reflect the progress that has been made. The progress is calculated by dividing the number of Subtests that have completed running by the total number of subtests defined in the test state property. Importantly, the value of this property does not reflect updates in the progress of individual subtests.

NOTES

IMPLEMENTATION INFO

A string, providing an explanation for why the test failed, or the value undefined if the test has not failed.

Before a test instance has been run for the first time, the value of this property will be undefined. The value will also be reset to undefined each time the test is started, and will remain undefined while the test is in progress. If the test fails, the value of this property is typically set in a call to one of the Expectation Methods, along with the result state property being set to false.

NOTES

IMPLEMENTATION INFO

A boolean, indicating whether or not the test passed, or the value undefined or Uize.Test.isAsync.

A value of true indicates that the test was completed and passed, while a value of false indicates that the test was completed and failed or was aborted with a catastrophic failure. A value of undefined indicates that the test result has not yet been determined, while a value of Uize.Test.isAsync indicates that determination of the result is waiting upon the completion of asynchronous code.

Before a test instance has been run for the first time, the value of this property will be undefined. The value will also be reset to undefined each time the test is started, and will remain undefined until the result is determined, or will be set to the constant value Uize.Test.isAsync if the test is known to be asynchronous.

NOTES

IMPLEMENTATION INFO

An instance of JavaScript's Date object, that is set to the time at which running of the test instance started.

Before a test instance has been run for the first time, the value of this property will be undefined. The value will be reset to the current time each time the test is started.

NOTES

IMPLEMENTATION INFO

A test function, or an array of child tests where each element is an instance of a Uize.Test subclass.

6.10.1. The Simple Test Case

6.10.2. The Child Tests Case

IMPLEMENTATION INFO

A string, representing the title of the test instance.

The title of a test is used when generating a synopsis for a test using the getSynopsis instance method. The title can also be used by a test runner application whose interface provides logging for tests as they are being run.

IMPLEMENTATION INFO

A reference to the Uize.Test instance that serves as the parent for the test instance.

A test instance is parented when it is instantiated by its parent test. The root test in a test tree is never parented, and so the value of the parent property for the root test remains undefined.

NOTES