diff --git a/examples/common.mk b/examples/common.mk
index 5c5377c07a..a79e3b937a 100644
--- a/examples/common.mk
+++ b/examples/common.mk
@@ -14,7 +14,7 @@ CPP_OBJS=$(addprefix objs/, $(CPP_SRC:.cpp=.o) $(TASK_OBJ))
 
 default: $(EXAMPLE)
 
-all: $(EXAMPLE) $(EXAMPLE)-sse4 $(EXAMPLE)-generic16
+all: $(EXAMPLE) $(EXAMPLE)-sse4 $(EXAMPLE)-generic16 $(EXAMPLE)-scalar
 
 .PHONY: dirs clean
 
@@ -57,3 +57,9 @@ objs/$(ISPC_SRC:.ispc=)_generic16.o: objs/$(ISPC_SRC:.ispc=)_generic16.cpp
 
 $(EXAMPLE)-generic16: $(CPP_OBJS) objs/$(ISPC_SRC:.ispc=)_generic16.o
 	$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS)
+
+objs/$(ISPC_SRC:.ispc=)_scalar.o: $(ISPC_SRC)
+	$(ISPC) $< -o $@ --target=generic-1
+
+$(EXAMPLE)-scalar: $(CPP_OBJS) objs/$(ISPC_SRC:.ispc=)_scalar.o
+	$(CXX) $(CXXFLAGS) -o $@ $^ $(LIBS)
diff --git a/run_tests.py b/run_tests.py
index ccd10e6048..724e1037e3 100755
--- a/run_tests.py
+++ b/run_tests.py
@@ -53,7 +53,8 @@
 else:
     ispc_exe = "../Release/ispc.exe"
 
-is_generic_target = options.target.find("generic-") != -1
+is_generic_target = (options.target.find("generic-") != -1 and
+                     options.target != "generic-1")
 if is_generic_target and options.include_file == None:
     if options.target == "generic-4":
         sys.stderr.write("No generics #include specified; using examples/intrinsics/sse4.h\n")
@@ -224,7 +225,7 @@ def run_test(filename):
                   "in test %s\n" % filename)
             return (1, 0)
         else:
-            is_generic_target = options.target.find("generic-") != -1
+            global is_generic_target
             if is_generic_target:
                 obj_name = "%s.cpp" % filename
 
diff --git a/tests/array-gather-multi-unif.ispc b/tests/array-gather-multi-unif.ispc
index bf0794daf5..d876f31415 100644
--- a/tests/array-gather-multi-unif.ispc
+++ b/tests/array-gather-multi-unif.ispc
@@ -15,7 +15,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 }
 
 export void result(uniform float RET[]) { 
-    if (programCount == 4)
+    if (programCount == 1)
+        RET[programIndex] = 1;
+    else if (programCount == 4)
         RET[programIndex] = 5.; 
     else
         RET[programIndex] = 10.; 
diff --git a/tests/array-pointer-duality-1.ispc b/tests/array-pointer-duality-1.ispc
index 4982897ede..b8ac18b3b8 100644
--- a/tests/array-pointer-duality-1.ispc
+++ b/tests/array-pointer-duality-1.ispc
@@ -3,13 +3,13 @@ export uniform int width() { return programCount; }
 
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
-    uniform float a[programCount];
-    for (unsigned int i = 0; i < programCount; ++i)
-        a[i] = aFOO[i];
+    uniform float a[programCount+4];
+    for (unsigned int i = 0; i < programCount+4; ++i)
+        a[i] = aFOO[min((int)i, programCount)];
 
     RET[programIndex] = *(a + 2);
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 3;
+    RET[programIndex] = (programCount == 1) ? 1 : 3;
 }
diff --git a/tests/array-scatter-unif-2.ispc b/tests/array-scatter-unif-2.ispc
index 2c989e9614..ef0c659bbb 100644
--- a/tests/array-scatter-unif-2.ispc
+++ b/tests/array-scatter-unif-2.ispc
@@ -14,4 +14,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 }
 
     
-export void result(uniform float RET[]) { RET[programIndex] = 5; }
+export void result(uniform float RET[]) { RET[programIndex] = programCount == 1 ? 0 : 5; }
diff --git a/tests/array-scatter-unif.ispc b/tests/array-scatter-unif.ispc
index 61aaa24a71..a553d70394 100644
--- a/tests/array-scatter-unif.ispc
+++ b/tests/array-scatter-unif.ispc
@@ -14,7 +14,9 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
     
 export void result(uniform float RET[]) { 
-    if (programCount == 4)
+    if (programCount == 1)
+        RET[programIndex] = 0;
+    else if (programCount == 4)
         RET[programIndex] = 2;
     else
         RET[programIndex] = 4;
diff --git a/tests/atomics-10.ispc b/tests/atomics-10.ispc
index 1e941f8175..194c0b0f81 100644
--- a/tests/atomics-10.ispc
+++ b/tests/atomics-10.ispc
@@ -13,5 +13,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 2;
+    RET[programIndex] = programCount == 1 ? 1 : 2;
 }
diff --git a/tests/atomics-13.ispc b/tests/atomics-13.ispc
index 71413ed0f2..fe9a5d1e74 100644
--- a/tests/atomics-13.ispc
+++ b/tests/atomics-13.ispc
@@ -12,5 +12,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = (programCount/2) - 1;
+    RET[programIndex] = programCount == 1 ? 0 : ((programCount/2) - 1);
 }
diff --git a/tests/atomics-6.ispc b/tests/atomics-6.ispc
index 778c5d0172..a15d3e38e2 100644
--- a/tests/atomics-6.ispc
+++ b/tests/atomics-6.ispc
@@ -10,5 +10,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 3000;
+    RET[programIndex] = (programCount == 1) ? 2 : 3000;
 }
diff --git a/tests/atomics-8.ispc b/tests/atomics-8.ispc
index c81a7838d5..ea2df46ed4 100644
--- a/tests/atomics-8.ispc
+++ b/tests/atomics-8.ispc
@@ -12,5 +12,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = programCount;
+    RET[programIndex] = (programCount == 1) ? 0 : programCount;
 }
diff --git a/tests/atomics-9.ispc b/tests/atomics-9.ispc
index 52396ad121..18961e0b09 100644
--- a/tests/atomics-9.ispc
+++ b/tests/atomics-9.ispc
@@ -13,5 +13,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 1;
+    RET[programIndex] = (programCount == 1) ? 0 : 1;
 }
diff --git a/tests/broadcast-1.ispc b/tests/broadcast-1.ispc
index 7cefce7ae8..27b88eccdf 100644
--- a/tests/broadcast-1.ispc
+++ b/tests/broadcast-1.ispc
@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     int a = aFOO[programIndex]; 
-    int br = broadcast(a, (uniform int)b-2);
+    int br = (programCount == 1) ? 4 : broadcast(a, (uniform int)b-2);
     RET[programIndex] = br;
 }
 
diff --git a/tests/broadcast-2.ispc b/tests/broadcast-2.ispc
index 2efc98ed0c..1cc1d0c492 100644
--- a/tests/broadcast-2.ispc
+++ b/tests/broadcast-2.ispc
@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     int16 a = aFOO[programIndex]; 
-    int16 b = broadcast(a, 2);
+    int16 b = (programCount == 1) ? 3 : broadcast(a, 2);
     RET[programIndex] = b;
 }
 
diff --git a/tests/broadcast-3.ispc b/tests/broadcast-3.ispc
index e1b1308bad..a456eb2fed 100644
--- a/tests/broadcast-3.ispc
+++ b/tests/broadcast-3.ispc
@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     int8 a = aFOO[programIndex]; 
-    int8 br = broadcast(a, (uniform int)b-2);
+    int8 br = (programCount == 1) ? 4 : broadcast(a, (uniform int)b-2);
     RET[programIndex] = br;
 }
 
diff --git a/tests/broadcast.ispc b/tests/broadcast.ispc
index e45bbf902c..1df835ae3b 100644
--- a/tests/broadcast.ispc
+++ b/tests/broadcast.ispc
@@ -3,7 +3,7 @@ export uniform int width() { return programCount; }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     float a = aFOO[programIndex]; 
-    float b = broadcast(a, 2);
+    float b = (programCount == 1) ? 3 : broadcast(a, 2);
     RET[programIndex] = b;
 }
 
diff --git a/tests/extract-1.ispc b/tests/extract-1.ispc
index 220107cb9d..7e8d7804fa 100644
--- a/tests/extract-1.ispc
+++ b/tests/extract-1.ispc
@@ -3,9 +3,9 @@ export uniform int width() { return programCount; }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
     double a = programIndex;
-    RET[programIndex] = extract(a, 3); 
+    RET[programIndex] = extract(a, min(programCount-1, 3)); 
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 3;
+    RET[programIndex] = (programCount == 1) ? 0 : 3;
 }
diff --git a/tests/packed-load-3.ispc b/tests/packed-load-3.ispc
index 150fd4285f..9055cb659b 100644
--- a/tests/packed-load-3.ispc
+++ b/tests/packed-load-3.ispc
@@ -12,5 +12,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 2;
+    RET[programIndex] = (programCount == 1) ? 1 : 2;
 }
diff --git a/tests/packed-load-5.ispc b/tests/packed-load-5.ispc
index ee3dae7b84..2678b069da 100644
--- a/tests/packed-load-5.ispc
+++ b/tests/packed-load-5.ispc
@@ -15,8 +15,12 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    for (uniform int i = 0; i < programCount/2; ++i) {
-        RET[2*i+1] = 10+i;
-        RET[2*i] = 10+programCount/2+i;
+    if (programCount == 1)
+        RET[0] = 10;
+    else {
+        for (uniform int i = 0; i < programCount/2; ++i) {
+            RET[2*i+1] = 10+i;
+            RET[2*i] = 10+programCount/2+i;
+        }
     }
 }
diff --git a/tests/packed-store-3.ispc b/tests/packed-store-3.ispc
index 8cec64e750..12a6368a82 100644
--- a/tests/packed-store-3.ispc
+++ b/tests/packed-store-3.ispc
@@ -13,5 +13,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = programCount/2;
+    RET[programIndex] = (programCount == 1) ? 1 : programCount/2;
 }
diff --git a/tests/popcnt-3.ispc b/tests/popcnt-3.ispc
index c1553086f5..110bf5e415 100644
--- a/tests/popcnt-3.ispc
+++ b/tests/popcnt-3.ispc
@@ -8,4 +8,4 @@ export void f_f(uniform float RET[4], uniform float aFOO[]) {
     RET[programIndex] = popcnt(a < 3);
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 2; }
+export void result(uniform float RET[]) { RET[programIndex] = programCount == 1 ? 1 : 2; }
diff --git a/tests/ptr-assign-lhs-math-1.ispc b/tests/ptr-assign-lhs-math-1.ispc
index 2b34cbae82..d28c17b0a4 100644
--- a/tests/ptr-assign-lhs-math-1.ispc
+++ b/tests/ptr-assign-lhs-math-1.ispc
@@ -2,8 +2,9 @@
 export uniform int width() { return programCount; }
 
 export void f_f(uniform float RET[], uniform float aFOO[]) {
-    uniform float a[programCount];
+    uniform float a[programCount+1];
     a[programIndex] = aFOO[programIndex];
+    a[programCount] = 1;
 
     uniform float * uniform ptr = a;
     *(ptr+1) = 0;
@@ -12,5 +13,6 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 
 export void result(uniform float RET[]) {
     RET[programIndex] = 1+programIndex;
-    RET[1] = 0;
+    if (programCount > 0)
+        RET[1] = 0;
 }
diff --git a/tests/reduce-add-double-1.ispc b/tests/reduce-add-double-1.ispc
index 08da8ea77b..9ff50b2c1c 100644
--- a/tests/reduce-add-double-1.ispc
+++ b/tests/reduce-add-double-1.ispc
@@ -5,7 +5,7 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     double v = aFOO[programIndex];
-    uniform float m;
+    uniform float m = 42;
     int iv = (int)v;
     if (iv & 1)
         m = reduce_add((double)iv);
@@ -14,7 +14,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 4;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 4;
     else if (programCount == 8) x = 16;
     else if (programCount == 16) x = 64;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-double-2.ispc b/tests/reduce-add-double-2.ispc
index 89c6a493a3..1be0d10bd8 100644
--- a/tests/reduce-add-double-2.ispc
+++ b/tests/reduce-add-double-2.ispc
@@ -13,7 +13,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 10;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 10;
     else if (programCount == 8) x = 36;
     else if (programCount == 16) x = 136;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-double.ispc b/tests/reduce-add-double.ispc
index 350bf191d6..e3b47554b4 100644
--- a/tests/reduce-add-double.ispc
+++ b/tests/reduce-add-double.ispc
@@ -11,4 +11,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = -3; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? -1 : -3; }
diff --git a/tests/reduce-add-float-1.ispc b/tests/reduce-add-float-1.ispc
index c01249fedd..dd37384936 100644
--- a/tests/reduce-add-float-1.ispc
+++ b/tests/reduce-add-float-1.ispc
@@ -14,7 +14,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 4;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 4;
     else if (programCount == 8) x = 16;
     else if (programCount == 16) x = 64;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-float-2.ispc b/tests/reduce-add-float-2.ispc
index 6cae8b44e0..53aa85aafc 100644
--- a/tests/reduce-add-float-2.ispc
+++ b/tests/reduce-add-float-2.ispc
@@ -13,7 +13,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 10;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 10;
     else if (programCount == 8) x = 36;
     else if (programCount == 16) x = 136;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-float.ispc b/tests/reduce-add-float.ispc
index 91fb5689fd..7c68bf28b3 100644
--- a/tests/reduce-add-float.ispc
+++ b/tests/reduce-add-float.ispc
@@ -11,4 +11,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = -3; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? -1 : -3; }
diff --git a/tests/reduce-add-int-1.ispc b/tests/reduce-add-int-1.ispc
index 18c2634a55..9ac887c6a0 100644
--- a/tests/reduce-add-int-1.ispc
+++ b/tests/reduce-add-int-1.ispc
@@ -14,7 +14,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 4;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 4;
     else if (programCount == 8) x = 16;
     else if (programCount == 16) x = 64;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-int.ispc b/tests/reduce-add-int.ispc
index 4ea4577d62..01ff745c2b 100644
--- a/tests/reduce-add-int.ispc
+++ b/tests/reduce-add-int.ispc
@@ -14,7 +14,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 10;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 10;
     else if (programCount == 8) x = 36;
     else if (programCount == 16) x = 136;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-int64-1.ispc b/tests/reduce-add-int64-1.ispc
index e60ca79198..cdc88bc32a 100644
--- a/tests/reduce-add-int64-1.ispc
+++ b/tests/reduce-add-int64-1.ispc
@@ -14,7 +14,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 4;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 4;
     else if (programCount == 8) x = 16;
     else if (programCount == 16) x = 64;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-int64.ispc b/tests/reduce-add-int64.ispc
index 5ef3dfee24..894dddeab6 100644
--- a/tests/reduce-add-int64.ispc
+++ b/tests/reduce-add-int64.ispc
@@ -13,7 +13,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 10;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 10;
     else if (programCount == 8) x = 36;
     else if (programCount == 16) x = 136;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-uint-1.ispc b/tests/reduce-add-uint-1.ispc
index 7702a67c53..291200a644 100644
--- a/tests/reduce-add-uint-1.ispc
+++ b/tests/reduce-add-uint-1.ispc
@@ -14,7 +14,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 4;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 4;
     else if (programCount == 8) x = 16;
     else if (programCount == 16) x = 64;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-uint.ispc b/tests/reduce-add-uint.ispc
index 8becef361b..70c40e2b2d 100644
--- a/tests/reduce-add-uint.ispc
+++ b/tests/reduce-add-uint.ispc
@@ -12,4 +12,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 10 * programCount/4; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 1 : (10 * programCount/4); }
diff --git a/tests/reduce-add-uint64-1.ispc b/tests/reduce-add-uint64-1.ispc
index d33170f5a2..5469a8984c 100644
--- a/tests/reduce-add-uint64-1.ispc
+++ b/tests/reduce-add-uint64-1.ispc
@@ -14,7 +14,8 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 export void result(uniform float RET[]) { 
     uniform int x = -1234;
-    if (programCount == 4) x = 4;
+    if (programCount == 1) x = 1;
+    else if (programCount == 4) x = 4;
     else if (programCount == 8) x = 16;
     else if (programCount == 16) x = 64;
     RET[programIndex] = x;
diff --git a/tests/reduce-add-uint64.ispc b/tests/reduce-add-uint64.ispc
index e637878af5..e44e790314 100644
--- a/tests/reduce-add-uint64.ispc
+++ b/tests/reduce-add-uint64.ispc
@@ -11,4 +11,6 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 10 * programCount/4; }
+export void result(uniform float RET[]) { 
+    RET[programIndex] = (programCount == 1) ? 1 : (10 * programCount/4);
+}
diff --git a/tests/reduce-equal-13.ispc b/tests/reduce-equal-13.ispc
index e37d597eee..66e97b62b2 100644
--- a/tests/reduce-equal-13.ispc
+++ b/tests/reduce-equal-13.ispc
@@ -4,8 +4,8 @@ export uniform int width() { return programCount; }
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     int a = aFOO[programIndex&1];
     RET[programIndex] = 1;
-    uniform bool re;
-    uniform int val;
+    uniform bool re = false;
+    uniform int val = 16;
     if (programIndex & 1) {
         re = reduce_equal(a, &val);
     }
@@ -13,5 +13,5 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 258;
+    RET[programIndex] = (programCount == 1) ? 16 : 258;
 }
diff --git a/tests/reduce-equal-3.ispc b/tests/reduce-equal-3.ispc
index ca158f82fd..62d7526176 100644
--- a/tests/reduce-equal-3.ispc
+++ b/tests/reduce-equal-3.ispc
@@ -9,5 +9,5 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 0;
+    RET[programIndex] = (programCount == 1) ? 1 : 0;
 }
diff --git a/tests/reduce-equal-4.ispc b/tests/reduce-equal-4.ispc
index 4c6f980828..43e2d643d6 100644
--- a/tests/reduce-equal-4.ispc
+++ b/tests/reduce-equal-4.ispc
@@ -2,7 +2,7 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    int a = aFOO[programIndex/(programCount/2)];
+    int a = aFOO[programIndex/max(1, (programCount/2))];
     RET[programIndex] = 0;
     if (programIndex >= programCount/2 && a < 4)
         RET[programIndex] = reduce_equal(a) ? 1 : 0; 
diff --git a/tests/reduce-equal-9.ispc b/tests/reduce-equal-9.ispc
index 24fde82cfa..dcafce204b 100644
--- a/tests/reduce-equal-9.ispc
+++ b/tests/reduce-equal-9.ispc
@@ -11,5 +11,5 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 0;
+    RET[programIndex] = (programCount == 1) ? 1 : 0;
 }
diff --git a/tests/reduce-equal.ispc b/tests/reduce-equal.ispc
index f09ec94037..38244afbdd 100644
--- a/tests/reduce-equal.ispc
+++ b/tests/reduce-equal.ispc
@@ -7,5 +7,5 @@ export void f_f(uniform float RET[], uniform float aFOO[]) {
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 0;
+    RET[programIndex] = (programCount == 1) ? 1 : 0;
 }
diff --git a/tests/reduce-max-double.ispc b/tests/reduce-max-double.ispc
index 672987ff58..61908beba7 100644
--- a/tests/reduce-max-double.ispc
+++ b/tests/reduce-max-double.ispc
@@ -5,10 +5,10 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     double v = aFOO[programIndex];
-    uniform float m;
+    uniform float m = 42;
     if (v >= 3)
         m = reduce_max(-v);
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = -3; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 42 : -3; }
diff --git a/tests/reduce-max-float.ispc b/tests/reduce-max-float.ispc
index 7a914c72bf..97290aee5e 100644
--- a/tests/reduce-max-float.ispc
+++ b/tests/reduce-max-float.ispc
@@ -5,10 +5,10 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float v = aFOO[programIndex];
-    uniform float m;
+    uniform float m = 42;
     if (v >= 3)
         m = reduce_max(-v);
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = -3; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 42 : -3; }
diff --git a/tests/reduce-max-int.ispc b/tests/reduce-max-int.ispc
index a66ac8b573..b7e98a3fc6 100644
--- a/tests/reduce-max-int.ispc
+++ b/tests/reduce-max-int.ispc
@@ -5,10 +5,10 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float v = aFOO[programIndex];
-    uniform float m;
+    uniform float m = 42;
     if (v >= 3)
         m = reduce_max(-(int)v);
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = -3; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 42 : -3; }
diff --git a/tests/reduce-max-int64.ispc b/tests/reduce-max-int64.ispc
index 08641a9a0b..3e3ae020e9 100644
--- a/tests/reduce-max-int64.ispc
+++ b/tests/reduce-max-int64.ispc
@@ -5,10 +5,10 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float v = aFOO[programIndex];
-    uniform float m;
+    uniform float m = 42;
     if (v >= 3)
         m = reduce_max(-(int64)v);
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = -3; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 42 : -3; }
diff --git a/tests/reduce-max-uint.ispc b/tests/reduce-max-uint.ispc
index ed0ef2829e..28b8fc5bc0 100644
--- a/tests/reduce-max-uint.ispc
+++ b/tests/reduce-max-uint.ispc
@@ -11,4 +11,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 2; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 1 : 2; }
diff --git a/tests/reduce-max-uint64.ispc b/tests/reduce-max-uint64.ispc
index ce5e52d43d..3b7f28d950 100644
--- a/tests/reduce-max-uint64.ispc
+++ b/tests/reduce-max-uint64.ispc
@@ -11,4 +11,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 2; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 1 : 2; }
diff --git a/tests/reduce-min-double.ispc b/tests/reduce-min-double.ispc
index 866aa57ec2..5e0222a060 100644
--- a/tests/reduce-min-double.ispc
+++ b/tests/reduce-min-double.ispc
@@ -11,4 +11,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = -2; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? -1 : -2; }
diff --git a/tests/reduce-min-float.ispc b/tests/reduce-min-float.ispc
index b0e890fb43..5f88e4db4e 100644
--- a/tests/reduce-min-float.ispc
+++ b/tests/reduce-min-float.ispc
@@ -11,4 +11,4 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = -2; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? -1 : -2; }
diff --git a/tests/reduce-min-uint.ispc b/tests/reduce-min-uint.ispc
index 85ac625b58..4695ebaeb4 100644
--- a/tests/reduce-min-uint.ispc
+++ b/tests/reduce-min-uint.ispc
@@ -5,10 +5,10 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float v = aFOO[programIndex];
-    uniform float m;
+    uniform float m = 42;
     if (v >= 3)
         m = reduce_min((unsigned int)v);
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 3; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 42 : 3; }
diff --git a/tests/reduce-min-uint64.ispc b/tests/reduce-min-uint64.ispc
index 2290dfd670..345b4bc2df 100644
--- a/tests/reduce-min-uint64.ispc
+++ b/tests/reduce-min-uint64.ispc
@@ -5,10 +5,10 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float v = aFOO[programIndex];
-    uniform float m;
+    uniform float m = 42;
     if (v >= 3)
         m = reduce_min((unsigned int64)v);
     RET[programIndex] = m;
 }
 
-export void result(uniform float RET[]) { RET[programIndex] = 3; }
+export void result(uniform float RET[]) { RET[programIndex] = (programCount == 1) ? 42 : 3; }
diff --git a/tests/shuffle-3.ispc b/tests/shuffle-3.ispc
index afe0b066b8..fa23e31116 100644
--- a/tests/shuffle-3.ispc
+++ b/tests/shuffle-3.ispc
@@ -2,9 +2,13 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    int8 a = aFOO[programIndex]; 
-    int8 shuf = shuffle(a, 1);
-    RET[programIndex] = shuf;
+    if (programCount == 1)
+        RET[0] = 2;
+    else {
+        int8 a = aFOO[programIndex]; 
+        int8 shuf = shuffle(a, 1);
+        RET[programIndex] = shuf;
+    }
 }
 
 export void result(uniform float RET[]) {
diff --git a/tests/shuffle.ispc b/tests/shuffle.ispc
index a17b1309cf..77ac8c88cf 100644
--- a/tests/shuffle.ispc
+++ b/tests/shuffle.ispc
@@ -2,9 +2,13 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    int32 a = aFOO[programIndex]; 
-    int32 shuf = shuffle(a, 1);
-    RET[programIndex] = shuf;
+    if (programCount == 1)
+        RET[0] = 2;
+    else {
+        int32 a = aFOO[programIndex]; 
+        int32 shuf = shuffle(a, 1);
+        RET[programIndex] = shuf;
+    }
 }
 
 export void result(uniform float RET[]) {
diff --git a/tests/shuffle2-1.ispc b/tests/shuffle2-1.ispc
index 5d33cdf93d..9516f3f8b6 100644
--- a/tests/shuffle2-1.ispc
+++ b/tests/shuffle2-1.ispc
@@ -2,10 +2,14 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    int32 aa = aFOO[programIndex]; 
-    int32 bb = aa + programCount;
-    int32 shuf = shuffle(aa, bb, programCount + 1);
-    RET[programIndex] = shuf;
+    if (programCount == 1)
+        RET[0] = 3;
+    else {
+        int32 aa = aFOO[programIndex]; 
+        int32 bb = aa + programCount;
+        int32 shuf = shuffle(aa, bb, programCount + 1);
+        RET[programIndex] = shuf;
+    }
 }
 
 export void result(uniform float RET[]) {
diff --git a/tests/shuffle2-2.ispc b/tests/shuffle2-2.ispc
index 56426201b6..a9ea697c8d 100644
--- a/tests/shuffle2-2.ispc
+++ b/tests/shuffle2-2.ispc
@@ -2,10 +2,14 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    int32 aa = aFOO[programIndex]; 
-    int32 bb = aa + programCount;
-    int32 shuf = shuffle(aa, bb, programIndex + 2);
-    RET[programIndex] = shuf;
+    if (programCount == 1)
+        RET[0] = 3;
+    else {
+        int32 aa = aFOO[programIndex]; 
+        int32 bb = aa + programCount;
+        int32 shuf = shuffle(aa, bb, programIndex + 2);
+        RET[programIndex] = shuf;
+    }
 }
 
 export void result(uniform float RET[]) {
diff --git a/tests/shuffle2-3.ispc b/tests/shuffle2-3.ispc
index 97040babd4..ac484198a8 100644
--- a/tests/shuffle2-3.ispc
+++ b/tests/shuffle2-3.ispc
@@ -2,10 +2,14 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    float aa = aFOO[programIndex]; 
-    float bb = aa + programCount;
-    float shuf = shuffle(aa, bb, programIndex + 2 + (int)b - 5);
-    RET[programIndex] = shuf;
+    if (programCount == 1)
+        RET[0] = 3;
+    else {
+        float aa = aFOO[programIndex]; 
+        float bb = aa + programCount;
+        float shuf = shuffle(aa, bb, programIndex + 2 + (int)b - 5);
+        RET[programIndex] = shuf;
+    }
 }
 
 export void result(uniform float RET[]) {
diff --git a/tests/shuffle2-7.ispc b/tests/shuffle2-7.ispc
index 832c84cf56..0eb3c521fa 100644
--- a/tests/shuffle2-7.ispc
+++ b/tests/shuffle2-7.ispc
@@ -2,10 +2,14 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    int16 aa = aFOO[programIndex]; 
-    int16 bb = aa + programCount;
-    int16 shuf = shuffle(aa, bb, programCount + 1);
-    RET[programIndex] = shuf;
+    if (programCount == 1)
+        RET[0] = 3;
+    else {
+        int16 aa = aFOO[programIndex]; 
+        int16 bb = aa + programCount;
+        int16 shuf = shuffle(aa, bb, programCount + 1);
+        RET[programIndex] = shuf;
+    }
 }
 
 export void result(uniform float RET[]) {
diff --git a/tests/shuffle2-8.ispc b/tests/shuffle2-8.ispc
index 190c0d9d8e..c479ced564 100644
--- a/tests/shuffle2-8.ispc
+++ b/tests/shuffle2-8.ispc
@@ -2,10 +2,14 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    int8 aa = aFOO[programIndex]; 
-    int8 bb = aa + programCount;
-    int8 shuf = shuffle(aa, bb, programIndex + 2);
-    RET[programIndex] = shuf;
+    if (programCount == 1)
+        RET[0] = 3;
+    else {
+        int8 aa = aFOO[programIndex]; 
+        int8 bb = aa + programCount;
+        int8 shuf = shuffle(aa, bb, programIndex + 2);
+        RET[programIndex] = shuf;
+    }
 }
 
 export void result(uniform float RET[]) {
diff --git a/tests/shuffle2-9.ispc b/tests/shuffle2-9.ispc
index 85bb9123f2..f56e5d9abc 100644
--- a/tests/shuffle2-9.ispc
+++ b/tests/shuffle2-9.ispc
@@ -2,10 +2,14 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    int16 aa = aFOO[programIndex]; 
-    int16 bb = aa + programCount;
-    int16 shuf = shuffle(aa, bb, programIndex + 2 + (int)b - 5);
-    RET[programIndex] = shuf;
+    if (programCount == 1)
+        RET[0] = 3;
+    else {
+        int16 aa = aFOO[programIndex]; 
+        int16 bb = aa + programCount;
+        int16 shuf = shuffle(aa, bb, programIndex + 2 + (int)b - 5);
+        RET[programIndex] = shuf;
+    }
 }
 
 export void result(uniform float RET[]) {
diff --git a/tests/store-int16-1.ispc b/tests/store-int16-1.ispc
index c333e29c68..c107dbab0f 100644
--- a/tests/store-int16-1.ispc
+++ b/tests/store-int16-1.ispc
@@ -1,8 +1,8 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform unsigned int16 x[2*programCount];
-    for (uniform int i = 0; i < 2*programCount; ++i)
+    uniform unsigned int16 x[2*programCount+1];
+    for (uniform int i = 0; i < 2*programCount+1; ++i)
         x[i] = 0xffff;
     unsigned int16 val = aFOO[programIndex];
     x[2+programIndex] = val;
diff --git a/tests/store-int16.ispc b/tests/store-int16.ispc
index 2fcd690e0e..a85394d866 100644
--- a/tests/store-int16.ispc
+++ b/tests/store-int16.ispc
@@ -1,8 +1,8 @@
 export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
-    uniform int16 x[2*programCount];
-    for (uniform int i = 0; i < 2*programCount; ++i)
+    uniform int16 x[2*programCount+1];
+    for (uniform int i = 0; i < 2*programCount+1; ++i)
         x[i] = 0xffff;
     unsigned int8 val = aFOO[programIndex];
     x[2+programIndex] = val;
diff --git a/tests/test-124.ispc b/tests/test-124.ispc
index e9b3e33666..2412e1c1b4 100644
--- a/tests/test-124.ispc
+++ b/tests/test-124.ispc
@@ -10,5 +10,5 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 
 export void result(uniform float RET[4]) {
-    RET[programIndex] = 1;
+    RET[programIndex] = (programCount == 1) ? 0 : 1;
 }
diff --git a/tests/test-127.ispc b/tests/test-127.ispc
index 445980018b..32aa371a0b 100644
--- a/tests/test-127.ispc
+++ b/tests/test-127.ispc
@@ -9,5 +9,5 @@ export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
 
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 10;
+    RET[programIndex] = (programCount == 1) ? 4 : 10;
 }
diff --git a/tests/test-128.ispc b/tests/test-128.ispc
index 24bdebe7c2..8c1a04f9b5 100644
--- a/tests/test-128.ispc
+++ b/tests/test-128.ispc
@@ -4,9 +4,9 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    RET[programIndex] = extract(a, 1);
+    RET[programIndex] = extract(a, min(1, programCount-1));
 }
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 2.;
+    RET[programIndex] = (programCount == 1) ? 1 : 2.;
 }
diff --git a/tests/test-129.ispc b/tests/test-129.ispc
index 1c3e2dff21..82f0af43c8 100644
--- a/tests/test-129.ispc
+++ b/tests/test-129.ispc
@@ -4,10 +4,10 @@ export uniform int width() { return programCount; }
 
 export void f_fu(uniform float RET[], uniform float aFOO[], uniform float b) {
     float a = aFOO[programIndex];
-    RET[programIndex] = extract(a, (uniform int)b-3);
+    RET[programIndex] = extract(a, min((uniform int)b-3, programCount-1));
 }
 
 
 export void result(uniform float RET[]) {
-    RET[programIndex] = 3;
+    RET[programIndex] = (programCount == 1) ? 1 : 3;
 }