casperjs 1.0.0.RC1

data/tests/suites/clientutils.js

@@ -0,0 +1,84 @@
+var fs = require('fs');
+var x = require('casper').selectXPath;
+
+function fakeDocument(html) {
+    window.document.body.innerHTML = html;
+}
+
+(function(casper) {
+    casper.test.comment('ClientUtils.encode()');
+    var clientutils = require('clientutils').create();
+    var testCases = {
+        'an empty string': '',
+        'a word':          'plop',
+        'a null char':     'a\u0000',
+        'an utf8 string':  'ÀÁÃÄÅÇÈÉÊËÌÍÎÏÒÓÔÕÖÙÚÛÜÝàáâãäåçèéêëìíîïðòóôõöùúûüýÿ',
+        'song lyrics':     ("Voilà l'été, j'aperçois le soleil\n" +
+                            "Les nuages filent et le ciel s'éclaircit\n" +
+                            "Et dans ma tête qui bourdonnent?\n" +
+                            "Les abeilles!"),
+        'a file contents': fs.read(phantom.casperPath + '/tests/site/alert.html')
+    };
+    for (var what in testCases) {
+        var source = testCases[what];
+        var encoded = clientutils.encode(source);
+        casper.test.assertEquals(clientutils.decode(encoded), source, 'ClientUtils.encode() encodes and decodes ' + what);
+    }
+})(casper);
+
+(function(casper) {
+    casper.test.comment('ClientUtils.exists()');
+    var clientutils = require('clientutils').create();
+    fakeDocument('<ul class="foo"><li>bar</li><li>baz</li></ul>');
+    casper.test.assert(clientutils.exists('ul'), 'ClientUtils.exists() checks that an element exist');
+    casper.test.assertNot(clientutils.exists('ol'), 'ClientUtils.exists() checks that an element exist');
+    casper.test.assert(clientutils.exists('ul.foo li'), 'ClientUtils.exists() checks that an element exist');
+    // xpath
+    casper.test.assert(clientutils.exists(x('//ul')), 'ClientUtils.exists() checks that an element exist using XPath');
+    casper.test.assertNot(clientutils.exists(x('//ol')), 'ClientUtils.exists() checks that an element exist using XPath');
+    fakeDocument(null);
+})(casper);
+
+(function(casper) {
+    casper.test.comment('ClientUtils.findAll()');
+    var clientutils = require('clientutils').create();
+    fakeDocument('<ul class="foo"><li>bar</li><li>baz</li></ul>');
+    casper.test.assertType(clientutils.findAll('li'), 'nodelist', 'ClientUtils.findAll() can find matching DOM elements');
+    casper.test.assertEquals(clientutils.findAll('li').length, 2, 'ClientUtils.findAll() can find matching DOM elements');
+    casper.test.assertType(clientutils.findAll('ol'), 'nodelist', 'ClientUtils.findAll() can find matching DOM elements');
+    casper.test.assertEquals(clientutils.findAll('ol').length, 0, 'ClientUtils.findAll() can find matching DOM elements');
+    // scoped
+    var scope = clientutils.findOne('ul');
+    casper.test.assertType(clientutils.findAll('li', scope), 'nodelist', 'ClientUtils.findAll() can find matching DOM elements within a given scope');
+    fakeDocument(null);
+})(casper);
+
+(function(casper) {
+    casper.test.comment('ClientUtils.findOne()');
+    var clientutils = require('clientutils').create();
+    fakeDocument('<ul class="foo"><li>bar</li><li>baz</li></ul>');
+    casper.test.assertType(clientutils.findOne('ul'), 'htmlulistelement', 'ClientUtils.findOne() can find a matching DOM element');
+    casper.test.assertNot(clientutils.findOne('ol'), 'ClientUtils.findOne() can find a matching DOM element');
+    // scoped
+    var scope = clientutils.findOne('ul');
+    casper.test.assertType(clientutils.findAll('li', scope), 'nodelist', 'ClientUtils.findAll() can find matching DOM elements within a given scope');
+    casper.test.assertEquals(clientutils.findAll('li', scope).length, 2, 'ClientUtils.findAll() can find matching DOM elements within a given scope');
+    fakeDocument(null);
+})(casper);
+
+(function(casper) {
+    casper.test.comment('ClientUtils.processSelector()');
+    var clientutils = require('clientutils').create();
+    // CSS3 selector
+    var cssSelector = clientutils.processSelector('html body > ul.foo li');
+    casper.test.assertType(cssSelector, 'object', 'ClientUtils.processSelector() can process a CSS3 selector');
+    casper.test.assertEquals(cssSelector.type, 'css', 'ClientUtils.processSelector() can process a CSS3 selector');
+    casper.test.assertEquals(cssSelector.path, 'html body > ul.foo li', 'ClientUtils.processSelector() can process a CSS3 selector');
+    // XPath selector
+    var xpathSelector = clientutils.processSelector(x('//li[text()="blah"]'));
+    casper.test.assertType(xpathSelector, 'object', 'ClientUtils.processSelector() can process a XPath selector');
+    casper.test.assertEquals(xpathSelector.type, 'xpath', 'ClientUtils.processSelector() can process a XPath selector');
+    casper.test.assertEquals(xpathSelector.path, '//li[text()="blah"]', 'ClientUtils.processSelector() can process a XPath selector');
+})(casper);
+
+casper.test.done();

data/tests/suites/coffee.coffee

@@ -0,0 +1,19 @@
+"A small subset of the run.js written in coffeescript"
+
+steps = 0
+
+casper.options.onStepComplete = -> steps++
+
+casper.start "tests/site/index.html", ->
+  @test.assertTitle "CasperJS test index", "Casper.start() casper can start itself an open an url"
+  @test.assertEquals @fetchText("ul li"), "onetwothree", "Casper.fetchText() can retrieves text contents"
+  @click "a[href=\"test.html\"]"
+
+casper.then ->
+  @test.assertTitle "CasperJS test target", "Casper.click() casper can click on a text link"
+  @click "a[href=\"form.html\"]"
+
+casper.run ->
+  @test.assertEquals steps, 3, "Casper.options.onStepComplete() is called on step complete"
+  @options.onStepComplete = null
+  @test.done()

data/tests/suites/fs.js

@@ -0,0 +1,36 @@
+var fs = require('fs'), t = casper.test;
+
+// Testing added methods
+(function() {
+    t.comment('fs.dirname()');
+    var tests = {
+        '/local/plop/foo.js':      '/local/plop',
+        'local/plop/foo.js':       'local/plop',
+        './local/plop/foo.js':     './local/plop',
+        'c:\\local\\plop\\foo.js': 'c:/local/plop',
+        'D:\\local\\plop\\foo.js': 'D:/local/plop',
+        'D:\\local\\plop\\':       'D:/local/plop',
+        'c:\\':                    'c:',
+        'c:':                      'c:'
+    };
+    for (var testCase in tests) {
+        t.assertEquals(fs.dirname(testCase), tests[testCase], 'fs.dirname() does its job for ' + testCase);
+    }
+})();
+
+(function() {
+    t.comment('fs.dirname()');
+    var tests = {
+        '/':                       false,
+        '/local/plop/foo.js':      false,
+        'D:\\local\\plop\\':       true,
+        'c:\\':                    true,
+        'c:':                      true,
+        '\\\\Server\\Plop':        true
+    };
+    for (var testCase in tests) {
+        t.assertEquals(fs.isWindows(testCase), tests[testCase], 'fs.isWindows() does its job for ' + testCase);
+    }
+})();
+
+t.done();

data/tests/suites/http_status.js

@@ -0,0 +1,28 @@
+var server = require('webserver').create();
+var service = server.listen(8090, function (request, response) {
+    var code = parseInt(/^\/(\d+)$/.exec(request.url)[1], 10);
+    response.statusCode = code;
+    response.write("");
+    response.close();
+});
+
+codes = [100, 101, 102, 118, 200, 201, 202, 203, 204, 205, 206, 207, 210,
+         300, 301, 302, 303, 304, 305, 307, 310,
+         400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413,
+              414, 415, 416, 417, 418, 422, 423, 424, 425, 426, 449, 450,
+         500, 501, 502, 503, 504, 505, 507, 509];
+
+casper.start('http://google.com').each(codes, function(self, code) {
+    if (code === 100) {
+        // HTTP 100 is CONTINUE, so don't expect a terminated response
+        return;
+    }
+    this.thenOpen('http://localhost:8090/' + code, function() {
+        this.test.assertHttpStatus(code);
+    });
+});
+
+casper.run(function() {
+    server.close();
+    this.test.done();
+});

data/tests/suites/injector.js

@@ -0,0 +1,64 @@
+var t = casper.test;
+var createInjector = function(fn, values) {
+    return require('injector').create(fn, values);
+};
+var testFn = function(a, b) { return a + b; };
+var injector = createInjector(testFn);
+var extract = injector.extract(testFn);
+
+t.comment('FunctionArgsInjector.extract()');
+t.assertType(extract, "object", 'FunctionArgsInjector.extract() returns an object');
+t.assertEquals(extract.name, null, 'FunctionArgsInjector.extract() process function name as expected');
+t.assertEquals(extract.body, 'return a + b;', 'FunctionArgsInjector.extract() process function body as expected');
+t.assertEquals(extract.args, ['a', 'b'], 'FunctionArgsInjector.extract() process function args as expected');
+
+function Plop(foo, bar) {
+    return 'foo: ' + foo +', bar: ' + bar;
+}
+function Plip() { return 'plop'; }
+function foo_bar(boz) {}
+var gni = function ($bubu_bibi, __popo__) {};
+var gno = function    (  arg1,    /*plop*/ arg2  ) {    };
+function issue129(term) {
+    // see issue #129
+    return term;
+    // see issue #129
+}
+t.assertEquals(injector.extract(Plop), {
+    name: 'Plop',
+    args: ['foo', 'bar'],
+    body: "return 'foo: ' + foo +', bar: ' + bar;"
+}, 'FunctionArgsInjector.extract() handles named functions with arguments and body');
+t.assertEquals(injector.extract(Plip), {
+    name: 'Plip',
+    args: [],
+    body: "return 'plop';"
+}, 'FunctionArgsInjector.extract() handles functions with no arguments');
+t.assertEquals(injector.extract(foo_bar), {
+    name: 'foo_bar',
+    args: ['boz'],
+    body: ""
+}, 'FunctionArgsInjector.extract() handles functions with no body');
+t.assertEquals(injector.extract(gni), {
+    name: null,
+    args: ['$bubu_bibi', '__popo__'],
+    body: ""
+}, 'FunctionArgsInjector.extract() handles anonymous functions with complex args passed');
+t.assertEquals(injector.extract(gno), {
+    name: null,
+    args: ['arg1', 'arg2'],
+    body: ""
+}, 'FunctionArgsInjector.extract() handles can filter comments in function args');
+
+t.comment('FunctionArgsInjector.process()');
+var processed;
+eval('processed = ' + injector.process({ a: 1, b: 2 }));
+
+t.assertType(processed, "function", 'FunctionArgsInjector.process() processed a function');
+t.assertEquals(processed(), 3, 'FunctionArgsInjector.process() processed the function correctly');
+
+// Issue #129
+var fnIssue129 = createInjector(issue129).process({term: 'fixed'});
+t.assertEquals(fnIssue129('fixed'), 'fixed', 'FunctionArgsInjector.process() has issue #129 fixed');
+
+t.done();

data/tests/suites/tester.js

@@ -0,0 +1,121 @@
+var fs = require('fs');
+
+var t = casper.test;
+
+casper.start();
+
+t.comment('Tester.testEquals()');
+t.assert(t.testEquals(null, null), 'Tester.testEquals() null equality');
+t.assertNot(t.testEquals(null, undefined), 'Tester.testEquals() null vs. undefined inequality');
+t.assert(t.testEquals("hi", "hi"), 'Tester.testEquals() string equality');
+t.assertNot(t.testEquals("hi", "ih"), 'Tester.testEquals() string inequality');
+t.assert(t.testEquals(5, 5), 'Tester.testEquals() number equality');
+t.assertNot(t.testEquals("5", 5), 'Tester.testEquals() number equality without implicit cast');
+t.assert(t.testEquals(5, 5.0), 'Tester.testEquals() number equality with cast');
+t.assertNot(t.testEquals(5, 10), 'Tester.testEquals() number inequality');
+t.assert(t.testEquals([], []), 'Tester.testEquals() empty array equality');
+t.assert(t.testEquals([1,2], [1,2]), 'Tester.testEquals() array equality');
+t.assert(t.testEquals([1,2,[1,2,function(){}]], [1,2,[1,2,function(){}]]), 'Tester.testEquals() complex array equality');
+t.assertNot(t.testEquals([1,2,[1,2,function(a){}]], [1,2,[1,2,function(b){}]]), 'Tester.testEquals() complex array inequality');
+t.assertNot(t.testEquals([1,2], [2,1]), 'Tester.testEquals() shuffled array inequality');
+t.assertNot(t.testEquals([1,2], [1,2,3]), 'Tester.testEquals() array length inequality');
+t.assert(t.testEquals({}, {}), 'Tester.testEquals() empty object equality');
+t.assert(t.testEquals({a:1,b:2}, {a:1,b:2}), 'Tester.testEquals() object length equality');
+t.assert(t.testEquals({a:1,b:2}, {b:2,a:1}), 'Tester.testEquals() shuffled object keys equality');
+t.assertNot(t.testEquals({a:1,b:2}, {a:1,b:3}), 'Tester.testEquals() object inequality');
+t.assert(t.testEquals({1:{name:"bob",age:28}, 2:{name:"john",age:26}}, {1:{name:"bob",age:28}, 2:{name:"john",age:26}}), 'Tester.testEquals() complex object equality');
+t.assertNot(t.testEquals({1:{name:"bob",age:28}, 2:{name:"john",age:26}}, {1:{name:"bob",age:28}, 2:{name:"john",age:27}}), 'Tester.testEquals() complex object inequality');
+t.assert(t.testEquals(function(x){return x;}, function(x){return x;}), 'Tester.testEquals() function equality');
+t.assertNot(t.testEquals(function(x){return x;}, function(y){return y+2;}), 'Tester.testEquals() function inequality');
+
+t.comment('Tester.sortFiles()');
+var testDirRoot = fs.pathJoin(phantom.casperPath, 'tests', 'testdir');
+var files = t.findTestFiles(testDirRoot);
+var expected = [
+    "01_a/abc.js",
+    "01_a/def.js",
+    "02_b/abc.js",
+    "03_a.js",
+    "03_b.js",
+    "04/01_init.js",
+    "04/02_do.js"
+].map(function(entry) {
+    return fs.pathJoin.apply(fs, [testDirRoot].concat(entry.split('/')));
+});
+t.assertEquals(files, expected, 'findTestFiles() find test files and sort them');
+
+casper.thenOpen('tests/site/index.html', function() {
+    t.comment('Tester.assertTextExists()');
+    t.assertTextExists('form', 'Tester.assertTextExists() checks that page body contains text');
+});
+
+casper.then(function() {
+    t.comment('Tester.assert()');
+    t.assert(true, 'Tester.assert() works as expected');
+
+    t.comment('Tester.assertNot()');
+    t.assertNot(false, 'Tester.assertNot() works as expected');
+
+    t.comment('Tester.assertEquals()');
+    t.assertEquals(true, true, 'Tester.assertEquals() works as expected');
+
+    t.comment('Tester.assertNotEquals()');
+    t.assertNotEquals(true, false, 'Tester.assertNotEquals() works as expected');
+
+    t.comment('Tester.assertEval()');
+    t.assertEval(function() {
+        return true;
+    }, 'Tester.assertEval() works as expected');
+
+    t.comment('Tester.assertEvalEquals()');
+    t.assertEvalEquals(function() {
+        return 42;
+    }, 42, 'Tester.assertEvalEquals() works as expected');
+
+    t.comment('Tester.assertExists()');
+    t.assertExists('body', 'Tester.assertExists() works as expected');
+
+    t.comment('Tester.assertDoesntExist()');
+    t.assertDoesntExist('foobar', 'Tester.assertDoesntExist() works as expected');
+
+    t.comment('Tester.assertHttpStatus()');
+    // using file:// protocol, HTTP status is always null
+    t.assertHttpStatus(null, 'Tester.assertHttpStatus() works as expected');
+
+    t.comment('Tester.assertMatch()');
+    t.assertMatch("the lazy dog", /lazy/, 'Tester.assertMatch() works as expected');
+
+    t.comment('Tester.assertRaises()');
+    t.assertRaises(function() {
+        throw new Error('plop');
+    }, [], 'Tester.assertRaises() works as expected');
+
+    t.comment('Tester.assertResourceExists()');
+    t.assertResourceExists(/index\.html/, 'Tester.assertResourceExists() works as expected');
+
+    t.comment('Tester.assertTitle()');
+    t.assertTitle('CasperJS test index', 'Tester.assertTitle() works as expected');
+
+    t.comment('Tester.assertTitleMatch()');
+    t.assertTitleMatch(/test index/, 'Tester.assertTitleMatch() works as expected');
+
+    t.comment('Tester.assertType()');
+    t.assertType("plop", "string", "Tester.assertType() works as expected");
+
+    t.comment('Tester.assertUrlMatch()');
+    t.assertUrlMatch(/index\.html$/, "Tester.assertUrlMatch() works as expected");
+});
+
+casper.then(function() {
+    t.comment('Tester.getFailures()');
+    t.assertEquals(typeof t.getFailures().length, "number", "Tester.getFailures() works as expected");
+
+    var passCount = t.getPasses().length;
+    t.comment('Tester.getPasses()');
+    t.assertEquals(1, 1, "Rogue assertEquals pass case");
+    t.assertEquals(t.getPasses().length, passCount + 1, "Tester.getPasses() works as expected");
+});
+
+casper.run(function() {
+    t.done();
+});

data/tests/suites/utils.js

@@ -0,0 +1,209 @@
+var utils = require('utils'), t = casper.test, x = require('casper').selectXPath;
+
+t.comment('fileExt()');
+(function() {
+    var testCases = {
+        'foo.ext':    'ext',
+        'FOO.EXT':    'ext',
+        'a.ext':      'ext',
+        '.ext':       'ext',
+        'toto.':      '',
+        ' plop.ext ': 'ext'
+    };
+
+    for (var testCase in testCases) {
+        t.assertEquals(utils.fileExt(testCase), testCases[testCase], 'fileExt() extract file extension');
+    }
+})();
+
+t.comment('fillBlanks()');
+(function() {
+    testCases = {
+        'foo':         'foo       ',
+        '  foo bar ':  '  foo bar ',
+        '  foo bar  ': '  foo bar  '
+    };
+
+    for (var testCase in testCases) {
+        t.assertEquals(utils.fillBlanks(testCase, 10), testCases[testCase], 'fillBlanks() fills blanks');
+    }
+})();
+
+t.comment('getPropertyPath()');
+(function() {
+    testCases = [
+        {
+            input:  utils.getPropertyPath({}, 'a.b.c'),
+            output: undefined
+        },
+        {
+            input:  utils.getPropertyPath([1, 2, 3], 'a.b.c'),
+            output: undefined
+        },
+        {
+            input:  utils.getPropertyPath({ a: { b: { c: 1 } }, c: 2 }, 'a.b.c'),
+            output: 1
+        },
+        {
+            input:  utils.getPropertyPath({ a: { b: { c: 1 } }, c: 2 }, 'a.b.x'),
+            output: undefined
+        },
+        {
+            input:  utils.getPropertyPath({ a: { b: { c: 1 } }, c: 2 }, 'a.b'),
+            output: { c: 1 }
+        },
+        {
+            input:  utils.getPropertyPath({ 'a-b': { 'c-d': 1} }, 'a-b.c-d'),
+            output: 1
+        },
+        {
+            input:  utils.getPropertyPath({ 'a.b': { 'c.d': 1} }, 'a.b.c.d'),
+            output: undefined
+        }
+    ];
+    testCases.forEach(function(testCase) {
+        t.assertEquals(testCase.input, testCase.output, 'getPropertyPath() gets a property using a path');
+    });
+})();
+
+t.comment('isArray()');
+(function() {
+    t.assertEquals(utils.isArray([]), true, 'isArray() checks for an Array');
+    t.assertEquals(utils.isArray({}), false, 'isArray() checks for an Array');
+    t.assertEquals(utils.isArray("foo"), false, 'isArray() checks for an Array');
+})();
+
+t.comment('isClipRect()');
+(function() {
+    testCases = [
+        [{},                                              false],
+        [{top: 2},                                        false],
+        [{top: 2, left: 2, width: 2, height: 2},          true],
+        [{top: 2, left: 2, height: 2, width: 2},          true],
+        [{top: 2, left: 2, width: 2, height: new Date()}, false]
+    ];
+
+    testCases.forEach(function(testCase) {
+        t.assertEquals(utils.isClipRect(testCase[0]), testCase[1], 'isClipRect() checks for a ClipRect');
+    });
+})();
+
+t.comment('isObject()');
+(function() {
+    t.assertEquals(utils.isObject({}), true, 'isObject() checks for an Object');
+    t.assertEquals(utils.isObject([]), true, 'isObject() checks for an Object');
+    t.assertEquals(utils.isObject(1), false, 'isObject() checks for an Object');
+    t.assertEquals(utils.isObject("1"), false, 'isObject() checks for an Object');
+    t.assertEquals(utils.isObject(function(){}), false, 'isObject() checks for an Object');
+    t.assertEquals(utils.isObject(new Function('return {};')()), true, 'isObject() checks for an Object');
+    t.assertEquals(utils.isObject(require('webpage').create()), true, 'isObject() checks for an Object');
+    t.assertEquals(utils.isObject(null), false, 'isObject() checks for an Object');
+})();
+
+t.comment('isValidSelector()');
+(function() {
+    t.assertEquals(utils.isValidSelector({}), false, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector(""), false, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector("a"), true, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector('div#plop form[name="form"] input[type="submit"]'), true, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector(x('//a')), true, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector({
+        type: "css",
+        path: 'div#plop form[name="form"] input[type="submit"]'
+    }), true, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector({
+        type: "xpath",
+        path: '//a'
+    }), true, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector({
+        type: "css"
+    }), false, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector({
+        type: "xpath"
+    }), false, 'isValidSelector() checks for a valid selector');
+    t.assertEquals(utils.isValidSelector({
+        type: "css3",
+        path: "a"
+    }), false, 'isValidSelector() checks for a valid selector');
+})();
+
+t.comment('isWebPage()');
+(function() {
+    var pageModule = require('webpage');
+    t.assertEquals(utils.isWebPage(pageModule), false, 'isWebPage() checks for a WebPage instance');
+    t.assertEquals(utils.isWebPage(pageModule.create()), true, 'isWebPage() checks for a WebPage instance');
+    t.assertEquals(utils.isWebPage(null), false, 'isWebPage() checks for a WebPage instance');
+})();
+
+t.comment('isJsFile()');
+(function() {
+    testCases = {
+        '':             false,
+        'toto.png':     false,
+        'plop':         false,
+        'gniii.coffee': true,
+        'script.js':    true
+    };
+
+    for (var testCase in testCases) {
+        t.assertEquals(utils.isJsFile(testCase), testCases[testCase], 'isJsFile() checks for js file');
+    }
+})();
+
+t.comment('mergeObjects()');
+(function() {
+    testCases = [
+        {
+            obj1: {a: 1}, obj2: {b: 2}, merged: {a: 1, b: 2}
+        },
+        {
+            obj1: {}, obj2: {a: 1}, merged: {a: 1}
+        },
+        {
+            obj1: {a: 1}, obj2: {}, merged: {a: 1}
+        },
+        {
+            obj1: {a: 1}, obj2: {a: 2}, merged: {a: 2}
+        },
+        {
+            obj1:   {x: 0, double: function(){return this.x*2;}},
+            obj2:   {triple: function(){return this.x*3;}},
+            merged: {
+                x: 0,
+                double: function(){return this.x*2;},
+                triple: function(){return this.x*3;}
+            }
+        }
+    ];
+
+    testCases.forEach(function(testCase) {
+        t.assertEquals(utils.mergeObjects(testCase.obj1, testCase.obj2), testCase.merged, 'mergeObjects() can merge objects');
+    });
+})();
+
+t.comment('unique()');
+(function() {
+    testCases = [
+        {
+            input:  [1,2,3],
+            output: [1,2,3]
+        },
+        {
+            input:  [1,2,3,2,1],
+            output: [1,2,3]
+        },
+        {
+            input:  ["foo", "bar", "foo"],
+            output: ["foo", "bar"]
+        },
+        {
+            input:  [],
+            output: []
+        }
+    ];
+    testCases.forEach(function(testCase) {
+        t.assertEquals(utils.unique(testCase.input), testCase.output, 'unique() computes unique values of an array');
+    });
+})();
+
+t.done();