function tree(array) {
    let treeNodes = new Map()
    let rootNode
    array.forEach((item) => {
        if (!treeNodes.has(item.c)) {
            let newNode = {
                val: item.c,
                children: []
            }
            treeNodes.set(item.c,newNode)
        }
        let childNode = treeNodes.get(item.c)
        if (!treeNodes.has(item.p)) {
            let newNode = {
                val: item.p,
                children: []
            }
            treeNodes.set(item.p,newNode)
        }
        let parentNode = treeNodes.get(item.p)
        parentNode.children.push(childNode)
    })
     
    for (let i=0; i<array.length; i++) {
      let flag = true
      for (let j=0; j<array.length; j++) {
        if (array[i].p === array[j].c) {
          flag = false
        }
      }
      if (flag) {
        rootNode = array[i].p
      }
    }
    
    return treeNodes.get(rootNode)
}
function removeDuplicate(head) {
    var curNode = head
    while(curNode) {
        var nextNode = curNode.next
        while(nextNode) {
            if(curNode.value === nextNode.value) {
                var preNode = nextNode.pre
                var nextNodeNext = nextNode.next
                preNode.next = nextNodeNext
                nextNodeNext.pre = preNode
            } else {
                nextNode = nextNode.next
            }
        }
        curNode = curNode.next
    }
}
function sizeof(obj) {
    let num = 0
    for(let key in obj){
        if (!obj[key] || typeof obj[key] !== 'object') {
            num = 
        }
        num = num + sizeof(obj[key])
    }
    return num
}

let createStore = (reducer) => {
    let state;
    //获取状态对象
    //存放所有的监听函数
    let listeners = [];
    let getState = () => state;
    //提供一个方法供外部调用派发action
    let dispath = (action) => {
        //调用管理员reducer得到新的state
        state = reducer(state, action);
        //执行所有的监听函数
        listeners.forEach((l) => l())
    }
    //订阅状态变化事件，当状态改变发生之后执行监听函数
    let subscribe = (listener) => {
        listeners.push(listener);
    }
    dispath();
    return {
        getState,
        dispath,
        subscribe
    }
}
let combineReducers=(renducers)=>{
    //传入一个renducers管理组，返回的是一个renducer
    return function(state={},action={}){
        let newState={};
        for(var attr in renducers){
            newState[attr]=renducers[attr](state[attr],action)
        }
        return newState;
    }
}
export {createStore,combineReducers};

export default function connect(mapStateToProps, mapDispatchToProps, mergeProps, options = {}) {
  return function wrapWithConnect(WrappedComponent) {
    class Connect extends Component {
      constructor(props, context) {
        // 从祖先Component处获得store
        this.store = props.store || context.store
        this.stateProps = computeStateProps(this.store, props)
        this.dispatchProps = computeDispatchProps(this.store, props)
        this.state = { storeState: null }
        // 对stateProps、dispatchProps、parentProps进行合并
        this.updateState()
      }
      shouldComponentUpdate(nextProps, nextState) {
        // 进行判断，当数据发生改变时，Component重新渲染
        if (propsChanged || mapStateProducedChange || dispatchPropsChanged) {
          this.updateState(nextProps)
            return true
          }
        }
        componentDidMount() {
          // 改变Component的state
          this.store.subscribe(() = {
            this.setState({
              storeState: this.store.getState()
            })
          })
        }
        render() {
          // 生成包裹组件Connect
          return (
            <WrappedComponent {...this.nextState} />
          )
        }
      }
      Connect.contextTypes = {
        store: storeShape
      }
      return Connect;
    }
  }

function parallaxScroll(elm, options) {
  var indicatorPosition = 0;
  var windowHeight = $window.height();
  var elHeight = elm.height();
  function loop() {
    var offsetTop = elm.offset().top;
    var scrollOffset = $window.scrollTop();
    if (scrollOffset >= offsetTop - windowHeight && scrollOffset <= offsetTop + elHeight) {
      var scrollPercent = (offsetTop - windowHeight - scrollOffset) / (windowHeight + elHeight);
      indicatorPosition += (scrollPercent - indicatorPosition) * options.factor;
      var calcOffset = indicatorPosition * options.offset;
      elm.css('background-position-y', calcOffset + 'px');
    }
    requestAnimationFrame(loop);
  }
  loop();
}

var assert = require("assert");
describe('Array', function() {
    describe('#indexOf()', function() {
        it('should return -1 when the value is not present', function() {
            assert.equal(-1, [1,2,3].indexOf(5));
            assert.equal(-1, [1,2,3].indexOf(0));
        });
    });
});

var should = require("should");
describe('Should test', function() {
    it('number', function() {
        (123).should.be.a.Number;
    });
    it('object property', function() {
        var obj = {name:'minghe',email:"minghe36@gmail.com"};
        obj.should.have.property('name','minghe');
        obj.should.have.property('email');
    });
});

var fs = require('fs');
var should = require('should');
describe('fs', function() {
    describe('#readFile()', function() {
        it('should not be null', function(done) {
            fs.readFile('./package.json', 'utf8', function(err,res){
                if (err) throw err;
                res.should.not.equal(null);
                done();
            });
        });
    });
});

var superagent = require('supertest');
var app = require('../app');
function request() {
    return superagent(app.listen());
}
describe('Routes', function () {
    describe('GET /', function () {
        it('should return 200', function (done) {
            request()
                .get('/')
                .expect(200, done);
        });
    });
});

request()
    .get('/')
    .expect(200, done);

request()
    .get('/')
    .expect(200)
    .end(function(err, res){
        if (err) return done(err);
        done();
    });

app.get('/api/user/:id',function *(){
    var user = {name:'minghe',email:'minghe36@gmail.com'};
    user = JSON.stringify(user);
    this.body = user;
})

it('should be json',function(done){
    request()
        .get('/api/user/1')
        .expect(200)
        .end(function(err, res){
            if (err) return done(err);
            var text = res.text;
            var json = JSON.parse(text);
            json.should.have.property('email');
            json.should.have.property('minghe');
            done();
        });
})

request()
    .get('/')
    .set('Accept', 'application/json')
    .expect('Content-Type', /json/)