imported 25 definitions from typescript-node-definitions

first batch: the easy pickings

- as per https://github.com/borisyankov/DefinitelyTyped/issues/115
- added DT headers (scraped creators from git history)
- added tests
- some modifications
- added CONTRIBUTORS.md for the substantial defs (>50 LOC)

nodeunit/nodeunit-tests.ts

@@ -0,0 +1,59 @@
+/// <reference path="nodeunit.d.ts" />
+
+import nodeunit = require('nodeunit');
+
+var num: number;
+var value: any;
+var actual: any;
+var expected: any;
+var message: string;
+var operator: string;
+var error: any;
+var block: () =>{
+
+};
+
+export var testGroup: nodeunit.ITestGroup = {
+	setUp: function (callback: nodeunit.ICallbackFunction) {
+		callback();
+	},
+	tearDown: function (callback: nodeunit.ICallbackFunction) {
+		callback();
+	},
+	test1: function (test: nodeunit.Test) {
+		test.expect(num);
+
+		test.fail(actual, expected, message, operator);
+		test.assert(value, message);
+		test.ok(value);
+		test.ok(value, message);
+		test.equal(actual, expected);
+		test.equal(actual, expected, message);
+		test.notEqual(actual, expected);
+		test.notEqual(actual, expected, message);
+		test.deepEqual(actual, expected);
+		test.deepEqual(actual, expected, message);
+		test.notDeepEqual(actual, expected);
+		test.notDeepEqual(actual, expected, message);
+		test.strictEqual(actual, expected);
+		test.strictEqual(actual, expected, message);
+		test.notStrictEqual(actual, expected);
+		test.notStrictEqual(actual, expected, message);
+		test.throws(block);
+		test.throws(block, error);
+		test.throws(block, error, message);
+		test.doesNotThrow(block);
+		test.doesNotThrow(block, error);
+		test.doesNotThrow(block, error, message);
+		test.ifError(value);
+
+		//assertion wrappers
+		test.equals(actual, expected);
+		test.equals(actual, expected, message);
+		test.same(actual, expected);
+		test.same(actual, expected, message);
+
+		test.done(error);
+		test.done();
+	}
+};

nodeunit/nodeunit.d.ts

@@ -0,0 +1,59 @@
+// Type definitions for nodeunit
+// Project: https://github.com/caolan/nodeunit
+// Definitions by: Jeff Goddard <https://github.com/jedigo>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+// Imported from: https://github.com/soywiz/typescript-node-definitions/nodeunit.d.ts
+
+declare module 'nodeunit' {
+	export interface Test {
+		done: ICallbackFunction;
+		expect(num: number): void;
+
+		//assersions from node assert module
+		fail(actual: any, expected: any, message: string, operator: string): void;
+		assert(value: any, message: string): void;
+		ok(value: any, message?: string): void;
+		equal(actual: any, expected: any, message?: string): void;
+		notEqual(actual: any, expected: any, message?: string): void;
+		deepEqual(actual: any, expected: any, message?: string): void;
+		notDeepEqual(actual: any, expected: any, message?: string): void;
+		strictEqual(actual: any, expected: any, message?: string): void;
+		notStrictEqual(actual: any, expected: any, message?: string): void;
+		throws(block: any, error?: any, message?: string): void;
+		doesNotThrow(block: any, error?: any, message?: string): void;
+		ifError(value: any): void;
+
+		//assertion wrappers
+		equals(actual: any, expected: any, message?: string): void;
+		same(actual: any, expected: any, message?: string): void;
+	}
+
+	// Test Group Usage:
+	//  var testGroup: nodeunit.ITestGroup = {
+	//        setUp: function (callback: nodeunit.ICallbackFunction): void {
+	//            callback();
+	//        },
+	//        tearDown: function (callback: nodeunit.ICallbackFunction): void {
+	//            callback();
+	//        },
+	//        test1: function (test: nodeunit.Test): void {
+	//            test.done();
+	//        }
+	//    }
+	//    exports.testgroup = testGroup;
+
+	export interface ITestBody {
+		(callback: Test): void;
+	}
+
+	export interface ITestGroup {
+		setUp?: (callback: ICallbackFunction) => void;
+		tearDown?: (callback: ICallbackFunction) => void;
+	}
+
+	export interface ICallbackFunction {
+		(err?: any): void;
+	}
+}
+