Refactor unit tests and add a few more test cases (gnosis/gp-v2-contracts#397)

This PR is a continuation from #390 and refactors the unit tests a little bit so they make more sense with the new interface, adding a couple more unit tests along the way. This was split into a separate PR to make it easier to review the changes in the parent PR.

### Test Plan

This is the test plan!

Author: LunaTechLab56

src/contracts/test/GPv2SigningTestInterface.sol

@@ -7,6 +7,7 @@ import "../libraries/GPv2Signing.sol";
 import "../libraries/GPv2Trade.sol";
 
 contract GPv2SigningTestInterface {
+    using GPv2Signing for GPv2Order.Data;
     using GPv2Signing for GPv2Signing.RecoveredOrder;
 
     bytes32 public constant DOMAIN_SEPARATOR =
@@ -17,49 +18,42 @@ contract GPv2SigningTestInterface {
             )
         );
 
-    function recoverOrdersFromTradesTest(
+    function recoverOrderFromTradeTest(
         IERC20[] calldata tokens,
-        GPv2Trade.Data[] calldata trades
+        GPv2Trade.Data calldata trade
     )
         external
         view
-        returns (
-            GPv2Signing.RecoveredOrder[] memory recoveredOrders,
-            uint256 mem,
-            uint256 gas_
-        )
+        returns (GPv2Signing.RecoveredOrder memory recoveredOrder, uint256 mem)
     {
         bytes32 domainSeparator = DOMAIN_SEPARATOR;
+        recoveredOrder = GPv2Signing.allocateRecoveredOrder();
 
-        recoveredOrders = new GPv2Signing.RecoveredOrder[](trades.length);
-        for (uint256 i = 0; i < recoveredOrders.length; i++) {
-            recoveredOrders[i].uid = new bytes(GPv2Order.UID_LENGTH);
-        }
-
-        // NOTE: Solidity keeps a total memory count at address 0x40. Check
-        // before and after decoding a trade to compute memory usage growth per
-        // call to `decodeTrade`. Additionally, write 0 past the free memory
-        // pointer so the size of `recoveredOrders` does not affect the gas
-        // measurement.
+        // NOTE: Solidity stores the free memory pointer at address 0x40. Read
+        // it before and after calling `processOrder` to ensure that there are
+        // no memory allocations.
         // solhint-disable-next-line no-inline-assembly
         assembly {
             mem := mload(0x40)
-            mstore(mem, 0)
         }
-        gas_ = gasleft();
 
-        for (uint256 i = 0; i < recoveredOrders.length; i++) {
-            recoveredOrders[i].recoverOrderFromTrade(
-                domainSeparator,
-                tokens,
-                trades[i]
-            );
-        }
+        recoveredOrder.recoverOrderFromTrade(domainSeparator, tokens, trade);
 
         // solhint-disable-next-line no-inline-assembly
         assembly {
             mem := sub(mload(0x40), mem)
         }
-        gas_ = gas_ - gasleft();
+    }
+
+    function recoverOrderSignerTest(
+        GPv2Order.Data memory order,
+        GPv2Signing.Scheme signingScheme,
+        bytes calldata signature
+    ) external view returns (address owner) {
+        (, owner) = order.recoverOrderSigner(
+            DOMAIN_SEPARATOR,
+            signingScheme,
+            signature
+        );
     }
 }

src/contracts/test/GPv2TradeTestInterface.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+pragma solidity ^0.7.6;
+pragma abicoder v2;
+
+import "../libraries/GPv2Order.sol";
+import "../libraries/GPv2Trade.sol";
+
+contract GPv2TradeTestInterface {
+    function extractOrderTest(
+        IERC20[] calldata tokens,
+        GPv2Trade.Data calldata trade
+    ) external pure returns (GPv2Order.Data memory order) {
+        GPv2Trade.extractOrder(trade, tokens, order);
+    }
+
+    function extractFlagsTest(uint256 flags)
+        external
+        pure
+        returns (
+            bytes32 kind,
+            bool partiallyFillable,
+            GPv2Signing.Scheme signingScheme
+        )
+    {
+        return GPv2Trade.extractFlags(flags);
+    }
+}

src/ts/settlement.ts

@@ -137,7 +137,13 @@ export type EncodedSettlement = [
  */
 export const MAX_TRADES_IN_SETTLEMENT = 2 ** 16 - 1;
 
-function encodeSigningScheme(scheme: SigningScheme): number {
+/**
+ * Encodes signing scheme as a bitfield.
+ *
+ * @param scheme The signing scheme to encode.
+ * @return The bitfield result.
+ */
+export function encodeSigningScheme(scheme: SigningScheme): number {
   switch (scheme) {
     case SigningScheme.EIP712:
       return 0b0000;
@@ -150,7 +156,13 @@ function encodeSigningScheme(scheme: SigningScheme): number {
   }
 }
 
-function encodeOrderFlags(flags: OrderFlags): number {
+/**
+ * Encodes order flags as a bitfield.
+ *
+ * @param flags The order flags to encode.
+ * @return The bitfield result.
+ */
+export function encodeOrderFlags(flags: OrderFlags): number {
   let kind;
   switch (flags.kind) {
     case OrderKind.SELL:
@@ -167,7 +179,13 @@ function encodeOrderFlags(flags: OrderFlags): number {
   return kind | partiallyFillable;
 }
 
-function encodeTradeFlags(flags: TradeFlags): number {
+/**
+ * Encodes trade flags as a bitfield.
+ *
+ * @param flags The trade flags to encode.
+ * @return The bitfield result.
+ */
+export function encodeTradeFlags(flags: TradeFlags): number {
   return encodeOrderFlags(flags) | encodeSigningScheme(flags.signingScheme);
 }