title: AssertionError: expected '0x0000000000000000000000000000000000000000'
body: <p>I am getting this error in testing my upgradeable smart contract.
  I am really stuck with this can anyone help me get out of this?</p>
  <p>contracts/StakingContract.sol</p>
  <pre><code>//SPDX-License-Identifier: MIT
  
  pragma solidity ^0.6.0;
  
  import &quot;@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol&quot;;
  import &quot;@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol&quot;;
  import &quot;@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol&quot;;
  import &quot;@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol&quot;;
  import &quot;@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol&quot;;
  import &quot;@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol&quot;;
  import &quot;@openzeppelin/contracts-upgradeable/utils/ReentrancyGuardUpgradeable.sol&quot;;
  import &quot;@openzeppelin/contracts-upgradeable/proxy/Initializable.sol&quot;;
  
  contract StakingContract is ERC20Upgradeable, OwnableUpgradeable, ReentrancyGuardUpgradeable {
      using SafeMathUpgradeable for uint256;
      using AddressUpgradeable for address;
      using SafeERC20Upgradeable for IERC20Upgradeable;
      
      event TokensStaked(address _tokenStaker, uint256 _amount, uint256 unlockTime);
      event TokenUnstaked(address _tokenStaker, uint256 _amount);
      
      // Variable that prevents _deposit method from being called 2 times
      bool private locked;
      
      // The total staked amount
      uint256 public totalStaked;
      
      mapping (address =&gt; uint256) public stakeBalances;
      mapping(address =&gt; uint256) private timestamp;
      
      function initialize(uint256 initialSupply)  public  initializer {
          __ERC20_init(&quot;MyToken&quot;, &quot;TKN&quot;);
          _mint(owner(), initialSupply);
      }
      
      function stakeTokens(address token, uint amount) external {
          stakeBalances[msg.sender] = stakeBalances[msg.sender].add(amount);
          timestamp[msg.sender] = block.timestamp.add(30 days);
          require(IERC20Upgradeable(token).allowance(msg.sender, address(this)) &gt;= amount, &quot;Check the token allowance&quot;);
          require(IERC20Upgradeable(token).transferFrom(msg.sender, address(this), amount), &quot;Transfer failed!&quot;);
          totalStaked = totalStaked.add(amount);
          
          emit TokensStaked(msg.sender, amount, timestamp[msg.sender]);
      }
      
      function unstakeTokens(address token, uint256 amount) external nonReentrant() {
          require(amount &lt;= stakeBalances[msg.sender], &quot;Sorry! You don't have sufficient stake balance.&quot;);
          require(block.timestamp &gt;= timestamp[msg.sender], &quot;Sorry! you cannot withdraw tokens before your stake time.&quot;);
          stakeBalances[msg.sender] = stakeBalances[msg.sender].sub(amount);
          require(IERC20Upgradeable(token).transfer(msg.sender, amount));
          totalStaked = totalStaked.sub(amount);
          
          emit TokenUnstaked(msg.sender, amount);
      }
      
      function ownerWithdraw(address token) external onlyOwner() nonReentrant() {
          require(IERC20Upgradeable(token).transfer(owner(), totalStaked), &quot;Transfer Failed!&quot;);
          uint256 ownerStakedBalance = stakeBalances[msg.sender];
          stakeBalances[msg.sender] = stakeBalances[msg.sender].sub(ownerStakedBalance);
          totalStaked = totalStaked.sub(totalStaked);
      }
  }
  </code></pre>
  <p>test/StakingContract.test.js</p>
  <pre><code>const { accounts, contract, web3 } = require('@openzeppelin/test-environment');
  const { expect } = require('chai');
  
  const { TestHelper } = require('@openzeppelin/cli');
  const { Contracts, ZWeb3 } = require('@openzeppelin/upgrades');
  
  // Import utilities from Test Helpers
  const { BN, expectEvent, expectRevert } = require('@openzeppelin/test-helpers');
  
  ZWeb3.initialize(web3.currentProvider);
  
  const Box = Contracts.getFromLocal('StakingContract');
  
  describe('StakingContract', function () {
    const [ owner, other ] = accounts;
  
    beforeEach(async function () {
      this.project = await TestHelper();
      this.proxy = await this.project.createProxy(Box);
    });
  
    it('retrieve returns a value previously stored', async function () {
      // Use large integer comparisons
      expect(await this.proxy.methods.owner().call()).to.equal(owner);
    });
  });
  </code></pre>
  <p>it gives the following error:</p>
  <pre><code>0 passing (864ms)
    1 failing
  
    1) StakingContract
         retrieve returns a value previously stored:
  
        AssertionError: expected '0x0000000000000000000000000000000000000000' to equal '0xA05c7D52b924DceB23a766ccB1e91e67b4aCF014'
        + expected - actual
  
        -0x0000000000000000000000000000000000000000
        +0xA05c7D52b924DceB23a766ccB1e91e67b4aCF014
  </code></pre>
  <p>I have tried to fix it with other things but the still issue persists.
  Thanks in advance.</p>