skip make test pass when no c++ compiler under theano/{tensor,sparse}

theano/sparse/tests/test_basic.py

@@ -1012,7 +1012,7 @@ class test_structureddot(unittest.TestCase):
             overhead_tol = 0.002  # seconds
             overhead_rtol = 1.1  # times as long
             self.assertTrue(numpy.allclose(theano_result, scipy_result))
-            if not theano.config.mode in ["DebugMode", "DEBUG_MODE"]:
+            if not theano.config.mode in ["DebugMode", "DEBUG_MODE"] and theano.config.cxx:
                 self.assertFalse(theano_time > overhead_rtol * scipy_time +
                                  overhead_tol)
 
@@ -1198,7 +1198,8 @@ class UsmmTests(unittest.TestCase):
             fast_compile = theano.config.mode == "FAST_COMPILE"
 
             if (y.type.dtype == up and format1 == 'csc' and format2 == 'dense'
-                and not fast_compile) and up in ('float32', 'float64'):
+                and not fast_compile and theano.config.cxx and
+                up in ('float32', 'float64')):
                 # The op UsmmCscDense should be inserted
                 assert (sum([isinstance(node.op, tensor.Elemwise) and
                              isinstance(node.op.scalar_op,

theano/sparse/tests/test_opt.py

@@ -37,6 +37,8 @@ def test_local_csm_properties_csm():
 
 
 def test_local_csm_grad_c():
+    if not theano.config.cxx:
+        raise SkipTest("G++ not available, so we need to skip this test.")
     data = tensor.vector()
     indices, indptr, shape = (tensor.ivector(), tensor.ivector(),
                               tensor.ivector())
@@ -60,6 +62,8 @@ def test_local_csm_grad_c():
 
 
 def test_local_mul_s_d():
+    if not theano.config.cxx:
+        raise SkipTest("G++ not available, so we need to skip this test.")
     mode = theano.compile.mode.get_default_mode()
     mode = mode.including("specialize", "local_mul_s_d")
 
@@ -76,6 +80,8 @@ def test_local_mul_s_d():
 
 
 def test_local_mul_s_v():
+    if not theano.config.cxx:
+        raise SkipTest("G++ not available, so we need to skip this test.")
     mode = theano.compile.mode.get_default_mode()
     mode = mode.including("specialize", "local_mul_s_v")
 
@@ -92,6 +98,8 @@ def test_local_mul_s_v():
 
 
 def test_local_structured_add_s_v():
+    if not theano.config.cxx:
+        raise SkipTest("G++ not available, so we need to skip this test.")
     mode = theano.compile.mode.get_default_mode()
     mode = mode.including("specialize", "local_structured_add_s_v")
 
@@ -108,6 +116,8 @@ def test_local_structured_add_s_v():
 
 
 def test_local_sampling_dot_csr():
+    if not theano.config.cxx:
+        raise SkipTest("G++ not available, so we need to skip this test.")
     mode = theano.compile.mode.get_default_mode()
     mode = mode.including("specialize", "local_sampling_dot_csr")
 

theano/tensor/tests/test_basic.py

@@ -4203,9 +4203,13 @@ class t_dot(unittest.TestCase):
                     e[0].split()[1:4] == ['are', 'not', 'aligned'] or
                     # Reported by blas or Theano.
                     e[0].split()[0:2] == ['Shape', 'mismatch:'] or
+                    # Reported by Theano perform
+                    e[0].split()[0:4] == ['Incompatible', 'shapes', 'for', 'gemv'] or
                     # Reported by Theano when 'exception_verbosity' is set
                     # to 'high'.
-                    e[0].split()[0:3] == ['dot', 'product', 'failed.'],
+                    e[0].split()[0:3] == ['dot', 'product', 'failed.']
+
+,
                     e)
         finally:
             _logger.setLevel(oldlevel)
@@ -5912,8 +5916,9 @@ def test_unalign():
     f.maker.fgraph.toposort()
     # FAST_COMPILE use the python code that support unaligned data
     # The DebugMode make a copy of the inputs, so they will be aligned.
-    should_raise = theano.config.mode not in ["FAST_COMPILE", "DebugMode",
-                                              "DEBUG_MODE"]
+    should_raise = (theano.config.mode not in ["FAST_COMPILE", "DebugMode",
+                                              "DEBUG_MODE"] and
+                    theano.config.linker != 'py')
     try:
         out_theano = f(a, b)
         assert not a.flags.aligned

theano/tensor/tests/test_blas.py

@@ -101,7 +101,8 @@ class t_gemm(TestCase):
 
             cmp_linker(copy(z), a, x, y, b, 'c|py')
             cmp_linker(copy(z), a, x, y, b, 'py')
-            if config.blas.ldflags and not dtype.startswith("complex"):
+            if (config.blas.ldflags and not dtype.startswith("complex")
+                and theano.config.cxx):
                 # If blas.ldflags is equal to '', the C code will not
                 # be generated
                 cmp_linker(copy(z), a, x, y, b, 'c')

theano/tensor/tests/test_elemwise.py

@@ -5,6 +5,7 @@ import time
 import unittest
 
 import numpy
+from nose.plugins.skip import SkipTest
 from numpy.testing import dec
 
 import theano
@@ -166,15 +167,21 @@ class test_Broadcast(unittest.TestCase):
         self.with_linker(gof.PerformLinker())
 
     def test_c(self):
+        if not theano.config.cxx:
+            raise SkipTest("G++ not available, so we need to skip this test.")
         self.with_linker(gof.CLinker())
 
     def test_perform_inplace(self):
         self.with_linker_inplace(gof.PerformLinker())
 
     def test_c_inplace(self):
+        if not theano.config.cxx:
+            raise SkipTest("G++ not available, so we need to skip this test.")
         self.with_linker_inplace(gof.CLinker())
 
     def test_fill(self):
+        if not theano.config.cxx:
+            raise SkipTest("G++ not available, so we need to skip this test.")
         x = TensorType('float64', [0, 0])('x')
         y = TensorType('float64', [1, 1])('y')
         e = Elemwise(scalar.Second(scalar.transfer_type(0)), {0: 0})(x, y)
@@ -185,6 +192,8 @@ class test_Broadcast(unittest.TestCase):
         assert (xv == yv).all()
 
     def test_weird_strides(self):
+        if not theano.config.cxx:
+            raise SkipTest("G++ not available, so we need to skip this test.")
         x = TensorType('float64', [0, 0, 0, 0, 0])('x')
         y = TensorType('float64', [0, 0, 0, 0, 0])('y')
         e = Elemwise(scalar.add)(x, y)
@@ -195,6 +204,8 @@ class test_Broadcast(unittest.TestCase):
         assert (f(xv, yv) == zv).all()
 
     def test_same_inputs(self):
+        if not theano.config.cxx:
+            raise SkipTest("G++ not available, so we need to skip this test.")
         x = TensorType('float64', [0, 0])('x')
         e = Elemwise(scalar.add)(x, x)
         f = gof.CLinker().accept(FunctionGraph([x], [e])).make_function()
@@ -374,6 +385,9 @@ class test_CAReduce(unittest_tools.InferShapeTester):
                              test_nan=True, tensor_op=tensor.all)
 
     def test_c(self):
+        if not theano.config.cxx:
+            raise SkipTest("G++ not available, so we need to skip this test.")
+
         for dtype in ["floatX", "complex64", "complex128", "int8", "uint8"]:
             self.with_linker(gof.CLinker(), scalar.add, dtype=dtype)
             self.with_linker(gof.CLinker(), scalar.mul, dtype=dtype)
@@ -390,6 +404,8 @@ class test_CAReduce(unittest_tools.InferShapeTester):
             self.with_linker(gof.CLinker(), scalar.xor, dtype=dtype)
 
     def test_c_nan(self):
+        if not theano.config.cxx:
+            raise SkipTest("G++ not available, so we need to skip this test.")
         for dtype in ["floatX", "complex64", "complex128"]:
             self.with_linker(gof.CLinker(), scalar.add, dtype=dtype,
                              test_nan=True)