ethereumjs/ethereumjs-common-3-test

查看test能够让你更好滴了解其API文档的使用

const tape = require('tape')

const Common = require('../index.js')

tape('[Common]: Initialization / Chain params', function (t) {

  t.test('Should initialize with chain provided', function (st) {//只使用chain来初始化一个Common对象

    let c = new Common('mainnet')//使用的是mainnet链

    st.equal(c.chainName(), 'mainnet', 'should initialize with chain name')//使用chainName API得到当前链名

    st.equal(c.chainId(), , 'should return correct chain Id') //得到chainId

    st.equal(c.networkId(), , 'should return correct network Id') //得到networkId

    st.equal(c.hardfork(), null, 'should set hardfork to null') //使用的硬分叉，因为没有设置，所以是null

    st.equal(c._isSupportedHardfork('constantinople'), true, 'should not restrict supported HFs') //是否支持constantinople硬分叉，这是默认支持的硬分叉类型中的一种，所以返回true

    c = new Common() //也可以使用chain ID数字来表示mainnet链

    st.equal(c.chainName(), 'mainnet', 'should initialize with chain Id')

    st.end()

  })

  t.test('Should initialize with chain and hardfork provided', function (st) { //使用chain和hardfork两个参数来初始化对象

    let c = new Common('mainnet', 'byzantium') //chain = mainnet ，hardfork = byzantium

    st.equal(c.hardfork(), 'byzantium', 'should return correct hardfork name')

    st.end()

  })

  t.test('Should initialize with supportedHardforks provided', function (st) { //使用chain、hardfork和supportedHardforks三个参数来初始化对象

    let c = new Common('mainnet', 'byzantium', ['byzantium', 'constantinople']) //supportedHardforks = ['byzantium', 'constantinople']，设置只支持这两个硬分叉类型

    st.equal(c._isSupportedHardfork('byzantium'), true, 'should return true for supported HF')

    st.equal(c._isSupportedHardfork('spuriousDragon'), false, 'should return false for unsupported HF')//因为supportedHardforks中没有它，所以不支持

    st.end()

  })

  t.test('Should handle initialization errors', function (st) {

    st.throws(function () { new Common('chainnotexisting') }, /not supported$/, 'should throw an exception on non-existing chain') // eslint-disable-line no-new ，不是支持的chain类型

    st.throws(function () { new Common('mainnet', 'hardforknotexisting') }, /not supported$/, 'should throw an exception on non-existing hardfork') // eslint-disable-line no-new ，不是支持的hardfork类型

    st.throws(function () { new Common('mainnet', 'spuriousDragon', ['byzantium', 'constantinople']) }, /supportedHardforks$/, 'should throw an exception on conflicting active/supported HF params') // eslint-disable-line no-new ，不是supportedHardforks中包含的hardfork类型

    st.end()

  })

  t.test('Should provide correct access to chain parameters', function (st) {

    let c = new Common('mainnet')

    st.equal(c.genesis().hash, '0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3', 'should return correct genesis hash')//返回当前链的初始状态中的hash值

    st.equal(c.hardforks()[]['block'], , 'should return correct hardfork data')//返回当前链的硬分叉数组中第四个分叉的'block'值

    st.equal(c.bootstrapNodes()[].port, , 'should return a bootstrap node array')//返回当前链的所有bootstrap节点字典中第一个节点的端口port值

    st.end()

  })

  t.test('Should be able to access data for all chains provided', function (st) {

    let c = new Common('mainnet')

    st.equal(c.genesis().hash, '0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3', 'mainnet')

    c.setChain('ropsten') //重新将链设置为ropsten

    st.equal(c.genesis().hash, '0x41941023680923e0fe4d74a34bdac8141f2540e3ae90623718e47d66d1ca4a2d', 'ropsten')

    c.setChain('rinkeby')

    st.equal(c.genesis().hash, '0x6341fd3daf94b748c72ced5a5b26028f2474f5f00d824504e4fa37a75767e177', 'rinkeby')

    c.setChain('kovan')

    st.equal(c.genesis().hash, '0xa3c565fc15c7478862d50ccd6561e3c06b24cc509bf388941c25ea985ce32cb9', 'kovan')

    c.setChain('goerli')

    st.equal(c.genesis().hash, '0xfa57319d09fd8a32faaf18d338c8a925a5a7975285bf29ecd024e083cba8abb1', 'goerli')

    st.end()

  })

  t.test('Should provide correct access to private network chain parameters', function (st) {//如果你连接的chain不是上面那些定义好的chain，而是你私有的或定制的，初始化的方式是下面这样的

    let chainParams = require('./testnet.json') //testnet.json中是具体的链描述信息

    let c = new Common(chainParams, 'byzantium')

    st.equal(c.chainName(), 'testnet', 'should initialize with chain name')

    st.equal(c.chainId(), , 'should return correct chain Id')

    st.equal(c.networkId(), , 'should return correct network Id')

    st.equal(c.genesis().hash, '0xaa00000000000000000000000000000000000000000000000000000000000000', 'should return correct genesis hash')

    st.equal(c.hardforks()[]['block'], , 'should return correct hardfork data')

    st.equal(c.bootstrapNodes()[].ip, '10.0.0.2', 'should return a bootstrap node array')

    st.end()

  })

  t.test('Should handle custom chain parameters with missing field', function (st) {

    let chainParams = require('./testnet.json')

    delete chainParams['hardforks'] //如果有任何内容的缺失，初始化时将报错

    st.throws(function () { new Common(chainParams) }, /Missing required/, 'should throw an exception on missing parameter') // eslint-disable-line no-new

    st.end()

  })

})

ethereumjs-common/tests/hardforks.js

const tape = require('tape')

const Common = require('../index.js')

tape('[Common]: Hardfork logic', function (t) {

  t.test('Hardfork access', function (st) {

    let supportedHardforks = [ //设置支持的硬分支类型

      'chainstart',

      'homestead',

      'dao',

      'tangerineWhistle',

      'spuriousDragon',

      'byzantium',

      'constantinople'

    ]

    let c

    for (let hardfork of supportedHardforks) {

      c = new Common('mainnet', hardfork)

      st.equal(c.hardfork(), hardfork, hardfork)

    }

    st.end()

  })

  t.test('hardforkBlock()', function (st) {

    let c = new Common('ropsten')

    st.equal(c.hardforkBlock('byzantium'), , 'should return the correct HF change block for byzantium (provided)') //得到byzantium分叉开始的区块数

    c = new Common('ropsten', 'byzantium')

    st.equal(c.hardforkBlock(), , 'should return the correct HF change block for byzantium (set)')

    st.end()

  })

  t.test('isHardforkBlock()', function (st) {

    let c = new Common('ropsten')

    st.equal(c.isHardforkBlock(, 'byzantium'), true, 'should return true for HF change block for byzantium (provided)')

    st.equal(c.isHardforkBlock(, 'byzantium'), false, 'should return false for another block for byzantium (provided)')

    c = new Common('ropsten', 'byzantium')

    st.equal(c.isHardforkBlock(), true, 'should return true for HF change block for byzantium (set)')

    st.equal(c.isHardforkBlock(), false, 'should return false for another block for byzantium (set)')

    st.end()

  })

  t.test('activeHardforks()', function (st) {

    let c = new Common('ropsten')

    st.equal(c.activeHardforks().length, , 'should return 5 active hardforks for Ropsten') //说明ropsten链中有5个活跃分叉类型

    st.equal(c.activeHardforks()[]['name'], 'spuriousDragon', 'should return the correct HF data for Ropsten')

    st.equal(c.activeHardforks().length, , 'should return 3 active hardforks for Ropsten up to block 9')//即直到区块9有的活跃分叉个数为3

    st.equal(c.activeHardforks().length, , 'should return 4 active hardforks for Ropsten up to block 10')

    c = new Common('ropsten', null, ['spuriousDragon', 'byzantium', 'constantinople'])

    //onlySupported: true说明只支持supportedHardforks里面的分叉，所以返回的结果就从5变成了2，只包含了2个活跃分叉类型

    st.equal(c.activeHardforks(null, { onlySupported: true }).length, , 'should return 2 active HFs when restricted to supported HFs')

    st.end()

  })

  t.test('activeHardfork()', function (st) {

    let c = new Common('ropsten')

    st.equal(c.activeHardfork(), 'byzantium', 'should return byzantium as latest active HF for Ropsten') //说明整条链最新的分叉为byzantium

    st.equal(c.activeHardfork(), 'spuriousDragon', 'should return spuriousDragon as latest active HF for Ropsten for block 10') //即到区块10的最新分叉类型为spuriousDragon

    c = new Common('ropsten', null, ['tangerineWhistle', 'spuriousDragon'])

    //返回'spuriousDragon'，因为supportedHardforks里最新的类型为它

    st.equal(c.activeHardfork(null, { onlySupported: true }), 'spuriousDragon', 'should return spuriousDragon as latest active HF for Ropsten with limited supported hardforks')

    st.end()

  })

  t.test('hardforkIsActiveOnBlock() / activeOnBlock()', function (st) {

    let c = new Common('ropsten')

    st.equal(c.hardforkIsActiveOnBlock('byzantium', ), true, 'Ropsten, byzantium (provided), 1700000 -> true')

    st.equal(c.hardforkIsActiveOnBlock('byzantium', ), true, 'Ropsten, byzantium (provided), 1700005 -> true')

    st.equal(c.hardforkIsActiveOnBlock('byzantium', ), false, 'Ropsten, byzantium (provided), 1699999 -> false')

    c = new Common('ropsten', 'byzantium')

    st.equal(c.hardforkIsActiveOnBlock(null, ), true, 'Ropsten, byzantium (set), 1700000 -> true')

    st.equal(c.activeOnBlock(), true, 'Ropsten, byzantium (set), 1700000 -> true (alias function)')

    st.equal(c.hardforkIsActiveOnBlock(null, ), true, 'Ropsten, byzantium (set), 1700005 -> true')

    st.equal(c.hardforkIsActiveOnBlock(null, ), false, 'Ropsten, byzantium (set), 1699999 -> false')

    st.end()

  })

  t.test('hardforkGteHardfork()', function (st) {

    let c = new Common('ropsten')

    st.equal(c.hardforkGteHardfork('constantinople', 'byzantium'), true, 'Ropsten, constantinople >= byzantium (provided) -> true')

    st.equal(c.hardforkGteHardfork('constantinople', 'byzantium', { onlyActive: true }), false, 'Ropsten, constantinople >= byzantium (provided), onlyActive -> fale')

    st.equal(c.hardforkGteHardfork('byzantium', 'byzantium'), true, 'Ropsten, byzantium >= byzantium (provided) -> true')

    st.equal(c.hardforkGteHardfork('spuriousDragon', 'byzantium'), false, 'Ropsten, spuriousDragon >= byzantium (provided) -> false')

    c = new Common('ropsten', 'byzantium')

    st.equal(c.hardforkGteHardfork(null, 'spuriousDragon'), true, 'Ropsten, byzantium (set) >= spuriousDragon -> true')

    st.equal(c.gteHardfork('spuriousDragon'), true, 'Ropsten, byzantium (set) >= spuriousDragon -> true (alias function)')

    st.equal(c.hardforkGteHardfork(null, 'spuriousDragon', { onlyActive: true }), true, 'Ropsten, byzantium (set) >= spuriousDragon, onlyActive -> true')

    st.equal(c.hardforkGteHardfork(null, 'byzantium'), true, 'Ropsten, byzantium (set) >= byzantium -> true')

    st.equal(c.hardforkGteHardfork(null, 'constantinople'), false, 'Ropsten, byzantium (set) >= constantinople -> false')

    st.end()

  })

  t.test('hardforkIsActiveOnChain()', function (st) {

    let c = new Common('ropsten')

    st.equal(c.hardforkIsActiveOnChain('byzantium'), true, 'should return true for byzantium (provided) on Ropsten')

    st.equal(c.hardforkIsActiveOnChain('dao'), false, 'should return false for dao (provided) on Ropsten')

    st.equal(c.hardforkIsActiveOnChain('constantinople'), false, 'should return false for constantinople (provided) on Ropsten')

    st.equal(c.hardforkIsActiveOnChain('notexistinghardfork'), false, 'should return false for a non-existing HF (provided) on Ropsten')

    //因为这里并没有设置，但是使用了onlySupported: true，所以会报出"spuriousDragon"为不支持的分叉的错误

    st.doesNotThrow(function () { c.hardforkIsActiveOnChain('spuriousDragon', { onlySupported: true }) }, /unsupported hardfork$/, 'should not throw with unsupported Hf (provided) and onlySupported set to false') // eslint-disable-line no-new

    c = new Common('ropsten', 'byzantium')

    st.equal(c.hardforkIsActiveOnChain(), true, 'should return true for byzantium (set) on Ropsten')

    c = new Common('ropsten', null, ['byzantium', 'constantinople'])

    st.throws(function () { c.hardforkIsActiveOnChain('spuriousDragon', { onlySupported: true }) }, /not set as supported in supportedHardforks$/, 'should throw with unsupported Hf and onlySupported set to true') // eslint-disable-line no-new

    st.end()

  })

  t.test('consensus()/finality()', function (st) {

    let c = new Common('mainnet')

    st.equal(c.consensus('byzantium'), 'pow', 'should return pow for byzantium consensus')//返回byzantium分叉共识为'pow'

    st.equal(c.consensus('constantinople'), 'pow', 'should return pow for constantinople consensus')

    st.equal(c.finality('byzantium'), null, 'should return null for byzantium finality')

    st.end()

  })

})

ethereumjs-common/tests/params.js

const tape = require('tape')

const Common = require('../index.js')

tape('[Common]: Parameter access', function (t) {//这个测试就是获取参数值

  t.test('Basic usage', function (st) {

    let c = new Common('mainnet')

    st.equal(c.param('gasPrices', 'ecAdd', 'byzantium'), , 'Should return correct value when HF directly provided')

    c.setHardfork('byzantium')

    st.equal(c.param('gasPrices', 'ecAdd'), , 'Should return correct value for HF set in class')

    st.end()

  })

  t.test('Error cases', function (st) {

    let c = new Common('mainnet')

    st.throws(function () { c.param('gasPrices', 'ecAdd') }, /neither a hardfork set nor provided by param$/, 'Should throw when no hardfork set or provided')

    st.throws(function () { c.param('gasPrizes', 'ecAdd', 'byzantium') }, /Topic gasPrizes not defined$/, 'Should throw when called with non-existing topic')

    st.throws(function () { c.param('gasPrices', 'notexistingvalue', 'byzantium') }, /value for notexistingvalue not found$/, 'Should throw when called with non-existing value')

    c.setHardfork('byzantium')

    st.equal(c.param('gasPrices', 'ecAdd'), , 'Should return correct value for HF set in class')

    c = new Common('mainnet', 'byzantium', ['byzantium', 'constantinople'])

    st.throws(function () { c.param('gasPrices', 'expByte', 'spuriousDragon') }, /supportedHardforks$/, 'Should throw when calling param() with an unsupported hardfork')

    st.throws(function () { c.paramByBlock('gasPrices', 'expByte', ) }, /supportedHardforks$/, 'Should throw when calling paramByBlock() with an unsupported hardfork')

    st.end()

  })

  t.test('Parameter updates', function (st) {

    let c = new Common('mainnet')

    st.throws(function () { c.param('gasPrices', 'ecAdd', 'spuriousDragon') }, /value for ecAdd not found$/, 'Should throw for a value set on a later HF')

    st.equal(c.param('pow', 'minerReward', 'chainstart'), '', 'Should return correct value for chain start')

    st.equal(c.param('pow', 'minerReward', 'byzantium'), '', 'Should reflect HF update changes')

    st.equal(c.param('gasPrices', 'netSstoreNoopGas', 'constantinople'), , 'Should return updated sstore gas prices for constantinople')

    st.end()

  })

  t.test('Access by block number, paramByBlock()', function (st) {

    let c = new Common('mainnet', 'byzantium')

    st.equal(c.paramByBlock('pow', 'minerReward', ), '', 'Should correctly translate block numbers into HF states (updated value)')

    st.equal(c.paramByBlock('pow', 'minerReward', ), '', 'Should correctly translate block numbers into HF states (original value)')

    st.end()

  })

})

ethereumjs-common/tests/testnet.json

{

  "name": "testnet",

  "chainId": ,

  "networkId": ,

  "comment": "Private test network",

  "genesis": {

    "hash": "0xaa00000000000000000000000000000000000000000000000000000000000000",

    "timestamp": null,

    "gasLimit": ,

    "difficulty": ,

    "nonce": "0xbb00000000000000",

    "extraData": "0xcc000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",

    "stateRoot": "0xdd00000000000000000000000000000000000000000000000000000000000000"

  },

  "hardforks": [

    {

      "name": "chainstart",

      "block": ,

      "consensus": "poa",

      "finality": null

    },

    {

      "name": "homestead",

      "block": ,

      "consensus": "poa",

      "finality": null

    },

    {

      "name": "tangerineWhistle",

      "block": ,

      "consensus": "poa",

      "finality": null

    },

    {

      "name": "spuriousDragon",

      "block": ,

      "consensus": "poa",

      "finality": null

    },

    {

      "name": "byzantium",

      "block": ,

      "consensus": "poa",

      "finality": null

    }

  ],

  "bootstrapNodes": [

    {

      "ip": "10.0.0.1",

      "port": ,

      "id": "",

      "location": "",

      "comment": ""

    },

    {

      "ip": "10.0.0.2",

      "port": ,

      "id": "",

      "location": "",

      "comment": ""

    }

  ]

}

ethereumjs/ethereumjs-common-3-test的更多相关文章

ethereumjs/ethereumjs-common-1-简介
为了了解ethereumjs/ethereumjs-block-3-代码的使用需要了解的一个模块 https://github.com/ethereumjs/ethereumjs-common Com ...
ethereumjs/ethereumjs-common-2-API文档
https://github.com/ethereumjs/ethereumjs-common/blob/master/docs/index.md 该API的调用的详细例子可见ethereumjs/e ...
ethereumjs/ethereumjs-vm-3-StateManager
https://github.com/ethereumjs/ethereumjs-vm/blob/master/docs/stateManager.md StateManager 要与本博客的ethe ...
ethereumjs/ethereumjs-block-3-tests
之前可以先了解一下另一个模块,看本博客的ethereumjs/ethereumjs-common部分内容通过tests测试文件能够帮助更好了解API的使用 ethereumjs-block/test ...
ethereumjs/ethereumjs-block-2-api
https://github.com/ethereumjs/ethereumjs-block/blob/master/docs/index.md 详细的调用代码可见本博客的ethereumjs/eth ...
ethereumjs/ethereumjs-blockchain-2-test
https://github.com/ethereumjs/ethereumjs-blockchain/tree/master/test 'use strict' const test = requi ...
ethereumjs/ethereumjs-util
ethereumjs/ethereumjs-util Most of the string manipulation methods are provided by ethjs-util 更多的字符串 ...
ethereumjs/ethereumjs-wallet
Utilities for handling Ethereum keys ethereumjs-wallet A lightweight wallet implementation. At the m ...
ethereumjs/ethereumjs-tx
https://github.com/ethereumjs/ethereumjs-tx A simple module for creating, manipulating and signing e ...
ethereumjs/ethereumjs-icap
https://github.com/ethereumjs/ethereumjs-icap ethereumjs-icap 安装: npm install ethereumjs-icap --save ...

随机推荐

php5.6+apache2.4+linux搭建php环境
前言最近突然想搭建个人博客,尽管笔者擅长java-web,但综合各种原因,于是选择了大众化的php+mysql搭建个人博客.对于php,只闻其大名,但从未学过,于是,笔者将从php环境搭建开始,到服 ...
ReadWriteLock
ReadWriteLock也是一个接口,只有两个方法一个用来获取读锁,一个用来获取写锁.也就是说将文件的读写操作分开,分成2个锁来分配给线程,从而使得多个线程可以同时进行读操作.下面的Reentra ...
zookeeper 典型应用
一.发布/订阅配置文件的集中管理. 问题:当分布式系统变多后,每个系统保存相应的配置文件,会造成同个文件有多份,修改起来非常麻烦. 解决方法:使用zk的发布/订阅功能,配合Watcher机制,在应用 ...
理解 RESTful 架构（转）
前言:REST指的是一组架构约束条件和原则." 如果一个架构符合REST的约束条件和原则,我们就称它为RESTful架构. 越来越多的人开始意识到,网站即软件,而且是一种新型的软件. 这种& ...
vue的v-html插值样式问题
content使用html插入文本和图片使用scoped样式,渲染失败. 原因: 解决方案: 采用全局样式或另外再加style标签单独渲染
hexo的next主题个性化教程:打造炫酷网站
看到有些next主题的网站很炫酷,那么是怎么配置的呢?接下来我会讲一讲如何实现一些炫酷的效果主要有以下32种: 在右上角或者左上角实现fork me on github 添加RSS 添加动态背景实 ...
【代码笔记】iOS-iphone开发之获取系统字体
代码: - (void)viewDidLoad { [super viewDidLoad]; // Do any additional setup after loading the view. NS ...
微格式(microformat)
由于HTML中缺少相应的元素,很难突出显示人.地点或日期等类型的信息.为了解决这个问题,有一组开发人员决定开发一套标准的命名约定盒标记模式来表示这些数据.这些命名约定基于vCard和iCalendar ...
Java动态代理和反射机制
反射机制 Java语言提供的一种基础功能,通过反射,我们可以操作这个类或对象,比如获取这个类中的方法.属性和构造方法等. 动态代理:分为JDK动态代理.cglib动态代理(spring中的动态代理). ...
数据契约（DataContract）里的DataMember特性
数据契约(DataContract) 服务契约定义了远程访问对象和可供调用的方法,数据契约则是服务端和客户端之间要传送的自定义数据类型. 一旦声明一个类型为DataContract,那么该类型就可 ...

ethereumjs/ethereumjs-common-3-test

ethereumjs/ethereumjs-common-3-test的更多相关文章

随机推荐

热门专题