// Add a test to run.
test( name, expected, test )

// Add an asynchronous test to run. The test must include a call to start().
asyncTest( name, expected, test )

// Specify how many assertions are expected to run within a test.
expect( amount );

// Separate tests into modules.
module( name, lifecycle )

// A boolean assertion, equivalent to JUnit's assertTrue. Passes if the first argument is truthy.
ok( state, message )

// A comparison assertion, equivalent to JUnit's assertEquals. Uses "==".
equals( actual, expected, message )

// A comparison assertion. Uses "===".
strictEqual( actual, expected, message )

// A deep recursive comparison assertion, working on primitive types, arrays and objects.
same( actual, expected, message )

// Start running tests again after the testrunner was stopped.
start()

// Stop the testrunner to wait to async tests to run. Call start() to continue.
stop( timeout )

var testrunner = require( "qunit" );

// set it to true if you want to report only errors
testrunner.options.errorsOnly = false;

// set it to false if you want to get error stack in report     
testrunner.options.errorStack = true;

// print a summary about all tested stuff after finish
testrunner.options.summary = true;

// add paths to require of test environment
testrunner.options.paths = require.paths;

// one code and tests file
testrunner.run({
    code: "/path/to/your/code.js",
    tests: "/path/to/your/tests.js"
});

// one code and multiple tests file
testrunner.run({
    code: "/path/to/your/code.js",
    tests: ["/path/to/your/tests.js", "/path/to/your/tests1.js"]
});    

// array of code and test files
testrunner.run([
    {
        code: "/path/to/your/code.js",
        tests: "/path/to/your/tests.js"
    },
    {
        code: "/path/to/your/code.js",
        tests: "/path/to/your/tests.js"
    }    
]);

// using testrunner callback
testrunner.run({
    code: "/path/to/your/code.js",
    tests: "/path/to/your/tests.js"
}, function( report ) {
    console.dir(report);
});    

module = QUnit.module;

QUnit.test;

test("a basic test example", function() {
  ok( true, "this test is fine" );
  var value = "hello";
  equals( "hello", value, "We expect value to be hello" );
});

module("Module A");

test("first test within module", 1, function() {
  ok( true, "all pass" );
});

test("second test within module", 2, function() {
  ok( true, "all pass" );
});

module("Module B", {
    setup: function() {
        // do some initial stuff before every test for this module
    },
    teardown: function() {
        // do some stuff after every test for this module
    }
});

test("some other test", function() {
  expect(2);
  equals( true, false, "failing test" );
  equals( true, true, "passing test" );
});

module("Module C", {
    setup: function() {
        // setup a shared environment for each test
        this.options = {test: 123};
    }
});

test("this test is using shared environment", 1, function() {
  same( {test:123}, this.options, "passing test" );
});    

asyncTest("this is an async test example", 2, function() {
    setTimeout(function() {
        ok(true, "finished async test");
        strictEqual( true, true, "Strict equal assertion uses ===" );
        start();
    }, 100);
});

$ node cli.js /path/to/your/code.js /path/to/your/tests.js

// add require.paths
$ node cli.js /path/to/your/code.js /path/to/your/tests.js /path/for/require,/path1/for/require