add some test

Author: hopperhuang

README.md

@@ -33,6 +33,10 @@ npm test
 8.	[Symbol](./test/symbol.js)
 9.	[Set and Map](./test/setAndMap.js)
 10.	[proxy](./test/proxy.js)
+11. [reflect](./test/reflect.js)
+12.	[Promise](./test/promise.js)
+13. [Iterator](./test/iterator.js)
+14.	[Generator](./test/generator.js)
 
 
 Babel

test/another.txt

@@ -0,0 +1 @@
+another

test/generator.js

@@ -0,0 +1,85 @@
+import {expect,assert} from 'chai';
+import 'babel-polyfill';
+describe("test generator",function(){
+	it('initialize genartor',function(){
+		function* generator(){
+			yield 1;
+			yield 2;
+			yield 3;
+		}
+		let testGenerator = generator();
+		expect(testGenerator instanceof generator).to.equal(true);
+	});
+	it('iterator is implied in generator instance',function(){
+		function* generator(){
+			yield 1;
+			yield 2;
+			yield 3;
+		}
+		let testGenerator = generator();
+		let testObject = [...testGenerator];
+		expect(testObject).to.deep.equal([1,2,3]);
+	});
+	it('test next method',function(){
+		let testArray = [];
+		function* generator(){
+			yield testArray.push(1);
+			yield testArray.push(2);
+			yield testArray.push(3);
+		}
+		let testGenerator = generator();
+		testGenerator.next();
+		expect(testArray).to.deep.equal([1]);
+	});
+	it('next method wiht param',function(){// the param will become the yield value before one
+		let testArray = [];
+		function* generator(){
+			let number = yield 1;
+			testArray.push(number);
+		}
+		let testGenerator = generator();
+		testGenerator.next();
+		testGenerator.next(1);
+		expect(testArray).to.deep.equal([1]);
+	});
+	it('Generator.prototype.throw',function(){
+		function* generator(){
+			try{
+				yield;
+			}	catch(error){//catch error in the generator
+				expect(error).to.equal('test error');
+			}
+			
+		}
+		let testGenerator = generator();
+		testGenerator.next();
+		testGenerator.throw('test error');//you can throw an error by yourself;
+		// when you thorw an error,the Generator.prototype.next will be invoked at the same time
+		// the process above like this; g.next() ==> g.throw() ==> (  g.next() ===> catch error in generator   )
+	});
+	it('Generator,prototype.return',function(){ //when the return value was invoked ,the return value will be {value:undefied,done:false}
+		function* generator(){
+			yield 1;
+			yield 2;
+			yield 3;
+		}
+		let testGenerator = generator();
+		testGenerator.next();
+		expect(testGenerator.return()).to.deep.equal({value:undefined,done:true});
+	});
+	it('yield* ',function(){//use yield* syntax you can call another generator function 
+		function* firstGenerator(){
+			yield 1;
+			yield 2;
+			yield 3;
+			yield 4;
+		}
+		function* secondGenerator(){
+			yield* firstGenerator();
+			yield 5;
+			yield 6;
+		}
+		let testGenerator = secondGenerator();
+		expect(testGenerator.next()).to.deep.equal({value:1,done:false});
+	});
+});

test/iterator.js

@@ -0,0 +1,59 @@
+import { expect, assert } from 'chai';
+import 'babel-polyfill';
+describe('test iterator', function() {//iterator on object
+	it('object iterator', function() {
+		let testObject = {
+			data: [1, 2, 3],
+			[Symbol.iterator]: function() {
+				let current = 0;
+				let self = this;
+				return {//return an object contains next method
+					next: function() {
+						if(current < self.data.length) {
+							return { value: self.data[current++], done: false };
+						} else {
+							return { value: undefined, done: true }
+						}
+					}
+				};
+			}
+		};
+		let testArray = [];
+		for(let value of testObject) {
+			testArray.push(value);
+		}
+		expect(testArray).to.deep.equal([1,2,3]);
+	});
+	it('constructor iterator',function(){
+		function TestIterator(start,stop){ //set iterator to a constructor
+			this.value = start;
+			this.stop = stop;
+			this[Symbol.iterator] = function(){
+				return this;
+			};
+			let self = this;
+			this.next = (function(){
+				return function(){
+					if(self.value <= self.stop){
+						let result = {value:self.value,done:false};
+						self.value++;
+						return result;
+					}	else {
+						return {value:undefined,done:true};
+					}
+				}
+			})();
+		}
+		let testObject = new TestIterator(1,3);
+		let testArray = [];
+		for(let value of testObject){
+			testArray.push(value);
+		}
+		expect(testArray).to.deep.equal([1,2,3]);
+	});
+	it('take iterator from Array',function(){
+		let testArray = [1,2,3];
+		let iterator = testArray[Symbol.iterator]();
+		expect(iterator.next().value).to.equal(1);
+	});
+});

test/promise.js

@@ -0,0 +1,59 @@
+import {expect,assert} from 'chai';
+import 'babel-polyfill';
+import fs from 'fs';
+describe('test Promise',function(){
+	it('Promise',function(){
+		let testPromise = new Promise(function(resolve,reject){
+			let string = 'xiaoming';
+			resolve(string);
+		});
+		return testPromise.then(function(data){ //when test promise you should return a promise object in the test
+			expect(data).to.equal('xiaoming');
+		});
+	});
+	it('Promise.prototype.then',function(){
+		let testPromise = new Promise(function(resolve,reject){
+			fs.readFile(__dirname + '/test.txt',function(error,buffer){
+				resolve(buffer.toString());
+			});
+		});
+		return testPromise.then(function(data){
+			expect(data).to.be.equal('test');
+		});
+	});
+	it('Promise.prototype.catch',function(){
+		let testPromise = new Promise(function(resole,reject){
+			reject(new Error('an error'));
+		});
+		return testPromise.catch(function(error){
+			expect(error.message).to.equal('an error');
+		});
+	});
+	it('Promise.resolve',function(){
+		let data = new Promise(function(resolve,reject){
+			fs.readFile(__dirname + '/test.txt',function(error,buffer){
+				resolve(buffer.toString());
+			});
+		});
+		let testPromise = Promise.resolve(data);
+		return testPromise.then(function(data){
+			expect(data).to.equal('test');
+		});
+	});
+	it('Promise.all',function(){
+		let testdata = new Promise(function(resolve,reject){
+			fs.readFile(__dirname + '/test.txt',function(error,buffer){
+				resolve(buffer.toString());
+			});
+		});
+		let anotherdata = new Promise(function(resolve,reject){
+			fs.readFile(__dirname + '/another.txt',function(error,buffer){
+				resolve(buffer.toString());
+			});
+		});
+		return Promise.all([testdata,anotherdata]).then(function(data){
+			expect(data[0]).to.equal('test');
+			expect(data[1]).to.equal('another');
+		});
+	});
+});

test/reflect.js

@@ -0,0 +1,29 @@
+import {expect,assert} from 'chai';
+import 'babel-polyfill';
+describe('reflect',function(){
+	it('Reflect.constructor',function(){
+		function Man(name,age){
+			this.name = name;
+			this.age = age;
+		}
+		let xiaoming = Reflect.construct(Man,['xiaoming',20]);
+		expect(xiaoming.name).to.equal('xiaoming');
+	});
+	it('Reflect.apply',function(){
+		function add(firstNumber,secondNumber){
+			return firstNumber + secondNumber;
+		}
+		let result = Reflect.apply(add,null,[1,2]);
+		expect(result).to.be.equal(3);
+	});
+	it('Reflect.set',function(){
+		let xiaoming = {};
+		Reflect.set(xiaoming,'name','xiaoming');
+		expect(xiaoming.name).to.equal('xiaoming')
+	});
+
+	it('Reflect.get',function(){
+		let xiaoming = {name:'xiaoming'};
+		expect(Reflect.get(xiaoming,'name')).to.equal('xiaoming');
+	});
+});

test/test.txt

@@ -0,0 +1 @@
+test