diff --git a/script/Counter.s.sol b/script/Counter.s.sol
deleted file mode 100644
index cdc1fe9..0000000
--- a/script/Counter.s.sol
+++ /dev/null
@@ -1,19 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.13;
-
-import {Script, console} from "forge-std/Script.sol";
-import {Counter} from "../src/Counter.sol";
-
-contract CounterScript is Script {
-    Counter public counter;
-
-    function setUp() public {}
-
-    function run() public {
-        vm.startBroadcast();
-
-        counter = new Counter();
-
-        vm.stopBroadcast();
-    }
-}
diff --git a/src/01-dont-init-def-val/IdRegDontInitDefVal.sol b/src/01-dont-init-def-val/IdRegDontInitDefVal.sol
new file mode 100644
index 0000000..38024b4
--- /dev/null
+++ b/src/01-dont-init-def-val/IdRegDontInitDefVal.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnop} from "../IdRegUnop.sol";
+
+contract IdRegDontInitDefVal is IdRegUnop {
+    function generateIds(uint256 numIds, address[] memory owners) external override {
+        if(numIds != owners.length)
+            revert NumIdsOwnersLengthMismatch(numIds, owners.length);
+
+        // @audit don't initialize loop variable to zero as solidity
+        // automatically initializes variable to their default value
+        // note: test shows no gas savings but does eliminate useless code
+        for(uint256 i; i<numIds; i++) {
+            // read next id from storage
+            uint256 newId = nextId;
+
+            // first id should start at 1
+            if(newId == 0) newId = 1;
+
+            // update the mapping
+            idToOwner[newId] = owners[i];
+
+            // update storage to increment next id
+            nextId = newId + 1;
+        }
+    }
+} 
\ No newline at end of file
diff --git a/src/02-init-past-def-val/IdRegInitPastDefVal.sol b/src/02-init-past-def-val/IdRegInitPastDefVal.sol
new file mode 100644
index 0000000..3b88a6d
--- /dev/null
+++ b/src/02-init-past-def-val/IdRegInitPastDefVal.sol
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnop} from "../IdRegUnop.sol";
+
+contract IdRegInitPastDefVal is IdRegUnop {
+    // @audit since first id is always 1 initialize
+    // storage past default 0 value
+    constructor() {
+        nextId = 1;
+    }
+
+    function generateIds(uint256 numIds, address[] memory owners) external override {
+        if(numIds != owners.length)
+            revert NumIdsOwnersLengthMismatch(numIds, owners.length);
+
+        for(uint256 i; i<numIds; i++) {
+            // read next id from storage
+            uint256 newId = nextId;
+
+            // @audit don't need to check against 0 every time
+            // as we now initialize past 0
+
+            // update the mapping
+            idToOwner[newId] = owners[i];
+
+            // update storage to increment next id
+            nextId = newId + 1;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/03-calldata-array-input/IdRegCalldataArrayInput.sol b/src/03-calldata-array-input/IdRegCalldataArrayInput.sol
new file mode 100644
index 0000000..4e453fd
--- /dev/null
+++ b/src/03-calldata-array-input/IdRegCalldataArrayInput.sol
@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnop} from "../IdRegUnop.sol";
+
+contract IdRegCalldataArrayInput is IdRegUnop {
+    constructor() {
+        nextId = 1;
+    }
+
+    // @audit use `calldata` for read-only array inputs
+    function generateIds(uint256 numIds, address[] calldata owners) external override {
+        if(numIds != owners.length)
+            revert NumIdsOwnersLengthMismatch(numIds, owners.length);
+
+        for(uint256 i; i<numIds; i++) {
+            // read next id from storage
+            uint256 newId = nextId;
+
+            // update the mapping
+            idToOwner[newId] = owners[i];
+
+            // update storage to increment next id
+            nextId = newId + 1;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/04-read-write-storage-once/IdRegReadWriteStorageOnce.sol b/src/04-read-write-storage-once/IdRegReadWriteStorageOnce.sol
new file mode 100644
index 0000000..4dcead2
--- /dev/null
+++ b/src/04-read-write-storage-once/IdRegReadWriteStorageOnce.sol
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnop} from "../IdRegUnop.sol";
+
+contract IdRegReadWriteStorageOnce is IdRegUnop {
+    constructor() {
+        nextId = 1;
+    }
+
+    function generateIds(uint256 numIds, address[] calldata owners) external override {
+        if(numIds != owners.length)
+            revert NumIdsOwnersLengthMismatch(numIds, owners.length);
+
+        // @audit read `nextId` from storage once
+        // read next id from storage
+        uint256 newId = nextId;
+
+        for(uint256 i; i<numIds; i++) {
+            // update the mapping
+            // @audit use cached `newId` to set idToOwner storage
+            // then increment cached `newId`
+            idToOwner[newId++] = owners[i];
+        }
+
+        // @audit write final `newId` to `nextId` storage once
+        nextId = newId;
+
+        // instead of reading from and to writing `nextId` storage
+        // during every loop iteration, we now only read and write
+        // storage once which is cheaper
+    }
+}
\ No newline at end of file
diff --git a/src/05-del-to-def-val/IdRegDelToDefVal.sol b/src/05-del-to-def-val/IdRegDelToDefVal.sol
new file mode 100644
index 0000000..208760a
--- /dev/null
+++ b/src/05-del-to-def-val/IdRegDelToDefVal.sol
@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnop} from "../IdRegUnop.sol";
+
+contract IdRegDelToDefVal is IdRegUnop {
+    function resetId(uint256 id) external override {
+        // @audit instead of writing the default value to storage,
+        // use `delete` for a potential gas refund
+        delete idToOwner[id];
+    }
+}
\ No newline at end of file
diff --git a/src/06-dont-cache-calldata-length/IdRegDontCacheCalldataLength.sol b/src/06-dont-cache-calldata-length/IdRegDontCacheCalldataLength.sol
new file mode 100644
index 0000000..98d48f7
--- /dev/null
+++ b/src/06-dont-cache-calldata-length/IdRegDontCacheCalldataLength.sol
@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnop} from "../IdRegUnop.sol";
+
+contract IdRegDontCacheCalldataLength is IdRegUnop {
+    function getOwnersForIds(uint256[] calldata ids) external view override returns(address[] memory) {
+        // @audit don't cache calldata length
+        // allocate output array in memory
+        address[] memory owners = new address[](ids.length);
+
+        // populate output array
+        for(uint256 i; i<ids.length; i++) {
+            owners[i] = idToOwner[ids[i]];
+        }
+
+        // return output array
+        return owners;
+    }
+}
\ No newline at end of file
diff --git a/src/07-use-named-return/IdRegUseNamedReturn.sol b/src/07-use-named-return/IdRegUseNamedReturn.sol
new file mode 100644
index 0000000..fa38ca2
--- /dev/null
+++ b/src/07-use-named-return/IdRegUseNamedReturn.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnop} from "../IdRegUnop.sol";
+
+contract IdRegUseNamedReturn is IdRegUnop {
+    function getOwnersForIds(uint256[] calldata ids) external view override returns(address[] memory owners) {
+        // @audit using named return, allocate output array in memory
+        owners = new address[](ids.length);
+
+        // populate output array
+        for(uint256 i; i<ids.length; i++) {
+            owners[i] = idToOwner[ids[i]];
+        }
+
+        // @audit removed explicit `return` statement
+    }
+}
\ No newline at end of file
diff --git a/src/Counter.sol b/src/Counter.sol
deleted file mode 100644
index aded799..0000000
--- a/src/Counter.sol
+++ /dev/null
@@ -1,14 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.13;
-
-contract Counter {
-    uint256 public number;
-
-    function setNumber(uint256 newNumber) public {
-        number = newNumber;
-    }
-
-    function increment() public {
-        number++;
-    }
-}
diff --git a/src/IIdReg.sol b/src/IIdReg.sol
new file mode 100644
index 0000000..e66ee42
--- /dev/null
+++ b/src/IIdReg.sol
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+interface IIdReg {
+    // errors
+    error NumIdsOwnersLengthMismatch(uint256 numIds, uint256 ownersLength);
+
+    // public API
+    //
+    // view functions
+    function nextId() external view returns(uint256);
+    function idToOwner(uint256 id) external view returns(address);
+    function getOwnersForIds(uint256[] calldata ids) external view returns(address[] memory);
+
+    // non-view functions which change state
+    function generateIds(uint256 numIds, address[] memory owners) external;
+    function resetId(uint256 id) external;
+
+}
\ No newline at end of file
diff --git a/src/IdRegUnop.sol b/src/IdRegUnop.sol
new file mode 100644
index 0000000..6e7e4ca
--- /dev/null
+++ b/src/IdRegUnop.sol
@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import { IIdReg } from "./IIdReg.sol";
+
+// unoptimized implementation
+contract IdRegUnop is IIdReg {
+    // next available id
+    uint256 public nextId;
+    
+    // mapping of valid ids to their owner
+    mapping(uint256 id => address owner) public idToOwner;
+
+    // creates `numIds` new valid ids in ascending
+    // order from previously created ids
+    // @audit external and public result in same gas cost, tested
+    // manually as this would break compilation with existing structure
+    function generateIds(uint256 numIds, address[] memory owners) external virtual {
+        if(numIds != owners.length)
+            revert NumIdsOwnersLengthMismatch(numIds, owners.length);
+
+        for(uint256 i=0; i<numIds; i++) {
+            // read next id from storage
+            uint256 newId = nextId;
+
+            // first id should start at 1
+            if(newId == 0) newId = 1;
+
+            // update the mapping
+            idToOwner[newId] = owners[i];
+
+            // update storage to increment next id
+            nextId = newId + 1;
+        }
+    }
+
+    // reset an id back to no owner
+    function resetId(uint256 id) external virtual {
+        idToOwner[id] = address(0);
+    }
+
+    // get owners for given list of ids
+    function getOwnersForIds(uint256[] calldata ids) external view virtual returns(address[] memory) {
+        // cache length
+        uint256 idsLength = ids.length;
+
+        // allocate output array in memory
+        address[] memory owners = new address[](idsLength);
+
+        // populate output array
+        for(uint256 i; i<idsLength; i++) {
+            owners[i] = idToOwner[ids[i]];
+        }
+
+        // return output array
+        return owners;
+    }
+}
\ No newline at end of file
diff --git a/test/01-dont-init-def-val/IdRegDontInitDefValTest.sol b/test/01-dont-init-def-val/IdRegDontInitDefValTest.sol
new file mode 100644
index 0000000..b254cd8
--- /dev/null
+++ b/test/01-dont-init-def-val/IdRegDontInitDefValTest.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnopTest} from "../IdRegUnopTest.sol";
+import {IdRegDontInitDefVal} from "../../src/01-dont-init-def-val/IdRegDontInitDefVal.sol";
+
+// Optimizer ON, 10000 runs
+// ========================
+// Pre  : 142049 gas
+// forge test --optimizer-runs 10000 --match-contract IdRegUnopTest --match-test test_generateIds -vvv
+// Post : 142049 gas (no improvement)
+// forge test --optimizer-runs 10000 --match-contract IdRegDontInitDefValTest --match-test test_generateIds -vvv
+//
+// Optimizer OFF
+// =============
+// Pre  : 142325 gas
+// forge test --match-contract IdRegUnopTest --match-test test_generateIds -vvv
+// Post : 142325 gas (no improvement)
+// forge test --match-contract IdRegDontInitDefValTest --match-test test_generateIds -vvv
+//
+// Conclusion
+// ==========
+// `for(uint256 i=0;)` costs the same as `for(uint256 i;)`
+contract IdRegDontInitDefValTest is IdRegUnopTest {
+    function setUp() external override {
+        idReg = new IdRegDontInitDefVal();
+    }
+}
\ No newline at end of file
diff --git a/test/02-init-past-def-val/IdRegInitPastDefValTest.sol b/test/02-init-past-def-val/IdRegInitPastDefValTest.sol
new file mode 100644
index 0000000..25337c6
--- /dev/null
+++ b/test/02-init-past-def-val/IdRegInitPastDefValTest.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnopTest} from "../IdRegUnopTest.sol";
+import {IdRegInitPastDefVal} from "../../src/02-init-past-def-val/IdRegInitPastDefVal.sol";
+
+// Optimizer ON, 10000 runs
+// ========================
+// Pre  : 142049 gas
+// forge test --optimizer-runs 10000 --match-contract IdRegUnopTest --match-test test_generateIds -vvv
+// Post : 124829 gas (12% cheaper)
+// forge test --optimizer-runs 10000 --match-contract IdRegInitPastDefValTest --match-test test_generateIds -vvv
+//
+// Optimizer OFF
+// =============
+// Pre  : 142325 gas
+// forge test --match-contract IdRegUnopTest --match-test test_generateIds -vvv
+// Post : 125105 gas (12% cheaper)
+// forge test --match-contract IdRegInitPastDefValTest --match-test test_generateIds -vvv
+//
+// Conclusion
+// ==========
+// Initializing values past their default is cheaper
+contract IdRegInitPastDefValTest is IdRegUnopTest {
+    function setUp() external override {
+        idReg = new IdRegInitPastDefVal();
+    }
+}
\ No newline at end of file
diff --git a/test/03-calldata-array-input/IdRegCalldataArrayInputTest.sol b/test/03-calldata-array-input/IdRegCalldataArrayInputTest.sol
new file mode 100644
index 0000000..4603d4d
--- /dev/null
+++ b/test/03-calldata-array-input/IdRegCalldataArrayInputTest.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnopTest} from "../IdRegUnopTest.sol";
+import {IdRegCalldataArrayInput} from "../../src/03-calldata-array-input/IdRegCalldataArrayInput.sol";
+
+// Optimizer ON, 10000 runs
+// ========================
+// Pre  : 124829 gas
+// forge test --optimizer-runs 10000 --match-contract IdRegInitPastDefValTest --match-test test_generateIds -vvv
+// Post : 124554 gas (0.22% cheaper)
+// forge test --optimizer-runs 10000 --match-contract IdRegCalldataArrayInputTest --match-test test_generateIds -vvv
+//
+// Optimizer OFF
+// =============
+// Pre  : 125105 gas
+// forge test --match-contract IdRegInitPastDefValTest --match-test test_generateIds -vvv
+// Post : 124827 gas (0.22% cheaper)
+// forge test --match-contract IdRegCalldataArrayInputTest --match-test test_generateIds -vvv
+//
+// Conclusion
+// ==========
+// Using `calldata` for array inputs is cheaper than `memory`
+contract IdRegCalldataArrayInputTest is IdRegUnopTest {
+    function setUp() external override {
+        idReg = new IdRegCalldataArrayInput();
+    }
+}
\ No newline at end of file
diff --git a/test/04-read-write-storage-once/IdRegCalldataArrayInputTest.sol b/test/04-read-write-storage-once/IdRegCalldataArrayInputTest.sol
new file mode 100644
index 0000000..a4a8cc3
--- /dev/null
+++ b/test/04-read-write-storage-once/IdRegCalldataArrayInputTest.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnopTest} from "../IdRegUnopTest.sol";
+import {IdRegReadWriteStorageOnce} from "../../src/04-read-write-storage-once/IdRegReadWriteStorageOnce.sol";
+
+// Optimizer ON, 10000 runs
+// ========================
+// Pre  : 124554 gas
+// forge test --optimizer-runs 10000 --match-contract IdRegCalldataArrayInputTest --match-test test_generateIds -vvv
+// Post : 123737 gas (0.66% cheaper)
+// forge test --optimizer-runs 10000 --match-contract IdRegReadWriteStorageOnceTest --match-test test_generateIds -vvv
+//
+// Optimizer OFF
+// =============
+// Pre  : 124827 gas
+// forge test --match-contract IdRegCalldataArrayInputTest --match-test test_generateIds -vvv
+// Post : 124010 gas (0.65% cheaper)
+// forge test --match-contract IdRegReadWriteStorageOnceTest --match-test test_generateIds -vvv
+//
+// Conclusion
+// ==========
+// Cache storage reads and writes is cheaper
+contract IdRegReadWriteStorageOnceTest is IdRegUnopTest {
+    function setUp() external override {
+        idReg = new IdRegReadWriteStorageOnce();
+    }
+}
\ No newline at end of file
diff --git a/test/05-del-to-def-val/IdRegCalldataArrayInputTest.sol b/test/05-del-to-def-val/IdRegCalldataArrayInputTest.sol
new file mode 100644
index 0000000..0a41646
--- /dev/null
+++ b/test/05-del-to-def-val/IdRegCalldataArrayInputTest.sol
@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnopTest} from "../IdRegUnopTest.sol";
+import {IdRegDelToDefVal} from "../../src/05-del-to-def-val/IdRegDelToDefVal.sol";
+
+// Optimizer ON, 10000 runs
+// ========================
+// Pre  : 979 gas
+// forge test --optimizer-runs 10000 --match-contract IdRegUnopTest --match-test test_resetId -vvv
+// Post : 979 gas (no improvement)
+// forge test --optimizer-runs 10000 --match-contract IdRegDelToDefVal --match-test test_resetId -vvv
+//
+// Optimizer OFF
+// =============
+// Pre  : 1018 gas
+// forge test --match-contract IdRegUnopTest --match-test test_resetId -vvv
+// Post : 1018 gas (no improvement)
+// forge test --match-contract IdRegDelToDefVal --match-test test_resetId -vvv
+//
+// Conclusion
+// ==========
+// Setting storage to default values costs the same
+// as using the `delete` keyword
+contract IdRegDelToDefValTest is IdRegUnopTest {
+    function setUp() external override {
+        idReg = new IdRegDelToDefVal();
+    }
+}
\ No newline at end of file
diff --git a/test/06-dont-cache-calldata-length/IdRegDontCacheCalldataLengthTest.sol b/test/06-dont-cache-calldata-length/IdRegDontCacheCalldataLengthTest.sol
new file mode 100644
index 0000000..d09e09e
--- /dev/null
+++ b/test/06-dont-cache-calldata-length/IdRegDontCacheCalldataLengthTest.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnopTest} from "../IdRegUnopTest.sol";
+import {IdRegDontCacheCalldataLength} from "../../src/06-dont-cache-calldata-length/IdRegDontCacheCalldataLength.sol";
+
+// Optimizer ON, 10000 runs
+// ========================
+// Pre  : 5294 gas
+// forge test --optimizer-runs 10000 --match-contract IdRegUnopTest --match-test test_getOwnersForIds -vvv
+// Post : 5289 gas (0.09% cheaper)
+// forge test --optimizer-runs 10000 --match-contract IdRegDontCacheCalldataLength --match-test test_getOwnersForIds -vvv
+//
+// Optimizer OFF
+// =============
+// Pre  : 5580 gas
+// forge test --match-contract IdRegUnopTest --match-test test_getOwnersForIds -vvv
+// Post : 5575 gas (0.09% cheaper)
+// forge test --match-contract IdRegDontCacheCalldataLength --match-test test_getOwnersForIds -vvv
+//
+// Conclusion
+// ==========
+// Cheaper not to cache `calldata` length
+contract IdRegDontCacheCalldataLengthTest is IdRegUnopTest {
+    function setUp() external override {
+        idReg = new IdRegDontCacheCalldataLength();
+    }
+}
\ No newline at end of file
diff --git a/test/07-use-named-return/IdRegDontCacheCalldataLengthTest.sol b/test/07-use-named-return/IdRegDontCacheCalldataLengthTest.sol
new file mode 100644
index 0000000..9fe2616
--- /dev/null
+++ b/test/07-use-named-return/IdRegDontCacheCalldataLengthTest.sol
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {IdRegUnopTest} from "../IdRegUnopTest.sol";
+import {IdRegUseNamedReturn} from "../../src/07-use-named-return/IdRegUseNamedReturn.sol";
+
+// Optimizer ON, 10000 runs
+// ========================
+// Pre  : 5289 gas
+// forge test --optimizer-runs 10000 --match-contract IdRegDontCacheCalldataLength --match-test test_getOwnersForIds -vvv
+// Post : 5281 gas (0.15% cheaper)
+// forge test --optimizer-runs 10000 --match-contract IdRegUseNamedReturn --match-test test_getOwnersForIds -vvv
+//
+// Optimizer OFF
+// =============
+// Pre  : 5575 gas
+// forge test --match-contract IdRegDontCacheCalldataLength --match-test test_getOwnersForIds -vvv
+// Post : 5567 gas (0.14% cheaper)
+// forge test --match-contract IdRegUseNamedReturn --match-test test_getOwnersForIds -vvv
+//
+// Conclusion
+// ==========
+// Using named returns is cheaper
+contract IdRegUseNamedReturnTest is IdRegUnopTest {
+    function setUp() external override {
+        idReg = new IdRegUseNamedReturn();
+    }
+}
\ No newline at end of file
diff --git a/test/Counter.t.sol b/test/Counter.t.sol
deleted file mode 100644
index 54b724f..0000000
--- a/test/Counter.t.sol
+++ /dev/null
@@ -1,24 +0,0 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity ^0.8.13;
-
-import {Test, console} from "forge-std/Test.sol";
-import {Counter} from "../src/Counter.sol";
-
-contract CounterTest is Test {
-    Counter public counter;
-
-    function setUp() public {
-        counter = new Counter();
-        counter.setNumber(0);
-    }
-
-    function test_Increment() public {
-        counter.increment();
-        assertEq(counter.number(), 1);
-    }
-
-    function testFuzz_SetNumber(uint256 x) public {
-        counter.setNumber(x);
-        assertEq(counter.number(), x);
-    }
-}
diff --git a/test/IdRegUnopTest.sol b/test/IdRegUnopTest.sol
new file mode 100644
index 0000000..fde7a3f
--- /dev/null
+++ b/test/IdRegUnopTest.sol
@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.28;
+
+import {Test, console} from "forge-std/Test.sol";
+import {IdRegUnop, IIdReg} from "../src/IdRegUnop.sol";
+
+contract IdRegUnopTest is Test {
+    IIdReg internal idReg;
+
+    uint256 constant NUM_IDS   = 5;
+    address constant OWNER_ID1 = address(0x1111);
+    address constant OWNER_ID2 = address(0x1112);
+    address constant OWNER_ID3 = address(0x1113);
+    address constant OWNER_ID4 = address(0x1114);
+    address constant OWNER_ID5 = address(0x1115);
+
+    function setUp() external virtual {
+        idReg = new IdRegUnop();
+    }
+
+    function test_generateIds() public {
+        // prepare inputs
+        address[] memory owners = new address[](NUM_IDS);
+        owners[0] = OWNER_ID1;
+        owners[1] = OWNER_ID2;
+        owners[2] = OWNER_ID3;
+        owners[3] = OWNER_ID4;
+        owners[4] = OWNER_ID5;
+
+        // call function under test
+        uint256 gasPre = gasleft();
+        idReg.generateIds(NUM_IDS, owners);
+        console.log("generateIds() cost %d gas", gasPre - gasleft());
+
+        // validate expected storage changes
+        //
+        // next id should be one greater than last created
+        assertEq(idReg.nextId(), NUM_IDS + 1);
+
+        // id should always start at 1; ID 0 should be invalid
+        assertEq(idReg.idToOwner(0), address(0));
+        
+        // valid ids correctly set
+        assertEq(idReg.idToOwner(1), OWNER_ID1);
+        assertEq(idReg.idToOwner(2), OWNER_ID2);
+        assertEq(idReg.idToOwner(3), OWNER_ID3);
+        assertEq(idReg.idToOwner(4), OWNER_ID4);
+        assertEq(idReg.idToOwner(5), OWNER_ID5);
+    }
+
+    function test_resetId() external {
+        // setup the ids
+        test_generateIds();
+
+        // call function under test
+        uint256 gasPre = gasleft();
+        idReg.resetId(1);
+        console.log("resetId() cost %d gas", gasPre - gasleft());
+
+        // verify it was reset
+        assertEq(idReg.idToOwner(1), address(0));
+    }
+
+    function test_getOwnersForIds() external {
+        // setup the ids
+        test_generateIds();
+
+        // prepare input
+        uint256[] memory ids = new uint256[](NUM_IDS);
+        ids[0] = 1;
+        ids[1] = 2;
+        ids[2] = 3;
+        ids[3] = 4;
+        ids[4] = 5;
+
+        // call function under test
+        uint256 gasPre = gasleft();
+        address[] memory owners = idReg.getOwnersForIds(ids);
+        console.log("getOwnersForIds() cost %d gas", gasPre - gasleft());
+
+        // verify correct owners returned
+        assertEq(owners[0], OWNER_ID1);
+        assertEq(owners[1], OWNER_ID2);
+        assertEq(owners[2], OWNER_ID3);
+        assertEq(owners[3], OWNER_ID4);
+        assertEq(owners[4], OWNER_ID5);
+    }
+}