def require_cython():
if not distributions.has_cython:
raise SkipTest('no cython support')
def setupClass(cls):
global pygraphviz
try:
import pygraphviz
except ImportError:
raise SkipTest('PyGraphviz not available.')
text_type(r[0])
for r in self.graph.query("SELECT ?name WHERE { GRAPH ?name {} }")
]
# Some SPARQL endpoint backends (like TDB) are not able to find empty named graphs
# (at least with this query)
if empty_graph_iri in named_graphs:
self.assertTrue(
empty_graph_iri in
[text_type(g.identifier) for g in self.graph.contexts()])
def testEmptyLiteral(self):
# test for https://github.com/RDFLib/rdflib/issues/457
# also see test_issue457.py which is sparql store independent!
g = self.graph.get_context(graphuri)
g.add((URIRef('http://example.com/s'), URIRef('http://example.com/p'),
Literal('')))
o = tuple(g)[0][2]
self.assertEqual(o, Literal(''), repr(o))
from nose import SkipTest
try:
assert len(urlopen(HOST).read()) > 0
except:
raise SkipTest(HOST + " is unavailable.")
if __name__ == '__main__':
unittest.main()
def setup_module(module):
from nose import SkipTest
try:
import sklearn
except ImportError:
raise SkipTest("scikit-learn is not installed")
def setupClass(cls):
global atlas
import platform
if platform.python_implementation()=='Jython':
raise SkipTest('graph atlas not available under Jython.')
import networkx.generators.atlas as atlas
instantiated already. Their working directory should be the current
directory: hyperopt/tests
To start the engines in hyperopt/hyperopt/tests/
use: $ ipcluster start --n=2
'''
from __future__ import print_function
import sys
from nose import SkipTest
try:
from IPython.parallel import Client
except ImportError:
print("Skipping IPython Tests (IPython not found)", file=sys.stderr)
raise SkipTest('IPython not present')
from hyperopt.ipy import IPythonTrials
import hyperopt.hp
import hyperopt.tpe
import hyperopt
def test0():
try:
client = Client(debug=True)
except IOError:
raise SkipTest()
client[:].use_dill()
trials = IPythonTrials(client, 'log')
def __init__(self):
if not have_h5py:
raise SkipTest('Need h5py for these tests')
def skipper(*args, **kwds):
if condition:
raise SkipTest(msg or 'conditional skip')
return test(*args, **kwds)
# coding: utf-8
from beaker.cache import clsmap, Cache, util
from beaker.exceptions import InvalidCacheBackendError
from beaker.middleware import CacheMiddleware
from nose import SkipTest
try:
from webtest import TestApp
except ImportError:
TestApp = None
try:
clsmap['ext:sqla']._init_dependencies()
except InvalidCacheBackendError:
raise SkipTest("an appropriate SQLAlchemy backend is not installed")
import sqlalchemy as sa
from beaker.ext.sqla import make_cache_table
engine = sa.create_engine('sqlite://')
metadata = sa.MetaData()
cache_table = make_cache_table(metadata)
metadata.create_all(engine)
def simple_app(environ, start_response):
extra_args = {}
clear = False
if environ.get('beaker.clear'):
clear = True
extra_args['type'] = 'ext:sqla'
def around_setup(self):
if getattr(sys, 'pypy_version_info', None):
raise SkipTest('pypy incompatible')
setup(self)
def setup_module(module):
from nose import SkipTest
try:
import pygraphviz
except:
raise SkipTest("pygraphviz not available")
def _skips_if_environ(*args, **kwargs):
if os.environ.get(env_var_name):
raise SkipTest('SKIP %s: %s set\n' % (
fun.__name__, env_var_name))
return fun(*args, **kwargs)
def _skips_if_pypy(*args, **kwargs):
if getattr(sys, 'pypy_version_info', None):
raise SkipTest('pypy incompatible')
return fun(*args, **kwargs)
def around_setup(self):
if PY3:
raise SkipTest('Python 3 incompatible')
setup(self)
def test_invalid_messages(self):
# TODO(paul) POSTing invalid data shows error messages and pre-fills
raise SkipTest('Not implemented')
def maybe(*args, **kw):
if predicate():
msg = "'%s' skipped: %s" % (fn_name, reason)
raise SkipTest(msg)
else:
return fn(*args, **kw)
def test_todo(self):
# If you see this, plesase remind yourself, that all this needs to be run
# per repository type !
raise SkipTest("todo")
def setup_module(module):
from nose import SkipTest
try:
import numpy
except:
raise SkipTest("NumPy not available")
#!/usr/bin/env python
import os, sys, time, random
import rdflib
import unittest
try:
from hashlib import md5
except ImportError:
from md5 import md5
import platform
if platform.system() == 'Java':
from nose import SkipTest
raise SkipTest('No os.pipe() in Jython, skipping')
# Adapted from http://icodesnip.com/snippet/python/simple-universally-unique-id-uuid-or-guid
def bnode_uuid():
"""
Generates a uuid on behalf of Python 2.4
"""
import socket
try:
preseed = os.urandom(16)
except NotImplementedError:
preseed = ''
# Have doubts about this. random.seed will just hash the string
random.seed('%s%s%s' % (preseed, os.getpid(), time.time()))
del preseed
t = long(time.time() * 1000.0)
r = long(random.random() * 100000000000000000L)
def setUp(self):
self.setup_zookeeper(read_only=True)
ver = self.client.server_version()
if ver[1] < 4:
raise SkipTest("Must use zookeeper 3.4 or above")
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
import tempfile
import numpy as np
from nose import SkipTest
try:
import matplotlib as mp
# Make really sure that we don't try to open an Xserver connection.
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
except ImportError:
raise SkipTest('Could not import matplotlib')
import nibabel
from ..img_plotting import demo_plot_roi, plot_anat, plot_img
mni_affine = np.array([[-2., 0., 0., 90.], [0., 2., 0., -126.],
[0., 0., 2., -72.], [0., 0., 0., 1.]])
def test_demo_plot_roi():
# This is only a smoke test
mp.use('svg', warn=False)
import pylab as pl
pl.switch_backend('svg')
demo_plot_roi()
# Test the black background code path
def testretweet(self):
# TODO(josh): Need a way to get random tweets to retweet.
raise SkipTest()
def setUp(self):
if sys.version_info >= (3, 0):
raise SkipTest("py3k: not relevant")
def test_setup_chameleon_genshi_renderer(self):
if PY3: raise SkipTest()
self.config.paths.templates = 'template_path'
self.config.setup_chameleon_genshi_renderer()
TODO: Looking at how we need to make the MockBundle write to``output``,
I wonder whether I shouldn't just do full-stack tests here instead of mocking.
"""
from __future__ import with_statement
import logging
from threading import Thread, Event
from nose.tools import assert_raises
from nose import SkipTest
import time
try:
import argparse
except ImportError:
raise SkipTest()
from webassets import Bundle
from webassets.exceptions import BuildError
from webassets.script import (main, CommandLineEnvironment, CommandError,
GenericArgparseImplementation)
from webassets.test import TempEnvironmentHelper
from webassets.utils import working_directory
def test_script():
"""Test simply that the main script can be invoked."""
main([])
class MockBundle(Bundle):
def test_setup_kajiki_renderer(self):
if PY3: raise SkipTest()
self.config.paths.templates = 'template_path'
self.config.setup_kajiki_renderer()
def test_produce__consume_large_messages(self, *args, **kwargs):
raise SkipTest("test currently fails for sync pika")
def skip_if_asked():
from nose import SkipTest
import sys
if '--no-skip' not in sys.argv:
raise SkipTest()
# encoding: utf-8
from __future__ import print_function
import rdfalchemy
from rdfalchemy.rdfSubject import rdfSubject
from rdfalchemy.descriptors import rdfLocale
from rdfalchemy.samples.doap import DOAP, Project
import platform
if platform.system() == 'Java':
from nose import SkipTest
raise SkipTest("Skipping, Java - Python unicode conflict")
rdfSubject.db.parse('rdfalchemy/samples/schema/doap.rdf')
p = Project(DOAP.SVNRepository)
Project.ls = rdfalchemy.rdfSingle(rdfalchemy.RDFS.label, cacheName='ls')
Project.lm = rdfalchemy.rdfMultiple(rdfalchemy.RDFS.label, cacheName='lm')
Project.len = rdfLocale(rdfalchemy.RDFS.label, 'en')
Project.les = rdfLocale(rdfalchemy.RDFS.label, 'es')
Project.lfr = rdfLocale(rdfalchemy.RDFS.label, 'fr')
def en_es_test():
assert p.len == u'Subversion Repository', p.len
assert p.les == u'Repositorio Subversion'
assert p.lfr == u'D\xe9p\xf4t Subversion'
# unkown resp
print(repr(p.ls))
print(repr(p.lm))
def newfunc(*args, **kwargs):
if cond:
raise SkipTest(msg if msg else "condition was True")
return func(*args, **kwargs)
