Implement tslint enum-naming to enforce PascalCase on enum members (#1474)

2 files changed, 22 insertions, 22 deletions

diff --git a/contracts/protocol/test/exchange/core.ts b/contracts/protocol/test/exchange/core.ts
index 42db8623d..700643b79 100644
--- a/contracts/protocol/test/exchange/core.ts
+++ b/contracts/protocol/test/exchange/core.ts
@@ -1043,7 +1043,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = new BigNumber(0);
-            const expectedOrderStatus = OrderStatus.FILLABLE;
+            const expectedOrderStatus = OrderStatus.Fillable;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1053,7 +1053,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
-            const expectedOrderStatus = OrderStatus.FULLY_FILLED;
+            const expectedOrderStatus = OrderStatus.FullyFilled;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1064,7 +1064,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = takerAssetFillAmount;
-            const expectedOrderStatus = OrderStatus.FILLABLE;
+            const expectedOrderStatus = OrderStatus.Fillable;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1074,7 +1074,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = new BigNumber(0);
-            const expectedOrderStatus = OrderStatus.CANCELLED;
+            const expectedOrderStatus = OrderStatus.Cancelled;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1086,7 +1086,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = takerAssetFillAmount;
-            const expectedOrderStatus = OrderStatus.CANCELLED;
+            const expectedOrderStatus = OrderStatus.Cancelled;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1098,7 +1098,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = new BigNumber(0);
-            const expectedOrderStatus = OrderStatus.EXPIRED;
+            const expectedOrderStatus = OrderStatus.Expired;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1112,7 +1112,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = takerAssetFillAmount;
-            const expectedOrderStatus = OrderStatus.EXPIRED;
+            const expectedOrderStatus = OrderStatus.Expired;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1126,7 +1126,7 @@ describe('Exchange core', () => {
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
             // FULLY_FILLED takes precedence over EXPIRED
-            const expectedOrderStatus = OrderStatus.FULLY_FILLED;
+            const expectedOrderStatus = OrderStatus.FullyFilled;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1136,7 +1136,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = new BigNumber(0);
-            const expectedOrderStatus = OrderStatus.INVALID_MAKER_ASSET_AMOUNT;
+            const expectedOrderStatus = OrderStatus.InvalidMakerAssetAmount;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
@@ -1146,7 +1146,7 @@ describe('Exchange core', () => {
             const orderInfo = await exchangeWrapper.getOrderInfoAsync(signedOrder);
             const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
             const expectedTakerAssetFilledAmount = new BigNumber(0);
-            const expectedOrderStatus = OrderStatus.INVALID_TAKER_ASSET_AMOUNT;
+            const expectedOrderStatus = OrderStatus.InvalidTakerAssetAmount;
             expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
             expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
             expect(orderInfo.orderStatus).to.equal(expectedOrderStatus);
diff --git a/contracts/protocol/test/exchange/wrapper.ts b/contracts/protocol/test/exchange/wrapper.ts
index c9efb0c9d..4c4506945 100644
--- a/contracts/protocol/test/exchange/wrapper.ts
+++ b/contracts/protocol/test/exchange/wrapper.ts
@@ -1288,7 +1288,7 @@ describe('Exchange wrappers', () => {
                 _.forEach(signedOrders, (signedOrder, index) => {
                     const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
                     const expectedTakerAssetFilledAmount = new BigNumber(0);
-                    const expectedOrderStatus = OrderStatus.FILLABLE;
+                    const expectedOrderStatus = OrderStatus.Fillable;
                     const orderInfo = ordersInfo[index];
                     expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
                     expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1303,7 +1303,7 @@ describe('Exchange wrappers', () => {
                 _.forEach(signedOrders, (signedOrder, index) => {
                     const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
                     const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
-                    const expectedOrderStatus = OrderStatus.FILLABLE;
+                    const expectedOrderStatus = OrderStatus.Fillable;
                     const orderInfo = ordersInfo[index];
                     expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
                     expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1317,7 +1317,7 @@ describe('Exchange wrappers', () => {
                 _.forEach(signedOrders, (signedOrder, index) => {
                     const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
                     const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount;
-                    const expectedOrderStatus = OrderStatus.FULLY_FILLED;
+                    const expectedOrderStatus = OrderStatus.FullyFilled;
                     const orderInfo = ordersInfo[index];
                     expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
                     expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1331,7 +1331,7 @@ describe('Exchange wrappers', () => {
                 _.forEach(signedOrders, (signedOrder, index) => {
                     const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
                     const expectedTakerAssetFilledAmount = new BigNumber(0);
-                    const expectedOrderStatus = OrderStatus.CANCELLED;
+                    const expectedOrderStatus = OrderStatus.Cancelled;
                     const orderInfo = ordersInfo[index];
                     expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
                     expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1347,7 +1347,7 @@ describe('Exchange wrappers', () => {
                 _.forEach(signedOrders, (signedOrder, index) => {
                     const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
                     const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
-                    const expectedOrderStatus = OrderStatus.CANCELLED;
+                    const expectedOrderStatus = OrderStatus.Cancelled;
                     const orderInfo = ordersInfo[index];
                     expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
                     expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1363,7 +1363,7 @@ describe('Exchange wrappers', () => {
                 _.forEach(signedOrders, (signedOrder, index) => {
                     const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
                     const expectedTakerAssetFilledAmount = new BigNumber(0);
-                    const expectedOrderStatus = OrderStatus.EXPIRED;
+                    const expectedOrderStatus = OrderStatus.Expired;
                     const orderInfo = ordersInfo[index];
                     expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
                     expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1381,7 +1381,7 @@ describe('Exchange wrappers', () => {
                 _.forEach(signedOrders, (signedOrder, index) => {
                     const expectedOrderHash = orderHashUtils.getOrderHashHex(signedOrder);
                     const expectedTakerAssetFilledAmount = signedOrder.takerAssetAmount.div(2);
-                    const expectedOrderStatus = OrderStatus.EXPIRED;
+                    const expectedOrderStatus = OrderStatus.Expired;
                     const orderInfo = ordersInfo[index];
                     expect(orderInfo.orderHash).to.be.equal(expectedOrderHash);
                     expect(orderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(expectedTakerAssetFilledAmount);
@@ -1408,7 +1408,7 @@ describe('Exchange wrappers', () => {
 
                 const expectedUnfilledOrderHash = orderHashUtils.getOrderHashHex(unfilledOrder);
                 const expectedUnfilledTakerAssetFilledAmount = new BigNumber(0);
-                const expectedUnfilledOrderStatus = OrderStatus.FILLABLE;
+                const expectedUnfilledOrderStatus = OrderStatus.Fillable;
                 const unfilledOrderInfo = ordersInfo[0];
                 expect(unfilledOrderInfo.orderHash).to.be.equal(expectedUnfilledOrderHash);
                 expect(unfilledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
@@ -1418,7 +1418,7 @@ describe('Exchange wrappers', () => {
 
                 const expectedPartialOrderHash = orderHashUtils.getOrderHashHex(partiallyFilledOrder);
                 const expectedPartialTakerAssetFilledAmount = partiallyFilledOrder.takerAssetAmount.div(2);
-                const expectedPartialOrderStatus = OrderStatus.FILLABLE;
+                const expectedPartialOrderStatus = OrderStatus.Fillable;
                 const partialOrderInfo = ordersInfo[1];
                 expect(partialOrderInfo.orderHash).to.be.equal(expectedPartialOrderHash);
                 expect(partialOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
@@ -1428,7 +1428,7 @@ describe('Exchange wrappers', () => {
 
                 const expectedFilledOrderHash = orderHashUtils.getOrderHashHex(fullyFilledOrder);
                 const expectedFilledTakerAssetFilledAmount = fullyFilledOrder.takerAssetAmount;
-                const expectedFilledOrderStatus = OrderStatus.FULLY_FILLED;
+                const expectedFilledOrderStatus = OrderStatus.FullyFilled;
                 const filledOrderInfo = ordersInfo[2];
                 expect(filledOrderInfo.orderHash).to.be.equal(expectedFilledOrderHash);
                 expect(filledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
@@ -1438,7 +1438,7 @@ describe('Exchange wrappers', () => {
 
                 const expectedCancelledOrderHash = orderHashUtils.getOrderHashHex(cancelledOrder);
                 const expectedCancelledTakerAssetFilledAmount = new BigNumber(0);
-                const expectedCancelledOrderStatus = OrderStatus.CANCELLED;
+                const expectedCancelledOrderStatus = OrderStatus.Cancelled;
                 const cancelledOrderInfo = ordersInfo[3];
                 expect(cancelledOrderInfo.orderHash).to.be.equal(expectedCancelledOrderHash);
                 expect(cancelledOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(
@@ -1448,7 +1448,7 @@ describe('Exchange wrappers', () => {
 
                 const expectedExpiredOrderHash = orderHashUtils.getOrderHashHex(expiredOrder);
                 const expectedExpiredTakerAssetFilledAmount = new BigNumber(0);
-                const expectedExpiredOrderStatus = OrderStatus.EXPIRED;
+                const expectedExpiredOrderStatus = OrderStatus.Expired;
                 const expiredOrderInfo = ordersInfo[4];
                 expect(expiredOrderInfo.orderHash).to.be.equal(expectedExpiredOrderHash);
                 expect(expiredOrderInfo.orderTakerAssetFilledAmount).to.be.bignumber.equal(