# This file is part of the pyMOR project (http://www.pymor.org).
# Copyright 2013-2019 pyMOR developers and contributors. All rights reserved.
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
from pymortests.base import runmodule
from pymortests.fixtures.analyticalproblem import analytical_problem, picklable_analytical_problem
from pymortests.pickling import assert_picklable, assert_picklable_without_dumps_function
def test_pickle(analytical_problem):
assert_picklable(analytical_problem)
def test_pickle_without_dumps_function(picklable_analytical_problem):
assert_picklable_without_dumps_function(picklable_analytical_problem)
if __name__ == "__main__":
runmodule(filename=__file__)
for g in self.grids:
for d in xrange(g.dim):
os, ps = g.reference_element(d).quadrature_info()
for t in os.keys():
for o, p in izip(os[t], ps[t]):
self.assertEqual(
g.quadrature_points(d, order=o, quadrature_type=t).shape, (g.size(d), p, g.dim_outer)
)
self.assertEqual(
g.quadrature_points(d, npoints=p, quadrature_type=t).shape, (g.size(d), p, g.dim_outer)
)
def test_quadrature_points_values(self):
for g in self.grids:
for d in xrange(g.dim):
A, B = g.embeddings(d)
os, ps = g.reference_element(d).quadrature_info()
for t in os.keys():
for o, p in izip(os[t], ps[t]):
Q = g.quadrature_points(d, order=o, quadrature_type=t)
q, _ = g.reference_element(d).quadrature(order=o, quadrature_type=t)
np.testing.assert_allclose(Q, g.quadrature_points(d, npoints=p, quadrature_type=t))
np.testing.assert_allclose(Q, B[:, np.newaxis, :] + np.einsum("eij,qj->eqi", A, q))
# this needs to go into every module that wants to use dynamically generated types, ie. testcases, below the test code
from pymor.core.dynamic import *
if __name__ == "__main__":
runmodule(name="pymortests.grid")
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
import numpy as np
from pymor.algorithms.basic import almost_equal
from pymor.core.pickle import dumps, loads
from pymortests.fixtures.discretization import discretization, picklable_discretization
from pymortests.base import runmodule
from pymortests.pickling import assert_picklable, assert_picklable_without_dumps_function
def test_pickle(discretization):
assert_picklable(discretization)
def test_pickle_without_dumps_function(picklable_discretization):
assert_picklable_without_dumps_function(picklable_discretization)
def test_pickle_by_solving(discretization):
d = discretization
d2 = loads(dumps(d))
d.disable_caching()
d2.disable_caching()
for mu in d.parameter_space.sample_randomly(3, seed=234):
assert np.all(almost_equal(d.solve(mu), d2.solve(mu)))
if __name__ == "__main__":
runmodule(filename=__file__)
# This file is part of the pyMor project (http://www.pymor.org).
# Copyright Holders: Felix Albrecht, Rene Milk, Stephan Rave
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
from __future__ import absolute_import, division, print_function
from pymor.core import defaults
from pymortests.base import TestBase, runmodule
class DefaultsTest(TestBase):
def testStr(self):
rep = str(defaults)
self.assertGreater(len(rep), 0)
if __name__ == "__main__":
runmodule(name='pymortests.core.defaults')
from pymortests.base import (TestBase, runmodule, SubclassForImplemetorsOf)
from pymor import core
@SubclassForImplemetorsOf(BasicInterface)
class PickleMeInterface(TestBase):
def testDump(self):
try:
obj = self.Type()
self.assertIsInstance(obj, self.Type)
if issubclass(self.Type, core.Unpicklable):
return
except TypeError as e:
self.logger.debug('PicklingError: Not testing {} because its init failed: {}'.format(self.Type, str(e)))
return
with tempfile.NamedTemporaryFile(mode='wb', delete=False) as dump_file:
core.dump(obj, dump_file)
dump_file.close()
f = open(dump_file.name, 'rb')
unpickled = core.load(f)
self.assertEqual(obj.__class__, unpickled.__class__)
os.unlink(dump_file.name)
# this needs to go into every module that wants to use dynamically generated types, ie. testcases, below the test code
from pymor.core.dynamic import *
if __name__ == "__main__":
runmodule(name='pymortests.core.pickling')
dump_file.close()
f = open(dump_file.name, 'rb')
unpickled = pymor.core.load(f)
self.assert_(getattr(obj, attribute_name) == getattr(unpickled, attribute_name))
os.unlink(dump_file.name)
picklme(AverageImplementer(), 'some_attribute')
picklme(CacheImplementer(), 'some_attribute')
picklme(RectGrid(num_intervals=(4, 4)), 'num_intervals')
def testDeprecated(self):
@decorators.Deprecated('use other stuff instead')
def deprecated_function():
pass
# Cause all warnings to always be triggered.
import warnings
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
# Trigger a warning.
deprecated_function()
# Verify some things
self.assertEqual(len(w), 1)
self.assertTrue(issubclass(w[-1].category, DeprecationWarning))
self.assertTrue("DeprecationWarning" in str(w[-1].message))
def testVersion(self):
self.assertGreater(pymor.version, pymor.NO_VERSION)
self.assertIsInstance(pymor.version, tuple)
if __name__ == "__main__":
runmodule(name='pymortests.core.interface')
from __future__ import absolute_import, division, print_function
from pymor import parameters
from pymortests.base import TestBase, runmodule
class TestCubicParameterspace(TestBase):
def setUp(self):
TestBase.setUp(self)
self.space = parameters.CubicParameterSpace({'diffusionl': 1}, 0.1, 1)
self.samples = 100
def _check_values(self, values):
self.assertEqual(len(values), self.samples)
for value in values:
self.assertTrue(self.space.contains(value))
def test_uniform(self):
values = list(self.space.sample_uniformly(self.samples))
self._check_values(values)
def test_randomly(self):
values = list(self.space.sample_randomly(self.samples))
self._check_values(values)
if __name__ == "__main__":
runmodule(name='pymortests.parameters')
grid = mock.Mock()
inst.validate_interface(object(), pymor.grids.boundaryinfos.AllDirichletBoundaryInfo(grid))
def test_disabled_contracts(self):
contracts.disable_all()
@contract
def disabled(phrase):
'''
:type phrase: str
'''
return phrase
# this should not throw w/ contracts disabled
disabled(int(8))
contracts.enable_all()
# this will still not throw because the disabled value is checked at decoration time only
disabled(int(8))
@contract
def enabled(phrase):
'''
:type phrase: str
'''
return phrase
# a newly decorated function will throw
with self.assertRaises(exceptions.ContractNotRespected):
enabled(int(8))
if __name__ == "__main__":
runmodule(name='pymortests.core.contract')
# This file is part of the pyMor project (http://www.pymor.org).
# Copyright Holders: Felix Albrecht, Rene Milk, Stephan Rave
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
from __future__ import absolute_import, division, print_function
import numpy as np
import random
from math import sin, exp
from pymortests.base import TestBase, runmodule
from pymor.playground.expression_function import ExpressionFunction
FUNCTIONS = [(ExpressionFunction(['x**2'], 'x'), lambda x: np.array([x ** 2])),
(ExpressionFunction(['x**2', 'sin(x)'], 'x'), lambda x: np.array([x ** 2, sin(x)])),
(ExpressionFunction(['exp(xp)'], 'xp'), lambda x: np.array([exp(x)]))]
class TestExpressionFunction(TestBase):
def test_eval(self):
for (fn, fe) in FUNCTIONS:
for x in (random.uniform(0, 1) for _ in xrange(9000)):
np.testing.assert_array_almost_equal(fn([x]), fe(x))
if __name__ == "__main__":
random.seed()
runmodule(name='pymortests.playground')
self.logger.info(int1 - int0)
def test_limit(self):
for c in [IamLimitedCached(cache.SMALL_MEMORY_CONFIG),
IamLimitedCached(cache.SMALL_DISK_CONFIG)]:
for i in range(25):
c.cache_region.backend.print_limit()
_ = c.me_takey_no_time(i)
c.cache_region.backend.print_limit()
def test_copy(self):
from copy import copy
x = IWillBeCopied()
x_id = x.my_id(1)
y = copy(x)
y_id = y.my_id(1)
self.assertNotEqual(x_id, y_id)
def test_backend_api(self):
for backend_cls in [cache.LimitedFileBackend, cache.LimitedMemoryBackend, cache.DummyBackend]:
backend = backend_cls({})
self.assertEqual(backend.get('mykey'), cache.NO_VALUE)
backend.set('mykey', 1)
self.assertEqual(backend.get('mykey'), 1 if backend_cls != cache.DummyBackend else cache.NO_VALUE)
backend.delete('mykey')
self.assertEqual(backend.get('mykey'), cache.NO_VALUE)
if __name__ == "__main__":
runmodule(name='pymortests.core.cache')
exercise_logger(logger)
def logclass(cls):
logger = cls.logger
exercise_logger(logger)
def test_logger():
import pymor
fails = []
for importer, pack_name, _ in pkgutil.walk_packages(
pymor.__path__, pymor.__name__ + ".", lambda n: fails.append(n)
):
yield logmodule, pack_name
try:
importer.find_module(pack_name).load_module(pack_name)
except TypeError, e:
fails.append(pack_name)
import pprint
if len(fails):
core.getLogger(__name__).error("Failed imports: {}".format(pprint.pformat(set(fails))))
for cls in pymor.core.interfaces.BasicInterface.implementors(True):
yield logclass, cls
if __name__ == "__main__":
runmodule(name="pymortests.core.logger")
self.assertFalse(True, "test is missing")
class CmpTest(TestBase):
def test_props(self):
tol_range = [None, 0.0, 1]
nan = float('nan')
inf = float('inf')
for (rtol, atol) in itertools.product(tol_range, tol_range):
msg = 'rtol: {} | atol {}'.format(rtol, atol)
self.assertTrue(float_cmp(0, 0, rtol, atol), msg)
self.assertTrue(float_cmp(-0, -0, rtol, atol), msg)
self.assertTrue(float_cmp(-1, -1, rtol, atol), msg)
self.assertTrue(float_cmp(0, -0, rtol, atol), msg)
self.assertFalse(float_cmp(2, -2, rtol, atol), msg)
self.assertFalse(float_cmp(nan, nan, rtol, atol), msg)
self.assertTrue(nan != nan)
self.assertFalse(nan == nan)
self.assertFalse(float_cmp(-nan, nan, rtol, atol), msg)
self.assertFalse(float_cmp(inf, inf, rtol, atol), msg)
self.assertFalse(inf != inf)
self.assertTrue(inf == inf)
self.assertTrue(float_cmp(-inf, inf, rtol, atol), msg)
if __name__ == "__main__":
runmodule(name='pymortests.tools')
g.quadrature_points(d, npoints=max(ps[t]) + 1, quadrature_type=t)
def test_quadrature_points_shape(self):
for g in self.grids:
for d in xrange(g.dim):
os, ps = g.reference_element(d).quadrature_info()
for t in os.keys():
for o, p in izip(os[t], ps[t]):
self.assertEqual(g.quadrature_points(d, order=o, quadrature_type=t).shape,
(g.size(d), p, g.dim_outer))
self.assertEqual(g.quadrature_points(d, npoints=p, quadrature_type=t).shape,
(g.size(d), p, g.dim_outer))
def test_quadrature_points_values(self):
for g in self.grids:
for d in xrange(g.dim):
A, B = g.embeddings(d)
os, ps = g.reference_element(d).quadrature_info()
for t in os.keys():
for o, p in izip(os[t], ps[t]):
Q = g.quadrature_points(d, order=o, quadrature_type=t)
q, _ = g.reference_element(d).quadrature(order=o, quadrature_type=t)
np.testing.assert_allclose(Q, g.quadrature_points(d, npoints=p, quadrature_type=t))
np.testing.assert_allclose(Q, B[:, np.newaxis, :] + np.einsum('eij,qj->eqi', A, q))
# this needs to go into every module that wants to use dynamically generated types, ie. testcases, below the test code
from pymor.core.dynamic import *
if __name__ == "__main__":
runmodule(name='pymortests.grid')
# This file is part of the pyMor project (http://www.pymor.org).
# Copyright Holders: Felix Albrecht, Rene Milk, Stephan Rave
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
from __future__ import absolute_import, division, print_function
from pymortests.base import runmodule
if __name__ == "__main__":
runmodule(name='pymortests.benchmarks')
