var assert = require('chai').assert;
var numbers = [1, 2, 3, 4, 5];

assert.isArray(numbers, 'is array of numbers');
assert.include(numbers, 2, 'array contains 2');
assert.lengthOf(numbers, 5, 'array contains 5 numbers');

var expect = require('chai').expect;
var numbers = [1, 2, 3, 4, 5];

expect(numbers).to.be.an('array').that.includes(2);
expect(numbers).to.have.lengthOf(5);

var should = require('chai').should();
var numbers = [1, 2, 3, 4, 5];

numbers.should.be.an('array').that.includes(2);
numbers.should.have.lengthOf(5);

// 开始一个或多个测试套件
describe('#sum()', function() {
    // 添加一个测试 hook
    beforeEach(function() {
        // ... 每次测试前执行的一些逻辑
    })

    // 测试功能
    it('should add numbers', function() {
        // 添加一个断言
        expect(sum(1, 2, 3, 4, 5)).to.equal(15);
    })

    // ... 更多测试
})

/* test/sum.js */

var sum = require('../sum');
var expect = require('chai').expect;

describe('#sum', function () {
    context('whitout arguments', function () {
        it('should return 0', function () {
            expect(sum()).to.equal(0);
        })
    })

    context('with number arguments', function () {
        it('should return sum of arguments', function () {
            expect(sum(1, 2, 3, 4, 5)).to.equal(15);
        })

        it('should return argument when only one argument is passed', function() {
            expect(sum(5)).to.equal(5);
        })
    })

    context('with non-number arguments', function() {
        it('should throw error', function() {
            expect(function() {
                sum(1, 2, '3', [4], 5)
            }).to.throw(TypeError, 'sum() expects only numbers.');
        })
    })
})

module.exports = function () {
    // 将参数对象转换成数组
    var args = Array.prototype.slice.call(arguments);

    // 如果参数数组中包含非数字参数，抛出 TypeError 错误
    if (!args.every(Number.isFinite)) {
        throw new TypeError('sum() expects only numbers.');
    }

    // 返回所有参数的和
    return args.reduce(function (a, b) {
        return a + b;
    }, 0);
}

it('test expectation', function(done) {
    // 测试异步代码
    // 调用 done() 终止测试并继续下一个测试
})

module.exports = function (string, callback) {
    var withCallback = typeof callback === 'function';

    try {
        var hash = crypto.createHash('md5')
            .update(string)
            .digest('hex');

        withCallback && callback(null, hash);
    } catch (e) {
        if (withCallback) {
            callback(e);
        } else {
            throw e;
        }
    }
}

/* test/md5.js */

var md5 = require('../md5');
var expect = require('chai').expect;

describe('#md5()', function() {
    context('with string argument', function() {
        it('should compute MD5 hash', function(done) {
            md5('Glad Chinda', function(err, hash) {
                // 使用 error 来调用 done() 回调函数,
                // 来终止带有错误的测试
                if (err) return done(err);

                // 添加以下断言
                expect(hash)
                    .to.be.a('string')
                    .that.matches(/^[a-f0-9]{32}$/)
                    .and.equal('877dbb93f50eb8a89012e15bd37ee7e4');
                
                // 调用 done() 回调函数来终止测试
                done();
            })
        })
    })

    context('with non-string argument', function() {
        it('should throw an error', function(done) {
            md5(12345, function(err, hash) {
                // 使用错误调用 done() 回调来终止测试
                if (err) {
                    expect(function() { throw err })
                        .to.throw(TypeError, 'The "data" argument must be one of type string, TypedArray, or DataView. Received type number');
                    
                    // 最后调用 done() 回调来终止测试并返回
                    return done();
                }

                // 调用 done() 回调来终止测试
                done();
            })
        })
    })
})

/* promise-md5.js */
const md5 = require('./md5');

module.exports = (string) => new Promise(
    (resolve, reject) => {
        md5(string, (err, hash) => {
            return err ? reject(err) : resolve(hash);
        })
    }
)

/* test/promise-md5.js */

var promiseMd5 = require('../promise-md5');
var expect = require('chai').expect;

describe('#promiseMd5()', function () {
    context('with string argument', function () {
        it('should compute MD5 hash', function () {
            return promiseMd5('Glad Chinda')
                .then(function (hash) {
                    // 添加一些断言
                    expect(hash)
                        .to.be.a('string')
                        .that.matches(/^[a-f0-9]{32}$/)
                        .and.equal('877dbb93f50eb8a89012e15bd37ee7e4');
                })
        })
    })

    context('with non-string argument', function () {
        it('should throw an error', function () {
            return promiseMd5(12345)
                .catch(function (err) {
                    expect(function () { throw err })
                        .to.throw(TypeError, 'The "data" argument must be one of type string, TypedArray, or DataView. Received type number');
                })
        })
    })
})

/* test/promise-md5.js */

var promiseMd5 = require('../promise-md5');
var expect = require('chai').expect;

describe('#promiseMd5()', function () {
    context('with string argument', function () {
        it('should compute MD5 hash', async function () {
            // 使用 await 等到 Promise 实现
            var hash = await promiseMd5('Glad Chinda');

            // 添加一些断言
            expect(hash)
                .to.be.a('string')
                .that.match(/^[a-z0-9]{32}$/)
                .and.equal('877dbb93f50eb8a89012e15bd37ee7e4');
        })
    })

    context('with non-string argument', function() {
        it('should throw an error', async function() {
            await promiseMd5(12345).catch(function(err) {
                // 添加一个断言以检查错误
                expect(function() { throw err })
                    .to.throw(TypeError, 'The "data" argument must be one of type string, TypedArray, or DataView. Received type number');
            })
        })
    })
})

describe('some module', function() {
    beforeEach(function() {
        // 每次测试之前运行的一些逻辑
        // 逻辑可以是同步的，也可以是异步的
    })
})

describe('some module', function() {
    // 使用命名函数
    beforeEach(function createSession() {
        // beforeEach: createSession
    })

    // 使用描述
    beforeEach('create a user session', function() {
        // beforeEach: create a user session
    })
})

var tests = 1;

// 在任何文件中的任何测试运行之后执行
afterEach(function() {
    console.log('Test #' + (tests++));
})

// 将测试延迟到 5 秒后
setTimeout(function () {
    run();
}, 5000);

describe('#flattenArray()', function() {
    // 待处理测试
    it('should flatten array');
})

// 此测试套件中的测试将运行
describe.only('#flattenArray()', function() {
    it('should flatten array', function() { })
})

// 此测试套件中的测试无法运行
describe('#mergeArray()', function() {
    it('should merge two arrays', function() { })
})

describe.only('#flattenrray()', function() {
    // 这个测试将被运行
    it.only('should flatten array', function() { });

    // 这个测试无法运行
    it('should recursively flatten array', function() { });
})

describe.only('#mergeArray()', function() {
    // 对于生产环境，将在运行时跳过此测试
    // 在生产中，它将无法运行，并将被标记为待处理
    it('should merge two arrays', function() {
        if (process.env.NODE_ENV === 'production') {
            return this.skip();
        }
    })
})

describe('test medium site', function() {
    // 这个套件中所有失败的测试都会重试2次
    this.retries(2);

    it('should load medium homepage', function() {
        // 这个测试用例测试失败后，会被重复5次
        this.retries(5);

        cy.visit('https://medium.com');
    })
})

describe('slow test', function() {
    // 在一秒之后，测试将被认为是缓慢的
    this.slow(1000);

    // 在指定的一秒钟之后完成
    it('should be complete in a second', function(done) {
        setTimeout(done, 1500);
    })

    // 立即完成
    it('should be complete instantly', function() { })
})

describe('some time-consuming operation', function() {
    // 给这个测试用例设置 5 秒的超时时间
    this.timeout(5000);

    before('some long step', function(done) {
        // 设置 hooks 的超时时间
        this.timeout(2500);

        setTimeout(done, 2250);
    })

    it('should take less than 200ms', function(done) {
        // 为当前测试用例设置超时时间
        this.timeout(200);

        setTimeout(done, 150);
    })
})

describe('some time-consuming operation', function() {
    // 在这个测试用例中关闭超时限制
    this.timeout(0);

    it('should take a long time', function(done) {
        setTimeout(done, 10000);
    })
})

/* public/sum.js */

function sum() {
    // Convert argument object to array
    var args = Array.prototype.slice.call(arguments);

    // Throw error if arguments contain non-finite number values
    if (!args.every(Number.isFinite)) {
        throw new TypeError('sum() expects only numbers');
    }

    // Return the sum of the arguments
    return args.reduce(function(a, b) {
        return a + b;
    }, 0);
}

/* public/sum.test.js */

describe('#sum()', function() {
    context('without arguments', function () {
        it('should return 0', function () {
            expect(sum()).to.equal(0);
        })
    })

    context('with number arguments', function () {
        it('should return sum of arguments', function () {
            expect(sum(1, 2, 3, 4, 5)).to.equal(15);
        })

        it('should return argument when only one argument is passed', function () {
            expect(sum(5)).to.equal(5);
        })
    })

    context('with non-number arguments', function () {
        it('should throw error', function() {
            expect(function() {
                sum(1, 2, '3', [4], 5)
            }).to.throw(TypeError, 'sum() expects only numbers.')
        })
    })
})