fix tests

contracts/token/ERC20/TokenVesting.sol

@@ -37,27 +37,27 @@ contract TokenVesting is Ownable {
    * _beneficiary, gradually in a linear fashion until _start + _duration. By then all
    * of the balance will have vested.
    * @param _beneficiary address of the beneficiary to whom vested tokens are transferred
-   * @param _cliff duration in seconds of the cliff in which tokens will begin to vest
+   * @param _cliffDuration duration in seconds of the cliff in which tokens will begin to vest
    * @param _start the time (as Unix time) at which point vesting starts
    * @param _duration duration in seconds of the period in which the tokens will vest
    * @param _revocable whether the vesting is revocable or not
    */
   constructor(
     address _beneficiary,
     uint256 _start,
-    uint256 _cliff,
+    uint256 _cliffDuration,
     uint256 _duration,
     bool _revocable
   )
     public
   {
     require(_beneficiary != address(0));
-    require(_cliff <= _duration);
+    require(_cliffDuration <= _duration);
 
     beneficiary_ = _beneficiary;
     revocable_ = _revocable;
     duration_ = _duration;
-    cliff_ = _start.add(_cliff);
+    cliff_ = _start.add(_cliffDuration);
     start_ = _start;
   }
 
@@ -97,10 +97,10 @@ contract TokenVesting is Ownable {
   }
 
   /**
-   * @return the amount released to an account.
+   * @return the amount of the token released.
    */
-  function getReleased(address _account) public view returns(uint256) {
-    return released_[_account];
+  function getReleased(address _token) public view returns(uint256) {
+    return released_[_token];
   }
 
   /**

test/token/ERC20/TokenVesting.test.js

@@ -13,46 +13,46 @@ require('chai')
 const ERC20Mintable = artifacts.require('ERC20Mintable');
 const TokenVesting = artifacts.require('TokenVesting');
 
-contract('TokenVesting', function ([_, owner, beneficiary]) {
+contract.only('TokenVesting', function ([_, owner, beneficiary]) {
   const amount = new BigNumber(1000);
   const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000';
 
   beforeEach(async function () {
     this.start = (await latestTime()) + duration.minutes(1); // +1 minute so it starts after contract instantiation
-    this.cliff = duration.years(1);
+    this.cliffDuration = duration.years(1);
     this.duration = duration.years(2);
   });
 
   it('rejects a duration shorter than the cliff', async function () {
-    const cliff = this.duration;
-    const duration = this.cliff;
+    const cliffDuration = this.duration;
+    const duration = this.cliffDuration;
 
-    cliff.should.be.gt(duration);
+    cliffDuration.should.be.gt(duration);
 
     await expectThrow(
-      TokenVesting.new(beneficiary, this.start, cliff, duration, true, { from: owner })
+      TokenVesting.new(beneficiary, this.start, cliffDuration, duration, true, { from: owner })
     );
   });
 
   it('requires a valid beneficiary', async function () {
     await expectThrow(
-      TokenVesting.new(ZERO_ADDRESS, this.start, this.cliff, this.duration, true, { from: owner })
+      TokenVesting.new(ZERO_ADDRESS, this.start, this.cliffDuration, this.duration, true, { from: owner })
     );
   });
 
   context('once deployed', function () {
     beforeEach(async function () {
-      this.vesting = await TokenVesting.new(beneficiary, this.start, this.cliff, this.duration, true, { from: owner });
+      this.vesting = await TokenVesting.new(beneficiary, this.start, this.cliffDuration, this.duration, true, { from: owner });
 
       this.token = await ERC20Mintable.new({ from: owner });
       await this.token.mint(this.vesting.address, amount, { from: owner });
     });
 
     it('can get state', async function () {
       (await this.vesting.getBeneficiary()).should.be.equal(beneficiary);
-      (await this.vesting.getCliff()).should.be.equal(this.cliff);
-      (await this.vesting.getStart()).should.be.equal(this.start);
-      (await this.vesting.getDuration()).should.be.equal(this.duration);
+      (await this.vesting.getCliff()).should.be.bignumber.equal(this.start + this.cliffDuration);
+      (await this.vesting.getStart()).should.be.bignumber.equal(this.start);
+      (await this.vesting.getDuration()).should.be.bignumber.equal(this.duration);
       (await this.vesting.isRevocable()).should.be.equal(true);
     });
 
@@ -64,42 +64,42 @@ contract('TokenVesting', function ([_, owner, beneficiary]) {
     });
 
     it('can be released after cliff', async function () {
-      await increaseTimeTo(this.start + this.cliff + duration.weeks(1));
+      await increaseTimeTo(this.start + this.cliffDuration + duration.weeks(1));
       await this.vesting.release(this.token.address);
     });
 
     it('should release proper amount after cliff', async function () {
-      await increaseTimeTo(this.start + this.cliff);
+      await increaseTimeTo(this.start + this.cliffDuration);
 
       const { receipt } = await this.vesting.release(this.token.address);
       const block = await ethGetBlock(receipt.blockNumber);
       const releaseTime = block.timestamp;
 
       const releasedAmount = amount.mul(releaseTime - this.start).div(this.duration).floor();
       (await this.token.balanceOf(beneficiary)).should.bignumber.equal(releasedAmount);
-      (await this.vesting.getReleased(beneficiary)).should.bignumber.equal(releasedAmount);
+      (await this.vesting.getReleased(this.token.address)).should.bignumber.equal(releasedAmount);
     });
 
     it('should linearly release tokens during vesting period', async function () {
-      const vestingPeriod = this.duration - this.cliff;
+      const vestingPeriod = this.duration - this.cliffDuration;
       const checkpoints = 4;
 
       for (let i = 1; i <= checkpoints; i++) {
-        const now = this.start + this.cliff + i * (vestingPeriod / checkpoints);
+        const now = this.start + this.cliffDuration + i * (vestingPeriod / checkpoints);
         await increaseTimeTo(now);
 
         await this.vesting.release(this.token.address);
         const expectedVesting = amount.mul(now - this.start).div(this.duration).floor();
         (await this.token.balanceOf(beneficiary)).should.bignumber.equal(expectedVesting);
-        (await this.vesting.getReleased(beneficiary)).should.bignumber.equal(expectedVesting);
+        (await this.vesting.getReleased(this.token.address)).should.bignumber.equal(expectedVesting);
       }
     });
 
     it('should have released all after end', async function () {
       await increaseTimeTo(this.start + this.duration);
       await this.vesting.release(this.token.address);
       (await this.token.balanceOf(beneficiary)).should.bignumber.equal(amount);
-      (await this.vesting.getReleased(beneficiary)).should.bignumber.equal(amount);
+      (await this.vesting.getReleased(this.token.address)).should.bignumber.equal(amount);
     });
 
     it('should be revoked by owner if revocable is set', async function () {
@@ -109,7 +109,7 @@ contract('TokenVesting', function ([_, owner, beneficiary]) {
 
     it('should fail to be revoked by owner if revocable not set', async function () {
       const vesting = await TokenVesting.new(
-        beneficiary, this.start, this.cliff, this.duration, false, { from: owner }
+        beneficiary, this.start, this.cliffDuration, this.duration, false, { from: owner }
       );
 
       await expectThrow(
@@ -119,7 +119,7 @@ contract('TokenVesting', function ([_, owner, beneficiary]) {
     });
 
     it('should return the non-vested tokens when revoked by owner', async function () {
-      await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
+      await increaseTimeTo(this.start + this.cliffDuration + duration.weeks(12));
 
       const vested = await this.vesting.vestedAmount(this.token.address);
 
@@ -129,7 +129,7 @@ contract('TokenVesting', function ([_, owner, beneficiary]) {
     });
 
     it('should keep the vested tokens when revoked by owner', async function () {
-      await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
+      await increaseTimeTo(this.start + this.cliffDuration + duration.weeks(12));
 
       const vestedPre = await this.vesting.vestedAmount(this.token.address);
 
@@ -141,7 +141,7 @@ contract('TokenVesting', function ([_, owner, beneficiary]) {
     });
 
     it('should fail to be revoked a second time', async function () {
-      await increaseTimeTo(this.start + this.cliff + duration.weeks(12));
+      await increaseTimeTo(this.start + this.cliffDuration + duration.weeks(12));
 
       await this.vesting.vestedAmount(this.token.address);