Template Upload

node_modules/reflect-metadata/test/harness.ts

@@ -0,0 +1,40 @@
+export interface TestResults {
+    passed: string[];
+    failed: [string, any][];
+}
+
+export function runTests(fixture: any): TestResults {
+    let results: TestResults = { passed: [], failed: [] };
+    for (let testName in fixture) {
+        let test = fixture[testName];
+        if (typeof test === "function") {
+            try {
+                test();
+                results.passed.push(testName);
+            }
+            catch (e) {
+                results.failed.push([testName, e]);
+            }
+        }
+    }
+    return results;
+}
+
+export function printResults(results: TestResults): void {
+    for (let [testName, error] of results.failed) {
+        let message = "stack" in error ? error.stack : String(error);
+        console.error(`${testName} failed.\n${message}`);
+    }
+
+    let passedCount = results.passed.length;
+    let failedCount = results.failed.length;
+    let totalCount = passedCount + failedCount;
+
+    let message = `Run ${failedCount > 0 ? "failed" : "succeeded" }: passed: ${passedCount}, failed: ${failedCount}, total: ${totalCount}.`;
+    if (results.failed.length) {
+        console.error(message);
+    }
+    else {
+        console.log(message);
+    }
+}

node_modules/reflect-metadata/test/reflect/reflect-decorate.ts

@@ -0,0 +1,208 @@
+// Reflect.decorate ( decorators, target [, propertyKey [, descriptor] ] )
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectDecorateThrowsIfDecoratorsArgumentNotArrayForFunctionOverload() {
+    let target = function() { };
+    assert.throws(() => Reflect.decorate(undefined, target, undefined, undefined), TypeError);
+}
+
+export function ReflectDecorateThrowsIfTargetArgumentNotFunctionForFunctionOverload() {
+    let decorators: (ClassDecorator | MethodDecorator | PropertyDecorator)[] = [];
+    let target = {};
+    assert.throws(() => Reflect.decorate(decorators, target, undefined, undefined), TypeError);
+}
+
+export function ReflectDecorateThrowsIfDecoratorsArgumentNotArrayForPropertyOverload() {
+    let target = {};
+    let name = "name";
+    assert.throws(() => Reflect.decorate(undefined, target, name, undefined), TypeError);
+}
+
+export function ReflectDecorateThrowsIfTargetArgumentNotObjectForPropertyOverload() {
+    let decorators: (ClassDecorator | MethodDecorator | PropertyDecorator)[] = [];
+    let target = 1;
+    let name = "name";
+    assert.throws(() => Reflect.decorate(decorators, target, name, undefined), TypeError);
+}
+
+export function ReflectDecorateThrowsIfDecoratorsArgumentNotArrayForPropertyDescriptorOverload() {
+    let target = {};
+    let name = "name";
+    let descriptor = {};
+    assert.throws(() => Reflect.decorate(undefined, target, name, descriptor), TypeError);
+}
+
+export function ReflectDecorateThrowsIfTargetArgumentNotObjectForPropertyDescriptorOverload() {
+    let decorators: (ClassDecorator | MethodDecorator | PropertyDecorator)[] = [];
+    let target = 1;
+    let name = "name";
+    let descriptor = {};
+    assert.throws(() => Reflect.decorate(decorators, target, name, descriptor), TypeError);
+}
+
+export function ReflectDecorateExecutesDecoratorsInReverseOrderForFunctionOverload() {
+    let order: number[] = [];
+    let decorators = [
+        (target: Function): void => { order.push(0); },
+        (target: Function): void => { order.push(1); }
+    ];
+    let target = function() { };
+    Reflect.decorate(decorators, target);
+    assert.deepEqual(order, [1, 0]);
+}
+
+export function ReflectDecorateExecutesDecoratorsInReverseOrderForPropertyOverload() {
+    let order: number[] = [];
+    let decorators = [
+        (target: Object, name: string | symbol): void => { order.push(0); },
+        (target: Object, name: string | symbol): void => { order.push(1); }
+    ];
+    let target = {};
+    let name = "name";
+    Reflect.decorate(decorators, target, name, undefined);
+    assert.deepEqual(order, [1, 0]);
+}
+
+export function ReflectDecorateExecutesDecoratorsInReverseOrderForPropertyDescriptorOverload() {
+    let order: number[] = [];
+    let decorators = [
+        (target: Object, name: string | symbol): void => { order.push(0); },
+        (target: Object, name: string | symbol): void => { order.push(1); }
+    ];
+    let target = {};
+    let name = "name";
+    let descriptor = {};
+    Reflect.decorate(decorators, target, name, descriptor);
+    assert.deepEqual(order, [1, 0]);
+}
+
+export function ReflectDecoratorPipelineForFunctionOverload() {
+    let A = function A(): void { };
+    let B = function B(): void { };
+    let decorators = [
+        (target: Function): any => { return undefined; },
+        (target: Function): any => { return A; },
+        (target: Function): any => { return B; }
+    ];
+    let target = function (): void { };
+    let result = Reflect.decorate(decorators, target);
+    assert.strictEqual(result, A);
+}
+
+export function ReflectDecoratorPipelineForPropertyOverload() {
+    let A = {};
+    let B = {};
+    let decorators = [
+        (target: Object, name: string | symbol): any => { return undefined; },
+        (target: Object, name: string | symbol): any => { return A; },
+        (target: Object, name: string | symbol): any => { return B; }
+    ];
+    let target = {};
+    let result = Reflect.decorate(decorators, target, "name", undefined);
+    assert.strictEqual(result, undefined);
+}
+
+export function ReflectDecoratorPipelineForPropertyDescriptorOverload() {
+    let A = {};
+    let B = {};
+    let C = {};
+    let decorators = [
+        (target: Object, name: string | symbol): any => { return undefined; },
+        (target: Object, name: string | symbol): any => { return A; },
+        (target: Object, name: string | symbol): any => { return B; }
+    ];
+    let target = {};
+    let result = Reflect.decorate(decorators, target, "name", C);
+    assert.strictEqual(result, A);
+}
+
+export function ReflectDecoratorCorrectTargetInPipelineForFunctionOverload() {
+    let sent: Function[] = [];
+    let A = function A(): void { };
+    let B = function B(): void { };
+    let decorators = [
+        (target: Function): any => { sent.push(target); return undefined; },
+        (target: Function): any => { sent.push(target); return undefined; },
+        (target: Function): any => { sent.push(target); return A; },
+        (target: Function): any => { sent.push(target); return B; }
+    ];
+    let target = function (): void { };
+    Reflect.decorate(decorators, target);
+    assert.deepEqual(sent, [target, B, A, A]);
+}
+
+export function ReflectDecoratorCorrectTargetInPipelineForPropertyOverload() {
+    let sent: Object[] = [];
+    let decorators = [
+        (target: Object, name: string | symbol): any => { sent.push(target); },
+        (target: Object, name: string | symbol): any => { sent.push(target); },
+        (target: Object, name: string | symbol): any => { sent.push(target); },
+        (target: Object, name: string | symbol): any => { sent.push(target); }
+    ];
+    let target = { };
+    Reflect.decorate(decorators, target, "name");
+    assert.deepEqual(sent, [target, target, target, target]);
+}
+
+export function ReflectDecoratorCorrectNameInPipelineForPropertyOverload() {
+    let sent: (symbol | string)[] = [];
+    let decorators = [
+        (target: Object, name: string | symbol): any => { sent.push(name); },
+        (target: Object, name: string | symbol): any => { sent.push(name); },
+        (target: Object, name: string | symbol): any => { sent.push(name); },
+        (target: Object, name: string | symbol): any => { sent.push(name); }
+    ];
+    let target = { };
+    Reflect.decorate(decorators, target, "name");
+    assert.deepEqual(sent, ["name", "name", "name", "name"]);
+}
+
+export function ReflectDecoratorCorrectTargetInPipelineForPropertyDescriptorOverload() {
+    let sent: Object[] = [];
+    let A = { };
+    let B = { };
+    let C = { };
+    let decorators = [
+        (target: Object, name: string | symbol): any => { sent.push(target); return undefined; },
+        (target: Object, name: string | symbol): any => { sent.push(target); return undefined; },
+        (target: Object, name: string | symbol): any => { sent.push(target); return A; },
+        (target: Object, name: string | symbol): any => { sent.push(target); return B; }
+    ];
+    let target = { };
+    Reflect.decorate(decorators, target, "name", C);
+    assert.deepEqual(sent, [target, target, target, target]);
+}
+
+export function ReflectDecoratorCorrectNameInPipelineForPropertyDescriptorOverload() {
+    let sent: (symbol | string)[] = [];
+    let A = { };
+    let B = { };
+    let C = { };
+    let decorators = [
+        (target: Object, name: string | symbol): any => { sent.push(name); return undefined; },
+        (target: Object, name: string | symbol): any => { sent.push(name); return undefined; },
+        (target: Object, name: string | symbol): any => { sent.push(name); return A; },
+        (target: Object, name: string | symbol): any => { sent.push(name); return B; }
+    ];
+    let target = { };
+    Reflect.decorate(decorators, target, "name", C);
+    assert.deepEqual(sent, ["name", "name", "name", "name"]);
+}
+
+export function ReflectDecoratorCorrectDescriptorInPipelineForPropertyDescriptorOverload() {
+    let sent: PropertyDescriptor[] = [];
+    let A = { };
+    let B = { };
+    let C = { };
+    let decorators = [
+        (target: Object, name: string | symbol, descriptor: PropertyDescriptor): any => { sent.push(descriptor); return undefined; },
+        (target: Object, name: string | symbol, descriptor: PropertyDescriptor): any => { sent.push(descriptor); return undefined; },
+        (target: Object, name: string | symbol, descriptor: PropertyDescriptor): any => { sent.push(descriptor); return A; },
+        (target: Object, name: string | symbol, descriptor: PropertyDescriptor): any => { sent.push(descriptor); return B; }
+    ];
+    let target = { };
+    Reflect.decorate(decorators, target, "name", C);
+    assert.deepEqual(sent, [C, B, A, A]);
+}

node_modules/reflect-metadata/test/reflect/reflect-definemetadata.ts

@@ -0,0 +1,17 @@
+// Reflect.defineMetadata ( metadataKey, metadataValue, target, propertyKey )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflectdefinemetadata--metadatakey-metadatavalue-target-propertykey-    
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectDefineMetadataInvalidTarget() {
+    assert.throws(() => Reflect.defineMetadata("key", "value", undefined, undefined), TypeError);
+}
+
+export function ReflectDefineMetadataValidTargetWithoutTargetKey() {
+    assert.doesNotThrow(() => Reflect.defineMetadata("key", "value", { }, undefined));
+}
+
+export function ReflectDefineMetadataValidTargetWithTargetKey() {
+    assert.doesNotThrow(() => Reflect.defineMetadata("key", "value", { }, "name"));
+}

node_modules/reflect-metadata/test/reflect/reflect-deletemetadata.ts

@@ -0,0 +1,38 @@
+// Reflect.deleteMetadata ( metadataKey, target [, propertyKey] )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflectdeletemetadata--metadatakey-target--propertykey-
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectDeleteMetadataInvalidTarget() {
+    assert.throws(() => Reflect.deleteMetadata("key", undefined, undefined), TypeError);
+}
+
+export function ReflectDeleteMetadataWhenNotDefinedWithoutTargetKey() {
+    let obj = {};
+    let result = Reflect.deleteMetadata("key", obj, undefined);
+    assert.equal(result, false);
+}
+
+export function ReflectDeleteMetadataWhenDefinedWithoutTargetKey() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, undefined);
+    let result = Reflect.deleteMetadata("key", obj, undefined);
+    assert.equal(result, true);
+}
+
+export function ReflectDeleteMetadataWhenDefinedOnPrototypeWithoutTargetKey() {
+    let prototype = {};
+    Reflect.defineMetadata("key", "value", prototype, undefined);
+    let obj = Object.create(prototype);
+    let result = Reflect.deleteMetadata("key", obj, undefined);
+    assert.equal(result, false);
+}
+
+export function ReflectHasOwnMetadataAfterDeleteMetadata() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, undefined);
+    Reflect.deleteMetadata("key", obj, undefined);
+    let result = Reflect.hasOwnMetadata("key", obj, undefined);
+    assert.equal(result, false);
+}

node_modules/reflect-metadata/test/reflect/reflect-getmetadata.ts

@@ -0,0 +1,51 @@
+// Reflect.getMetadata ( metadataKey, target [, propertyKey] )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflectgetmetadata--metadatakey-target--propertykey-
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectGetMetadataInvalidTarget() {
+    assert.throws(() => Reflect.getMetadata("key", undefined, undefined), TypeError);
+}
+
+export function ReflectGetMetadataWithoutTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.getMetadata("key", obj, undefined);
+    assert.equal(result, undefined);
+}
+
+export function ReflectGetMetadataWithoutTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, undefined);
+    let result = Reflect.getMetadata("key", obj, undefined);
+    assert.equal(result, "value");
+}
+
+export function ReflectGetMetadataWithoutTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, undefined);
+    let result = Reflect.getMetadata("key", obj, undefined);
+    assert.equal(result, "value");
+}
+
+export function ReflectGetMetadataWithTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.getMetadata("key", obj, "name");
+    assert.equal(result, undefined);
+}
+
+export function ReflectGetMetadataWithTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, "name");
+    let result = Reflect.getMetadata("key", obj, "name");
+    assert.equal(result, "value");
+}
+
+export function ReflectGetMetadataWithTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, "name");
+    let result = Reflect.getMetadata("key", obj, "name");
+    assert.equal(result, "value");
+}

node_modules/reflect-metadata/test/reflect/reflect-getmetadatakeys.ts

@@ -0,0 +1,98 @@
+// Reflect.getMetadataKeys ( target [, propertyKey] )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflectgetmetadatakeys--target--propertykey-
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectGetMetadataKeysInvalidTarget() {
+    // 1. If Type(target) is not Object, throw a TypeError exception.
+    assert.throws(() => Reflect.getMetadataKeys(undefined, undefined), TypeError);
+}
+
+export function ReflectGetMetadataKeysWithoutTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.getMetadataKeys(obj, undefined);
+    assert.deepEqual(result, []);
+}
+
+export function ReflectGetMetadataKeysWithoutTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, undefined);
+    let result = Reflect.getMetadataKeys(obj, undefined);
+    assert.deepEqual(result, ["key"]);
+}
+
+export function ReflectGetMetadataKeysWithoutTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, undefined);
+    let result = Reflect.getMetadataKeys(obj, undefined);
+    assert.deepEqual(result, ["key"]);
+}
+
+export function ReflectGetMetadataKeysOrderWithoutTargetKey() {
+    let obj = {};
+    Reflect.defineMetadata("key1", "value", obj, undefined);
+    Reflect.defineMetadata("key0", "value", obj, undefined);
+    let result = Reflect.getMetadataKeys(obj, undefined);
+    assert.deepEqual(result, ["key1", "key0"]);
+}
+
+export function ReflectGetMetadataKeysOrderAfterRedefineWithoutTargetKey() {
+    let obj = {};
+    Reflect.defineMetadata("key1", "value", obj, undefined);
+    Reflect.defineMetadata("key0", "value", obj, undefined);
+    Reflect.defineMetadata("key1", "value", obj, undefined);
+    let result = Reflect.getMetadataKeys(obj, undefined);
+    assert.deepEqual(result, ["key1", "key0"]);
+}
+
+export function ReflectGetMetadataKeysOrderWithoutTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    Reflect.defineMetadata("key2", "value", prototype, undefined);
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key1", "value", obj, undefined);
+    Reflect.defineMetadata("key0", "value", obj, undefined);
+    let result = Reflect.getMetadataKeys(obj, undefined);
+    assert.deepEqual(result, ["key1", "key0", "key2"]);
+}
+
+export function ReflectGetMetadataKeysWithTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.getMetadataKeys(obj, "name");
+    assert.deepEqual(result, []);
+}
+
+export function ReflectGetMetadataKeysWithTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, "name");
+    let result = Reflect.getMetadataKeys(obj, "name");
+    assert.deepEqual(result, ["key"]);
+}
+
+export function ReflectGetMetadataKeysWithTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, "name");
+    let result = Reflect.getMetadataKeys(obj, "name");
+    assert.deepEqual(result, ["key"]);
+}
+
+export function ReflectGetMetadataKeysOrderAfterRedefineWithTargetKey() {
+    let obj = {};
+    Reflect.defineMetadata("key1", "value", obj, "name");
+    Reflect.defineMetadata("key0", "value", obj, "name");
+    Reflect.defineMetadata("key1", "value", obj, "name");
+    let result = Reflect.getMetadataKeys(obj, "name");
+    assert.deepEqual(result, ["key1", "key0"]);
+}
+
+export function ReflectGetMetadataKeysOrderWithTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    Reflect.defineMetadata("key2", "value", prototype, "name");
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key1", "value", obj, "name");
+    Reflect.defineMetadata("key0", "value", obj, "name");
+    let result = Reflect.getMetadataKeys(obj, "name");
+    assert.deepEqual(result, ["key1", "key0", "key2"]);
+}

node_modules/reflect-metadata/test/reflect/reflect-getownmetadata.ts

@@ -0,0 +1,51 @@
+// Reflect.getOwnMetadata ( metadataKey, target [, propertyKey] )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflectgetownmetadata--metadatakey-target--propertykey-
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectGetOwnMetadataInvalidTarget() {
+    assert.throws(() => Reflect.getOwnMetadata("key", undefined, undefined), TypeError);
+}
+
+export function ReflectGetOwnMetadataWithoutTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.getOwnMetadata("key", obj, undefined);
+    assert.equal(result, undefined);
+}
+
+export function ReflectGetOwnMetadataWithoutTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, undefined);
+    let result = Reflect.getOwnMetadata("key", obj, undefined);
+    assert.equal(result, "value");
+}
+
+export function ReflectGetOwnMetadataWithoutTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, undefined);
+    let result = Reflect.getOwnMetadata("key", obj, undefined);
+    assert.equal(result, undefined);
+}
+
+export function ReflectGetOwnMetadataWithTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.getOwnMetadata("key", obj, "name");
+    assert.equal(result, undefined);
+}
+
+export function ReflectGetOwnMetadataWithTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, "name");
+    let result = Reflect.getOwnMetadata("key", obj, "name");
+    assert.equal(result, "value");
+}
+
+export function ReflectGetOwnMetadataWithTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, "name");
+    let result = Reflect.getOwnMetadata("key", obj, "name");
+    assert.equal(result, undefined);
+}

node_modules/reflect-metadata/test/reflect/reflect-getownmetadatakeys.ts

@@ -0,0 +1,78 @@
+// Reflect.getOwnMetadataKeysKeys ( target [, propertyKey] )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflectgetownmetadatakeyskeys--target--propertykey-
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectGetOwnMetadataKeysKeysInvalidTarget() {
+    // 1. If Type(target) is not Object, throw a TypeError exception.
+    assert.throws(() => Reflect.getOwnMetadataKeys(undefined, undefined), TypeError);
+}
+
+export function ReflectGetOwnMetadataKeysWithoutTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.getOwnMetadataKeys(obj, undefined);
+    assert.deepEqual(result, []);
+}
+
+export function ReflectGetOwnMetadataKeysWithoutTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, undefined);
+    let result = Reflect.getOwnMetadataKeys(obj, undefined);
+    assert.deepEqual(result, ["key"]);
+}
+
+export function ReflectGetOwnMetadataKeysWithoutTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, undefined);
+    let result = Reflect.getOwnMetadataKeys(obj, undefined);
+    assert.deepEqual(result, []);
+}
+
+export function ReflectGetOwnMetadataKeysOrderWithoutTargetKey() {
+    let obj = {};
+    Reflect.defineMetadata("key1", "value", obj, undefined);
+    Reflect.defineMetadata("key0", "value", obj, undefined);
+    let result = Reflect.getOwnMetadataKeys(obj, undefined);
+    assert.deepEqual(result, ["key1", "key0"]);
+}
+
+export function ReflectGetOwnMetadataKeysOrderAfterRedefineWithoutTargetKey() {
+    let obj = {};
+    Reflect.defineMetadata("key1", "value", obj, undefined);
+    Reflect.defineMetadata("key0", "value", obj, undefined);
+    Reflect.defineMetadata("key1", "value", obj, undefined);
+    let result = Reflect.getOwnMetadataKeys(obj, undefined);
+    assert.deepEqual(result, ["key1", "key0"]);
+}
+
+export function ReflectGetOwnMetadataKeysWithTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.getOwnMetadataKeys(obj, "name");
+    assert.deepEqual(result, []);
+}
+
+export function ReflectGetOwnMetadataKeysWithTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, "name");
+    let result = Reflect.getOwnMetadataKeys(obj, "name");
+    assert.deepEqual(result, ["key"]);
+}
+
+export function ReflectGetOwnMetadataKeysWithTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, "name");
+    let result = Reflect.getOwnMetadataKeys(obj, "name");
+    assert.deepEqual(result, []);
+}
+
+export function ReflectGetOwnMetadataKeysOrderAfterRedefineWithTargetKey() {
+    let obj = {};
+    Reflect.defineMetadata("key1", "value", obj, "name");
+    Reflect.defineMetadata("key0", "value", obj, "name");
+    Reflect.defineMetadata("key1", "value", obj, "name");
+    let result = Reflect.getOwnMetadataKeys(obj, "name");
+    assert.deepEqual(result, ["key1", "key0"]);
+}

node_modules/reflect-metadata/test/reflect/reflect-hasmetadata.ts

@@ -0,0 +1,51 @@
+// Reflect.hasMetadata ( metadataKey, target [, propertyKey] )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflecthasmetadata--metadatakey-target--propertykey-
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectHasMetadataInvalidTarget() {
+    assert.throws(() => Reflect.hasMetadata("key", undefined, undefined), TypeError);
+}
+
+export function ReflectHasMetadataWithoutTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.hasMetadata("key", obj, undefined);
+    assert.equal(result, false);
+}
+
+export function ReflectHasMetadataWithoutTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, undefined);
+    let result = Reflect.hasMetadata("key", obj, undefined);
+    assert.equal(result, true);
+}
+
+export function ReflectHasMetadataWithoutTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, undefined);
+    let result = Reflect.hasMetadata("key", obj, undefined);
+    assert.equal(result, true);
+}
+
+export function ReflectHasMetadataWithTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.hasMetadata("key", obj, "name");
+    assert.equal(result, false);
+}
+
+export function ReflectHasMetadataWithTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, "name");
+    let result = Reflect.hasMetadata("key", obj, "name");
+    assert.equal(result, true);
+}
+
+export function ReflectHasMetadataWithTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, "name");
+    let result = Reflect.hasMetadata("key", obj, "name");
+    assert.equal(result, true);
+}

node_modules/reflect-metadata/test/reflect/reflect-hasownmetadata.ts

@@ -0,0 +1,51 @@
+// Reflect.hasOwnMetadata ( metadataKey, target [, propertyKey] )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflecthasownmetadata--metadatakey-target--propertykey-
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectHasOwnMetadataInvalidTarget() {
+    assert.throws(() => Reflect.hasOwnMetadata("key", undefined, undefined), TypeError);
+}
+
+export function ReflectHasOwnMetadataWithoutTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.hasOwnMetadata("key", obj, undefined);
+    assert.equal(result, false);
+}
+
+export function ReflectHasOwnMetadataWithoutTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, undefined);
+    let result = Reflect.hasOwnMetadata("key", obj, undefined);
+    assert.equal(result, true);
+}
+
+export function ReflectHasOwnMetadataWithoutTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, undefined);
+    let result = Reflect.hasOwnMetadata("key", obj, undefined);
+    assert.equal(result, false);
+}
+
+export function ReflectHasOwnMetadataWithTargetKeyWhenNotDefined() {
+    let obj = {};
+    let result = Reflect.hasOwnMetadata("key", obj, "name");
+    assert.equal(result, false);
+}
+
+export function ReflectHasOwnMetadataWithTargetKeyWhenDefined() {
+    let obj = {};
+    Reflect.defineMetadata("key", "value", obj, "name");
+    let result = Reflect.hasOwnMetadata("key", obj, "name");
+    assert.equal(result, true);
+}
+
+export function ReflectHasOwnMetadataWithTargetKeyWhenDefinedOnPrototype() {
+    let prototype = {};
+    let obj = Object.create(prototype);
+    Reflect.defineMetadata("key", "value", prototype, "name");
+    let result = Reflect.hasOwnMetadata("key", obj, "name");
+    assert.equal(result, false);
+}

node_modules/reflect-metadata/test/reflect/reflect-metadata.ts

@@ -0,0 +1,38 @@
+// Reflect.metadata ( metadataKey, metadataValue )
+// - https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#reflectmetadata--metadatakey-metadatavalue-
+
+import "../../Reflect";
+import * as assert from "assert";
+
+export function ReflectMetadataReturnsDecoratorFunction() {
+    let result = Reflect.metadata("key", "value");
+    assert.equal(typeof result, "function");
+}
+
+export function ReflectMetadataDecoratorThrowsWithInvalidTargetWithTargetKey() {
+    let decorator = Reflect.metadata("key", "value");
+    assert.throws(() => decorator(undefined, "name"), TypeError);
+}
+
+export function ReflectMetadataDecoratorThrowsWithInvalidTargetWithoutTargetKey() {
+    let decorator = Reflect.metadata("key", "value");
+    assert.throws(() => decorator({}, undefined), TypeError);
+}
+
+export function ReflectMetadataDecoratorSetsMetadataOnTargetWithoutTargetKey() {
+    let decorator = Reflect.metadata("key", "value");
+    let target = function () {}
+    decorator(target);
+
+    let result = Reflect.hasOwnMetadata("key", target, undefined);
+    assert.equal(result, true);
+}
+
+export function ReflectMetadataDecoratorSetsMetadataOnTargetWithTargetKey() {
+    let decorator = Reflect.metadata("key", "value");
+    let target = {}
+    decorator(target, "name");
+
+    let result = Reflect.hasOwnMetadata("key", target, "name");
+    assert.equal(result, true);
+}

node_modules/reflect-metadata/test/run.ts

@@ -0,0 +1,5 @@
+import { runTests, printResults } from './harness';
+import * as spec from "./spec";
+
+let results = runTests(spec);
+printResults(results);

node_modules/reflect-metadata/test/spec.ts

@@ -0,0 +1,10 @@
+export * from "./reflect/reflect-decorate";
+export * from "./reflect/reflect-metadata";
+export * from "./reflect/reflect-definemetadata";
+export * from "./reflect/reflect-hasownmetadata";
+export * from "./reflect/reflect-hasmetadata";
+export * from "./reflect/reflect-getownmetadata";
+export * from "./reflect/reflect-getmetadata";
+export * from "./reflect/reflect-getownmetadatakeys";
+export * from "./reflect/reflect-getmetadatakeys";
+export * from "./reflect/reflect-deletemetadata";

node_modules/reflect-metadata/test/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "noImplicitAny": true,
+    "sourceMap": true,
+    "module": "commonjs",
+    "outDir": "../temp/"
+  },
+  "files": [
+    "../Reflect.ts",
+    "../typings/node.d.ts",
+    "reflect/reflect-decorate.ts",
+    "reflect/reflect-metadata.ts",
+    "reflect/reflect-definemetadata.ts",
+    "reflect/reflect-hasownmetadata.ts",
+    "reflect/reflect-hasmetadata.ts",
+    "reflect/reflect-getownmetadata.ts",
+    "reflect/reflect-getmetadata.ts",
+    "reflect/reflect-getownmetadatakeys.ts",
+    "reflect/reflect-getmetadatakeys.ts",
+    "reflect/reflect-deletemetadata.ts",
+    "harness.ts",
+    "spec.ts",
+    "run.ts"
+  ]
+}