Exemplo n.º 1
0
def main(argv=sys.argv[1:]):

    parser = argparse.ArgumentParser()
    parser.add_argument(
            '-v', '--verbose',
            action='store_true',
            help="Logging is normally set to an INFO level. When this flag "
                 "is used logging is set to DEBUG. ")

    args = parser.parse_args(argv)

    # Configure logging
    logging_level = logging.DEBUG if args.verbose is True else logging.INFO
    logging.basicConfig()
    logging.getLogger().setLevel(logging_level)

    xunit_file = os.path.join(os.environ.get('RIFT_MODULE_TEST'),
                              "restconf_systest.xml")
    nose.runmodule(
        argv=[sys.argv[0],
             "--logging-level={}".format(logging.getLevelName(logging_level)),
             "--logging-format={}".format(
                '%(asctime)-15s %(levelname)s %(message)s'),
             "--nocapture", # display stdout immediately
             "--with-xunit",
             "--xunit-file=%s" % xunit_file])
Exemplo n.º 2
0
def main():
    """The main routine."""
    # Parse arguments
    local_url = 'http://localhost:{}'.format(LOCAL_TEST_PORT)
    parser = argparse.ArgumentParser(description='Run web-service tests')
    parser.add_argument(
            '-e', '--endpoint', dest='endpoint', default='auto',
            help='Which server to test against.\n'
                 'auto:  {} (server starts automatically)\n'
                 'local: http://localhost:8080\n'
                 'prod:  https://url-caster.appspot.com\n'
                 'dev:   https://url-caster-dev.appspot.com\n'
                 '*:     Other values interpreted literally'
                 .format(local_url))
    parser.add_argument('-x', '--experimental', dest='experimental', action='store_true', default=False)
    args = parser.parse_args()

    # Setup the endpoint
    endpoint = args.endpoint
    server = None
    if endpoint.lower() == 'auto':
        endpoint = local_url
        print 'Starting local server1...',
        server = subprocess.Popen([
            '/usr/bin/python /home/happy/google_appengine/dev_appserver.py', os.path.dirname(__file__),
            '--port', str(LOCAL_TEST_PORT),
            '--admin_port', str(LOCAL_TEST_PORT + 1),
        ], bufsize=1, stderr=subprocess.PIPE, preexec_fn=os.setsid)
        # Wait for the server to start up
        while True:
            line = server.stderr.readline()
            if 'Unable to bind' in line:
                print 'Rogue server already running.'
                return 1
            if 'running at: {}'.format(local_url) in line:
                break
        print 'done'
    elif endpoint.lower() == 'local':
        endpoint = 'http://localhost:8080'
    elif endpoint.lower() == 'prod':
        endpoint = 'https://url-caster.appspot.com'
    elif endpoint.lower() == 'dev':
        endpoint = 'https://url-caster-dev.appspot.com'
    PwsTest.HOST = endpoint
    PwsTest.ENABLE_EXPERIMENTAL = args.experimental

    # Run the tests
    try:
        nose.runmodule()
    finally:
        # Teardown the endpoint
        if server:
            os.killpg(os.getpgid(server.pid), signal.SIGINT)
            server.wait()

    # We should never get here since nose.runmodule will call exit
    return 0
Exemplo n.º 3
0
def main():
    """The main routine."""
    # Parse arguments
    local_url = 'http://localhost:{}'.format(LOCAL_TEST_PORT)
    parser = argparse.ArgumentParser(description='Run web-service tests')
    parser.add_argument(
            '-e', '--endpoint', dest='endpoint', default='AUTO',
            help='Which server to test against.\n'
                 'AUTO:  {} (server starts automatically)\n'
                 'LOCAL: http://localhost:8080\n'
                 'PROD:  http://url-caster.appspot.com\n'
                 'DEV:   http://url-caster-dev.appspot.com\n'
                 '*:     Other values interpreted literally'
                 .format(local_url))
    args = parser.parse_args()

    # Setup the endpoint
    endpoint = args.endpoint
    server = None
    if endpoint == 'AUTO':
        endpoint = local_url
        print 'Starting local server...',
        server = subprocess.Popen([
            'dev_appserver.py', os.path.dirname(__file__),
            '--port', str(LOCAL_TEST_PORT),
            '--admin_port', str(LOCAL_TEST_PORT + 1),
        ], bufsize=1, stderr=subprocess.PIPE, preexec_fn=os.setsid)
        # Wait for the server to start up
        while True:
            line = server.stderr.readline()
            if 'Unable to bind' in line:
                print 'Rogue server already running.'
                return 1
            if 'running at: {}'.format(local_url) in line:
                break
        print 'done'
    elif endpoint == 'LOCAL':
        endpoint = 'http://localhost:8080'
    elif endpoint == 'PROD':
        endpoint = 'http://url-caster.appspot.com'
    elif endpoint == 'DEV':
        endpoint = 'http://url-caster-dev.appspot.com'
    PwsTest.HOST = endpoint

    # Run the tests
    try:
        nose.runmodule()
    finally:
        # Teardown the endpoint
        if server:
            os.killpg(os.getpgid(server.pid), signal.SIGINT)
            server.wait()

    # We should never get here since nose.runmodule will call exit
    return 0
Exemplo n.º 4
0
def _run_tests(path):
    """Runs tests on a library located at path"""
    global rx_h5, nucs, npert, G
    rx_h5 = tb.openFile(path, 'r')

    nucs = rx_h5.root.transmute_nucs_LL[:]
    npert = len(rx_h5.root.perturbations)
    G = len(rx_h5.root.energy[0]) - 1

    nose.runmodule(__name__, argv=[__file__])

    rx_h5.close()
Exemplo n.º 5
0
def run_module(name, file):
    """Run current test cases of the file.

    Args:
        name: __name__ attribute of the file.
        file: __file__ attribute of the file.
    """

    if name == '__main__':

        nose.runmodule(argv=[file, '-vvs', '-x', '--pdb', '--pdb-failure'],
                       exit=False)
Exemplo n.º 6
0
def main():
    '''Run test'''
    # Get line
    argv = list(sys.argv)
    # Add configuration
    argv.extend([
        '--verbosity=2',
        '--exe',
        '--nocapture',
        '--with-nosango',
    ])
    # Run test
    nose.runmodule(argv=argv)
Exemplo n.º 7
0
def runmodule(level=logging.INFO, verbosity=1, argv=[]):
    """
    :param argv: optional list of string with additional options passed to nose.run
    see http://nose.readthedocs.org/en/latest/usage.html
    """
    if argv is None:
        return nose.runmodule()
    
    setlog(level)

    """ ensures stdout is printed after the tests results"""
    import sys
    from io import StringIO
    module_name = sys.modules["__main__"].__file__

    old_stdout = sys.stdout
    sys.stdout = mystdout = StringIO()
    
    result = nose.run(
        argv=[
            sys.argv[0], 
            module_name,
            '-s','--nologcapture', 
            '--verbosity=%d'%verbosity,
        ]+argv
    )
    
    sys.stdout = old_stdout
    print(mystdout.getvalue())
Exemplo n.º 8
0
    def test(**kwargs):
        """ Run all pylada nose tests

            Does not include some C++ only tests, nor tests that require
            external programs such as vasp. Those should be run via ctest.
        """
        from os.path import dirname
        from nose import runmodule
        return runmodule(dirname(__file__), **kwargs)
Exemplo n.º 9
0
def main():
    """Main routine, executed when this file is run as a script """

    # Create a tempdir, as a subdirectory of the current one, which all tests
    # use for their storage.  By default, it is removed at the end.
    global TESTDIR
    cwd = os.getcwd()
    TESTDIR = tempfile.mkdtemp(prefix='tmp-testdata-',dir=cwd)
    
    print "Running tests:"
    # This call form is ipython-friendly
    try:
        os.chdir(TESTDIR)
        nose.runmodule(argv=[__file__,'-vvs'],
                       exit=False)
    finally:
        os.chdir(cwd)

    print
    print "Cleanup - removing temp directory:", TESTDIR
    # If you need to debug a problem, comment out the next line that cleans
    # up the temp directory, and you can see in there all temporary files
    # created by the test code
    shutil.rmtree(TESTDIR)

    print """
***************************************************************************
                           TESTS FINISHED
***************************************************************************

If the printout above did not finish in 'OK' but instead says 'FAILED', copy
and send the *entire* output, including the system information below, for help.
We'll do our best to assist you.  You can send your message to the Scipy user
mailing list:

    http://mail.scipy.org/mailman/listinfo/scipy-user

but feel free to also CC directly: [email protected]
"""
    sys_info()
Exemplo n.º 10
0
def main(args=None):
    """ run tests for module
    """
    options = parse_test_args(args)

    if options.nonose or options.test:
        # Run tests outside of nose.
        module = sys.modules['__main__']
        functions = inspect.getmembers(module, inspect.isfunction)
        if options.test:
            func = module.__dict__.get('_test_' + options.test)
            if func is None:
                print 'No test named _test_%s' % options.test
                print 'Known tests are:', [name[6:] for name, func in functions
                                                if name.startswith('_test_')]
                sys.exit(1)
            tests = [func]
        else:
            # Run all tests.
            tests = [func for name, func in functions
                        if name.startswith('_test_')]

        TEST_CONFIG['modname'] = '__main__'
        setup_server(virtual_display=False)
        browser = SafeDriver(setup_chrome())
        try:
            for test in tests:
                try:
                    test(browser)
                except SkipTest:
                    pass
        finally:
            if not options.noclose:
                try:
                    browser.quit()
                except WindowsError:
                    # if it already died, calling kill on a defunct process
                    # raises a WindowsError: Access Denied
                    pass
                teardown_server()
    else:
        # Run under nose.
        import nose
        sys.argv.append('--cover-package=openmdao.')
        sys.argv.append('--cover-erase')
        sys.exit(nose.runmodule())
Exemplo n.º 11
0
def main(args=None):
    """ run tests for module
    """
    options = parse_test_args(args)

    if options.nonose or options.test:
        # Run tests outside of nose.
        module = sys.modules['__main__']
        functions = inspect.getmembers(module, inspect.isfunction)
        if options.test:
            func = module.__dict__.get('_test_' + options.test)
            if func is None:
                print 'No test named _test_%s' % options.test
                print 'Known tests are:', [name[6:] for name, func in functions
                                                if name.startswith('_test_')]
                sys.exit(1)
            tests = [func]
        else:
            # Run all tests.
            tests = [func for name, func in functions
                        if name.startswith('_test_')]

        setup_server(virtual_display=False)
        browser = SafeDriver(setup_chrome())
        try:
            for test in tests:
                test(browser)
        finally:
            if not options.noclose:
                browser.quit()
                teardown_server()
    else:
        # Run under nose.
        import nose
        sys.argv.append('--cover-package=openmdao.')
        sys.argv.append('--cover-erase')
        sys.exit(nose.runmodule())
Exemplo n.º 12
0
@cleanup
def test_determinism():
    import os
    import sys
    from subprocess import check_call
    from nose.tools import assert_equal

    plots = []
    for i in range(3):
        check_call(
            [
                sys.executable,
                "-R",
                "-c",
                "from matplotlib.tests.test_backend_svg "
                "import _test_determinism;"
                '_test_determinism("determinism.svg")',
            ]
        )
        with open("determinism.svg", "rb") as fd:
            plots.append(fd.read())
        os.unlink("determinism.svg")
    for p in plots[1:]:
        assert_equal(p, plots[0])


if __name__ == "__main__":
    import nose

    nose.runmodule(argv=["-s", "--with-doctest"], exit=False)
Exemplo n.º 13
0
from nose.tools import ok_

from goldminer import scrapper

# import application packages

__author__ = 'Sergey Krushinsky'
__copyright__ = "Copyright 2014"
__license__ = "Apache"
__version__ = "1.0.0"
__email__ = "*****@*****.**"


class TestDefaultSession():
    def __init__(self):
        self.session = scrapper.create_session()

    def test_user_agent(self):
        ua = self.session.headers.get('user-agent')
        ok_(ua in scrapper.ALT_USER_AGENTS)


if __name__ == '__main__':
    import logging
    logging.basicConfig(
        level=logging.DEBUG,
        datefmt='%Y-%m-%d %H:%M:%S',
        format='%(asctime)s - %(levelname)-8s - %(message)s',
    )
    nose.runmodule(argv=['-d', '-s', '--verbose'])
Exemplo n.º 14
0
import nose
import sys

print("sys.platform = ", sys.platform)
print("sys.version = ", sys.version)

if sys.platform.startswith('win'):
    print("!!! Skipping Tests")
    print("!!! There are known failures in pyamg 3.0.2 on windows")
    print("!!! See https://github.com/pyamg/pyamg/issues/168")
elif sys.platform == 'darwin' and sys.version.startswith('2.7'):
    print("!!! Skipping Tests")
    print("!!! There are known failures in pyamg 3.0.2 on Python 2.7 / OSX")
    print("!!! See https://github.com/pyamg/pyamg/issues/165")
else:
    config = nose.config.Config(verbosity=2)
    nose.runmodule('pyamg', config=config)
Exemplo n.º 15
0
    '''
    >>> plt.plot(edges[:-1], squaretg.pdf(edges[:-1], 10), 'r')
    [<matplotlib.lines.Line2D object at 0x06EBFDB0>]
    >>> plt.fill(edges[4:8], squaretg.pdf(edges[4:8], 10), 'r')
    [<matplotlib.patches.Polygon object at 0x0725BA90>]
    >>> plt.show()
    >>> plt.fill_between(edges[4:8], squaretg.pdf(edges[4:8], 10), y2=0, 'r')
    SyntaxError: non-keyword arg after keyword arg (<console>, line 1)
    >>> plt.fill_between(edges[4:8], squaretg.pdf(edges[4:8], 10), 0, 'r')
    Traceback (most recent call last):
    AttributeError: 'module' object has no attribute 'fill_between'
    >>> fig = figure()
    Traceback (most recent call last):
    NameError: name 'figure' is not defined
    >>> ax1 = fig.add_subplot(311)
    Traceback (most recent call last):
    NameError: name 'fig' is not defined
    >>> fig = plt.figure()
    >>> ax1 = fig.add_subplot(111)
    >>> ax1.fill_between(edges[4:8], squaretg.pdf(edges[4:8], 10), 0, 'r')
    Traceback (most recent call last):
    AttributeError: 'AxesSubplot' object has no attribute 'fill_between'
    >>> ax1.fill(edges[4:8], squaretg.pdf(edges[4:8], 10), 0, 'r')
    Traceback (most recent call last):
    '''

    import nose
    nose.runmodule(
        argv=['__main__', '-vvs', '-x'],  #,'--pdb', '--pdb-failure'],
        exit=False)
Exemplo n.º 16
0
        # Trained on sparse format
        sparse_classifier = AdaBoostRegressor(
            base_estimator=CustomSVR(probability=True),
            random_state=1).fit(X_train_sparse, y_train)

        # Trained on dense format
        dense_classifier = dense_results = AdaBoostRegressor(
            base_estimator=CustomSVR(probability=True),
            random_state=1).fit(X_train, y_train)

        # predict
        sparse_results = sparse_classifier.predict(X_test_sparse)
        dense_results = dense_classifier.predict(X_test)
        assert_array_equal(sparse_results, dense_results)

        # staged_predict
        sparse_results = sparse_classifier.staged_predict(X_test_sparse)
        dense_results = dense_classifier.staged_predict(X_test)
        for sprase_res, dense_res in zip(sparse_results, dense_results):
            assert_array_equal(sprase_res, dense_res)

        types = [i.data_type_ for i in sparse_classifier.estimators_]

        assert all([(t == csc_matrix or t == csr_matrix) for t in types])


if __name__ == "__main__":
    import nose
    nose.runmodule()
        self.assertTrue(len(dates) > 6)

    def test_get_call_data(self):
        with tm.assertRaises(NotImplementedError):
            self.goog.get_call_data()

    def test_get_put_data(self):
        with tm.assertRaises(NotImplementedError):
            self.goog.get_put_data()

    def test_get_near_stock_price(self):
        with tm.assertRaises(NotImplementedError):
            self.goog.get_near_stock_price()

    def test_get_forward_data(self):
        with tm.assertRaises(NotImplementedError):
            self.goog.get_forward_data([1, 2, 3])

    def test_get_all_data(self):
        with tm.assertRaises(NotImplementedError):
            self.goog.get_all_data()

    def test_get_options_data_with_year(self):
        with tm.assertRaises(NotImplementedError):
            self.goog.get_options_data(year=2016)


if __name__ == '__main__':
    nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                   exit=False)  # pragma: no cover
Exemplo n.º 18
0
            return 0.
    E.value = 2

    def test_logp(self):
        self.B.rand()
        lp1 = utils.logp_of_set(set([self.A,self.B,self.D]))
        assert_equal(lp1, self.A.logp+self.B.logp+self.D.logp)

    def test_ZeroProb(self):
        self.B.value = -1
        for i in xrange(1000):
            try:
                utils.logp_of_set(set([self.A,self.B,self.D, self.E]))
            except:
                cls,  inst, tb = sys.exc_info()
                assert(cls is ZeroProbability)

    def test_other_err(self):
        self.B.rand()
        for i in xrange(1000):
            try:
                utils.logp_of_set(set([self.A,self.B,self.D,self.E]))
            except:
                cls,  inst, tb = sys.exc_info()
                assert(cls is RuntimeError)


if __name__ == '__main__':
    C =nose.config.Config(verbosity=1)
    nose.runmodule(config=C)
Exemplo n.º 19
0
                   yticklabels=LOWERCASE_CHARS[-10:],
                   cmap=red_purple)
    # fig.savefig(
    #     '%s/baseline_images/test_pcolormesh/pcolormesh_positive_other_cmap.png' %
    #     os.path.dirname(__file__))

@image_comparison(baseline_images=['pcolormesh_lognorm'],
                  extensions=['png'])
def test_pcolormesh_lognorm():
    np.random.seed(10)

    x = np.abs(np.random.randn(10, 10))
    ppl.pcolormesh(x,
                   norm=LogNorm(vmin=x.min().min(), vmax=x.max().max()))
    # fig.savefig('%s/baseline_images/test_pcolormesh/test_pcolormesh_lognorm.png' %
    #             os.path.dirname(__file__))

@image_comparison(baseline_images=['pcolormesh_axes'], extensions=['png'])
def test_pcolormesh_axes():
    np.random.seed(10)
    x=np.arange(0,100,10)
    y=np.arange(0,20,2)

    ppl.pcolormesh(x, y, np.random.randn(10, 10))
    # fig.savefig('%s/baseline_images/test_pcolormesh/pcolormesh.png' %
    #             os.path.dirname(__file__))

if __name__ == '__main__':
    import nose
    nose.runmodule(argv=['-s', '--with-doctest'])
Exemplo n.º 20
0
        self.assertTrue(idx.equals(DatetimeIndex(dates, tz="US/Eastern")))
        idx = idx.tz_convert("UTC")
        self.assertTrue(idx.equals(DatetimeIndex(dates, tz="UTC")))

        dates = ["2010-12-01 00:00", "2010-12-02 00:00", NaT]
        idx = DatetimeIndex(dates)
        idx = idx.tz_localize("US/Pacific")
        self.assertTrue(idx.equals(DatetimeIndex(dates, tz="US/Pacific")))
        idx = idx.tz_convert("US/Eastern")
        expected = ["2010-12-01 03:00", "2010-12-02 03:00", NaT]
        self.assertTrue(idx.equals(DatetimeIndex(expected, tz="US/Eastern")))

        idx = idx + offsets.Hour(5)
        expected = ["2010-12-01 08:00", "2010-12-02 08:00", NaT]
        self.assertTrue(idx.equals(DatetimeIndex(expected, tz="US/Eastern")))
        idx = idx.tz_convert("US/Pacific")
        expected = ["2010-12-01 05:00", "2010-12-02 05:00", NaT]
        self.assertTrue(idx.equals(DatetimeIndex(expected, tz="US/Pacific")))

        idx = idx + np.timedelta64(3, "h")
        expected = ["2010-12-01 08:00", "2010-12-02 08:00", NaT]
        self.assertTrue(idx.equals(DatetimeIndex(expected, tz="US/Pacific")))

        idx = idx.tz_convert("US/Eastern")
        expected = ["2010-12-01 11:00", "2010-12-02 11:00", NaT]
        self.assertTrue(idx.equals(DatetimeIndex(expected, tz="US/Eastern")))


if __name__ == "__main__":
    nose.runmodule(argv=[__file__, "-vvs", "-x", "--pdb", "--pdb-failure"], exit=False)
    # check calling w/ named arguments
    shape_args = list(shape_args)

    vals = [meth(x, *shape_args) for meth in meths]
    npt.assert_(np.all(np.isfinite(vals)))

    names, a, k = shape_argnames[:], shape_args[:], {}
    while names:
        k.update({names.pop(): a.pop()})
        v = [meth(x, *a, **k) for meth in meths]
        npt.assert_array_equal(vals, v)
        if not 'n' in k.keys():
            # `n` is first parameter of moment(), so can't be used as named arg
            npt.assert_equal(distfn.moment(3, *a, **k),
                             distfn.moment(3, *shape_args))

    # unknown arguments should not go through:
    k.update({'kaboom': 42})
    npt.assert_raises(TypeError, distfn.cdf, x, **k)


def check_scale_docstring(distfn):
    if distfn.__doc__ is not None:
        # Docstrings can be stripped if interpreter is run with -OO
        npt.assert_('scale' not in distfn.__doc__)


if __name__ == "__main__":
    # nose.run(argv=['', __file__])
    nose.runmodule(argv=[__file__,'-s'], exit=False)
Exemplo n.º 22
0
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;        #
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER        #
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT      #
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN       #
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE         #
# POSSIBILITY OF SUCH DAMAGE.                                             #
# #########################################################################

from __future__ import (absolute_import, division, print_function,
                        unicode_literals)

from tomopy.prep.phase import *
from test.util import read_file
from numpy.testing import assert_allclose
import numpy as np

__author__ = "Doga Gursoy"
__copyright__ = "Copyright (c) 2015, UChicago Argonne, LLC."
__docformat__ = 'restructuredtext en'


def test_retrieve_phase():
    assert_allclose(retrieve_phase(read_file('proj.npy')),
                    read_file('retrieve_phase.npy'),
                    rtol=1e-6)


if __name__ == '__main__':
    import nose
    nose.runmodule(exit=False)
Exemplo n.º 23
0
                                   frames=iter(range(5)))


def test_movie_writer_registry():
    ffmpeg_path = mpl.rcParams['animation.ffmpeg_path']
    # Not sure about the first state as there could be some writer
    # which set rcparams
    #assert_false(animation.writers._dirty)
    assert_true(len(animation.writers._registered) > 0)
    animation.writers.list()  # resets dirty state
    assert_false(animation.writers._dirty)
    mpl.rcParams['animation.ffmpeg_path'] = u"not_available_ever_xxxx"
    assert_true(animation.writers._dirty)
    animation.writers.list()  # resets
    assert_false(animation.writers._dirty)
    assert_false(animation.writers.is_available("ffmpeg"))
    # something which is guaranteed to be available in path
    # and exits immediately
    bin = u"true" if sys.platform != 'win32' else u"where"
    mpl.rcParams['animation.ffmpeg_path'] = bin
    assert_true(animation.writers._dirty)
    animation.writers.list()  # resets
    assert_false(animation.writers._dirty)
    assert_true(animation.writers.is_available("ffmpeg"))
    mpl.rcParams['animation.ffmpeg_path'] = ffmpeg_path


if __name__ == "__main__":
    import nose
    nose.runmodule(argv=['-s', '--with-doctest'], exit=False)
Exemplo n.º 24
0
        import numpy as np
        import scipy.spatial

        np.random.seed(1234)
        points = np.random.rand(15, 2) * 5 + np.array([130, 40])

        hull = cesiumpy.spatial.ConvexHull(points)
        polyline = hull.get_polyline()

        expected = [
            130.37690620821488, 41.844120030009876, 132.51541582653905,
            40.06884224795341, 133.89987904059402, 41.36296302641321,
            134.6657005099126, 43.25689071613289, 134.7906967684185,
            44.379663173710476, 133.86413310806188, 44.41320595318058,
            131.38232127571547, 44.00936088767509, 130.95759725189447,
            43.11054385519916, 130.37690620821488, 41.844120030009876
        ]

        self.assertEqual(polyline.positions.x, expected)

        hull = scipy.spatial.ConvexHull(points)
        hull = cesiumpy.spatial.ConvexHull(hull)
        polyline = hull.get_polyline()
        self.assertEqual(polyline.positions.x, expected)


if __name__ == '__main__':
    nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                   exit=False)
Exemplo n.º 25
0
        ndmap = NdIndexableMapping(data, dimensions=[self.dim1, self.dim2])

        reduced_dims = ['intdim']
        reduced_ndmap = ndmap.reindex(reduced_dims)

        self.assertEqual(reduced_ndmap.dimension_labels, reduced_dims)

    def test_idxmapping_adddimension(self):
        ndmap = NdIndexableMapping(self.init_items_1D_list, dimensions=[self.dim1])
        ndmap2d = ndmap.add_dimension(self.dim2, 0, 0.5)

        self.assertEqual(ndmap2d.keys(), [(0.5, 1), (0.5, 5)])
        self.assertEqual(ndmap2d.dimensions, [self.dim2, self.dim1])

    def test_idxmapping_clone(self):
        ndmap = NdIndexableMapping(self.init_items_1D_list, dimensions=[self.dim1])
        cloned_ndmap = ndmap.clone(data_type=str)

        self.assertEqual(cloned_ndmap.data_type, str)

    def test_idxmapping_apply_key_type(self):
        data = dict([(0.5, 'a'), (1.5, 'b')])
        ndmap = NdIndexableMapping(data, dimensions=[self.dim1])

        self.assertEqual(ndmap.keys(), [0, 1])


if __name__ == "__main__":
    import nose
    nose.runmodule(argv=[sys.argv[0], "--logging-level", "ERROR"])
Exemplo n.º 26
0
        assert self.real_output[i] == self.expected_output[i], \
            "Real output %r doesn't match to expected %r for example #%s" % (self.real_output[i], self.expected_output[i], i)


def test_example():
    for example in EXAMPLES:
        runner = ExampleFileTestSuite(example)
        # we want to have granular test, one test case per line
        # nose show each test as "executable, arg1, arg2", that's
        # why we want pass example name again, even test runner already knows it
        for i in runner.test_cases():
            yield runner.run_test, example, i

def assert_python_version(current_version):
    exec_version = subprocess.check_output(
        ['python', '-c', 'import sys; print(sys.version_info)'], stderr=subprocess.STDOUT).strip()
    assert current_version == exec_version.decode('utf-8')


def test_python_version():
    # check that `python something.py` will run the same version interepreter as it is running
    import sys
    current_version = str(sys.version_info)
    # do a yield to show in the test output the python version
    yield assert_python_version, current_version


if __name__ == '__main__':
    import nose, sys
    if not nose.runmodule():
        sys.exit(1)
Exemplo n.º 27
0
                called_save.append(True)

            def write_cells(self, *args, **kwargs):
                called_write_cells.append(True)

        def check_called(func):
            func()
            self.assertTrue(len(called_save) >= 1)
            self.assertTrue(len(called_write_cells) >= 1)
            del called_save[:]
            del called_write_cells[:]

        register_writer(DummyClass)
        writer = ExcelWriter('something.test')
        tm.assert_isinstance(writer, DummyClass)
        df = tm.makeCustomDataframe(1, 1)
        panel = tm.makePanel()
        func = lambda: df.to_excel('something.test')
        check_called(func)
        check_called(lambda: panel.to_excel('something.test'))
        val = get_option('io.excel.xlsx.writer')
        set_option('io.excel.xlsx.writer', 'dummy')
        check_called(lambda: df.to_excel('something.xlsx'))
        check_called(lambda: df.to_excel('something.xls', engine='dummy'))
        set_option('io.excel.xlsx.writer', val)


if __name__ == '__main__':
    nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                   exit=False)
Exemplo n.º 28
0
    F = f.integ()
    exact = F(b) - F(a)

    assert_allclose(gk_quad(f,a,b, n=n)[0], exact, rtol=1e-14,atol=0)


class test_shanks(unittest.TestCase):
    """tests for shanks"""

    def test_pi(self):
        """4 * sum((-1)**k * (2 * k+1)**(-1))"""
        nn = 10
        seq = np.array([4*sum((-1)**n/(2*n+1) for n in range(m)) for
                        m in range(1, nn)])

        assert_allclose(shanks(seq, -8), np.pi, atol=1e-6)

    def test_pi_max_shanks_ind(self):
        """4 * sum((-1)**k * (2 * k+1)**(-1))"""
        nn = 10
        seq = np.array([4*sum((-1)**n/(2*n+1) for n in range(m)) for
                        m in range(1, nn)])

        assert_allclose(shanks(seq, -50), np.pi, atol=1e-8)



if __name__ == '__main__':
    import nose
    nose.runmodule(argv=['nose', '--verbosity=3', '--with-doctest'])
#    nose.runmodule(argv=['nose', '--verbosity=3'])
Exemplo n.º 29
0
from nose.tools.trivial import ok_
from numpy.testing import assert_allclose

import math
import numpy as np
from geotecha.piecewise.piecewise_linear_1d import PolyLine

from geotecha.mathematics.root_finding import find_n_roots

from scipy.special import j0


def test_find_n_roots():
    """test for find_n_roots"""
    #find_n_roots(func, args=(), n=1, x0=0.001, dx=0.001, p=1.0, fsolve_kwargs={}):

    assert_allclose(find_n_roots(math.sin, n=3, x0=0.1, dx=0.1, p=1.01),
                    np.arange(1, 4) * np.pi,
                    atol=1e-5)

    #bessel roots from  http://mathworld.wolfram.com/BesselFunctionZeros.html
    assert_allclose(find_n_roots(j0, n=3, x0=0.1, dx=0.1, p=1.01),
                    np.array([2.4048, 5.5201, 8.6537]),
                    atol=1e-4)


if __name__ == '__main__':

    import nose
    nose.runmodule(argv=['nose', '--verbosity=3', '--with-doctest'])
#    nose.runmodule(argv=['nose', '--verbosity=3'])
Exemplo n.º 30
0
                                  np.transpose, obj, axes=1)


class TestNoNewAttributesMixin(tm.TestCase):

    def test_mixin(self):
        class T(NoNewAttributesMixin):
            pass

        t = T()
        self.assertFalse(hasattr(t, "__frozen"))
        t.a = "test"
        self.assertEqual(t.a, "test")
        t._freeze()
        # self.assertTrue("__frozen" not in dir(t))
        self.assertIs(getattr(t, "__frozen"), True)

        def f():
            t.b = "test"

        self.assertRaises(AttributeError, f)
        self.assertFalse(hasattr(t, "b"))


if __name__ == '__main__':
    import nose

    nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
                   # '--with-coverage', '--cover-package=pandas.core'],
                   exit=False)
Exemplo n.º 31
0
        for name, expected in zip(('HairEyeColor', 'Titanic', 'iris3'),
                                  (hec, titanic, iris3)):
            df = com.load_data(name)
            table = r[name]
            names = r['dimnames'](table)
            try:
                columns = list(r['names'](names))[::-1]
            except TypeError:
                columns = ['X{:d}'.format(i) for i in range(len(names))][::-1]
            columns.append('value')
            assert np.array_equal(df.columns, columns)
            result = df.head()
            cond = ((result.sort(axis=1) == expected.sort(axis=1))).values
            assert np.all(cond)

    def test_factor(self):
        for name in ('state.division', 'state.region'):
            vector = r[name]
            factors = list(r['factor'](vector))
            level = list(r['levels'](vector))
            factors = [level[index - 1] for index in factors]
            result = com.load_data(name)
            assert np.equal(result, factors)


if __name__ == '__main__':
    nose.runmodule(
        argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
        # '--with-coverage', '--cover-package=pandas.core'],
        exit=False)
Exemplo n.º 32
0
    def test_endog_only_raise(self):
        np.testing.assert_raises(Exception, sm_data.handle_data,
                                            (self.y, None, 'raise'))

    def test_endog_only_drop(self):
        y = self.y
        y = y.dropna()
        data = sm_data.handle_data(self.y, None, 'drop')
        np.testing.assert_array_equal(data.endog, y.values)

    def test_mv_endog(self):
        y = self.X
        y = y.ix[~np.isnan(y.values).any(axis=1)]
        data = sm_data.handle_data(self.X, None, 'drop')
        np.testing.assert_array_equal(data.endog, y.values)

    def test_labels(self):
        2, 10, 14
        labels = pandas.Index([0, 1, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 15,
                               16, 17, 18, 19, 20, 21, 22, 23, 24])
        data = sm_data.handle_data(self.y, self.X, 'drop')
        np.testing.assert_(data.row_labels.equals(labels))



if __name__ == "__main__":
    import nose
    #nose.runmodule(argv=[__file__, '-vvs', '-x', '--pdb', '--pdb-failure'],
    #        exit=False)
    nose.runmodule(argv=[__file__, '-vvs', '-x'], exit=False)
Exemplo n.º 33
0
    def test_overlapping_linear(self):
        assert_allclose(back_calc_drain_spacing_from_eta(0.71017973670799939, 't',
                            mu_overlapping_linear,
                            0.05, 5, 2, muw=1),
                            [  1.61711464,   0.84904594,  16.9809188 ],
                            atol=1e-4)

    def test_n_falls_below_s(self):
        assert_raises(ValueError, back_calc_drain_spacing_from_eta, 5, 't',
                            mu_constant,
                            0.05, 5, 2, muw=1)

    def test_multipe_s(self):
        assert_raises(ValueError, back_calc_drain_spacing_from_eta, 1, 't',
                            mu_constant,
                            0.05, [5,6], 2, muw=1)
    def test_multipe_kap(self):
        assert_raises(ValueError, back_calc_drain_spacing_from_eta, 1, 't',
                            mu_constant,
                            0.05, [5,6], 2, muw=1)


if __name__ == '__main__':

    import nose
#    nose.runmodule(argv=['nose', '--verbosity=3', '--with-doctest'])
    nose.runmodule(argv=['nose', 'test_smear_zones:test_mu_parabolic.test_s_n_unequal_len', '--verbosity=3', '--with-doctest', '--doctest-options=+ELLIPSIS'])
#    nose.runmodule(argv=['nosetests', 'test_foxcon:test_foxcon.test__update_Hlayers', '--verbosity=3', '--with-doctest', '--doctest-options=+ELLIPSIS'])
#    nose.runmodule(argv=['nose', '--verbosity=3'])

#test_mu_parabolic
Exemplo n.º 34
0
    out = pml_hybrid(synthetic_data(), theta=(0., 1.))
    assert_equals(out.shape, (4, 5, 5))
    assert_equals(np.isnan(out).sum(), 0)


def test_pml_quad():
    out = pml_quad(synthetic_data(), theta=(0., 1.))
    assert_equals(out.shape, (4, 5, 5))
    assert_equals(np.isnan(out).sum(), 0)


def test_sirt():
    out = sirt(synthetic_data(), theta=(0., 1.))
    assert_equals(out.shape, (4, 5, 5))
    assert_equals(np.isnan(out).sum(), 0)


def test_write_center():
    dpath = os.path.join('test', 'tmp')
    write_center(synthetic_data(), [0., 1.], dpath, center=[3, 5, 0.5])
    assert_equals(os.path.isfile(os.path.join(dpath, '3.00.tiff')), True)
    assert_equals(os.path.isfile(os.path.join(dpath, '3.50.tiff')), True)
    assert_equals(os.path.isfile(os.path.join(dpath, '4.00.tiff')), True)
    assert_equals(os.path.isfile(os.path.join(dpath, '4.50.tiff')), True)
    shutil.rmtree(dpath)


if __name__ == '__main__':
    import nose
    nose.runmodule(exit=False)
Exemplo n.º 35
0
    pdf_r = np.array([3.941955996757291e-04, 1.568067236862745e-03,
                      6.136996029432048e-03, 3.183098861837907e-01,
                      3.167418189469279e-01, 1.269297588738406e-01])
    pdf_st = skewt.pdf(x, 1, 10)  #args = (df, alpha) = (1, 10))
    assert_(np.allclose(pdf_st, pdf_r, rtol=1e-13, atol=1e-25))

    #noquote(sprintf("%.15e,", pst(c(-2,-1, -0.5,0,1,2), shape=10, df=1)))
    cdf_r = np.array([7.893671370544414e-04, 1.575817262600422e-03,
                      3.128720749105560e-03, 3.172551743055351e-02,
                      5.015758172626005e-01, 7.056221318361879e-01])
    cdf_st = skewt.cdf(x, 1, 10)  #args = (df, alpha) = (1, 10)
    assert_(np.allclose(cdf_st, cdf_r, rtol=1e-13, atol=1e-25))



if __name__ == '__main__':
    import nose
    nose.runmodule(argv=['__main__','-vvs','-x','--pdb', '--pdb-failure'],
                   exit=False)

    print ('Done')


'''
>>> skewt.pdf([-2,-1,0,1,2], 10000000, 10)
array([  2.98557345e-90,   3.68850289e-24,   3.98942271e-01,
         4.83941426e-01,   1.07981952e-01])
>>> skewt.pdf([-2,-1,0,1,2], np.inf, 10)
array([ nan,  nan,  nan,  nan,  nan])
'''
Exemplo n.º 36
0
    A = np.ones((5, 5))
    A[1:2, 1:2] = np.nan

    ax1.imshow(A, interpolation='nearest')

    A = np.zeros((5, 5), dtype=np.bool)
    A[1:2, 1:2] = True
    A = np.ma.masked_array(np.ones((5, 5), dtype=np.uint16), A)

    ax2.imshow(A, interpolation='nearest')


@image_comparison(baseline_images=['imshow_endianess'],
                  remove_text=True, extensions=['png'])
def test_imshow_endianess():
    x = np.arange(10)
    X, Y = np.meshgrid(x, x)
    Z = ((X-5)**2 + (Y-5)**2)**0.5

    fig, (ax1, ax2) = plt.subplots(1, 2)

    kwargs = dict(origin="lower", interpolation='nearest',
                  cmap='viridis')

    ax1.imshow(Z.astype('<f8'), **kwargs)
    ax2.imshow(Z.astype('>f8'), **kwargs)


if __name__ == '__main__':
    nose.runmodule(argv=['-s', '--with-doctest'], exit=False)
Exemplo n.º 37
0
        ----------
        value: list or tuple
            The values to use in the tests
        """
        print(self.traj_file)
        ideal_atoms, _ = value[0]
        write_traj = Trajectory(self.traj_file.name, mode='w')
        traj = []
        for i in range(3):
            write_traj.write(ideal_atoms)
            traj.append(ideal_atoms)

        self.traj_file.close()
        assert os.path.exists(self.traj_file.name)
        print(self.traj_file)
        read_traj = TrajectoryReader(self.traj_file.name)
        print(len(traj), len(read_traj))
        assert len(traj) == len(read_traj)
        del traj


if __name__ == '__main__':
    import nose

    nose.runmodule(argv=['--with-doctest',
                         # '--nocapture',
                         '-v',
                         '-x'
                         ],
                   exit=False)
Exemplo n.º 38
0
            neigh = neighbors.NearestNeighbors(n_neighbors=n_neighbors,
                                               algorithm=algorithm,
                                               metric=metric, **kwds)
            neigh.fit(X)
            results.append(neigh.kneighbors(test, return_distance=True))

        assert_array_almost_equal(results[0][0], results[1][0])
        assert_array_almost_equal(results[0][1], results[1][1])


def test_callable_metric():
    metric = lambda x1, x2: np.sqrt(np.sum(x1 ** 2 + x2 ** 2))

    X = np.random.RandomState(42).rand(20, 2)
    nbrs1 = neighbors.NearestNeighbors(3, algorithm='auto', metric=metric)
    nbrs2 = neighbors.NearestNeighbors(3, algorithm='brute', metric=metric)

    nbrs1.fit(X)
    nbrs2.fit(X)

    dist1, ind1 = nbrs1.kneighbors(X)
    dist2, ind2 = nbrs2.kneighbors(X)

    assert_array_almost_equal(dist1, dist2)


if __name__ == '__main__':
    import nose
    nose.runmodule()
Exemplo n.º 39
0
    res_olsg = OLS(g_inv, exogg).fit()

    #> NeweyWest(fm, lag = 4, prewhite = FALSE, sandwich = TRUE, verbose=TRUE, adjust=TRUE)
    #Lag truncation parameter chosen: 4
    #                     (Intercept)                   ggdp                  lint
    cov1_r = [
        [1.40643899878678802, -0.3180328707083329709, -0.060621111216488610],
        [-0.31803287070833292, 0.1097308348999818661, 0.000395311760301478],
        [-0.06062111121648865, 0.0003953117603014895, 0.087511528912470993]
    ]

    #> NeweyWest(fm, lag = 4, prewhite = FALSE, sandwich = TRUE, verbose=TRUE, adjust=FALSE)
    #Lag truncation parameter chosen: 4
    #                    (Intercept)                  ggdp                  lint
    cov2_r = [
        [1.3855512908840137, -0.313309610252268500, -0.059720797683570477],
        [-0.3133096102522685, 0.108101169035130618, 0.000389440793564339],
        [-0.0597207976835705, 0.000389440793564336, 0.086211852740503622]
    ]

    cov1, se1 = sw.cov_hac_simple(res_olsg, nlags=4, use_correction=True)
    cov2, se2 = sw.cov_hac_simple(res_olsg, nlags=4, use_correction=False)
    assert_almost_equal(cov1, cov1_r, decimal=14)
    assert_almost_equal(cov2, cov2_r, decimal=14)


if __name__ == '__main__':
    import nose
    nose.runmodule(argv=[__file__, '-vvs', '-x'], exit=False)
    #test_hac_simple()