Update docs

test/proxy/Clones.test.js

@@ -1,4 +1,6 @@
 const { expectEvent, expectRevert } = require('@openzeppelin/test-helpers');
+const { computeCreate2Address } = require('../helpers/create2');
+const { expect } = require('chai');
 
 const shouldBehaveLikeClone = require('./Clones.behaviour');
 
@@ -44,6 +46,19 @@ contract('Clones', function (accounts) {
       const salt = web3.utils.randomHex(32);
       const factory = await ClonesMock.new();
       const predicted = await factory.predictDeterministicAddress(implementation, salt);
+
+      const creationCode = [
+        '0x3d602d80600a3d3981f3363d3d373d3d3d363d73',
+        implementation.replace(/0x/, '').toLowerCase(),
+        '5af43d82803e903d91602b57fd5bf3',
+      ].join('');
+
+      expect(computeCreate2Address(
+        salt,
+        creationCode,
+        factory.address,
+      )).to.be.equal(predicted);
+
       expectEvent(
         await factory.cloneDeterministic(implementation, salt, '0x'),
         'NewInstance',

test/proxy/utils/Initializable.test.js

@@ -3,8 +3,12 @@ const { expect } = require('chai');
 
 const InitializableMock = artifacts.require('InitializableMock');
 const ConstructorInitializableMock = artifacts.require('ConstructorInitializableMock');
+const ChildConstructorInitializableMock = artifacts.require('ChildConstructorInitializableMock');
 const ReinitializerMock = artifacts.require('ReinitializerMock');
 const SampleChild = artifacts.require('SampleChild');
+const DisableBad1 = artifacts.require('DisableBad1');
+const DisableBad2 = artifacts.require('DisableBad2');
+const DisableOk = artifacts.require('DisableOk');
 
 contract('Initializable', function (accounts) {
   describe('basic testing without inheritance', function () {
@@ -54,6 +58,13 @@ contract('Initializable', function (accounts) {
     expect(await contract2.onlyInitializingRan()).to.equal(true);
   });
 
+  it('multiple constructor levels can be initializers', async function () {
+    const contract2 = await ChildConstructorInitializableMock.new();
+    expect(await contract2.initializerRan()).to.equal(true);
+    expect(await contract2.childInitializerRan()).to.equal(true);
+    expect(await contract2.onlyInitializingRan()).to.equal(true);
+  });
+
   describe('reinitialization', function () {
     beforeEach('deploying', async function () {
       this.contract = await ReinitializerMock.new();
@@ -79,6 +90,7 @@ contract('Initializable', function (accounts) {
 
     it('cannot nest reinitializers', async function () {
       expect(await this.contract.counter()).to.be.bignumber.equal('0');
+      await expectRevert(this.contract.nestedReinitialize(2, 2), 'Initializable: contract is already initialized');
       await expectRevert(this.contract.nestedReinitialize(2, 3), 'Initializable: contract is already initialized');
       await expectRevert(this.contract.nestedReinitialize(3, 2), 'Initializable: contract is already initialized');
     });
@@ -175,4 +187,17 @@ contract('Initializable', function (accounts) {
       expect(await this.contract.child()).to.be.bignumber.equal(child);
     });
   });
+
+  describe('disabling initialization', function () {
+    it('old and new patterns in bad sequence', async function () {
+      await expectRevert(DisableBad1.new(), 'Initializable: contract is already initialized');
+      await expectRevert(DisableBad2.new(), 'Initializable: contract is initializing');
+    });
+
+    it('old and new patterns in good sequence', async function () {
+      const ok = await DisableOk.new();
+      await expectEvent.inConstruction(ok, 'Initialized', { version: '1' });
+      await expectEvent.inConstruction(ok, 'Initialized', { version: '255' });
+    });
+  });
 });