diff --git a/test/Big.cpp b/test/Big.cpp
index e3b95b6..39e38d4 100644
--- a/test/Big.cpp
+++ b/test/Big.cpp
@@ -3,82 +3,40 @@
 #include <string>
 
 TEST_CASE("SBigAdd", "[big]") {
+    BigDataTest a, b, c;
+
     SECTION("adds 0 and 1") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 1);
 
         SBigAdd(a, b, c);
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 
     SECTION("adds 1 and 2") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 1);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 2);
 
         SBigAdd(a, b, c);
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 3);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 
     SECTION("adds 0x12345678 and 0x23456789") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0x12345678);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 0x23456789);
 
         SBigAdd(a, b, c);
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 0x3579BE01);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 
     SECTION("adds 0xFFFFFFFF and 0xF0F0F0F0") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0xFFFFFFFF);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 0xF0F0F0F0);
 
         SBigAdd(a, b, c);
@@ -86,17 +44,11 @@ TEST_CASE("SBigAdd", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0xF0F0F0EF);
         CHECK(a->Primary()[1] == 0x1);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 }
 
 TEST_CASE("SBigAnd", "[big]") {
-    BigDataTest a;
-    BigDataTest b;
-    BigDataTest c;
+    BigDataTest a, b, c;
 
     SECTION("overwrites output") {
         SBigFromUnsigned(a, 123456);
@@ -130,61 +82,45 @@ TEST_CASE("SBigAnd", "[big]") {
 }
 
 TEST_CASE("SBigBitLen", "[big]") {
+    BigDataTest num;
+
     SECTION("returns bit length of 1") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 1);
 
         uint32_t len;
         SBigBitLen(num, &len);
 
         CHECK(len == 1);
-
-        SBigDel(num);
     }
 
     SECTION("returns bit length of 5") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 5);
 
         uint32_t len;
         SBigBitLen(num, &len);
 
         CHECK(len == 3);
-
-        SBigDel(num);
     }
 
     SECTION("returns bit length of 0xFFFF") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0xFFFF);
 
         uint32_t len;
         SBigBitLen(num, &len);
 
         CHECK(len == 16);
-
-        SBigDel(num);
     }
 
     SECTION("returns bit length of 0xFFFFFFFF") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0xFFFFFFFF);
 
         uint32_t len;
         SBigBitLen(num, &len);
 
         CHECK(len == 32);
-
-        SBigDel(num);
     }
 
     SECTION("returns bit length of 0x22222222AAAAAAAA") {
-        BigData* num;
-        SBigNew(&num);
         uint64_t num_ = 0x22222222AAAAAAAA;
         SBigFromBinary(num, reinterpret_cast<uint8_t*>(&num_), sizeof(num_));
 
@@ -192,25 +128,17 @@ TEST_CASE("SBigBitLen", "[big]") {
         SBigBitLen(num, &len);
 
         CHECK(len == 62);
-
-        SBigDel(num);
     }
 }
 
 TEST_CASE("SBigCompare", "[big]") {
-    SECTION("compares 10 and 1") {
-        BigData* a;
-        SBigNew(&a);
-        SBigFromUnsigned(a, 10);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("compares 10 and 1") {
+        SBigFromUnsigned(a, 10);
         SBigFromUnsigned(b, 1);
 
         CHECK(SBigCompare(a, b) == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
@@ -319,29 +247,23 @@ TEST_CASE("SBigDiv", "[big]") {
 }
 
 TEST_CASE("SBigFromBinary", "[big]") {
+    BigDataTest num;
+
     SECTION("creates bigdata from 0") {
-        BigData* num;
-        SBigNew(&num);
         uint32_t data = 0;
         SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data));
 
         CHECK(num->Primary().Count() == 1);
         CHECK(num->Primary()[0] == 0);
-
-        SBigDel(num);
     }
 
     SECTION("creates bigdata from 0x123456789ABCDEF0") {
-        BigData* num;
-        SBigNew(&num);
         uint64_t data = 0x123456789ABCDEF0;
         SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data));
 
         CHECK(num->Primary().Count() == 2);
         CHECK(num->Primary()[0] == 0x9ABCDEF0);
         CHECK(num->Primary()[1] == 0x12345678);
-
-        SBigDel(num);
     }
 }
 
@@ -372,26 +294,20 @@ TEST_CASE("SBigFromStr", "[big]") {
 }
 
 TEST_CASE("SBigFromUnsigned", "[big]") {
+    BigDataTest num;
+
     SECTION("creates bigdata from 0") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0);
 
         CHECK(num->Primary().Count() == 1);
         CHECK(num->Primary()[0] == 0);
-
-        SBigDel(num);
     }
 
     SECTION("creates bigdata from 0x12345678") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0x12345678);
 
         CHECK(num->Primary().Count() == 1);
         CHECK(num->Primary()[0] == 0x12345678);
-
-        SBigDel(num);
     }
 }
 TEST_CASE("SBigInc", "[big]") {
@@ -507,16 +423,9 @@ TEST_CASE("SBigIsZero", "[big]") {
 }
 
 TEST_CASE("SBigMod", "[big]") {
+    BigDataTest a, b, c;
     SECTION("mods 7 by 4") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 7);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 4);
 
         SBigMod(a, b, c);
@@ -525,30 +434,14 @@ TEST_CASE("SBigMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 3);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 
     SECTION("mods 7 by 4 then mods 9 by 5") {
-        BigData* a;
-        SBigNew(&a);
+        BigDataTest b1, c1, b2, c2;
 
-        BigData* b1;
-        SBigNew(&b1);
         SBigFromUnsigned(b1, 7);
-
-        BigData* c1;
-        SBigNew(&c1);
         SBigFromUnsigned(c1, 4);
-
-        BigData* b2;
-        SBigNew(&b2);
         SBigFromUnsigned(b2, 9);
-
-        BigData* c2;
-        SBigNew(&c2);
         SBigFromUnsigned(c2, 5);
 
         SBigMod(a, b1, c1);
@@ -564,25 +457,11 @@ TEST_CASE("SBigMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 4);
-
-        SBigDel(a);
-        SBigDel(b1);
-        SBigDel(c1);
-        SBigDel(b2);
-        SBigDel(c2);
     }
 
     SECTION("mods 0x9999444488885555 by 0xFFFFFFFF") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0x9999444488885555;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 0xFFFFFFFF);
 
         SBigMod(a, b, c);
@@ -591,24 +470,14 @@ TEST_CASE("SBigMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 0x2221999A);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 }
 
 TEST_CASE("SBigMul", "[big]") {
+    BigDataTest a, b, c;
+
     SECTION("multiplies 0 and 1") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 1);
 
         SBigMul(a, b, c);
@@ -616,22 +485,10 @@ TEST_CASE("SBigMul", "[big]") {
         a->Primary().Trim();
 
         CHECK(a->Primary().Count() == 0);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 
     SECTION("multiplies 2 and 4") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 4);
 
         SBigMul(a, b, c);
@@ -640,22 +497,10 @@ TEST_CASE("SBigMul", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 8);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 
     SECTION("multiplies 0xFFFFFFFF and 0x100") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0xFFFFFFFF);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 0x100);
 
         SBigMul(a, b, c);
@@ -665,22 +510,10 @@ TEST_CASE("SBigMul", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0xFFFFFF00);
         CHECK(a->Primary()[1] == 0xFF);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 
     SECTION("multiplies 0xFFFFFF and 0x11223344") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0xFFFFFF);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 0x11223344);
 
         SBigMul(a, b, c);
@@ -690,28 +523,14 @@ TEST_CASE("SBigMul", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0x32DDCCBC);
         CHECK(a->Primary()[1] == 0x112233);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
     }
 }
 
 TEST_CASE("SBigPowMod", "[big]") {
+    BigDataTest a, b, c, d;
     SECTION("takes 256 to the 8th power and mods the result by 999") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 256);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 8);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 999);
 
         SBigPowMod(a, b, c, d);
@@ -720,11 +539,6 @@ TEST_CASE("SBigPowMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 160);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 }
 
@@ -820,12 +634,9 @@ TEST_CASE("SBigOr", "[big]") {
 }
 
 TEST_CASE("SBigShl", "[big]") {
-    SECTION("shifts 256 left 7 bits") {
-        BigData* a;
-        SBigNew(&a);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("shifts 256 left 7 bits") {
         SBigFromUnsigned(b, 256);
 
         SBigShl(a, b, 7);
@@ -834,19 +645,13 @@ TEST_CASE("SBigShl", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 32768);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
 TEST_CASE("SBigShr", "[big]") {
-    SECTION("shifts 256 right 7 bits") {
-        BigData* a;
-        SBigNew(&a);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("shifts 256 right 7 bits") {
         SBigFromUnsigned(b, 256);
 
         SBigShr(a, b, 7);
@@ -855,19 +660,13 @@ TEST_CASE("SBigShr", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 2);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
 TEST_CASE("SBigSquare", "[big]") {
-    SECTION("squares 0xFFFFFFFF") {
-        BigData* a;
-        SBigNew(&a);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("squares 0xFFFFFFFF") {
         SBigFromUnsigned(b, 0xFFFFFFFF);
 
         SBigSquare(a, b);
@@ -877,9 +676,6 @@ TEST_CASE("SBigSquare", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0x1);
         CHECK(a->Primary()[1] == 0xFFFFFFFE);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
@@ -910,9 +706,9 @@ TEST_CASE("SBigSub", "[big]") {
 }
 
 TEST_CASE("SBigToBinaryBuffer", "[big]") {
+    BigDataTest num;
+
     SECTION("returns expected buffer for bigdata representing 0") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0);
 
         uint8_t buffer[4];
@@ -920,13 +716,9 @@ TEST_CASE("SBigToBinaryBuffer", "[big]") {
         SBigToBinaryBuffer(num, buffer, sizeof(buffer), &bytes);
 
         REQUIRE(bytes == 0);
-
-        SBigDel(num);
     }
 
     SECTION("returns expected buffer for bigdata representing 0x12345678") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0x12345678);
 
         uint8_t buffer[4];
@@ -935,13 +727,9 @@ TEST_CASE("SBigToBinaryBuffer", "[big]") {
 
         CHECK(bytes == 4);
         CHECK(*reinterpret_cast<uint32_t*>(buffer) == 0x12345678);
-
-        SBigDel(num);
     }
 
     SECTION("returns expected buffer for bigdata representing 0x123456789ABCDEF0") {
-        BigData* num;
-        SBigNew(&num);
         uint64_t data = 0x123456789ABCDEF0;
         SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data));
 
@@ -951,7 +739,5 @@ TEST_CASE("SBigToBinaryBuffer", "[big]") {
 
         CHECK(bytes == 8);
         CHECK(*reinterpret_cast<uint64_t*>(buffer) == 0x123456789ABCDEF0);
-
-        SBigDel(num);
     }
 }
diff --git a/test/big/Ops.cpp b/test/big/Ops.cpp
index 78cb50d..5365de0 100644
--- a/test/big/Ops.cpp
+++ b/test/big/Ops.cpp
@@ -3,15 +3,12 @@
 #include "test/Test.hpp"
 
 TEST_CASE("Add", "[big]") {
-    SECTION("adds 0 and 1") {
-        BigData* a;
-        SBigNew(&a);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("adds 0 and 1") {
         SBigFromUnsigned(b, 0);
 
-        uint64_t c = 1;
+        uint32_t c = 1;
 
         Add(a->Primary(), b->Primary(), c);
 
@@ -19,20 +16,12 @@ TEST_CASE("Add", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("adds 2 and 4") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
 
-        uint64_t c = 4;
+        uint32_t c = 4;
 
         Add(a->Primary(), b->Primary(), c);
 
@@ -40,20 +29,12 @@ TEST_CASE("Add", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 6);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("adds 0xFFFFFFFF and 0xCCCCCCCC") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0xFFFFFFFF);
 
-        uint64_t c = 0xCCCCCCCC;
+        uint32_t c = 0xCCCCCCCC;
 
         Add(a->Primary(), b->Primary(), c);
 
@@ -62,16 +43,11 @@ TEST_CASE("Add", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0xCCCCCCCB);
         CHECK(a->Primary()[1] == 0x1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
 TEST_CASE("And", "[big]") {
-    BigDataTest a;
-    BigDataTest b;
-    BigDataTest c;
+    BigDataTest a, b, c;
 
     SECTION("overwrites output") {
         SBigFromUnsigned(a, 123456);
@@ -105,93 +81,51 @@ TEST_CASE("And", "[big]") {
 }
 
 TEST_CASE("Compare", "[big]") {
-    SECTION("compares 0 and 1") {
-        BigData* a;
-        SBigNew(&a);
-        SBigFromUnsigned(a, 0);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("compares 0 and 1") {
+        SBigFromUnsigned(a, 0);
         SBigFromUnsigned(b, 1);
 
         CHECK(Compare(a->Primary(), b->Primary()) == -1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("compares 1 and 1") {
-        BigData* a;
-        SBigNew(&a);
         SBigFromUnsigned(a, 1);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 1);
 
         CHECK(Compare(a->Primary(), b->Primary()) == 0);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("compares 10 and 1") {
-        BigData* a;
-        SBigNew(&a);
         SBigFromUnsigned(a, 10);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 1);
 
         CHECK(Compare(a->Primary(), b->Primary()) == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("compares 0x1111111111111111 and 0x22222222") {
-        BigData* a;
-        SBigNew(&a);
         uint64_t data = 0x1111111111111111;
         SBigFromBinary(a, reinterpret_cast<uint8_t*>(&data), sizeof(data));
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0x22222222);
 
         CHECK(Compare(a->Primary(), b->Primary()) == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("compares 0x11111111 and 0x2222222222222222") {
-        BigData* a;
-        SBigNew(&a);
         SBigFromUnsigned(a, 0x11111111);
-
-        BigData* b;
-        SBigNew(&b);
+        
         uint64_t data = 0x2222222222222222;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&data), sizeof(data));
 
         CHECK(Compare(a->Primary(), b->Primary()) == -1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
 TEST_CASE("Div", "[big]") {
+    BigDataTest a, b, c, d;
     SECTION("divides 2 by 1") {
-        BigData* a;
-        SBigNew(&a);
-
         uint32_t b;
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 2);
 
         uint64_t d = 1;
@@ -201,24 +135,10 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 2);
         CHECK(b == 0);
-
-        SBigDel(a);
-        SBigDel(c);
     }
 
     SECTION("divides 2 by 1 (buffer divisor)") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 2);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 1);
 
         Div(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -229,21 +149,11 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 2);
         CHECK(b->Primary().Count() == 0);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("divides 5 by 2") {
-        BigData* a;
-        SBigNew(&a);
-
         uint32_t b;
 
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 5);
 
         uint64_t d = 2;
@@ -253,19 +163,11 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 2);
         CHECK(b == 1);
-
-        SBigDel(a);
-        SBigDel(c);
     }
 
     SECTION("divides 7 by 4") {
-        BigData* a;
-        SBigNew(&a);
-
         uint32_t b;
 
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 7);
 
         uint64_t d = 4;
@@ -275,24 +177,10 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
         CHECK(b == 3);
-
-        SBigDel(a);
-        SBigDel(c);
     }
 
     SECTION("divides 7 by 4 (buffer divisor)") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 7);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 4);
 
         Div(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -304,21 +192,11 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary()[0] == 1);
         CHECK(b->Primary().Count() == 1);
         CHECK(b->Primary()[0] == 3);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("divides 0x9999444488885555 by 0x2222") {
-        BigData* a;
-        SBigNew(&a);
-
         uint32_t b;
 
-        BigData* c;
-        SBigNew(&c);
         uint64_t c_ = 0x9999444488885555;
         SBigFromBinary(c, reinterpret_cast<uint8_t*>(&c_), sizeof(c_));
 
@@ -330,25 +208,12 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary()[0] == 0x00040002);
         CHECK(a->Primary()[1] == 0x48002);
         CHECK(b == 0x1111);
-
-        SBigDel(a);
-        SBigDel(c);
     }
 
     SECTION("divides 0x9999444488885555 by 0x2222 (buffer divisor)") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
-
-        BigData* c;
-        SBigNew(&c);
         uint64_t c_ = 0x9999444488885555;
         SBigFromBinary(c, reinterpret_cast<uint8_t*>(&c_), sizeof(c_));
 
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 0x2222);
 
         Div(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -361,21 +226,11 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary()[1] == 0x48002);
         CHECK(b->Primary().Count() == 1);
         CHECK(b->Primary()[0] == 0x1111);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("divides 0x9999444488885555 by 0xFFFFFFFF") {
-        BigData* a;
-        SBigNew(&a);
-
         uint32_t b;
 
-        BigData* c;
-        SBigNew(&c);
         uint64_t c_ = 0x9999444488885555;
         SBigFromBinary(c, reinterpret_cast<uint8_t*>(&c_), sizeof(c_));
 
@@ -386,25 +241,12 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 0x99994445);
         CHECK(b == 0x2221999A);
-
-        SBigDel(a);
-        SBigDel(c);
     }
 
     SECTION("divides 0x9999444488885555 by 0xFFFFFFFF (buffer divisor)") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
-
-        BigData* c;
-        SBigNew(&c);
         uint64_t c_ = 0x9999444488885555;
         SBigFromBinary(c, reinterpret_cast<uint8_t*>(&c_), sizeof(c_));
 
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 0xFFFFFFFF);
 
         Div(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -416,27 +258,12 @@ TEST_CASE("Div", "[big]") {
         CHECK(a->Primary()[0] == 0x99994445);
         CHECK(b->Primary().Count() == 1);
         CHECK(b->Primary()[0] == 0x2221999A);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("divides 0x9999444488885555 by 0x1111222233334444 (buffer divisor)") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
-
-        BigData* c;
-        SBigNew(&c);
         uint64_t c_ = 0x9999444488885555;
         SBigFromBinary(c, reinterpret_cast<uint8_t*>(&c_), sizeof(c_));
 
-        BigData* d;
-        SBigNew(&d);
         uint64_t d_ = 0x1111222233334444;
         SBigFromBinary(d, reinterpret_cast<uint8_t*>(&d_), sizeof(d_));
 
@@ -450,11 +277,6 @@ TEST_CASE("Div", "[big]") {
         CHECK(b->Primary().Count() == 2);
         CHECK(b->Primary()[0] == 0xEEEE3335);
         CHECK(b->Primary()[1] == 0x11103332);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 }
 
@@ -582,65 +404,42 @@ TEST_CASE("ExtractLowPartSx", "[big]") {
 }
 
 TEST_CASE("HighBitPos", "[big]") {
+    BigDataTest num;
     SECTION("returns position of high bit for 0") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0);
 
         CHECK(HighBitPos(num->Primary()) == 0);
-
-        SBigDel(num);
     }
 
     SECTION("returns position of high bit for 0x1000") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0x1000);
 
         CHECK(HighBitPos(num->Primary()) == 12);
-
-        SBigDel(num);
     }
 
     SECTION("returns position of high bit for 0x1111") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0x1111);
 
         CHECK(HighBitPos(num->Primary()) == 12);
-
-        SBigDel(num);
     }
 
     SECTION("returns position of high bit for 0xFFFF") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0xFFFF);
 
         CHECK(HighBitPos(num->Primary()) == 15);
-
-        SBigDel(num);
     }
 
     SECTION("returns position of high bit for 0xFFFFFFFF") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0xFFFFFFFF);
 
         CHECK(HighBitPos(num->Primary()) == 31);
-
-        SBigDel(num);
     }
 
     SECTION("returns position of high bit for 0x123456789ABCDEF0") {
-        BigData* num;
-        SBigNew(&num);
         uint64_t data = 0x123456789ABCDEF0;
         SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data));
 
         CHECK(HighBitPos(num->Primary()) == 60);
-
-        SBigDel(num);
     }
 }
 
@@ -671,12 +470,9 @@ TEST_CASE("InsertLowPart", "[big]") {
 }
 
 TEST_CASE("Mul", "[big]") {
-    SECTION("multiplies 0 and 1") {
-        BigData* a;
-        SBigNew(&a);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("multiplies 0 and 1") {
         SBigFromUnsigned(b, 0);
 
         uint64_t c = 1;
@@ -686,17 +482,9 @@ TEST_CASE("Mul", "[big]") {
         a->Primary().Trim();
 
         CHECK(a->Primary().Count() == 0);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("multiplies 2 and 4") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
 
         uint64_t c = 4;
@@ -707,17 +495,9 @@ TEST_CASE("Mul", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 8);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("multiplies 0xFFFFFFFF and 0x100") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0xFFFFFFFF);
 
         uint64_t c = 0x100;
@@ -729,27 +509,15 @@ TEST_CASE("Mul", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0xFFFFFF00);
         CHECK(a->Primary()[1] == 0xFF);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
 TEST_CASE("MulMod", "[big]") {
+    BigDataTest a, b, c, d;
+
     SECTION("multiplies 0xFFFFFFFF by 0x100 and mods the result by 0xABC") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0xFFFFFFFF);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 0x100);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 0xABC);
 
         MulMod(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -758,29 +526,15 @@ TEST_CASE("MulMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 0x624);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("multiplies 0x123456789ABCDEF0 by 0xFEDCBA9876543210 and mods the result by 0x10000000") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0x123456789ABCDEF0;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
-        BigData* c;
-        SBigNew(&c);
         uint64_t c_ = 0xFEDCBA9876543210;
         SBigFromBinary(c, reinterpret_cast<uint8_t*>(&c_), sizeof(c_));
 
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 0x10000000);
 
         MulMod(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -789,11 +543,6 @@ TEST_CASE("MulMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 0x618CF00);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 }
 
@@ -812,20 +561,11 @@ TEST_CASE("MakeLarge", "[big]") {
 }
 
 TEST_CASE("PowMod", "[big]") {
+    BigDataTest a, b, c, d;
+
     SECTION("takes 0 to the 0th power and mods the result by 1") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 0);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 1);
 
         PowMod(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -834,27 +574,11 @@ TEST_CASE("PowMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("takes 2 to the 0th power and mods the result by 7") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 0);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 7);
 
         PowMod(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -863,27 +587,11 @@ TEST_CASE("PowMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("takes 2 to the 4th power and mods the result by 7") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 4);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 7);
 
         PowMod(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -892,27 +600,11 @@ TEST_CASE("PowMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 2);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("takes 256 to the 8th power and mods the result by 999") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 256);
-
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 8);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 999);
 
         PowMod(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -921,28 +613,13 @@ TEST_CASE("PowMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 160);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("takes 0x100000000 to the 2nd power and mods the result by 0xAAAAFFFF") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0x100000000;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 2);
-
-        BigData* d;
-        SBigNew(&d);
         SBigFromUnsigned(d, 0xAAAAFFFF);
 
         PowMod(a->Primary(), b->Primary(), c->Primary(), d->Primary(), a->Stack());
@@ -951,28 +628,14 @@ TEST_CASE("PowMod", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 0x6AA94002);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 
     SECTION("takes 0xABCDEF1234567890 to the 16th power and mods the result by 0xEEEE000000000001") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0xABCDEF1234567890;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
-        BigData* c;
-        SBigNew(&c);
         SBigFromUnsigned(c, 16);
 
-        BigData* d;
-        SBigNew(&d);
         uint64_t d_ = 0xEEEE000000000001;
         SBigFromBinary(d, reinterpret_cast<uint8_t*>(&d_), sizeof(d_));
 
@@ -983,18 +646,13 @@ TEST_CASE("PowMod", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0x950A5465);
         CHECK(a->Primary()[1] == 0xA0CB742F);
-
-        SBigDel(a);
-        SBigDel(b);
-        SBigDel(c);
-        SBigDel(d);
     }
 }
 
 TEST_CASE("SetOne", "[big]") {
+    BigDataTest num;
+
     SECTION("sets buffer to one") {
-        BigData* num;
-        SBigNew(&num);
         uint64_t data = 0x123456789ABCDEF0;
         SBigFromBinary(num, reinterpret_cast<uint8_t*>(&data), sizeof(data));
 
@@ -1004,15 +662,13 @@ TEST_CASE("SetOne", "[big]") {
 
         CHECK(num->Primary().Count() == 1);
         CHECK(num->Primary()[0] == 1);
-
-        SBigDel(num);
     }
 }
 
 TEST_CASE("SetZero", "[big]") {
+    BigDataTest num;
+    
     SECTION("sets buffer to zero") {
-        BigData* num;
-        SBigNew(&num);
         SBigFromUnsigned(num, 0x12345678);
 
         CHECK(num->Primary().Count() == 1);
@@ -1020,18 +676,13 @@ TEST_CASE("SetZero", "[big]") {
         SetZero(num->Primary());
 
         CHECK(num->Primary().Count() == 0);
-
-        SBigDel(num);
     }
 }
 
 TEST_CASE("Shl", "[big]") {
-    SECTION("shifts 0 left 1 bit") {
-        BigData* a;
-        SBigNew(&a);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("shifts 0 left 1 bit") {
         SBigFromUnsigned(b, 0);
 
         Shl(a->Primary(), b->Primary(), 1);
@@ -1039,17 +690,9 @@ TEST_CASE("Shl", "[big]") {
         a->Primary().Trim();
 
         CHECK(a->Primary().Count() == 0);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 1 left 0 bits") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 1);
 
         Shl(a->Primary(), b->Primary(), 0);
@@ -1058,17 +701,9 @@ TEST_CASE("Shl", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 1 left 1 bit") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 1);
 
         Shl(a->Primary(), b->Primary(), 1);
@@ -1077,17 +712,9 @@ TEST_CASE("Shl", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 2);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 2 left 1 bit") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
 
         Shl(a->Primary(), b->Primary(), 1);
@@ -1096,17 +723,9 @@ TEST_CASE("Shl", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 4);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 256 left 7 bits") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 256);
 
         Shl(a->Primary(), b->Primary(), 7);
@@ -1115,17 +734,9 @@ TEST_CASE("Shl", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 32768);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 0xFFFFFFFF left 10 bits") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0xFFFFFFFF;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
@@ -1136,17 +747,9 @@ TEST_CASE("Shl", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0xFFFFFC00);
         CHECK(a->Primary()[1] == 0x3FF);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 0x1000000000000000 left 1 bit") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0x1000000000000000;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
@@ -1157,17 +760,9 @@ TEST_CASE("Shl", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0);
         CHECK(a->Primary()[1] == 0x20000000);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 0x1000000000000000 left 16 bits") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0x1000000000000000;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
@@ -1179,19 +774,13 @@ TEST_CASE("Shl", "[big]") {
         CHECK(a->Primary()[0] == 0);
         CHECK(a->Primary()[1] == 0);
         CHECK(a->Primary()[2] == 0x1000);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
 TEST_CASE("Shr", "[big]") {
-    SECTION("shifts 0 right 1 bit") {
-        BigData* a;
-        SBigNew(&a);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("shifts 0 right 1 bit") {
         SBigFromUnsigned(b, 0);
 
         Shr(a->Primary(), b->Primary(), 1);
@@ -1199,17 +788,9 @@ TEST_CASE("Shr", "[big]") {
         a->Primary().Trim();
 
         CHECK(a->Primary().Count() == 0);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 1 right 0 bits") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 1);
 
         Shr(a->Primary(), b->Primary(), 0);
@@ -1218,17 +799,9 @@ TEST_CASE("Shr", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 1 right 1 bit") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 1);
 
         Shr(a->Primary(), b->Primary(), 1);
@@ -1236,17 +809,9 @@ TEST_CASE("Shr", "[big]") {
         a->Primary().Trim();
 
         CHECK(a->Primary().Count() == 0);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 2 right 1 bit") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
 
         Shr(a->Primary(), b->Primary(), 1);
@@ -1255,17 +820,9 @@ TEST_CASE("Shr", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 2 right 1 bit") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
 
         Shr(a->Primary(), b->Primary(), 1);
@@ -1274,17 +831,9 @@ TEST_CASE("Shr", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 256 right 7 bits") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 256);
 
         Shr(a->Primary(), b->Primary(), 7);
@@ -1293,17 +842,9 @@ TEST_CASE("Shr", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 2);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 0x1000000000000000 right 2 bits") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0x1000000000000000;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
@@ -1314,17 +855,9 @@ TEST_CASE("Shr", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0);
         CHECK(a->Primary()[1] == 0x4000000);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("shifts 0x1000000000000000 right 32 bits") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0x1000000000000000;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
@@ -1334,19 +867,13 @@ TEST_CASE("Shr", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 0x10000000);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }
 
 TEST_CASE("Square", "[big]") {
-    SECTION("squares 0") {
-        BigData* a;
-        SBigNew(&a);
+    BigDataTest a, b;
 
-        BigData* b;
-        SBigNew(&b);
+    SECTION("squares 0") {
         SBigFromUnsigned(b, 0);
 
         Square(a->Primary(), b->Primary(), a->Stack());
@@ -1354,17 +881,9 @@ TEST_CASE("Square", "[big]") {
         a->Primary().Trim();
 
         CHECK(a->Primary().Count() == 0);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("squares 1") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 1);
 
         Square(a->Primary(), b->Primary(), a->Stack());
@@ -1373,17 +892,9 @@ TEST_CASE("Square", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 1);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("squares 2") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
 
         Square(a->Primary(), b->Primary(), a->Stack());
@@ -1392,17 +903,9 @@ TEST_CASE("Square", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 4);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("squares 2") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 2);
 
         Square(a->Primary(), b->Primary(), a->Stack());
@@ -1411,17 +914,9 @@ TEST_CASE("Square", "[big]") {
 
         CHECK(a->Primary().Count() == 1);
         CHECK(a->Primary()[0] == 4);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("squares 0xFFFFFFFF") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         SBigFromUnsigned(b, 0xFFFFFFFF);
 
         Square(a->Primary(), b->Primary(), a->Stack());
@@ -1431,17 +926,9 @@ TEST_CASE("Square", "[big]") {
         CHECK(a->Primary().Count() == 2);
         CHECK(a->Primary()[0] == 0x1);
         CHECK(a->Primary()[1] == 0xFFFFFFFE);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 
     SECTION("squares 0x1111111111111111") {
-        BigData* a;
-        SBigNew(&a);
-
-        BigData* b;
-        SBigNew(&b);
         uint64_t b_ = 0x1111111111111111;
         SBigFromBinary(b, reinterpret_cast<uint8_t*>(&b_), sizeof(b_));
 
@@ -1454,9 +941,6 @@ TEST_CASE("Square", "[big]") {
         CHECK(a->Primary()[1] == 0xfedcba9);
         CHECK(a->Primary()[2] == 0x89abcdf0);
         CHECK(a->Primary()[3] == 0x1234567);
-
-        SBigDel(a);
-        SBigDel(b);
     }
 }