Avoid ignoring unsuccessful routine creation

Unsuccessful routine creation is a bug that must be caught instead of
being silently ignored.

Bug: b/148295813
Change-Id: Ic718f0420d6833362944c96a3d172813eba3c207
Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/40568
Tested-by: Nicolas Capens <nicolascapens@google.com>
Kokoro-Presubmit: kokoro <noreply+kokoro@google.com>
Reviewed-by: Antonio Maiorano <amaiorano@google.com>
diff --git a/src/Reactor/ReactorUnitTests.cpp b/src/Reactor/ReactorUnitTests.cpp
index 2ffbcdb..cb446b7 100644
--- a/src/Reactor/ReactorUnitTests.cpp
+++ b/src/Reactor/ReactorUnitTests.cpp
@@ -131,12 +131,9 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		int one[2] = { 1, 0 };
-		int result = routine(&one[1], 2);
-		EXPECT_EQ(result, reference(&one[1], 2));
-	}
+	int one[2] = { 1, 0 };
+	int result = routine(&one[1], 2);
+	EXPECT_EQ(result, reference(&one[1], 2));
 }
 
 TEST(ReactorUnitTests, Uninitialized)
@@ -162,11 +159,8 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		int result = routine();
-		EXPECT_EQ(result, result);  // Anything is fine, just don't crash
-	}
+	int result = routine();
+	EXPECT_EQ(result, result);  // Anything is fine, just don't crash
 }
 
 TEST(ReactorUnitTests, Unreachable)
@@ -186,11 +180,8 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		int result = routine(16);
-		EXPECT_EQ(result, 20);
-	}
+	int result = routine(16);
+	EXPECT_EQ(result, 20);
 }
 
 TEST(ReactorUnitTests, VariableAddress)
@@ -207,11 +198,8 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		int result = routine(16);
-		EXPECT_EQ(result, 20);
-	}
+	int result = routine(16);
+	EXPECT_EQ(result, 20);
 }
 
 TEST(ReactorUnitTests, SubVectorLoadStore)
@@ -232,36 +220,33 @@
 
 	auto routine = function("one");
 
-	if(routine)
+	int8_t in[16 * 5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+		                  17, 18, 19, 20, 21, 22, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0,
+		                  25, 26, 27, 28, 29, 30, 31, 32, 0, 0, 0, 0, 0, 0, 0, 0,
+		                  33, 34, 35, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+		                  37, 38, 39, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+
+	int8_t out[16 * 5] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
+
+	routine(in, out);
+
+	for(int row = 0; row < 5; row++)
 	{
-		int8_t in[16 * 5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-			                  17, 18, 19, 20, 21, 22, 23, 24, 0, 0, 0, 0, 0, 0, 0, 0,
-			                  25, 26, 27, 28, 29, 30, 31, 32, 0, 0, 0, 0, 0, 0, 0, 0,
-			                  33, 34, 35, 36, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-			                  37, 38, 39, 40, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-		int8_t out[16 * 5] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
-
-		routine(in, out);
-
-		for(int row = 0; row < 5; row++)
+		for(int col = 0; col < 16; col++)
 		{
-			for(int col = 0; col < 16; col++)
-			{
-				int i = row * 16 + col;
+			int i = row * 16 + col;
 
-				if(in[i] == 0)
-				{
-					EXPECT_EQ(out[i], -1) << "Row " << row << " column " << col << " not left untouched.";
-				}
-				else
-				{
-					EXPECT_EQ(out[i], in[i]) << "Row " << row << " column " << col << " not equal to input.";
-				}
+			if(in[i] == 0)
+			{
+				EXPECT_EQ(out[i], -1) << "Row " << row << " column " << col << " not left untouched.";
+			}
+			else
+			{
+				EXPECT_EQ(out[i], in[i]) << "Row " << row << " column " << col << " not equal to input.";
 			}
 		}
 	}
@@ -283,28 +268,25 @@
 
 	auto routine = function("one");
 
-	if(routine)
+	int8_t out[16 * 4] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
+
+	int8_t exp[16 * 4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+		                   17, 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   25, 26, 27, 28, 29, 30, 31, 32, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   33, 34, 35, 36, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1 };
+
+	routine(out);
+
+	for(int row = 0; row < 4; row++)
 	{
-		int8_t out[16 * 4] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
-
-		int8_t exp[16 * 4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-			                   17, 18, 19, 20, 21, 22, 23, 24, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   25, 26, 27, 28, 29, 30, 31, 32, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   33, 34, 35, 36, 37, 38, 39, 40, -1, -1, -1, -1, -1, -1, -1, -1 };
-
-		routine(out);
-
-		for(int row = 0; row < 4; row++)
+		for(int col = 0; col < 16; col++)
 		{
-			for(int col = 0; col < 16; col++)
-			{
-				int i = row * 16 + col;
+			int i = row * 16 + col;
 
-				EXPECT_EQ(out[i], exp[i]);
-			}
+			EXPECT_EQ(out[i], exp[i]);
 		}
 	}
 }
@@ -323,24 +305,21 @@
 
 	auto routine = function("one");
 
-	if(routine)
+	int8_t ref[16 * 5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
+		                   1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
+
+	int8_t out[16 * 5] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+		                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
+
+	routine(out);
+
+	for(int row = 0; row < 2; row++)
 	{
-		int8_t ref[16 * 5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
-			                   1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
-
-		int8_t out[16 * 5] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-			                   -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 };
-
-		routine(out);
-
-		for(int row = 0; row < 2; row++)
+		for(int col = 0; col < 16; col++)
 		{
-			for(int col = 0; col < 16; col++)
-			{
-				int i = row * 16 + col;
+			int i = row * 16 + col;
 
-				EXPECT_EQ(out[i], ref[i]) << "Row " << row << " column " << col << " not equal to reference.";
-			}
+			EXPECT_EQ(out[i], ref[i]) << "Row " << row << " column " << col << " not equal to reference.";
 		}
 	}
 }
@@ -360,21 +339,18 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		int out[2][4];
+	int out[2][4];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0x07080304);
-		EXPECT_EQ(out[0][1], 0x15161112);
+	EXPECT_EQ(out[0][0], 0x07080304);
+	EXPECT_EQ(out[0][1], 0x15161112);
 
-		EXPECT_EQ(out[1][0], 0x16120804);
-		EXPECT_EQ(out[1][1], 0x01020304);
-		EXPECT_EQ(out[1][2], 0x06080204);
-	}
+	EXPECT_EQ(out[1][0], 0x16120804);
+	EXPECT_EQ(out[1][1], 0x01020304);
+	EXPECT_EQ(out[1][2], 0x06080204);
 }
 
 static uint16_t swizzleCode4(int i)
@@ -424,83 +400,80 @@
 
 	auto routine = function("one");
 
-	if(routine)
+	struct
 	{
-		struct
-		{
-			float f[256 + 256 + 2][4];
-			int i[388][4];
-		} out;
+		float f[256 + 256 + 2][4];
+		int i[388][4];
+	} out;
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		for(int i = 0; i < 256; i++)
-		{
-			EXPECT_EQ(out.f[i][0], float((i >> 0) & 0x03) + 1.0f);
-			EXPECT_EQ(out.f[i][1], float((i >> 2) & 0x03) + 1.0f);
-			EXPECT_EQ(out.f[i][2], float((i >> 4) & 0x03) + 1.0f);
-			EXPECT_EQ(out.f[i][3], float((i >> 6) & 0x03) + 1.0f);
-		}
+	for(int i = 0; i < 256; i++)
+	{
+		EXPECT_EQ(out.f[i][0], float((i >> 0) & 0x03) + 1.0f);
+		EXPECT_EQ(out.f[i][1], float((i >> 2) & 0x03) + 1.0f);
+		EXPECT_EQ(out.f[i][2], float((i >> 4) & 0x03) + 1.0f);
+		EXPECT_EQ(out.f[i][3], float((i >> 6) & 0x03) + 1.0f);
+	}
 
-		for(int i = 0; i < 256; i++)
-		{
-			EXPECT_EQ(out.f[256 + i][0], float((i >> 0) & 0x03) + 1.0f);
-			EXPECT_EQ(out.f[256 + i][1], float((i >> 2) & 0x03) + 1.0f);
-			EXPECT_EQ(out.f[256 + i][2], float((i >> 4) & 0x03) + 5.0f);
-			EXPECT_EQ(out.f[256 + i][3], float((i >> 6) & 0x03) + 5.0f);
-		}
+	for(int i = 0; i < 256; i++)
+	{
+		EXPECT_EQ(out.f[256 + i][0], float((i >> 0) & 0x03) + 1.0f);
+		EXPECT_EQ(out.f[256 + i][1], float((i >> 2) & 0x03) + 1.0f);
+		EXPECT_EQ(out.f[256 + i][2], float((i >> 4) & 0x03) + 5.0f);
+		EXPECT_EQ(out.f[256 + i][3], float((i >> 6) & 0x03) + 5.0f);
+	}
 
-		EXPECT_EQ(out.f[512 + 0][0], 1.0f);
-		EXPECT_EQ(out.f[512 + 0][1], 5.0f);
-		EXPECT_EQ(out.f[512 + 0][2], 2.0f);
-		EXPECT_EQ(out.f[512 + 0][3], 6.0f);
+	EXPECT_EQ(out.f[512 + 0][0], 1.0f);
+	EXPECT_EQ(out.f[512 + 0][1], 5.0f);
+	EXPECT_EQ(out.f[512 + 0][2], 2.0f);
+	EXPECT_EQ(out.f[512 + 0][3], 6.0f);
 
-		EXPECT_EQ(out.f[512 + 1][0], 3.0f);
-		EXPECT_EQ(out.f[512 + 1][1], 7.0f);
-		EXPECT_EQ(out.f[512 + 1][2], 4.0f);
-		EXPECT_EQ(out.f[512 + 1][3], 8.0f);
+	EXPECT_EQ(out.f[512 + 1][0], 3.0f);
+	EXPECT_EQ(out.f[512 + 1][1], 7.0f);
+	EXPECT_EQ(out.f[512 + 1][2], 4.0f);
+	EXPECT_EQ(out.f[512 + 1][3], 8.0f);
 
-		EXPECT_EQ(out.i[0][0], 0x00050001);
-		EXPECT_EQ(out.i[0][1], 0x00060002);
-		EXPECT_EQ(out.i[0][2], 0x00000000);
-		EXPECT_EQ(out.i[0][3], 0x00000000);
+	EXPECT_EQ(out.i[0][0], 0x00050001);
+	EXPECT_EQ(out.i[0][1], 0x00060002);
+	EXPECT_EQ(out.i[0][2], 0x00000000);
+	EXPECT_EQ(out.i[0][3], 0x00000000);
 
-		EXPECT_EQ(out.i[1][0], 0x00070003);
-		EXPECT_EQ(out.i[1][1], 0x00080004);
-		EXPECT_EQ(out.i[1][2], 0x00000000);
-		EXPECT_EQ(out.i[1][3], 0x00000000);
+	EXPECT_EQ(out.i[1][0], 0x00070003);
+	EXPECT_EQ(out.i[1][1], 0x00080004);
+	EXPECT_EQ(out.i[1][2], 0x00000000);
+	EXPECT_EQ(out.i[1][3], 0x00000000);
 
-		EXPECT_EQ(out.i[2][0], 0x0A020901);
-		EXPECT_EQ(out.i[2][1], 0x0C040B03);
-		EXPECT_EQ(out.i[2][2], 0x00000000);
-		EXPECT_EQ(out.i[2][3], 0x00000000);
+	EXPECT_EQ(out.i[2][0], 0x0A020901);
+	EXPECT_EQ(out.i[2][1], 0x0C040B03);
+	EXPECT_EQ(out.i[2][2], 0x00000000);
+	EXPECT_EQ(out.i[2][3], 0x00000000);
 
-		EXPECT_EQ(out.i[3][0], 0x0E060D05);
-		EXPECT_EQ(out.i[3][1], 0x10080F07);
-		EXPECT_EQ(out.i[3][2], 0x00000000);
-		EXPECT_EQ(out.i[3][3], 0x00000000);
+	EXPECT_EQ(out.i[3][0], 0x0E060D05);
+	EXPECT_EQ(out.i[3][1], 0x10080F07);
+	EXPECT_EQ(out.i[3][2], 0x00000000);
+	EXPECT_EQ(out.i[3][3], 0x00000000);
 
-		for(int i = 0; i < 256; i++)
-		{
-			EXPECT_EQ(out.i[4 + i / 2][0 + (i % 2) * 2] & 0xFFFF,
-			          ((i >> 0) & 0x03) + 1);
-			EXPECT_EQ(out.i[4 + i / 2][0 + (i % 2) * 2] >> 16,
-			          ((i >> 2) & 0x03) + 1);
-			EXPECT_EQ(out.i[4 + i / 2][1 + (i % 2) * 2] & 0xFFFF,
-			          ((i >> 4) & 0x03) + 1);
-			EXPECT_EQ(out.i[4 + i / 2][1 + (i % 2) * 2] >> 16,
-			          ((i >> 6) & 0x03) + 1);
-		}
+	for(int i = 0; i < 256; i++)
+	{
+		EXPECT_EQ(out.i[4 + i / 2][0 + (i % 2) * 2] & 0xFFFF,
+		          ((i >> 0) & 0x03) + 1);
+		EXPECT_EQ(out.i[4 + i / 2][0 + (i % 2) * 2] >> 16,
+		          ((i >> 2) & 0x03) + 1);
+		EXPECT_EQ(out.i[4 + i / 2][1 + (i % 2) * 2] & 0xFFFF,
+		          ((i >> 4) & 0x03) + 1);
+		EXPECT_EQ(out.i[4 + i / 2][1 + (i % 2) * 2] >> 16,
+		          ((i >> 6) & 0x03) + 1);
+	}
 
-		for(int i = 0; i < 256; i++)
-		{
-			EXPECT_EQ(out.i[132 + i][0], ((i >> 0) & 0x03) + 1);
-			EXPECT_EQ(out.i[132 + i][1], ((i >> 2) & 0x03) + 1);
-			EXPECT_EQ(out.i[132 + i][2], ((i >> 4) & 0x03) + 1);
-			EXPECT_EQ(out.i[132 + i][3], ((i >> 6) & 0x03) + 1);
-		}
+	for(int i = 0; i < 256; i++)
+	{
+		EXPECT_EQ(out.i[132 + i][0], ((i >> 0) & 0x03) + 1);
+		EXPECT_EQ(out.i[132 + i][1], ((i >> 2) & 0x03) + 1);
+		EXPECT_EQ(out.i[132 + i][2], ((i >> 4) & 0x03) + 1);
+		EXPECT_EQ(out.i[132 + i][3], ((i >> 6) & 0x03) + 1);
 	}
 }
 
@@ -518,124 +491,116 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		int out[3][4];
+	int out[3][4];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0x16151413);
-		EXPECT_EQ(out[0][1], 0x12111009);
-		EXPECT_EQ(out[0][2], 0x08070605);
-		EXPECT_EQ(out[0][3], 0x04030201);
+	EXPECT_EQ(out[0][0], 0x16151413);
+	EXPECT_EQ(out[0][1], 0x12111009);
+	EXPECT_EQ(out[0][2], 0x08070605);
+	EXPECT_EQ(out[0][3], 0x04030201);
 
-		EXPECT_EQ(out[1][0], 0x08070605);
-		EXPECT_EQ(out[1][1], 0x04030201);
+	EXPECT_EQ(out[1][0], 0x08070605);
+	EXPECT_EQ(out[1][1], 0x04030201);
 
-		EXPECT_EQ(out[2][0], 0x15161314);
-		EXPECT_EQ(out[2][1], 0x11120910);
-		EXPECT_EQ(out[2][2], 0x07080506);
-		EXPECT_EQ(out[2][3], 0x03040102);
-	}
+	EXPECT_EQ(out[2][0], 0x15161314);
+	EXPECT_EQ(out[2][1], 0x11120910);
+	EXPECT_EQ(out[2][2], 0x07080506);
+	EXPECT_EQ(out[2][3], 0x03040102);
 }
 
 TEST(ReactorUnitTests, Shuffle)
 {
+	// |select| is [0aaa:0bbb:0ccc:0ddd] where |aaa|, |bbb|, |ccc|
+	// and |ddd| are 7-bit selection indices. For a total (1 << 12)
+	// possibilities.
+	const int kSelectRange = 1 << 12;
+
+	// Unfortunately, testing the whole kSelectRange results in a test
+	// that is far too slow to run, because LLVM spends exponentially more
+	// time optimizing the function below as the number of test cases
+	// increases.
+	//
+	// To work-around the problem, only test a subset of the range by
+	// skipping every kRangeIncrement value.
+	//
+	// Set this value to 1 if you want to test the whole implementation,
+	// which will take a little less than 2 minutes on a fast workstation.
+	//
+	// The default value here takes about 1390ms, which is a little more than
+	// what the Swizzle test takes (993 ms) on my machine. A non-power-of-2
+	// value ensures a better spread over possible values.
+	const int kRangeIncrement = 11;
+
+	auto rangeIndexToSelect = [](int i) {
+		return static_cast<unsigned short>(
+		    (((i >> 9) & 7) << 0) |
+		    (((i >> 6) & 7) << 4) |
+		    (((i >> 3) & 7) << 8) |
+		    (((i >> 0) & 7) << 12));
+	};
+
+	FunctionT<int(void *)> function;
 	{
-		// |select| is [0aaa:0bbb:0ccc:0ddd] where |aaa|, |bbb|, |ccc|
-		// and |ddd| are 7-bit selection indices. For a total (1 << 12)
-		// possibilities.
-		const int kSelectRange = 1 << 12;
+		Pointer<Byte> out = function.Arg<0>();
 
-		// Unfortunately, testing the whole kSelectRange results in a test
-		// that is far too slow to run, because LLVM spends exponentially more
-		// time optimizing the function below as the number of test cases
-		// increases.
-		//
-		// To work-around the problem, only test a subset of the range by
-		// skipping every kRangeIncrement value.
-		//
-		// Set this value to 1 if you want to test the whole implementation,
-		// which will take a little less than 2 minutes on a fast workstation.
-		//
-		// The default value here takes about 1390ms, which is a little more than
-		// what the Swizzle test takes (993 ms) on my machine. A non-power-of-2
-		// value ensures a better spread over possible values.
-		const int kRangeIncrement = 11;
-
-		auto rangeIndexToSelect = [](int i) {
-			return static_cast<unsigned short>(
-			    (((i >> 9) & 7) << 0) |
-			    (((i >> 6) & 7) << 4) |
-			    (((i >> 3) & 7) << 8) |
-			    (((i >> 0) & 7) << 12));
-		};
-
-		FunctionT<int(void *)> function;
+		for(int i = 0; i < kSelectRange; i += kRangeIncrement)
 		{
-			Pointer<Byte> out = function.Arg<0>();
+			unsigned short select = rangeIndexToSelect(i);
 
-			for(int i = 0; i < kSelectRange; i += kRangeIncrement)
-			{
-				unsigned short select = rangeIndexToSelect(i);
+			*Pointer<Float4>(out + 16 * i) = Shuffle(Float4(1.0f, 2.0f, 3.0f, 4.0f),
+			                                         Float4(5.0f, 6.0f, 7.0f, 8.0f),
+			                                         select);
 
-				*Pointer<Float4>(out + 16 * i) = Shuffle(Float4(1.0f, 2.0f, 3.0f, 4.0f),
-				                                         Float4(5.0f, 6.0f, 7.0f, 8.0f),
-				                                         select);
+			*Pointer<Int4>(out + (kSelectRange + i) * 16) = Shuffle(Int4(10, 11, 12, 13),
+			                                                        Int4(14, 15, 16, 17),
+			                                                        select);
 
-				*Pointer<Int4>(out + (kSelectRange + i) * 16) = Shuffle(Int4(10, 11, 12, 13),
-				                                                        Int4(14, 15, 16, 17),
-				                                                        select);
-
-				*Pointer<UInt4>(out + (2 * kSelectRange + i) * 16) = Shuffle(UInt4(100, 101, 102, 103),
-				                                                             UInt4(104, 105, 106, 107),
-				                                                             select);
-			}
-
-			Return(0);
+			*Pointer<UInt4>(out + (2 * kSelectRange + i) * 16) = Shuffle(UInt4(100, 101, 102, 103),
+			                                                             UInt4(104, 105, 106, 107),
+			                                                             select);
 		}
 
-		auto routine = function("one");
+		Return(0);
+	}
 
-		if(routine)
-		{
-			struct
-			{
-				float f[kSelectRange][4];
-				int i[kSelectRange][4];
-				unsigned u[kSelectRange][4];
-			} out;
+	auto routine = function("one");
 
-			memset(&out, 0, sizeof(out));
+	struct
+	{
+		float f[kSelectRange][4];
+		int i[kSelectRange][4];
+		unsigned u[kSelectRange][4];
+	} out;
 
-			routine(&out);
+	memset(&out, 0, sizeof(out));
 
-			for(int i = 0; i < kSelectRange; i += kRangeIncrement)
-			{
-				EXPECT_EQ(out.f[i][0], float(1.0f + (i & 7)));
-				EXPECT_EQ(out.f[i][1], float(1.0f + ((i >> 3) & 7)));
-				EXPECT_EQ(out.f[i][2], float(1.0f + ((i >> 6) & 7)));
-				EXPECT_EQ(out.f[i][3], float(1.0f + ((i >> 9) & 7)));
-			}
+	routine(&out);
 
-			for(int i = 0; i < kSelectRange; i += kRangeIncrement)
-			{
-				EXPECT_EQ(out.i[i][0], int(10 + (i & 7)));
-				EXPECT_EQ(out.i[i][1], int(10 + ((i >> 3) & 7)));
-				EXPECT_EQ(out.i[i][2], int(10 + ((i >> 6) & 7)));
-				EXPECT_EQ(out.i[i][3], int(10 + ((i >> 9) & 7)));
-			}
+	for(int i = 0; i < kSelectRange; i += kRangeIncrement)
+	{
+		EXPECT_EQ(out.f[i][0], float(1.0f + (i & 7)));
+		EXPECT_EQ(out.f[i][1], float(1.0f + ((i >> 3) & 7)));
+		EXPECT_EQ(out.f[i][2], float(1.0f + ((i >> 6) & 7)));
+		EXPECT_EQ(out.f[i][3], float(1.0f + ((i >> 9) & 7)));
+	}
 
-			for(int i = 0; i < kSelectRange; i += kRangeIncrement)
-			{
-				EXPECT_EQ(out.u[i][0], unsigned(100 + (i & 7)));
-				EXPECT_EQ(out.u[i][1], unsigned(100 + ((i >> 3) & 7)));
-				EXPECT_EQ(out.u[i][2], unsigned(100 + ((i >> 6) & 7)));
-				EXPECT_EQ(out.u[i][3], unsigned(100 + ((i >> 9) & 7)));
-			}
-		}
+	for(int i = 0; i < kSelectRange; i += kRangeIncrement)
+	{
+		EXPECT_EQ(out.i[i][0], int(10 + (i & 7)));
+		EXPECT_EQ(out.i[i][1], int(10 + ((i >> 3) & 7)));
+		EXPECT_EQ(out.i[i][2], int(10 + ((i >> 6) & 7)));
+		EXPECT_EQ(out.i[i][3], int(10 + ((i >> 9) & 7)));
+	}
+
+	for(int i = 0; i < kSelectRange; i += kRangeIncrement)
+	{
+		EXPECT_EQ(out.u[i][0], unsigned(100 + (i & 7)));
+		EXPECT_EQ(out.u[i][1], unsigned(100 + ((i >> 3) & 7)));
+		EXPECT_EQ(out.u[i][2], unsigned(100 + ((i >> 6) & 7)));
+		EXPECT_EQ(out.u[i][3], unsigned(100 + ((i >> 9) & 7)));
 	}
 }
 
@@ -688,12 +653,9 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		int result = routine();
+	int result = routine();
 
-		EXPECT_EQ(result, 1000402222);
-	}
+	EXPECT_EQ(result, 1000402222);
 }
 
 TEST(ReactorUnitTests, MinMax)
@@ -720,64 +682,61 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int out[10][4];
+	unsigned int out[10][4];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0x00000000u);
-		EXPECT_EQ(out[0][1], 0x00000000u);
-		EXPECT_EQ(out[0][2], 0x00000000u);
-		EXPECT_EQ(out[0][3], 0x80000000u);
+	EXPECT_EQ(out[0][0], 0x00000000u);
+	EXPECT_EQ(out[0][1], 0x00000000u);
+	EXPECT_EQ(out[0][2], 0x00000000u);
+	EXPECT_EQ(out[0][3], 0x80000000u);
 
-		EXPECT_EQ(out[1][0], 0x3F800000u);
-		EXPECT_EQ(out[1][1], 0x3F800000u);
-		EXPECT_EQ(out[1][2], 0x00000000u);
-		EXPECT_EQ(out[1][3], 0x80000000u);
+	EXPECT_EQ(out[1][0], 0x3F800000u);
+	EXPECT_EQ(out[1][1], 0x3F800000u);
+	EXPECT_EQ(out[1][2], 0x00000000u);
+	EXPECT_EQ(out[1][3], 0x80000000u);
 
-		EXPECT_EQ(out[2][0], 0x00000000u);
-		EXPECT_EQ(out[2][1], 0x00000000u);
-		EXPECT_EQ(out[2][2], 0xFFFFFFFFu);
-		EXPECT_EQ(out[2][3], 0x00000000u);
+	EXPECT_EQ(out[2][0], 0x00000000u);
+	EXPECT_EQ(out[2][1], 0x00000000u);
+	EXPECT_EQ(out[2][2], 0xFFFFFFFFu);
+	EXPECT_EQ(out[2][3], 0x00000000u);
 
-		EXPECT_EQ(out[3][0], 0x00000001u);
-		EXPECT_EQ(out[3][1], 0x00000001u);
-		EXPECT_EQ(out[3][2], 0x00000000u);
-		EXPECT_EQ(out[3][3], 0x00000000u);
+	EXPECT_EQ(out[3][0], 0x00000001u);
+	EXPECT_EQ(out[3][1], 0x00000001u);
+	EXPECT_EQ(out[3][2], 0x00000000u);
+	EXPECT_EQ(out[3][3], 0x00000000u);
 
-		EXPECT_EQ(out[4][0], 0x00000000u);
-		EXPECT_EQ(out[4][1], 0x00000000u);
-		EXPECT_EQ(out[4][2], 0x00000000u);
-		EXPECT_EQ(out[4][3], 0x00000000u);
+	EXPECT_EQ(out[4][0], 0x00000000u);
+	EXPECT_EQ(out[4][1], 0x00000000u);
+	EXPECT_EQ(out[4][2], 0x00000000u);
+	EXPECT_EQ(out[4][3], 0x00000000u);
 
-		EXPECT_EQ(out[5][0], 0x00000001u);
-		EXPECT_EQ(out[5][1], 0x00000001u);
-		EXPECT_EQ(out[5][2], 0xFFFFFFFFu);
-		EXPECT_EQ(out[5][3], 0x00000000u);
+	EXPECT_EQ(out[5][0], 0x00000001u);
+	EXPECT_EQ(out[5][1], 0x00000001u);
+	EXPECT_EQ(out[5][2], 0xFFFFFFFFu);
+	EXPECT_EQ(out[5][3], 0x00000000u);
 
-		EXPECT_EQ(out[6][0], 0x00000000u);
-		EXPECT_EQ(out[6][1], 0x0000FFFFu);
-		EXPECT_EQ(out[6][2], 0x00000000u);
-		EXPECT_EQ(out[6][3], 0x00000000u);
+	EXPECT_EQ(out[6][0], 0x00000000u);
+	EXPECT_EQ(out[6][1], 0x0000FFFFu);
+	EXPECT_EQ(out[6][2], 0x00000000u);
+	EXPECT_EQ(out[6][3], 0x00000000u);
 
-		EXPECT_EQ(out[7][0], 0x00010001u);
-		EXPECT_EQ(out[7][1], 0x00000000u);
-		EXPECT_EQ(out[7][2], 0x00000000u);
-		EXPECT_EQ(out[7][3], 0x00000000u);
+	EXPECT_EQ(out[7][0], 0x00010001u);
+	EXPECT_EQ(out[7][1], 0x00000000u);
+	EXPECT_EQ(out[7][2], 0x00000000u);
+	EXPECT_EQ(out[7][3], 0x00000000u);
 
-		EXPECT_EQ(out[8][0], 0x00000000u);
-		EXPECT_EQ(out[8][1], 0x00000000u);
-		EXPECT_EQ(out[8][2], 0x00000000u);
-		EXPECT_EQ(out[8][3], 0x00000000u);
+	EXPECT_EQ(out[8][0], 0x00000000u);
+	EXPECT_EQ(out[8][1], 0x00000000u);
+	EXPECT_EQ(out[8][2], 0x00000000u);
+	EXPECT_EQ(out[8][3], 0x00000000u);
 
-		EXPECT_EQ(out[9][0], 0x00010001u);
-		EXPECT_EQ(out[9][1], 0x0000FFFFu);
-		EXPECT_EQ(out[9][2], 0x00000000u);
-		EXPECT_EQ(out[9][3], 0x00000000u);
-	}
+	EXPECT_EQ(out[9][0], 0x00010001u);
+	EXPECT_EQ(out[9][1], 0x0000FFFFu);
+	EXPECT_EQ(out[9][2], 0x00000000u);
+	EXPECT_EQ(out[9][3], 0x00000000u);
 }
 
 TEST(ReactorUnitTests, NotNeg)
@@ -803,59 +762,56 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int out[10][4];
+	unsigned int out[10][4];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0xAAAAAAAAu);
-		EXPECT_EQ(out[0][1], 0x00000000u);
-		EXPECT_EQ(out[0][2], 0x00000000u);
-		EXPECT_EQ(out[0][3], 0x00000000u);
+	EXPECT_EQ(out[0][0], 0xAAAAAAAAu);
+	EXPECT_EQ(out[0][1], 0x00000000u);
+	EXPECT_EQ(out[0][2], 0x00000000u);
+	EXPECT_EQ(out[0][3], 0x00000000u);
 
-		EXPECT_EQ(out[1][0], 0x0000AAAAu);
-		EXPECT_EQ(out[1][1], 0x00000000u);
-		EXPECT_EQ(out[1][2], 0x00000000u);
-		EXPECT_EQ(out[1][3], 0x00000000u);
+	EXPECT_EQ(out[1][0], 0x0000AAAAu);
+	EXPECT_EQ(out[1][1], 0x00000000u);
+	EXPECT_EQ(out[1][2], 0x00000000u);
+	EXPECT_EQ(out[1][3], 0x00000000u);
 
-		EXPECT_EQ(out[2][0], 0xAAAAAAAAu);
-		EXPECT_EQ(out[2][1], 0x55555555u);
-		EXPECT_EQ(out[2][2], 0xFFFFFFFFu);
-		EXPECT_EQ(out[2][3], 0x00000000u);
+	EXPECT_EQ(out[2][0], 0xAAAAAAAAu);
+	EXPECT_EQ(out[2][1], 0x55555555u);
+	EXPECT_EQ(out[2][2], 0xFFFFFFFFu);
+	EXPECT_EQ(out[2][3], 0x00000000u);
 
-		EXPECT_EQ(out[3][0], 0x5555AAAAu);
-		EXPECT_EQ(out[3][1], 0x0000FFFFu);
-		EXPECT_EQ(out[3][2], 0x00000000u);
-		EXPECT_EQ(out[3][3], 0x00000000u);
+	EXPECT_EQ(out[3][0], 0x5555AAAAu);
+	EXPECT_EQ(out[3][1], 0x0000FFFFu);
+	EXPECT_EQ(out[3][2], 0x00000000u);
+	EXPECT_EQ(out[3][3], 0x00000000u);
 
-		EXPECT_EQ(out[4][0], 0xAAAAAAABu);
-		EXPECT_EQ(out[4][1], 0x00000000u);
-		EXPECT_EQ(out[4][2], 0x00000000u);
-		EXPECT_EQ(out[4][3], 0x00000000u);
+	EXPECT_EQ(out[4][0], 0xAAAAAAABu);
+	EXPECT_EQ(out[4][1], 0x00000000u);
+	EXPECT_EQ(out[4][2], 0x00000000u);
+	EXPECT_EQ(out[4][3], 0x00000000u);
 
-		EXPECT_EQ(out[5][0], 0x0000AAABu);
-		EXPECT_EQ(out[5][1], 0x00000000u);
-		EXPECT_EQ(out[5][2], 0x00000000u);
-		EXPECT_EQ(out[5][3], 0x00000000u);
+	EXPECT_EQ(out[5][0], 0x0000AAABu);
+	EXPECT_EQ(out[5][1], 0x00000000u);
+	EXPECT_EQ(out[5][2], 0x00000000u);
+	EXPECT_EQ(out[5][3], 0x00000000u);
 
-		EXPECT_EQ(out[6][0], 0xAAAAAAABu);
-		EXPECT_EQ(out[6][1], 0x55555556u);
-		EXPECT_EQ(out[6][2], 0x00000000u);
-		EXPECT_EQ(out[6][3], 0x00000001u);
+	EXPECT_EQ(out[6][0], 0xAAAAAAABu);
+	EXPECT_EQ(out[6][1], 0x55555556u);
+	EXPECT_EQ(out[6][2], 0x00000000u);
+	EXPECT_EQ(out[6][3], 0x00000001u);
 
-		EXPECT_EQ(out[7][0], 0x5556AAABu);
-		EXPECT_EQ(out[7][1], 0x00010000u);
-		EXPECT_EQ(out[7][2], 0x00000000u);
-		EXPECT_EQ(out[7][3], 0x00000000u);
+	EXPECT_EQ(out[7][0], 0x5556AAABu);
+	EXPECT_EQ(out[7][1], 0x00010000u);
+	EXPECT_EQ(out[7][2], 0x00000000u);
+	EXPECT_EQ(out[7][3], 0x00000000u);
 
-		EXPECT_EQ(out[8][0], 0xBF800000u);
-		EXPECT_EQ(out[8][1], 0x3F800000u);
-		EXPECT_EQ(out[8][2], 0x80000000u);
-		EXPECT_EQ(out[8][3], 0x00000000u);
-	}
+	EXPECT_EQ(out[8][0], 0xBF800000u);
+	EXPECT_EQ(out[8][1], 0x3F800000u);
+	EXPECT_EQ(out[8][2], 0x80000000u);
+	EXPECT_EQ(out[8][3], 0x00000000u);
 }
 
 TEST(ReactorUnitTests, FPtoUI)
@@ -876,24 +832,21 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int out[2][4];
+	unsigned int out[2][4];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0xF0000000u);
-		EXPECT_EQ(out[0][1], 0xC0000000u);
-		EXPECT_EQ(out[0][2], 0x00000001u);
-		EXPECT_EQ(out[0][3], 0xF000F000u);
+	EXPECT_EQ(out[0][0], 0xF0000000u);
+	EXPECT_EQ(out[0][1], 0xC0000000u);
+	EXPECT_EQ(out[0][2], 0x00000001u);
+	EXPECT_EQ(out[0][3], 0xF000F000u);
 
-		EXPECT_EQ(out[1][0], 0xF0000000u);
-		EXPECT_EQ(out[1][1], 0x80000000u);
-		EXPECT_EQ(out[1][2], 0x00000000u);
-		EXPECT_EQ(out[1][3], 0xCCCC0000u);
-	}
+	EXPECT_EQ(out[1][0], 0xF0000000u);
+	EXPECT_EQ(out[1][1], 0x80000000u);
+	EXPECT_EQ(out[1][2], 0x00000000u);
+	EXPECT_EQ(out[1][3], 0xCCCC0000u);
 }
 
 TEST(ReactorUnitTests, VectorCompare)
@@ -915,40 +868,37 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int out[6][4];
+	unsigned int out[6][4];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0x00000000u);
-		EXPECT_EQ(out[0][1], 0xFFFFFFFFu);
-		EXPECT_EQ(out[0][2], 0xFFFFFFFFu);
-		EXPECT_EQ(out[0][3], 0xFFFFFFFFu);
+	EXPECT_EQ(out[0][0], 0x00000000u);
+	EXPECT_EQ(out[0][1], 0xFFFFFFFFu);
+	EXPECT_EQ(out[0][2], 0xFFFFFFFFu);
+	EXPECT_EQ(out[0][3], 0xFFFFFFFFu);
 
-		EXPECT_EQ(out[1][0], 0x00000000u);
-		EXPECT_EQ(out[1][1], 0x00000000u);
-		EXPECT_EQ(out[1][2], 0x00000000u);
-		EXPECT_EQ(out[1][3], 0xFFFFFFFFu);
+	EXPECT_EQ(out[1][0], 0x00000000u);
+	EXPECT_EQ(out[1][1], 0x00000000u);
+	EXPECT_EQ(out[1][2], 0x00000000u);
+	EXPECT_EQ(out[1][3], 0xFFFFFFFFu);
 
-		EXPECT_EQ(out[2][0], 0xFF000000u);
-		EXPECT_EQ(out[2][1], 0x00000000u);
+	EXPECT_EQ(out[2][0], 0xFF000000u);
+	EXPECT_EQ(out[2][1], 0x00000000u);
 
-		EXPECT_EQ(out[3][0], 0xFFFFFFFFu);
-		EXPECT_EQ(out[3][1], 0xFFFFFFFFu);
-		EXPECT_EQ(out[3][2], 0xFFFFFFFFu);
-		EXPECT_EQ(out[3][3], 0xFFFFFFFFu);
+	EXPECT_EQ(out[3][0], 0xFFFFFFFFu);
+	EXPECT_EQ(out[3][1], 0xFFFFFFFFu);
+	EXPECT_EQ(out[3][2], 0xFFFFFFFFu);
+	EXPECT_EQ(out[3][3], 0xFFFFFFFFu);
 
-		EXPECT_EQ(out[4][0], 0xFFFFFFFFu);
-		EXPECT_EQ(out[4][1], 0x00000000u);
-		EXPECT_EQ(out[4][2], 0x00000000u);
-		EXPECT_EQ(out[4][3], 0xFFFFFFFFu);
+	EXPECT_EQ(out[4][0], 0xFFFFFFFFu);
+	EXPECT_EQ(out[4][1], 0x00000000u);
+	EXPECT_EQ(out[4][2], 0x00000000u);
+	EXPECT_EQ(out[4][3], 0xFFFFFFFFu);
 
-		EXPECT_EQ(out[5][0], 0x00000000u);
-		EXPECT_EQ(out[5][1], 0xFFFFFFFFu);
-	}
+	EXPECT_EQ(out[5][0], 0x00000000u);
+	EXPECT_EQ(out[5][1], 0xFFFFFFFFu);
 }
 
 TEST(ReactorUnitTests, SaturatedAddAndSubtract)
@@ -1005,56 +955,53 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int out[14][2];
+	unsigned int out[14][2];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0x08080808u);
-		EXPECT_EQ(out[0][1], 0x08080808u);
+	EXPECT_EQ(out[0][0], 0x08080808u);
+	EXPECT_EQ(out[0][1], 0x08080808u);
 
-		EXPECT_EQ(out[1][0], 0xFFFFFFFFu);
-		EXPECT_EQ(out[1][1], 0xFEFFFFFFu);
+	EXPECT_EQ(out[1][0], 0xFFFFFFFFu);
+	EXPECT_EQ(out[1][1], 0xFEFFFFFFu);
 
-		EXPECT_EQ(out[2][0], 0x00000000u);
-		EXPECT_EQ(out[2][1], 0x08060402u);
+	EXPECT_EQ(out[2][0], 0x00000000u);
+	EXPECT_EQ(out[2][1], 0x08060402u);
 
-		EXPECT_EQ(out[3][0], 0x08080808u);
-		EXPECT_EQ(out[3][1], 0x08080808u);
+	EXPECT_EQ(out[3][0], 0x08080808u);
+	EXPECT_EQ(out[3][1], 0x08080808u);
 
-		EXPECT_EQ(out[4][0], 0x7F7F7F7Fu);
-		EXPECT_EQ(out[4][1], 0x7E7F7F7Fu);
+	EXPECT_EQ(out[4][0], 0x7F7F7F7Fu);
+	EXPECT_EQ(out[4][1], 0x7E7F7F7Fu);
 
-		EXPECT_EQ(out[5][0], 0x80808080u);
-		EXPECT_EQ(out[5][1], 0x88868482u);
+	EXPECT_EQ(out[5][0], 0x80808080u);
+	EXPECT_EQ(out[5][1], 0x88868482u);
 
-		EXPECT_EQ(out[6][0], 0x80808080u);
-		EXPECT_EQ(out[6][1], 0x88868482u);
+	EXPECT_EQ(out[6][0], 0x80808080u);
+	EXPECT_EQ(out[6][1], 0x88868482u);
 
-		EXPECT_EQ(out[7][0], 0x00040004u);
-		EXPECT_EQ(out[7][1], 0x00040004u);
+	EXPECT_EQ(out[7][0], 0x00040004u);
+	EXPECT_EQ(out[7][1], 0x00040004u);
 
-		EXPECT_EQ(out[8][0], 0x7FFF7FFFu);
-		EXPECT_EQ(out[8][1], 0x7FFE7FFFu);
+	EXPECT_EQ(out[8][0], 0x7FFF7FFFu);
+	EXPECT_EQ(out[8][1], 0x7FFE7FFFu);
 
-		EXPECT_EQ(out[9][0], 0x80008000u);
-		EXPECT_EQ(out[9][1], 0x80048002u);
+	EXPECT_EQ(out[9][0], 0x80008000u);
+	EXPECT_EQ(out[9][1], 0x80048002u);
 
-		EXPECT_EQ(out[10][0], 0x80008000u);
-		EXPECT_EQ(out[10][1], 0x80048002u);
+	EXPECT_EQ(out[10][0], 0x80008000u);
+	EXPECT_EQ(out[10][1], 0x80048002u);
 
-		EXPECT_EQ(out[11][0], 0x00040004u);
-		EXPECT_EQ(out[11][1], 0x00040004u);
+	EXPECT_EQ(out[11][0], 0x00040004u);
+	EXPECT_EQ(out[11][1], 0x00040004u);
 
-		EXPECT_EQ(out[12][0], 0xFFFFFFFFu);
-		EXPECT_EQ(out[12][1], 0xFFFEFFFFu);
+	EXPECT_EQ(out[12][0], 0xFFFFFFFFu);
+	EXPECT_EQ(out[12][1], 0xFFFEFFFFu);
 
-		EXPECT_EQ(out[13][0], 0x00000000u);
-		EXPECT_EQ(out[13][1], 0x00040002u);
-	}
+	EXPECT_EQ(out[13][0], 0x00000000u);
+	EXPECT_EQ(out[13][1], 0x00040002u);
 }
 
 TEST(ReactorUnitTests, Unpack)
@@ -1077,24 +1024,21 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int in[1][2];
-		unsigned int out[2][2];
+	unsigned int in[1][2];
+	unsigned int out[2][2];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		in[0][0] = 0xABCDEF12u;
-		in[0][1] = 0x34567890u;
+	in[0][0] = 0xABCDEF12u;
+	in[0][1] = 0x34567890u;
 
-		routine(&in, &out);
+	routine(&in, &out);
 
-		EXPECT_EQ(out[0][0], 0x78EF9012u);
-		EXPECT_EQ(out[0][1], 0x34AB56CDu);
+	EXPECT_EQ(out[0][0], 0x78EF9012u);
+	EXPECT_EQ(out[0][1], 0x34AB56CDu);
 
-		EXPECT_EQ(out[1][0], 0xEFEF1212u);
-		EXPECT_EQ(out[1][1], 0xABABCDCDu);
-	}
+	EXPECT_EQ(out[1][0], 0xEFEF1212u);
+	EXPECT_EQ(out[1][1], 0xABABCDCDu);
 }
 
 TEST(ReactorUnitTests, Pack)
@@ -1124,32 +1068,29 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int out[6][2];
+	unsigned int out[6][2];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0x0201FEFFu);
-		EXPECT_EQ(out[0][1], 0xFCFD0403u);
+	EXPECT_EQ(out[0][0], 0x0201FEFFu);
+	EXPECT_EQ(out[0][1], 0xFCFD0403u);
 
-		EXPECT_EQ(out[1][0], 0x02010000u);
-		EXPECT_EQ(out[1][1], 0x00000403u);
+	EXPECT_EQ(out[1][0], 0x02010000u);
+	EXPECT_EQ(out[1][1], 0x00000403u);
 
-		EXPECT_EQ(out[2][0], 0xFFFEFFFFu);
-		EXPECT_EQ(out[2][1], 0x00020001u);
+	EXPECT_EQ(out[2][0], 0xFFFEFFFFu);
+	EXPECT_EQ(out[2][1], 0x00020001u);
 
-		EXPECT_EQ(out[3][0], 0x00040003u);
-		EXPECT_EQ(out[3][1], 0xFFFCFFFDu);
+	EXPECT_EQ(out[3][0], 0x00040003u);
+	EXPECT_EQ(out[3][1], 0xFFFCFFFDu);
 
-		EXPECT_EQ(out[4][0], 0x00000000u);
-		EXPECT_EQ(out[4][1], 0x00020001u);
+	EXPECT_EQ(out[4][0], 0x00000000u);
+	EXPECT_EQ(out[4][1], 0x00020001u);
 
-		EXPECT_EQ(out[5][0], 0x00040003u);
-		EXPECT_EQ(out[5][1], 0x00000000u);
-	}
+	EXPECT_EQ(out[5][0], 0x00040003u);
+	EXPECT_EQ(out[5][1], 0x00000000u);
 }
 
 TEST(ReactorUnitTests, MulHigh)
@@ -1186,40 +1127,37 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int out[6][4];
+	unsigned int out[6][4];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0x00080002u);
-		EXPECT_EQ(out[0][1], 0x008D000Fu);
+	EXPECT_EQ(out[0][0], 0x00080002u);
+	EXPECT_EQ(out[0][1], 0x008D000Fu);
 
-		EXPECT_EQ(out[1][0], 0x00080002u);
-		EXPECT_EQ(out[1][1], 0xE8C0000Fu);
+	EXPECT_EQ(out[1][0], 0x00080002u);
+	EXPECT_EQ(out[1][1], 0xE8C0000Fu);
 
-		EXPECT_EQ(out[2][0], 0x00000000u);
-		EXPECT_EQ(out[2][1], 0xFFFFFE9Cu);
-		EXPECT_EQ(out[2][2], 0xFFFFFF23u);
-		EXPECT_EQ(out[2][3], 0x01480000u);
+	EXPECT_EQ(out[2][0], 0x00000000u);
+	EXPECT_EQ(out[2][1], 0xFFFFFE9Cu);
+	EXPECT_EQ(out[2][2], 0xFFFFFF23u);
+	EXPECT_EQ(out[2][3], 0x01480000u);
 
-		EXPECT_EQ(out[3][0], 0x00000000u);
-		EXPECT_EQ(out[3][1], 0x00000179u);
-		EXPECT_EQ(out[3][2], 0x00000311u);
-		EXPECT_EQ(out[3][3], 0xB5680000u);
+	EXPECT_EQ(out[3][0], 0x00000000u);
+	EXPECT_EQ(out[3][1], 0x00000179u);
+	EXPECT_EQ(out[3][2], 0x00000311u);
+	EXPECT_EQ(out[3][3], 0xB5680000u);
 
-		EXPECT_EQ(out[4][0], 0x3FFFFFFFu);
-		EXPECT_EQ(out[4][1], 0xC0000000u);
-		EXPECT_EQ(out[4][2], 0x3FFF8000u);
-		EXPECT_EQ(out[4][3], 0x00000000u);
+	EXPECT_EQ(out[4][0], 0x3FFFFFFFu);
+	EXPECT_EQ(out[4][1], 0xC0000000u);
+	EXPECT_EQ(out[4][2], 0x3FFF8000u);
+	EXPECT_EQ(out[4][3], 0x00000000u);
 
-		EXPECT_EQ(out[5][0], 0x3FFFFFFFu);
-		EXPECT_EQ(out[5][1], 0x3FFFFFFFu);
-		EXPECT_EQ(out[5][2], 0x40008000u);
-		EXPECT_EQ(out[5][3], 0xFFFFFFFEu);
-	}
+	EXPECT_EQ(out[5][0], 0x3FFFFFFFu);
+	EXPECT_EQ(out[5][1], 0x3FFFFFFFu);
+	EXPECT_EQ(out[5][2], 0x40008000u);
+	EXPECT_EQ(out[5][3], 0xFFFFFFFEu);
 }
 
 TEST(ReactorUnitTests, MulAdd)
@@ -1238,17 +1176,14 @@
 
 	auto routine = function("one");
 
-	if(routine)
-	{
-		unsigned int out[1][2];
+	unsigned int out[1][2];
 
-		memset(&out, 0, sizeof(out));
+	memset(&out, 0, sizeof(out));
 
-		routine(&out);
+	routine(&out);
 
-		EXPECT_EQ(out[0][0], 0x000AE34Au);
-		EXPECT_EQ(out[0][1], 0x009D5254u);
-	}
+	EXPECT_EQ(out[0][0], 0x000AE34Au);
+	EXPECT_EQ(out[0][1], 0x009D5254u);
 }
 
 TEST(ReactorUnitTests, PointersEqual)
@@ -1501,11 +1436,8 @@
 
 		auto routine = function("one");
 
-		if(routine)
-		{
-			int res = routine();
-			EXPECT_EQ(res, 1 + 2 + 3 + 4);
-		}
+		int res = routine();
+		EXPECT_EQ(res, 1 + 2 + 3 + 4);
 	}
 }
 
@@ -1528,11 +1460,8 @@
 
 		auto routine = function("one");
 
-		if(routine)
-		{
-			int res = routine();
-			EXPECT_EQ(res, 1 + 2 + 3 + 4 + 5);
-		}
+		int res = routine();
+		EXPECT_EQ(res, 1 + 2 + 3 + 4 + 5);
 	}
 }
 
@@ -1555,11 +1484,8 @@
 
 		auto routine = function("one");
 
-		if(routine)
-		{
-			int res = routine();
-			EXPECT_EQ(res, 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
-		}
+		int res = routine();
+		EXPECT_EQ(res, 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
 	}
 }
 
@@ -1586,11 +1512,8 @@
 
 		auto routine = function("one");
 
-		if(routine)
-		{
-			int res = routine();
-			EXPECT_EQ(res, 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
-		}
+		int res = routine();
+		EXPECT_EQ(res, 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8);
 	}
 }
 
@@ -1614,11 +1537,8 @@
 
 		auto routine = function("one");
 
-		if(routine)
-		{
-			int res = routine();
-			EXPECT_EQ(res, 12345);
-		}
+		int res = routine();
+		EXPECT_EQ(res, 12345);
 	}
 }
 
@@ -1781,12 +1701,9 @@
 
 		routine = function("one");
 
-		if(routine)
-		{
-			auto callable = (int (*)(CType))routine->getEntry();
-			CType in = {};
-			EXPECT_EQ(callable(in), 1);
-		}
+		auto callable = (int (*)(CType))routine->getEntry();
+		CType in = {};
+		EXPECT_EQ(callable(in), 1);
 	}
 }
 
@@ -1847,32 +1764,29 @@
 
 		routine = function("one");
 
-		if(routine)
+		auto callable = (CType * (*)(CType *, unsigned int)) routine->getEntry();
+
+		union PtrInt
 		{
-			auto callable = (CType * (*)(CType *, unsigned int)) routine->getEntry();
+			CType *p;
+			size_t i;
+		};
 
-			union PtrInt
-			{
-				CType *p;
-				size_t i;
-			};
+		PtrInt base;
+		base.i = 0x10000;
 
-			PtrInt base;
-			base.i = 0x10000;
+		for(int i = 0; i < 5; i++)
+		{
+			PtrInt reference;
+			reference.p = &base.p[i];
 
-			for(int i = 0; i < 5; i++)
-			{
-				PtrInt reference;
-				reference.p = &base.p[i];
+			PtrInt result;
+			result.p = callable(base.p, i);
 
-				PtrInt result;
-				result.p = callable(base.p, i);
+			auto expect = reference.i - base.i;
+			auto got = result.i - base.i;
 
-				auto expect = reference.i - base.i;
-				auto got = result.i - base.i;
-
-				EXPECT_EQ(got, expect) << "i:" << i;
-			}
+			EXPECT_EQ(got, expect) << "i:" << i;
 		}
 	}
 }