diff --git a/.coveragerc b/.coveragerc
new file mode 100644
index 0000000000000000000000000000000000000000..321e5ca09d0fec5a6ef31f33007b48e5b9491a93
--- /dev/null
+++ b/.coveragerc
@@ -0,0 +1,2 @@
+[run]
+omit = */tests/*
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
index 9eec19adef3452e5e2054dbb3c77deeb72c52308..4e38a622f445da2db051b862cccb5cdd0aa0b19e 100644
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -3,4 +3,4 @@ job:
- python3 setup.py build
- python3 setup.py build_ext -i
- make -C doc clean && make -C doc html
- - nosetests3 --with-coverage --cover-package kwant
+ - py.test --cov=kwant kwant
\ No newline at end of file
diff --git a/INSTALL.rst b/INSTALL.rst
index 451724a1685cd0c9c9f9105ebb57c7966809b33d..7e82648d734dbf0f98ddc73a9fc48da89fbd1cfe 100644
--- a/INSTALL.rst
+++ b/INSTALL.rst
@@ -39,7 +39,7 @@ The following software is highly recommended though not strictly required:
footprint. (Kwant uses only the sequential, single core version
of MUMPS. The advantages due to MUMPS as used by Kwant are thus independent
of the number of CPU cores of the machine on which Kwant runs.)
- * The `nose testing framework <http://nose.readthedocs.org/>`_ for running the
+ * The `py.test testing framework <http://http://pytest.org/>`_ for running the
tests included with Kwant.
In addition, to build a copy of Kwant that has been checked-out directly from
@@ -152,7 +152,7 @@ root.
1. Install the required packages. On Debian-based systems like Ubuntu this can
be done by running the command ::
- sudo apt-get install python-dev python-scipy python-matplotlib python-nose g++ gfortran libopenblas-dev liblapack-dev libmumps-scotch-dev
+ sudo apt-get install python3-dev python3-scipy python3-matplotlib python3-pytest g++ gfortran libopenblas-dev liblapack-dev libmumps-scotch-dev
2. Unpack Tinyarray, enter its directory. To build and install, run ::
@@ -231,7 +231,7 @@ installed as ::
brew tap homebrew/science
brew tap homebrew/python
brew tap kwant-project/kwant
- pip install nose six
+ pip install pytest pytest-runner six
brew install numpy scipy matplotlib
Note that during the installation you will be told which paths to add when you
diff --git a/examples/test_square.py b/examples/test_square.py
new file mode 100644
index 0000000000000000000000000000000000000000..29b782e693e918ff483a1d33e8e4e8a97a4eb76c
--- /dev/null
+++ b/examples/test_square.py
@@ -0,0 +1,35 @@
+import square
+from pytest import raises
+from numpy.testing import assert_almost_equal
+
+def test_nodeid_to_from_pos():
+ s = square.System((3, 4), 1)
+ raises(Exception, s.nodeid_from_pos, (0, -2))
+ raises(Exception, s.nodeid_from_pos, (-1, 3))
+ raises(Exception, s.nodeid_from_pos, (3, 1))
+ raises(Exception, s.pos_from_nodeid, -1)
+ raises(Exception, s.pos_from_nodeid, 12)
+ assert s.nodeid_from_pos((0, 0)) == 0
+ assert s.nodeid_from_pos(s.pos_from_nodeid(7)) == 7
+ assert s.pos_from_nodeid(s.nodeid_from_pos((2, 3))) == (2, 3)
+
+def test_hamiltonian():
+ sys = square.System((4, 5), 1)
+ for i in range(sys.graph.num_nodes):
+ shape = sys.hamiltonian(i, i).shape
+ assert len(shape) == 2
+ assert shape[0] == 1
+ for j in sys.graph.out_neighbors(i):
+ m = sys.hamiltonian(i, j)
+ shape = m.shape
+ m_herm = m.T.conj()
+ assert_almost_equal(m, m_herm)
+ assert_almost_equal(m_herm, sys.hamiltonian(j, i))
+
+def test_selfenergy():
+ syst = square.System((2, 4), 1)
+ for lead in range(len(syst.lead_interfaces)):
+ se = syst.leads[lead].selfenergy(0)
+ assert len(se.shape) == 2
+ assert se.shape[0] == se.shape[1]
+ assert se.shape[0] == len(syst.lead_interfaces[lead])
diff --git a/examples/tests/test_square.py b/examples/tests/test_square.py
deleted file mode 100644
index 32a7a8bd616182becc5048336158d955a42eb41b..0000000000000000000000000000000000000000
--- a/examples/tests/test_square.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import square
-from nose.tools import assert_equal, assert_raises
-from numpy.testing import assert_almost_equal
-
-def test_nodeid_to_from_pos():
- s = square.System((3, 4), 1)
- assert_raises(Exception, s.nodeid_from_pos, (0, -2))
- assert_raises(Exception, s.nodeid_from_pos, (-1, 3))
- assert_raises(Exception, s.nodeid_from_pos, (3, 1))
- assert_raises(Exception, s.pos_from_nodeid, -1)
- assert_raises(Exception, s.pos_from_nodeid, 12)
- assert_equal(s.nodeid_from_pos((0, 0)), 0)
- assert_equal(s.nodeid_from_pos(s.pos_from_nodeid(7)), 7)
- assert_equal(s.pos_from_nodeid(s.nodeid_from_pos((2, 3))), (2, 3))
-
-def test_hamiltonian():
- syst = square.System((4, 5), 1)
- for i in range(syst.graph.num_nodes):
- shape = syst.hamiltonian(i, i).shape
- assert_equal(len(shape), 2)
- assert_equal(shape[0], 1)
- for j in syst.graph.out_neighbors(i):
- m = syst.hamiltonian(i, j)
- shape = m.shape
- m_herm = m.T.conj()
- assert_almost_equal(m, m_herm)
- assert_almost_equal(m_herm, syst.hamiltonian(j, i))
-
-def test_selfenergy():
- syst = square.System((2, 4), 1)
- for lead in range(len(syst.lead_interfaces)):
- se = syst.leads[lead].selfenergy(0)
- assert_equal(len(se.shape), 2)
- assert_equal(se.shape[0], se.shape[1])
- assert_equal(se.shape[0], len(syst.lead_interfaces[lead]))
diff --git a/kwant/__init__.py b/kwant/__init__.py
index 389d01460ece35c116d43fe704851183d34149f6..ad7cd876b5d4e96babdb8b1ed1498ef15b287f50 100644
--- a/kwant/__init__.py
+++ b/kwant/__init__.py
@@ -53,11 +53,11 @@ else:
__all__.extend(['plotter', 'plot'])
-def test(verbose=1):
- from nose.core import run
+def test(verbose=True):
+ from pytest import main
import os.path
- return run(argv=[__file__, os.path.dirname(os.path.abspath(__file__)),
- "-s", "--verbosity="+str(verbose)])
+ return main([os.path.dirname(os.path.abspath(__file__)),
+ "-s"] + (['-v'] if verbose else []))
test.__test__ = False
diff --git a/kwant/graph/tests/test_core.py b/kwant/graph/tests/test_core.py
index 14cdad0ba633b1989a1341450ee82472ba6df86e..e657bdc51b9bc7804d649841cc43f6b9f18be71e 100644
--- a/kwant/graph/tests/test_core.py
+++ b/kwant/graph/tests/test_core.py
@@ -9,7 +9,7 @@
from io import StringIO
from itertools import zip_longest
import numpy as np
-from nose.tools import assert_equal, assert_raises
+from pytest import raises
from kwant.graph.core import (Graph, NodeDoesNotExistError,
EdgeDoesNotExistError, DisabledFeatureError)
@@ -18,25 +18,25 @@ def test_empty():
g = graph.compressed()
assert not g.twoway
assert not g.edge_nr_translation
- assert_raises(NodeDoesNotExistError, g.out_neighbors, 0)
- assert_raises(NodeDoesNotExistError, g.has_edge, 0, 0)
- assert_raises(DisabledFeatureError, g.edge_id, 0)
+ raises(NodeDoesNotExistError, g.out_neighbors, 0)
+ raises(NodeDoesNotExistError, g.has_edge, 0, 0)
+ raises(DisabledFeatureError, g.edge_id, 0)
g = graph.compressed(twoway=True, edge_nr_translation=True)
assert g.twoway
assert g.edge_nr_translation
- assert_raises(NodeDoesNotExistError, g.in_neighbors, 0)
- assert_raises(NodeDoesNotExistError, g.out_edge_ids, 0)
- assert_raises(NodeDoesNotExistError, g.in_edge_ids, 0)
- assert_raises(EdgeDoesNotExistError, g.edge_id, 0)
+ raises(NodeDoesNotExistError, g.in_neighbors, 0)
+ raises(NodeDoesNotExistError, g.out_edge_ids, 0)
+ raises(NodeDoesNotExistError, g.in_edge_ids, 0)
+ raises(EdgeDoesNotExistError, g.edge_id, 0)
def test_num_nodes():
graph = Graph()
- assert_equal(graph.num_nodes, 0)
+ assert graph.num_nodes == 0
graph.num_nodes = 2
- assert_equal(graph.num_nodes, 2)
- assert_raises(ValueError, graph.__setattr__, 'num_nodes', 1)
+ assert graph.num_nodes == 2
+ raises(ValueError, graph.__setattr__, 'num_nodes', 1)
g = graph.compressed()
- assert_equal(g.num_nodes, 2)
+ assert g.num_nodes == 2
def test_large():
num_edges = 1000
@@ -45,15 +45,15 @@ def test_large():
graph.add_edge(i, i + 1)
g = graph.compressed()
g2 = graph.compressed(twoway=True)
- assert_equal(num_edges, g.num_nodes - 1)
+ assert num_edges == g.num_nodes - 1
for i in range(num_edges):
- assert_equal(tuple(g.out_neighbors(i)), (i + 1,))
- assert_equal(tuple(g2.in_neighbors(i + 1)), (i,))
+ assert tuple(g.out_neighbors(i)) == (i + 1,)
+ assert tuple(g2.in_neighbors(i + 1)) == (i,)
def check_dot(dot_expect, graph):
output = StringIO()
graph.write_dot(output)
- assert_equal(output.getvalue(), dot_expect)
+ assert output.getvalue() == dot_expect
output.close()
def test_small():
@@ -72,55 +72,55 @@ def test_small():
g = g.compressed(twoway=True)
for edge_should, edge_is in zip_longest(edges, g):
- assert_equal(edge_should, edge_is)
+ assert edge_should == edge_is
edge_ids = []
for edge in edges:
edge_ids.append(g.first_edge_id(*edge))
- assert_equal(tuple(g.out_neighbors(0)), (1, 2))
- assert_equal(tuple(g.in_neighbors(0)), ())
- assert_equal(tuple(g.out_edge_ids(0)), (edge_ids[0], edge_ids[1]))
- assert_equal(tuple(g.in_edge_ids(0)), ())
+ assert tuple(g.out_neighbors(0)) == (1, 2)
+ assert tuple(g.in_neighbors(0)) == ()
+ assert tuple(g.out_edge_ids(0)) == (edge_ids[0], edge_ids[1])
+ assert tuple(g.in_edge_ids(0)) == ()
- assert_equal(tuple(g.out_neighbors(1)), (2,))
- assert_equal(tuple(g.in_neighbors(1)), (0, 2))
- assert_equal(tuple(g.out_edge_ids(1)), (edge_ids[2],))
- assert_equal(tuple(g.in_edge_ids(1)), (edge_ids[0], edge_ids[3]))
+ assert tuple(g.out_neighbors(1)) == (2,)
+ assert tuple(g.in_neighbors(1)) == (0, 2)
+ assert tuple(g.out_edge_ids(1)) == (edge_ids[2],)
+ assert tuple(g.in_edge_ids(1)) == (edge_ids[0], edge_ids[3])
- assert_equal(tuple(g.out_neighbors(2)), (1,))
- assert_equal(tuple(g.in_neighbors(2)), (0, 1))
- assert_equal(tuple(g.out_edge_ids(2)), (edge_ids[3],))
- assert_equal(tuple(g.in_edge_ids(2)), (edge_ids[1], edge_ids[2]))
+ assert tuple(g.out_neighbors(2)) == (1,)
+ assert tuple(g.in_neighbors(2)) == (0, 1)
+ assert tuple(g.out_edge_ids(2)) == (edge_ids[3],)
+ assert tuple(g.in_edge_ids(2)) == (edge_ids[1], edge_ids[2])
assert g.has_edge(0, 1)
g.first_edge_id(0, 1)
assert not g.has_edge(1, 0)
- assert_raises(IndexError, g.first_edge_id, 1, 0)
+ raises(IndexError, g.first_edge_id, 1, 0)
check_dot(dot_expect, g)
def test_negative_node_ids():
g = Graph()
- assert_raises(ValueError, g.add_edge, 0, -1)
+ raises(ValueError, g.add_edge, 0, -1)
g = Graph(allow_negative_nodes=True)
g.add_edge(0, -1)
g.add_edge(-2, 0)
- assert_raises(ValueError, g.add_edge, -3, -4)
- assert_raises(ValueError, g.compressed)
+ raises(ValueError, g.add_edge, -3, -4)
+ raises(ValueError, g.compressed)
g1 = g.compressed(allow_lost_edges=True)
- assert_equal(g1.num_px_edges, 1)
- assert_equal(g1.num_xp_edges, 0)
+ assert g1.num_px_edges == 1
+ assert g1.num_xp_edges == 0
assert g1.has_edge(0, -1)
- assert_raises(DisabledFeatureError, g1.has_edge, -2, 0)
- assert_equal(tuple(g1.out_neighbors(0)), (-1,))
+ raises(DisabledFeatureError, g1.has_edge, -2, 0)
+ assert tuple(g1.out_neighbors(0)) == (-1,)
g2 = g.compressed(twoway=True)
- assert_equal(g2.num_px_edges, 1)
- assert_equal(g2.num_xp_edges, 1)
+ assert g2.num_px_edges == 1
+ assert g2.num_xp_edges == 1
assert g2.has_edge(0, -1)
assert g2.has_edge(-2, 0)
- assert_equal(tuple(g2.out_neighbors(0)), (-1,))
- assert_equal(tuple(g2.in_neighbors(0)), (-2,))
+ assert tuple(g2.out_neighbors(0)) == (-1,)
+ assert tuple(g2.in_neighbors(0)) == (-2,)
def test_add_edges():
edges = [(0, 1), (1, 2), (2, 3), (3, 0),
@@ -143,39 +143,39 @@ def test_add_edges():
g.write_dot(output)
dot = output.getvalue()
if prev_dot is not None:
- assert_equal(dot, prev_dot)
+ assert dot == prev_dot
prev_dot = dot
def test_edge_ids():
gr = Graph(allow_negative_nodes=True)
edges = [(0, -1), (-1, 0), (1, 2), (1, 2), (0, -1), (-1, 0), (-1, 0)]
for edge_nr, edge in enumerate(edges):
- assert_equal(gr.add_edge(*edge), edge_nr)
+ assert gr.add_edge(*edge) == edge_nr
g = gr.compressed(twoway=True, edge_nr_translation=True)
assert g.twoway
assert g.edge_nr_translation
- assert_equal(sorted(g.out_edge_ids(1)), sorted(g.in_edge_ids(2)))
+ assert sorted(g.out_edge_ids(1)) == sorted(g.in_edge_ids(2))
for edge_id in g.out_edge_ids(1):
- assert_equal(g.tail(edge_id), 1)
- assert_equal(g.head(edge_id), 2)
+ assert g.tail(edge_id) == 1
+ assert g.head(edge_id) == 2
for i, edge_id in enumerate(g.all_edge_ids(0, -1)):
if i == 0:
- assert_equal(edge_id, g.first_edge_id(0, -1))
- assert_equal(g.tail(edge_id), 0)
- assert_equal(g.head(edge_id), -1)
- assert_equal(i, 1)
+ assert edge_id == g.first_edge_id(0, -1)
+ assert g.tail(edge_id) == 0
+ assert g.head(edge_id) == -1
+ assert i == 1
for i, edge_id in enumerate(g.all_edge_ids(-1, 0)):
if i == 0:
- assert_equal(edge_id, g.first_edge_id(-1, 0))
- assert_equal(g.tail(edge_id), None)
- assert_equal(g.head(edge_id), 0)
- assert_equal(i, 2)
+ assert edge_id == g.first_edge_id(-1, 0)
+ assert g.tail(edge_id) == None
+ assert g.head(edge_id) == 0
+ assert i == 2
for edge_nr, edge in enumerate(edges):
if edge[0] < 0: continue
edge_id = g.edge_id(edge_nr)
- assert_equal(edge, (g.tail(edge_id), g.head(edge_id)))
+ assert edge == (g.tail(edge_id), g.head(edge_id))
g = gr.compressed(edge_nr_translation=True, allow_lost_edges=True)
- assert_raises(EdgeDoesNotExistError, g.edge_id, 1)
+ raises(EdgeDoesNotExistError, g.edge_id, 1)
diff --git a/kwant/graph/tests/test_dissection.py b/kwant/graph/tests/test_dissection.py
index fb21fe786737a2f784d6d1de09df528ce4dfc1d8..1eaaee4ddb4845fee7e423dc82c7c00ef508f75d 100644
--- a/kwant/graph/tests/test_dissection.py
+++ b/kwant/graph/tests/test_dissection.py
@@ -6,7 +6,6 @@
# the file AUTHORS.rst at the top-level directory of this distribution and at
# http://kwant-project.org/authors.
-from nose.tools import assert_true
import numpy as np
# from kwant.graph import Graph, dissection
# from kwant.graph.dissection import edge_dissection
@@ -41,4 +40,4 @@ def _DISABLED_test_edge_dissection():
found[entry] += 1
parse_tree(tree)
- assert_true((found == 1).all())
+ assert (found == 1).all()
diff --git a/kwant/graph/tests/test_scotch.py b/kwant/graph/tests/test_scotch.py
index 2ded31ae2f863eceee4a371b0e2db6a35eb70788..3f40364b045a5cc09d74ad937467e53a6ae58a38 100644
--- a/kwant/graph/tests/test_scotch.py
+++ b/kwant/graph/tests/test_scotch.py
@@ -6,7 +6,6 @@
# the file AUTHORS.rst at the top-level directory of this distribution and at
# http://kwant-project.org/authors.
-from nose.tools import assert_true
from kwant.graph import Graph
# from kwant.graph.scotch import bisect, reset
@@ -30,7 +29,7 @@ def _DISABLED_test_bisect():
parts = bisect(g)
for i in range(g.num_nodes):
- assert_true(parts[i] == 0 or parts[i] == 1)
+ assert parts[i] == 0 or parts[i] == 1
def _DISABLED_test_reset():
size = 5
@@ -53,4 +52,4 @@ def _DISABLED_test_reset():
reset()
parts2 = bisect(g)
- assert_true((parts1 == parts2).all())
+ assert (parts1 == parts2).all()
diff --git a/kwant/graph/tests/test_utils.py b/kwant/graph/tests/test_utils.py
index 0906765e5fd587dfe7fa2345bf06cb44c6dc8748..e6d5f02ae7bc8410f13f8f9ca1a02b270fa53190 100644
--- a/kwant/graph/tests/test_utils.py
+++ b/kwant/graph/tests/test_utils.py
@@ -7,7 +7,6 @@
# http://kwant-project.org/authors.
import numpy as np
-from nose.tools import assert_equal, assert_true
from kwant.graph import Graph
from kwant.graph.utils import (make_undirected, remove_duplicates,
induced_subgraph)
@@ -24,36 +23,36 @@ def test_make_undirected():
# First, test with no duplicates removed,
g2 = make_undirected(g, remove_dups=False)
- assert_equal(g2.num_nodes, g.num_nodes)
- assert_equal(g2.num_edges, 6)
- assert_true(g2.has_edge(0, 1))
- assert_true(g2.has_edge(1, 0))
- assert_true(g2.has_edge(1, 2))
- assert_true(g2.has_edge(2, 1))
+ assert g2.num_nodes == g.num_nodes
+ assert g2.num_edges == 6
+ assert g2.has_edge(0, 1)
+ assert g2.has_edge(1, 0)
+ assert g2.has_edge(1, 2)
+ assert g2.has_edge(2, 1)
# then with duplicates removed,
g2 = make_undirected(g, remove_dups=True)
- assert_equal(g2.num_nodes, g.num_nodes)
- assert_equal(g2.num_edges, 4)
- assert_true(g2.has_edge(0, 1))
- assert_true(g2.has_edge(1, 0))
- assert_true(g2.has_edge(1, 2))
- assert_true(g2.has_edge(2, 1))
+ assert g2.num_nodes == g.num_nodes
+ assert g2.num_edges == 4
+ assert g2.has_edge(0, 1)
+ assert g2.has_edge(1, 0)
+ assert g2.has_edge(1, 2)
+ assert g2.has_edge(2, 1)
# and finally with weights.
g2, edge_w2 = make_undirected(g, remove_dups=True, calc_weights=True)
- assert_equal(g2.num_nodes, g.num_nodes)
- assert_equal(g2.num_edges, 4)
- assert_true(g2.has_edge(0, 1))
- assert_true(g2.has_edge(1, 0))
- assert_true(g2.has_edge(1, 2))
- assert_true(g2.has_edge(2, 1))
- assert_equal(edge_w2[g2.first_edge_id(0,1)], 2)
- assert_equal(edge_w2[g2.first_edge_id(1,0)], 2)
- assert_equal(edge_w2[g2.first_edge_id(1,2)], 1)
- assert_equal(edge_w2[g2.first_edge_id(2,1)], 1)
+ assert g2.num_nodes == g.num_nodes
+ assert g2.num_edges == 4
+ assert g2.has_edge(0, 1)
+ assert g2.has_edge(1, 0)
+ assert g2.has_edge(1, 2)
+ assert g2.has_edge(2, 1)
+ assert edge_w2[g2.first_edge_id(0,1)] == 2
+ assert edge_w2[g2.first_edge_id(1,0)] == 2
+ assert edge_w2[g2.first_edge_id(1,2)] == 1
+ assert edge_w2[g2.first_edge_id(2,1)] == 1
def test_remove_duplicates():
graph = Graph()
@@ -64,19 +63,19 @@ def test_remove_duplicates():
# First test without edge weights,
g = graph.compressed()
remove_duplicates(g)
- assert_equal(g.num_edges, 2)
- assert_true(g.has_edge(0, 1))
- assert_true(g.has_edge(1, 2))
+ assert g.num_edges == 2
+ assert g.has_edge(0, 1)
+ assert g.has_edge(1, 2)
# then with edge weights.
g = graph.compressed()
edge_w = np.array([1,1,1], dtype=gint_dtype)
remove_duplicates(g, edge_w)
- assert_equal(g.num_edges, 2)
- assert_true(g.has_edge(0, 1))
- assert_true(g.has_edge(1, 2))
- assert_equal(edge_w[g.first_edge_id(0,1)], 2)
- assert_equal(edge_w[g.first_edge_id(1,2)], 1)
+ assert g.num_edges == 2
+ assert g.has_edge(0, 1)
+ assert g.has_edge(1, 2)
+ assert edge_w[g.first_edge_id(0,1)] == 2
+ assert edge_w[g.first_edge_id(1,2)] == 1
def test_induced_subgraph():
@@ -91,44 +90,38 @@ def test_induced_subgraph():
# First test select array,
select = np.array([True, True, True, False, False, True])
g2 = induced_subgraph(g, select)
- assert_equal(g2.num_nodes, 4)
- assert_equal(g2.num_edges, 3)
- assert_true(g2.has_edge(0, 1))
- assert_true(g2.has_edge(1, 0))
- assert_true(g2.has_edge(1, 2))
+ assert g2.num_nodes == 4
+ assert g2.num_edges == 3
+ assert g2.has_edge(0, 1)
+ assert g2.has_edge(1, 0)
+ assert g2.has_edge(1, 2)
# then test select function.
g2 = induced_subgraph(g, lambda i: select[i])
- assert_equal(g2.num_nodes, 4)
- assert_equal(g2.num_edges, 3)
- assert_true(g2.has_edge(0, 1))
- assert_true(g2.has_edge(1, 0))
- assert_true(g2.has_edge(1, 2))
+ assert g2.num_nodes == 4
+ assert g2.num_edges == 3
+ assert g2.has_edge(0, 1)
+ assert g2.has_edge(1, 0)
+ assert g2.has_edge(1, 2)
# Now the same with edge weights.
edge_w = np.arange(g.num_edges, dtype=gint_dtype)
g2, edge_w2 = induced_subgraph(g, select, edge_w)
- assert_equal(g2.num_nodes, 4)
- assert_equal(g2.num_edges, 3)
- assert_true(g2.has_edge(0, 1))
- assert_true(g2.has_edge(1, 0))
- assert_true(g2.has_edge(1, 2))
- assert_equal(edge_w[g.first_edge_id(0,1)],
- edge_w2[g2.first_edge_id(0,1)])
- assert_equal(edge_w[g.first_edge_id(1,0)],
- edge_w2[g2.first_edge_id(1,0)])
- assert_equal(edge_w[g.first_edge_id(1,2)],
- edge_w2[g2.first_edge_id(1,2)])
+ assert g2.num_nodes == 4
+ assert g2.num_edges == 3
+ assert g2.has_edge(0, 1)
+ assert g2.has_edge(1, 0)
+ assert g2.has_edge(1, 2)
+ assert edge_w[g.first_edge_id(0,1)] == edge_w2[g2.first_edge_id(0,1)]
+ assert edge_w[g.first_edge_id(1,0)] == edge_w2[g2.first_edge_id(1,0)]
+ assert edge_w[g.first_edge_id(1,2)] == edge_w2[g2.first_edge_id(1,2)]
g2, edge_w2 = induced_subgraph(g, lambda i: select[i], edge_w)
- assert_equal(g2.num_nodes, 4)
- assert_equal(g2.num_edges, 3)
- assert_true(g2.has_edge(0, 1))
- assert_true(g2.has_edge(1, 0))
- assert_true(g2.has_edge(1, 2))
- assert_equal(edge_w[g.first_edge_id(0,1)],
- edge_w2[g2.first_edge_id(0,1)])
- assert_equal(edge_w[g.first_edge_id(1,0)],
- edge_w2[g2.first_edge_id(1,0)])
- assert_equal(edge_w[g.first_edge_id(1,2)],
- edge_w2[g2.first_edge_id(1,2)])
+ assert g2.num_nodes == 4
+ assert g2.num_edges == 3
+ assert g2.has_edge(0, 1)
+ assert g2.has_edge(1, 0)
+ assert g2.has_edge(1, 2)
+ assert edge_w[g.first_edge_id(0,1)] == edge_w2[g2.first_edge_id(0,1)]
+ assert edge_w[g.first_edge_id(1,0)] == edge_w2[g2.first_edge_id(1,0)]
+ assert edge_w[g.first_edge_id(1,2)] == edge_w2[g2.first_edge_id(1,2)]
diff --git a/kwant/linalg/tests/test_linalg.py b/kwant/linalg/tests/test_linalg.py
index 7b70728ced8dae5d91de80c7d32e42aea0a2ceeb..c092f010210596fdbb95274e07ee2145fb3eb9c8 100644
--- a/kwant/linalg/tests/test_linalg.py
+++ b/kwant/linalg/tests/test_linalg.py
@@ -10,7 +10,6 @@ from kwant.linalg import (
lu_factor, lu_solve, rcond_from_lu, gen_eig, schur,
convert_r2c_schur, order_schur, evecs_from_schur, gen_schur,
convert_r2c_gen_schur, order_gen_schur, evecs_from_gen_schur)
-from nose.tools import assert_equal, assert_true
import numpy as np
from ._test_utils import _Random, assert_array_almost_equal
@@ -79,8 +78,8 @@ def test_rcond_from_lu():
#the assertions here
#Note: in my experience the estimate is excellent for somewhat
#larger matrices
- assert_true(err1/rcond1 < 0.1)
- assert_true(errI/rcondI < 0.1)
+ assert err1/rcond1 < 0.1
+ assert errI/rcondI < 0.1
_test_rcond_from_lu(np.float32)
_test_rcond_from_lu(np.float64)
@@ -174,8 +173,8 @@ def test_evecs_from_schur():
vl, vr = evecs_from_schur(t, q, select, left=True, right=True)
- assert_equal(vr.shape[1], 2)
- assert_equal(vl.shape[1], 2)
+ assert vr.shape[1] == 2
+ assert vl.shape[1] == 2
assert_array_almost_equal(dtype, np.dot(a, vr),
np.dot(vr, np.diag(ev[select])))
assert_array_almost_equal(dtype, np.dot(vl.T.conj(), a),
@@ -183,8 +182,8 @@ def test_evecs_from_schur():
vl, vr = evecs_from_schur(t, q, lambda i: i<2, left=True, right=True)
- assert_equal(vr.shape[1], 2)
- assert_equal(vl.shape[1], 2)
+ assert vr.shape[1] == 2
+ assert vl.shape[1] == 2
assert_array_almost_equal(dtype, np.dot(a, vr),
np.dot(vr, np.diag(ev[select])))
assert_array_almost_equal(dtype, np.dot(vl.T.conj(), a),
@@ -318,8 +317,8 @@ def test_evecs_from_gen_schur():
vl, vr = evecs_from_gen_schur(s, t, q, z, select,
left=True, right=True)
- assert_equal(vr.shape[1], 2)
- assert_equal(vl.shape[1], 2)
+ assert vr.shape[1] == 2
+ assert vl.shape[1] == 2
assert_array_almost_equal(dtype,
np.dot(a, np.dot(vr,
np.diag(beta[select]))),
@@ -336,8 +335,8 @@ def test_evecs_from_gen_schur():
vl, vr = evecs_from_gen_schur(s, t, q, z, lambda i: i<2, left=True,
right=True)
- assert_equal(vr.shape[1], 2)
- assert_equal(vl.shape[1], 2)
+ assert vr.shape[1] == 2
+ assert vl.shape[1] == 2
assert_array_almost_equal(dtype,
np.dot(a, np.dot(vr,
np.diag(beta[select]))),
diff --git a/kwant/linalg/tests/test_mumps.py b/kwant/linalg/tests/test_mumps.py
index 3e1959cab6716baaab5b91feca4db54cb85cd3cc..2f0ac64e053a01e20f350e1165ee85001ea98c35 100644
--- a/kwant/linalg/tests/test_mumps.py
+++ b/kwant/linalg/tests/test_mumps.py
@@ -14,12 +14,15 @@ except ImportError:
from kwant.lattice import honeycomb
from kwant.builder import Builder, HoppingKind
-from numpy.testing.decorators import skipif
+import pytest
import numpy as np
import scipy.sparse as sp
from ._test_utils import _Random, assert_array_almost_equal
-@skipif(no_mumps)
+
+pytestmark = pytest.mark.skipif(no_mumps, reason="MUMPS not installed")
+
+
def test_lu_with_dense():
def _test_lu_with_dense(dtype):
rand = _Random()
@@ -48,7 +51,6 @@ def test_lu_with_dense():
_test_lu_with_dense(np.complex128)
-@skipif(no_mumps)
def test_schur_complement_with_dense():
def _test_schur_complement_with_dense(dtype):
rand = _Random()
@@ -60,7 +62,6 @@ def test_schur_complement_with_dense():
_test_schur_complement_with_dense(np.complex128)
-@skipif(no_mumps)
def test_error_minus_9(r=10):
"""Test if MUMPSError -9 is properly caught by increasing memory"""
diff --git a/kwant/physics/tests/test_dispersion.py b/kwant/physics/tests/test_dispersion.py
index 6c36669ecc9a0f873f211773519387e1d1f6a8b8..414ac17854a8e491c8010900686f938b5f35d5ac 100644
--- a/kwant/physics/tests/test_dispersion.py
+++ b/kwant/physics/tests/test_dispersion.py
@@ -7,7 +7,7 @@
# http://kwant-project.org/authors.
from numpy.testing import assert_array_almost_equal, assert_almost_equal
-from nose.tools import assert_raises
+from pytest import raises
import kwant
from math import pi, cos, sin
@@ -45,4 +45,4 @@ def test_raise_nonhermitian():
syst[lat(0)] = 1j
syst[lat(0), lat(1)] = complex(cos(0.2), sin(0.2))
syst = syst.finalized()
- assert_raises(ValueError, kwant.physics.Bands, syst)
+ raises(ValueError, kwant.physics.Bands, syst)
diff --git a/kwant/physics/tests/test_noise.py b/kwant/physics/tests/test_noise.py
index 26331c5a9b51d555d9a1acdbbffc6d9a162f6c33..23dbbc1523b42352ee2e92fd274af5d5af3749b1 100644
--- a/kwant/physics/tests/test_noise.py
+++ b/kwant/physics/tests/test_noise.py
@@ -7,7 +7,7 @@
# http://kwant-project.org/authors.
import numpy as np
-from nose.tools import assert_raises
+from pytest import raises
from numpy.testing import assert_almost_equal
import kwant
from kwant.physics import two_terminal_shotnoise
@@ -37,7 +37,7 @@ def test_multiterminal_input():
syst = twoterminal_system()
syst.attach_lead(syst.leads[0].builder)
sol = kwant.smatrix(syst.finalized(), out_leads=[0], in_leads=[0])
- assert_raises(ValueError, two_terminal_shotnoise, sol)
+ raises(ValueError, two_terminal_shotnoise, sol)
def test_twoterminal():
diff --git a/kwant/solvers/tests/_test_sparse.py b/kwant/solvers/tests/_test_sparse.py
index 3e35a76e176fe1ff7271448c10c91e0411e0451c..99e2bd729efb32ec6656c641d0350d4dbe7e89a2 100644
--- a/kwant/solvers/tests/_test_sparse.py
+++ b/kwant/solvers/tests/_test_sparse.py
@@ -9,8 +9,8 @@
from math import cos, sin
import numpy as np
-from nose.tools import assert_raises
-from numpy.testing import assert_equal, assert_almost_equal
+from pytest import raises
+from numpy.testing import assert_almost_equal
import kwant
n = 5
@@ -67,7 +67,7 @@ def test_output(smatrix):
assert_almost_equal(abs(s1), abs(s2))
assert_almost_equal(np.dot(s.T.conj(), s),
np.identity(s.shape[0]))
- assert_raises(ValueError, smatrix, fsyst, out_leads=[])
+ raises(ValueError, smatrix, fsyst, out_leads=[])
modes = smatrix(fsyst).lead_info
h = fsyst.leads[0].cell_hamiltonian()
t = fsyst.leads[0].inter_cell_hopping()
@@ -101,7 +101,7 @@ def test_one_lead(smatrix):
assert_almost_equal(np.dot(s.conjugate().transpose(), s),
np.identity(s.shape[0]))
- assert_raises(ValueError, smatrix, fsyst.precalculate(what='selfenergy'))
+ raises(ValueError, smatrix, fsyst.precalculate(what='selfenergy'))
# Test that a system with one lead with no propagating modes has a
# 0x0 S-matrix.
@@ -175,7 +175,7 @@ def test_two_equal_leads(smatrix):
fsyst = system.finalized()
for syst in (fsyst, fsyst.precalculate(), fsyst.precalculate(what='all')):
check_fsyst(syst)
- assert_raises(ValueError, check_fsyst, fsyst.precalculate(what='selfenergy'))
+ raises(ValueError, check_fsyst, fsyst.precalculate(what='selfenergy'))
# Test the same, but with a larger scattering region.
system = kwant.Builder()
@@ -186,7 +186,7 @@ def test_two_equal_leads(smatrix):
fsyst = system.finalized()
for syst in (fsyst, fsyst.precalculate(), fsyst.precalculate(what='all')):
check_fsyst(syst)
- assert_raises(ValueError, check_fsyst, fsyst.precalculate(what='selfenergy'))
+ raises(ValueError, check_fsyst, fsyst.precalculate(what='selfenergy'))
# Test a more complicated graph with non-singular hopping.
@@ -214,7 +214,7 @@ def test_graph_system(smatrix):
assert_almost_equal(np.dot(s.conjugate().transpose(), s),
np.identity(s.shape[0]))
n_modes = len(leads[0].momenta) // 2
- assert_equal(len(leads[1].momenta) // 2, n_modes)
+ assert len(leads[1].momenta) // 2 == n_modes
assert_almost_equal(s[: n_modes, : n_modes], 0)
t_elements = np.sort(abs(np.asarray(s[n_modes:, :n_modes])),
axis=None)
@@ -337,7 +337,7 @@ def test_many_leads(*factories):
if i in out_leads and j in in_leads:
assert_almost_equal(br.transmission(i, j), trans[i, j])
else:
- assert_raises(ValueError, br.transmission, i, j)
+ raises(ValueError, br.transmission, i, j)
if len(out_leads) == len(in_leads) == 4:
assert_almost_equal(br.conductance_matrix(), cmat)
@@ -386,7 +386,7 @@ def test_selfenergy(greens_function, smatrix):
for syst in (fsyst, fsyst.precalculate(what='selfenergy'),
fsyst.precalculate(what='all')):
check_fsyst(syst)
- assert_raises(ValueError, check_fsyst, fsyst.precalculate(what='modes'))
+ raises(ValueError, check_fsyst, fsyst.precalculate(what='modes'))
def test_selfenergy_reflection(greens_function, smatrix):
@@ -415,7 +415,7 @@ def test_selfenergy_reflection(greens_function, smatrix):
fsyst.precalculate(what='all')):
sol = greens_function(syst, 0, (), [0], [0])
assert_almost_equal(sol.transmission(0,0), t.transmission(0,0))
- assert_raises(ValueError, greens_function, fsyst.precalculate(what='modes'),
+ raises(ValueError, greens_function, fsyst.precalculate(what='modes'),
0, (), [0], [0])
@@ -448,9 +448,9 @@ def test_ldos(ldos):
fsyst.precalculate(what='all')):
assert_almost_equal(ldos(finsyst, 0),
np.array([1, 1]) / (2 * np.pi))
- assert_raises(ValueError, ldos, fsyst.precalculate(what='selfenergy'), 0)
+ raises(ValueError, ldos, fsyst.precalculate(what='selfenergy'), 0)
fsyst.leads[0] = LeadWithOnlySelfEnergy(fsyst.leads[0])
- assert_raises(NotImplementedError, ldos, fsyst, 0)
+ raises(NotImplementedError, ldos, fsyst, 0)
def test_wavefunc_ldos_consistency(wave_function, ldos):
@@ -491,6 +491,6 @@ def test_wavefunc_ldos_consistency(wave_function, ldos):
for fsyst in (syst, syst.precalculate(what='modes'),
syst.precalculate(what='all')):
check(fsyst)
- assert_raises(ValueError, check, syst.precalculate(what='selfenergy'))
+ raises(ValueError, check, syst.precalculate(what='selfenergy'))
syst.leads[0] = LeadWithOnlySelfEnergy(syst.leads[0])
- assert_raises(NotImplementedError, check, syst)
+ raises(NotImplementedError, check, syst)
diff --git a/kwant/solvers/tests/test_mumps.py b/kwant/solvers/tests/test_mumps.py
index e07aa120162d69304f405eaeef9443ff60a050fd..a9f39eaace7b3461b4f9b48df31590fa4522ac83 100644
--- a/kwant/solvers/tests/test_mumps.py
+++ b/kwant/solvers/tests/test_mumps.py
@@ -6,8 +6,7 @@
# the file AUTHORS.rst at the top-level directory of this distribution and at
# http://kwant-project.org/authors.
-#from nose.plugins.skip import Skip, SkipTest
-from numpy.testing.decorators import skipif
+import pytest
try:
from kwant.solvers.mumps import (
smatrix, greens_function, ldos, wave_function, options, reset_options)
@@ -16,7 +15,8 @@ try:
except ImportError:
no_mumps = True
-
+pytestmark = pytest.mark.skipif(no_mumps, reason="MUMPS not installed")
+
opt_list=[{},
{'nrhs' : 1},
{'nrhs' : 10},
@@ -25,7 +25,6 @@ opt_list=[{},
{'nrhs' : 2, 'ordering' : 'amd', 'sparse_rhs' : True}]
-@skipif(no_mumps)
def test_output():
for opts in opt_list:
reset_options()
@@ -33,7 +32,6 @@ def test_output():
_test_sparse.test_output(smatrix)
-@skipif(no_mumps)
def test_one_lead():
for opts in opt_list:
reset_options()
@@ -41,7 +39,6 @@ def test_one_lead():
_test_sparse.test_one_lead(smatrix)
-@skipif(no_mumps)
def test_smatrix_shape():
for opts in opt_list:
reset_options()
@@ -49,14 +46,12 @@ def test_smatrix_shape():
_test_sparse.test_smatrix_shape(smatrix)
-@skipif(no_mumps)
def test_two_equal_leads():
for opts in opt_list:
reset_options()
options(**opts)
_test_sparse.test_two_equal_leads(smatrix)
-@skipif(no_mumps)
def test_graph_system():
for opts in opt_list:
reset_options()
@@ -64,7 +59,6 @@ def test_graph_system():
_test_sparse.test_graph_system(smatrix)
-@skipif(no_mumps)
def test_singular_graph_system():
for opts in opt_list:
reset_options()
@@ -72,7 +66,6 @@ def test_singular_graph_system():
_test_sparse.test_singular_graph_system(smatrix)
-@skipif(no_mumps)
def test_tricky_singular_hopping():
for opts in opt_list:
reset_options()
@@ -80,7 +73,6 @@ def test_tricky_singular_hopping():
_test_sparse.test_tricky_singular_hopping(smatrix)
-@skipif(no_mumps)
def test_many_leads():
for opts in opt_list:
reset_options()
@@ -88,7 +80,6 @@ def test_many_leads():
_test_sparse.test_many_leads(greens_function, smatrix)
-@skipif(no_mumps)
def test_selfenergy():
for opts in opt_list:
reset_options()
@@ -96,7 +87,6 @@ def test_selfenergy():
_test_sparse.test_selfenergy(greens_function, smatrix)
-@skipif(no_mumps)
def test_selfenergy_reflection():
for opts in opt_list:
reset_options()
@@ -104,7 +94,6 @@ def test_selfenergy_reflection():
_test_sparse.test_selfenergy_reflection(greens_function, smatrix)
-@skipif(no_mumps)
def test_very_singular_leads():
for opts in opt_list:
reset_options()
@@ -112,7 +101,6 @@ def test_very_singular_leads():
_test_sparse.test_very_singular_leads(smatrix)
-@skipif(no_mumps)
def test_ldos():
for opts in opt_list:
reset_options()
@@ -120,7 +108,6 @@ def test_ldos():
_test_sparse.test_ldos(ldos)
-@skipif(no_mumps)
def test_wavefunc_ldos_consistency():
for opts in opt_list:
options(**opts)
diff --git a/kwant/solvers/tests/test_sparse.py b/kwant/solvers/tests/test_sparse.py
index f93d7771f9c88f3d287539dec47f647e4f32f7e7..95a2afe36cb1910f740feb6784e233fa7577f88b 100644
--- a/kwant/solvers/tests/test_sparse.py
+++ b/kwant/solvers/tests/test_sparse.py
@@ -6,7 +6,6 @@
# the file AUTHORS.rst at the top-level directory of this distribution and at
# http://kwant-project.org/authors.
-from nose.plugins.skip import SkipTest
from kwant.solvers.sparse import smatrix, greens_function, ldos, wave_function
import kwant.solvers.sparse
from . import _test_sparse
@@ -55,14 +54,6 @@ def test_very_singular_leads():
_test_sparse.test_very_singular_leads(smatrix)
-def test_umfpack_del():
- if kwant.solvers.sparse.uses_umfpack:
- assert hasattr(kwant.solvers.sparse.umfpack.UmfpackContext,
- '__del__')
- else:
- raise SkipTest
-
-
def test_ldos():
_test_sparse.test_ldos(ldos)
diff --git a/kwant/tests/test_builder.py b/kwant/tests/test_builder.py
index ba19b2a1f003882848519fa2278eb0deca660d4d..91359908a25d2b7d5fda79c71aa364a7fb79ae6a 100644
--- a/kwant/tests/test_builder.py
+++ b/kwant/tests/test_builder.py
@@ -9,8 +9,8 @@
import warnings
from random import Random
import itertools as it
-from nose.tools import assert_raises, assert_true, assert_not_equal, assert_less
-from numpy.testing import assert_equal, assert_almost_equal
+from pytest import raises
+from numpy.testing import assert_almost_equal
import tinyarray as ta
import numpy as np
import kwant
@@ -83,7 +83,7 @@ def test_bad_keys():
syst[[fam(0), fam(1)]] = None
syst[fam(0), fam(1)] = None
try:
- assert_raises(error, func, key)
+ raises(error, func, key)
except AssertionError:
print(func, error, key)
raise
@@ -96,24 +96,24 @@ def test_site_families():
yafam = builder.SimpleSiteFamily('another_name')
syst[fam(0)] = 7
- assert_equal(syst[fam(0)], 7)
+ assert syst[fam(0)] == 7
assert len(set([fam, ofam, fam('a'), ofam('a'), yafam])) == 3
syst[fam(1)] = 123
- assert_equal(syst[fam(1)], 123)
- assert_equal(syst[ofam(1)], 123)
- assert_raises(KeyError, syst.__getitem__, yafam(1))
+ assert syst[fam(1)] == 123
+ assert syst[ofam(1)] == 123
+ raises(KeyError, syst.__getitem__, yafam(1))
# test site families compare equal/not-equal
- assert_equal(fam, ofam)
- assert_not_equal(fam, yafam)
- assert_not_equal(fam, None)
- assert_not_equal(fam, 'a')
+ assert fam == ofam
+ assert fam != yafam
+ assert fam != None
+ assert fam != 'a'
# test site families sorting
fam1 = builder.SimpleSiteFamily(norbs=1)
fam2 = builder.SimpleSiteFamily(norbs=2)
- assert_less(fam1, fam2) # string '1' is lexicographically less than '2'
+ assert fam1 < fam2 # string '1' is lexicographically less than '2'
class VerySimpleSymmetry(builder.Symmetry):
@@ -151,43 +151,41 @@ def check_construction_and_indexing(sites, sites_fd, hoppings, hoppings_fd,
syst[hopping] = t
for hopping in unknown_hoppings:
- assert_raises(KeyError, syst.__setitem__, hopping, t)
+ raises(KeyError, syst.__setitem__, hopping, t)
assert (fam(5), fam(123)) not in syst
assert (sites[0], fam(5, 123)) not in syst
assert (fam(7, 8), sites[0]) not in syst
for site in sites:
assert site in syst
- assert_equal(syst[site], V)
+ assert syst[site] == V
for hop in hoppings:
rev_hop = hop[1], hop[0]
assert hop in syst
assert rev_hop in syst
- assert_equal(syst[hop], t)
- assert_equal(syst[rev_hop], t.conjugate())
+ assert syst[hop] == t
+ assert syst[rev_hop] == t.conjugate()
- assert_equal(syst.degree(sites[0]), 2)
- assert_equal(sorted(s for s in syst.neighbors(sites[0])),
- sorted([sites[1], sites[-1]]))
+ assert syst.degree(sites[0]) == 2
+ assert (sorted(s for s in syst.neighbors(sites[0])) ==
+ sorted([sites[1], sites[-1]]))
del syst[hoppings]
- assert_equal(list(syst.hoppings()), [])
+ assert list(syst.hoppings()) == []
syst[hoppings] = t
del syst[sites[0]]
- assert_equal(sorted(tuple(s)
- for s in syst.sites()), sorted(sites_fd[1:]))
- assert_equal(sorted((a, b)
- for a, b in syst.hoppings()),
- sorted(hoppings_fd[1:-1]))
+ assert sorted(tuple(s) for s in syst.sites()) == sorted(sites_fd[1:])
+ assert (sorted((a, b) for a, b in syst.hoppings()) ==
+ sorted(hoppings_fd[1:-1]))
- assert_equal(sorted((tuple(site.tag), value)
- for site, value in syst.site_value_pairs()),
- sorted((tuple(site.tag), syst[site]) for site in syst.sites()))
- assert_equal(sorted((tuple(a.tag), tuple(b.tag), value)
- for (a, b), value in syst.hopping_value_pairs()),
- sorted((tuple(a.tag), tuple(b.tag), syst[a, b])
- for a, b in syst.hoppings()))
+ assert (sorted((tuple(site.tag), value)
+ for site, value in syst.site_value_pairs()) ==
+ sorted((tuple(site.tag), syst[site]) for site in syst.sites()))
+ assert (sorted((tuple(a.tag), tuple(b.tag), value)
+ for (a, b), value in syst.hopping_value_pairs()) ==
+ sorted((tuple(a.tag), tuple(b.tag), syst[a, b])
+ for a, b in syst.hoppings()))
def test_construction_and_indexing():
@@ -236,8 +234,8 @@ def test_hermitian_conjugation():
syst[fam(0), fam(1)] = f
assert syst[fam(0), fam(1)] is f
assert isinstance(syst[fam(1), fam(0)], builder.HermConjOfFunc)
- assert_equal(syst[fam(1), fam(0)](fam(1), fam(0), 2),
- syst[fam(0), fam(1)](fam(0), fam(1), 2).conjugate().transpose())
+ assert (syst[fam(1), fam(0)](fam(1), fam(0), 2) ==
+ syst[fam(0), fam(1)](fam(0), fam(1), 2).conjugate().transpose())
syst[fam(0), fam(1)] = syst[fam(1), fam(0)]
assert isinstance(syst[fam(0), fam(1)], builder.HermConjOfFunc)
assert syst[fam(1), fam(0)] is f
@@ -253,11 +251,11 @@ def test_value_equality_and_identity():
assert syst[fam(1)] is m
syst[fam(0), fam(1)] = m
- assert_equal(syst[fam(1), fam(0)], m.transpose().conjugate())
+ assert syst[fam(1), fam(0)] == m.transpose().conjugate()
assert syst[fam(0), fam(1)] is m
syst[fam(1), fam(0)] = m
- assert_equal(syst[fam(0), fam(1)], m.transpose().conjugate())
+ assert syst[fam(0), fam(1)] == m.transpose().conjugate()
assert syst[fam(1), fam(0)] is m
@@ -282,11 +280,11 @@ def check_onsite(fsyst, sites, subset=False, check_values=True):
assert site in sites
# Check that all sites of `sites` are in `fsyst`.
for site in sites:
- assert_equal(freq[site], 1)
+ assert freq[site] == 1
def check_hoppings(fsyst, hops):
- assert_equal(fsyst.graph.num_edges, 2 * len(hops))
+ assert fsyst.graph.num_edges == 2 * len(hops)
for edge_id, edge in enumerate(fsyst.graph):
tail, head = edge
tail = fsyst.sites[tail].tag
@@ -300,7 +298,7 @@ def check_hoppings(fsyst, hops):
def check_id_by_site(fsyst):
for i, site in enumerate(fsyst.sites):
- assert_equal(fsyst.id_by_site[site], i)
+ assert fsyst.id_by_site[site] == i
def test_finalization():
@@ -368,7 +366,7 @@ def test_finalization():
check_onsite(fsyst, sr_sites)
check_hoppings(fsyst, sr_hops)
# check that sites are sorted
- assert_equal(fsyst.sites, sorted(fam(*site) for site in sr_sites))
+ assert fsyst.sites == tuple(sorted(fam(*site) for site in sr_sites))
# Build lead from blueprint and test it.
lead = builder.Builder(kwant.TranslationalSymmetry((size, 0)))
@@ -379,7 +377,7 @@ def test_finalization():
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
lead.finalized() # Trigger the warning.
- assert_equal(len(w), 1)
+ assert len(w) == 1
assert issubclass(w[0].category, RuntimeWarning)
assert "disconnected" in str(w[0].message)
for (a, b), value in lead_hops.items():
@@ -397,36 +395,36 @@ def test_finalization():
# Attach lead to system with empty interface.
syst.leads.append(builder.BuilderLead(lead, ()))
- assert_raises(ValueError, syst.finalized)
+ raises(ValueError, syst.finalized)
# Attach lead with improper interface.
syst.leads[-1] = builder.BuilderLead(
lead, 2 * tuple(builder.Site(fam, n) for n in neighbors))
- assert_raises(ValueError, syst.finalized)
+ raises(ValueError, syst.finalized)
# Attach lead properly.
syst.leads[-1] = builder.BuilderLead(
lead, (builder.Site(fam, n) for n in neighbors))
fsyst = syst.finalized()
- assert_equal(len(fsyst.lead_interfaces), 1)
- assert_equal([fsyst.sites[i].tag for i in fsyst.lead_interfaces[0]],
- neighbors)
+ assert len(fsyst.lead_interfaces) == 1
+ assert ([fsyst.sites[i].tag for i in fsyst.lead_interfaces[0]] ==
+ neighbors)
# test that we cannot finalize a system with a badly sorted interface order
- assert_raises(ValueError, lead._finalized_infinite,
- [builder.Site(fam, n) for n in reversed(neighbors)])
+ raises(ValueError, lead._finalized_infinite,
+ [builder.Site(fam, n) for n in reversed(neighbors)])
# site ordering independent of whether interface was specified
flead_order = lead._finalized_infinite([builder.Site(fam, n)
for n in neighbors])
- assert_equal(flead.sites, flead_order.sites)
+ assert flead.sites == flead_order.sites
syst.leads[-1] = builder.BuilderLead(
lead, (builder.Site(fam, n) for n in neighbors))
fsyst = syst.finalized()
- assert_equal(len(fsyst.lead_interfaces), 1)
- assert_equal([fsyst.sites[i].tag for i in fsyst.lead_interfaces[0]],
- neighbors)
+ assert len(fsyst.lead_interfaces) == 1
+ assert ([fsyst.sites[i].tag for i in fsyst.lead_interfaces[0]] ==
+ neighbors)
# Add a hopping to the lead which couples two next-nearest cells and check
# whether this leads to an error.
@@ -434,7 +432,7 @@ def test_finalization():
b = rng.choice(possible_neighbors)
b = b[0] + 2 * size, b[1]
lead[fam(*a), fam(*b)] = random_hopping_integral(rng)
- assert_raises(ValueError, lead.finalized)
+ raises(ValueError, lead.finalized)
def test_site_ranges():
@@ -448,17 +446,17 @@ def test_site_ranges():
sites = list(map(lat, range(10)))
ranges = site_ranges(sites)
expected = [(0, lat.norbs, 0), (10, 0, 10 * lat.norbs)]
- assert_equal(ranges, expected)
+ assert ranges == expected
# pair of site families
sites = it.chain(map(lat1a, range(4)), map(lat1b, range(6)),
map(lat1a, range(4)))
expected = [(0, 1, 0), (4, 1, 4), (10, 1, 10), (14, 0, 14)]
- assert_equal(expected, site_ranges(tuple(sites)))
+ assert expected == site_ranges(tuple(sites))
sites = it.chain(map(lat2, range(4)), map(lat1a, range(6)),
map(lat1b, range(4)))
expected = [(0, 2, 0), (4, 1, 4*2), (10, 1, 4*2+6), (14, 0, 4*2+10)]
- assert_equal(expected, site_ranges(tuple(sites)))
+ assert expected == site_ranges(tuple(sites))
# test with an actual builder
for lat in (lat1a, lat2):
@@ -467,11 +465,11 @@ def test_site_ranges():
syst[sites] = np.eye(lat.norbs)
ranges = syst.finalized().site_ranges
expected = [(0, lat.norbs, 0), (10, 0, 10 * lat.norbs)]
- assert_equal(ranges, expected)
+ assert ranges == expected
# poison system with a single site with no norbs defined
syst[kwant.lattice.chain()(0)] = 1
ranges = syst.finalized().site_ranges
- assert_equal(ranges, None)
+ assert ranges == None
def test_hamiltonian_evaluation():
@@ -492,20 +490,18 @@ def test_hamiltonian_evaluation():
syst[((fam(*tags[i]), fam(*tags[j])) for (i, j) in edges)] = f_hopping
fsyst = syst.finalized()
- assert_equal(fsyst.graph.num_nodes, len(tags))
- assert_equal(fsyst.graph.num_edges, 2 * len(edges))
+ assert fsyst.graph.num_nodes == len(tags)
+ assert fsyst.graph.num_edges == 2 * len(edges)
for i in range(len(tags)):
site = fsyst.sites[i]
assert site in sites
- assert_equal(fsyst.hamiltonian(i, i),
- syst[site](site))
+ assert fsyst.hamiltonian(i, i) == syst[site](site)
for t, h in fsyst.graph:
tsite = fsyst.sites[t]
hsite = fsyst.sites[h]
- assert_equal(fsyst.hamiltonian(t, h),
- syst[tsite, hsite](tsite, hsite))
+ assert fsyst.hamiltonian(t, h) == syst[tsite, hsite](tsite, hsite)
# test when user-function raises errors
def onsite_raises(site):
@@ -517,16 +513,17 @@ def test_hamiltonian_evaluation():
def test_raising(fsyst, hop):
a, b = hop
# exceptions are converted to kwant.UserCodeError and we add our message
- with assert_raises(kwant.UserCodeError) as ctx:
+ with raises(kwant.UserCodeError) as ctx:
fsyst.hamiltonian(a, a)
msg = 'Error occurred in user-supplied value function "onsite_raises"'
- assert_true(msg in str(ctx.exception))
+ assert msg in ctx.exconly()
for hop in [(a, b), (b, a)]:
- with assert_raises(kwant.UserCodeError) as ctx:
+ with raises(kwant.UserCodeError) as ctx:
fsyst.hamiltonian(*hop)
- msg = 'Error occurred in user-supplied value function "hopping_raises"'
- assert_true(msg in str(ctx.exception))
+ msg = ('Error occurred in user-supplied '
+ 'value function "hopping_raises"')
+ assert msg in ctx.exconly()
# test with finite system
new_hop = (fam(-1, 0), fam(0, 0))
@@ -558,8 +555,8 @@ def test_dangling():
return syst
syst0 = make_system()
- assert_equal(sorted(site.tag for site in syst0.dangling()),
- sorted([(3,), (5,), (6,), (7,), (8,)]))
+ assert (sorted(site.tag for site in syst0.dangling()) ==
+ sorted([(3,), (5,), (6,), (7,), (8,)]))
syst0.eradicate_dangling()
syst1 = make_system()
@@ -569,10 +566,10 @@ def test_dangling():
break
del syst1[dangling]
- assert_equal(sorted(site.tag for site in syst0.sites()),
- sorted([(0,), (1,), (2,)]))
- assert_equal(sorted(site.tag for site in syst0.sites()),
- sorted(site.tag for site in syst1.sites()))
+ assert (sorted(site.tag for site in syst0.sites()) ==
+ sorted([(0,), (1,), (2,)]))
+ assert (sorted(site.tag for site in syst0.sites()) ==
+ sorted(site.tag for site in syst1.sites()))
def test_builder_with_symmetry():
@@ -596,30 +593,29 @@ def test_builder_with_symmetry():
syst[hoppings] = t
# TODO: Once Tinyarray supports "<" the conversion to tuple can be removed.
- assert_equal(sorted(tuple(site.tag) for site in syst.sites()),
- sorted(set(tuple(hop[0].tag) for hop in hoppings_fd)))
+ assert (sorted(tuple(site.tag) for site in syst.sites()) ==
+ sorted(set(tuple(hop[0].tag) for hop in hoppings_fd)))
for sites in hoppings_fd:
for site in sites:
assert site in syst
- assert_equal(syst[site], V)
+ assert syst[site] == V
# TODO: Once Tinyarray supports "<" the conversion to tuple can be removed.
- assert_equal(sorted((tuple(a.tag), tuple(b.tag))
- for a, b in syst.hoppings()),
- sorted((tuple(a.tag), tuple(b.tag)) for a, b in hoppings_fd))
+ assert (sorted((tuple(a.tag), tuple(b.tag)) for a, b in syst.hoppings()) ==
+ sorted((tuple(a.tag), tuple(b.tag)) for a, b in hoppings_fd))
for hop in hoppings_fd:
rhop = hop[1], hop[0]
assert hop in syst
assert rhop in syst
- assert_equal(syst[hop], t)
- assert_equal(syst[rhop], t.conjugate())
+ assert syst[hop] == t
+ assert syst[rhop] == t.conjugate()
del syst[g(0, 6, -4), g(0, 11, -9)]
assert (g(0, 1, 0), g(0, -4, 5)) not in syst
del syst[g(0, 3, -3)]
- assert_equal(list((a.tag, b.tag) for a, b in syst.hoppings()),
- [((0, 0, 2), (5, 0, -3))])
+ assert (list((a.tag, b.tag) for a, b in syst.hoppings()) == [((0, 0, 2),
+ (5, 0, -3))])
def test_attach_lead():
@@ -629,13 +625,13 @@ def test_attach_lead():
syst = builder.Builder()
syst[fam(1)] = 0
lead = builder.Builder(VerySimpleSymmetry(-2))
- assert_raises(ValueError, syst.attach_lead, lead)
+ raises(ValueError, syst.attach_lead, lead)
lead[fam(0)] = 1
- assert_raises(ValueError, syst.attach_lead, lead)
+ raises(ValueError, syst.attach_lead, lead)
lead[fam(1)] = 1
syst.attach_lead(lead)
- assert_raises(ValueError, syst.attach_lead, lead, fam(5))
+ raises(ValueError, syst.attach_lead, lead, fam(5))
syst = builder.Builder()
# The tag of the site that is added in the following line is an empty tuple.
@@ -647,14 +643,14 @@ def test_attach_lead():
syst[fam(0)] = 1
lead[fam(0), fam(1)] = lead[fam(0), fam(2)] = 1
syst.attach_lead(lead)
- assert_equal(len(list(syst.sites())), 4)
- assert_equal(set(syst.leads[0].interface), set([fam(-1), fam(0)]))
+ assert len(list(syst.sites())) == 4
+ assert set(syst.leads[0].interface) == set([fam(-1), fam(0)])
syst[fam(-10)] = syst[fam(-11)] = 0
syst.attach_lead(lead)
- assert_equal(set(syst.leads[1].interface), set([fam(-10), fam(-11)]))
- assert_equal(len(list(syst.sites())), 6)
+ assert set(syst.leads[1].interface) == set([fam(-10), fam(-11)])
+ assert len(list(syst.sites())) == 6
syst.attach_lead(lead, fam(-5))
- assert_equal(set(syst.leads[0].interface), set([fam(-1), fam(0)]))
+ assert set(syst.leads[0].interface) == set([fam(-1), fam(0)])
syst.finalized()
@@ -669,7 +665,7 @@ def test_neighbors_not_in_single_domain():
lead[((fam(0, y), fam(1, y)) for y in range(3))] = 1
lead[((fam(0, y), fam(0, y + 1)) for y in range(2))] = 1
sr.leads.append(builder.BuilderLead(lead, [fam(i, i) for i in range(3)]))
- assert_raises(ValueError, sr.finalized)
+ raises(ValueError, sr.finalized)
def test_iadd():
@@ -696,14 +692,12 @@ def test_iadd():
other_syst.leads.append(lead1)
syst += other_syst
- assert_equal(syst.leads, [lead0, lead1])
- expected = sorted([[(0,), 1], [(1,), 2], [(2,), 2]])
- assert_equal(sorted(((s.tag, v) for s, v in syst.site_value_pairs())),
- expected)
- expected = sorted([[(0,), (1,), 1], [(1,), (2,), 1]])
- assert_equal(sorted(((a.tag, b.tag, v)
- for (a, b), v in syst.hopping_value_pairs())),
- expected)
+ assert syst.leads == [lead0, lead1]
+ expected = sorted([((0,), 1), ((1,), 2), ((2,), 2)])
+ assert sorted(((s.tag, v) for s, v in syst.site_value_pairs())) == expected
+ expected = sorted([((0,), (1,), 1), ((1,), (2,), 1)])
+ assert (sorted(((a.tag, b.tag, v) for (a, b), v in
+ syst.hopping_value_pairs())) == expected)
# y=0: y=1:
@@ -726,22 +720,22 @@ def test_HoppingKind():
((0, 4, 0), h, h, 21),
((0, 0, 1), g, h, 4)]:
ph = list(builder.HoppingKind(delta, ga, gb)(syst))
- assert_equal(len(ph), n)
+ assert len(ph) == n
ph = set(ph)
- assert_equal(len(ph), n)
+ assert len(ph) == n
ph2 = list((
sym.to_fd(b, a) for a, b in
builder.HoppingKind(ta.negative(delta), gb, ga)(syst)))
- assert_equal(len(ph2), n)
+ assert len(ph2) == n
ph2 = set(ph2)
- assert_equal(ph2, ph)
+ assert ph2 == ph
for a, b in ph:
assert a.family == ga
assert b.family == gb
assert sym.to_fd(a) == a
- assert_equal(a.tag - b.tag, delta)
+ assert a.tag - b.tag == delta
# test hashability and equality
hk = builder.HoppingKind((1, 0), g)
diff --git a/kwant/tests/test_lattice.py b/kwant/tests/test_lattice.py
index 92a36ca21996c4fa1d1a92b413eae0374b3080c4..b57ef13727846e43ee351fdcaeadaf9960fbdad3 100644
--- a/kwant/tests/test_lattice.py
+++ b/kwant/tests/test_lattice.py
@@ -9,8 +9,7 @@
from math import sqrt
import numpy as np
import tinyarray as ta
-from nose.tools import assert_raises, assert_not_equal
-from numpy.testing import assert_equal
+from pytest import raises
from kwant import lattice, builder
@@ -24,7 +23,7 @@ def test_closest():
lat = lattice.general(np.random.randn(3, 3))
for i in range(50):
tag = np.random.randint(10, size=(3,))
- assert_equal(lat.closest(lat(*tag).pos), tag)
+ assert lat.closest(lat(*tag).pos) == tag
def test_general():
@@ -34,12 +33,12 @@ def test_general():
for sl in lat.sublattices:
tag = (-5, 33)
site = sl(*tag)
- assert_equal(tag, sl.closest(site.pos))
+ assert tag == sl.closest(site.pos)
# Test 2D lattice with 1 vector.
lat = lattice.general([[1, 0]])
site = lat(0)
- assert_raises(ValueError, lat, 0, 1)
+ raises(ValueError, lat, 0, 1)
def test_neighbors():
@@ -69,8 +68,8 @@ def test_shape():
if in_circle(site.pos):
sites_alt.append(site)
assert len(sites) == len(sites_alt)
- assert_equal(set(sites), set(sites_alt))
- assert_raises(ValueError, lat.shape(in_circle, (10, 10))().__next__)
+ assert set(sites) == set(sites_alt)
+ raises(ValueError, lat.shape(in_circle, (10, 10))().__next__)
# Check if narrow ribbons work.
for period in (0, 1), (1, 0), (1, -1):
@@ -97,7 +96,7 @@ def test_wire():
syst = builder.Builder(lattice.TranslationalSymmetry((2, 0, 0)))
syst[lat.wire(center, 8.6)] = 1
sites1 = set(syst.sites())
- assert_equal(sites1, sites2)
+ assert sites1 == sites2
def test_translational_symmetry():
@@ -106,47 +105,47 @@ def test_translational_symmetry():
f3 = lattice.general(np.identity(3))
shifted = lambda site, delta: site.family(*ta.add(site.tag, delta))
- assert_raises(ValueError, ts, (0, 0, 4), (0, 5, 0), (0, 0, 2))
+ raises(ValueError, ts, (0, 0, 4), (0, 5, 0), (0, 0, 2))
sym = ts((3.3, 0))
- assert_raises(ValueError, sym.add_site_family, f2)
+ raises(ValueError, sym.add_site_family, f2)
# Test lattices with dimension smaller than dimension of space.
f2in3 = lattice.general([[4, 4, 0], [4, -4, 0]])
sym = ts((8, 0, 0))
sym.add_site_family(f2in3)
sym = ts((8, 0, 1))
- assert_raises(ValueError, sym.add_site_family, f2in3)
+ raises(ValueError, sym.add_site_family, f2in3)
# Test automatic fill-in of transverse vectors.
sym = ts((1, 2))
sym.add_site_family(f2)
- assert_not_equal(sym.site_family_data[f2][2], 0)
+ assert sym.site_family_data[f2][2] != 0
sym = ts((1, 0, 2), (3, 0, 2))
sym.add_site_family(f3)
- assert_not_equal(sym.site_family_data[f3][2], 0)
+ assert sym.site_family_data[f3][2] != 0
transl_vecs = np.array([[10, 0], [7, 7]], dtype=int)
sym = ts(*transl_vecs)
- assert_equal(sym.num_directions, 2)
+ assert sym.num_directions == 2
sym2 = ts(*transl_vecs[: 1, :])
sym2.add_site_family(f2, transl_vecs[1:, :])
for site in [f2(0, 0), f2(4, 0), f2(2, 1), f2(5, 5), f2(15, 6)]:
assert sym.in_fd(site)
assert sym2.in_fd(site)
- assert_equal(sym.which(site), (0, 0))
- assert_equal(sym2.which(site), (0,))
+ assert sym.which(site), (0 == 0)
+ assert sym2.which(site) == (0,)
for v in [(1, 0), (0, 1), (-1, 0), (0, -1), (5, 10), (-111, 573)]:
site2 = shifted(site, np.dot(v, transl_vecs))
assert not sym.in_fd(site2)
assert (v[0] != 0) != sym2.in_fd(site2)
- assert_equal(sym.to_fd(site2), site)
+ assert sym.to_fd(site2) == site
assert (v[1] == 0) == (sym2.to_fd(site2) == site)
- assert_equal(sym.which(site2), v)
- assert_equal(sym2.which(site2), v[:1])
+ assert sym.which(site2) == v
+ assert sym2.which(site2) == v[:1]
for hop in [(0, 0), (100, 0), (0, 5), (-2134, 3213)]:
- assert_equal(sym.to_fd(site2, shifted(site2, hop)),
- (site, shifted(site, hop)))
+ assert (sym.to_fd(site2, shifted(site2, hop)) ==
+ (site, shifted(site, hop)))
# Test act for hoppings belonging to different lattices.
f2p = lattice.general(2 * np.identity(2))
@@ -184,10 +183,10 @@ def test_translational_symmetry_reversed():
sym = lattice.TranslationalSymmetry(*periods)
rsym = sym.reversed()
for site in sites:
- assert_equal(sym.to_fd(site), rsym.to_fd(site))
- assert_equal(sym.which(site), -rsym.which(site))
+ assert sym.to_fd(site) == rsym.to_fd(site)
+ assert sym.which(site) == -rsym.which(site)
vec = np.array([1, 1, 1])
- assert_equal(sym.act(vec, site), rsym.act(-vec, site))
+ assert sym.act(vec, site), rsym.act(-vec == site)
except ValueError:
pass
@@ -202,31 +201,31 @@ def test_monatomic_lattice():
def test_norbs():
id_mat = np.identity(2)
# Monatomic lattices
- assert_equal(lattice.general(id_mat).norbs, None)
- assert_equal(lattice.general(id_mat, norbs=2).norbs, 2)
+ assert lattice.general(id_mat).norbs == None
+ assert lattice.general(id_mat, norbs=2).norbs == 2
# Polyatomic lattices
lat = lattice.general(id_mat, basis=id_mat, norbs=None)
for l in lat.sublattices:
- assert_equal(l.norbs, None)
+ assert l.norbs == None
lat = lattice.general(id_mat, basis=id_mat, norbs=2)
for l in lat.sublattices:
- assert_equal(l.norbs, 2)
+ assert l.norbs == 2
lat = lattice.general(id_mat, basis=id_mat, norbs=[1, 2])
for l, n in zip(lat.sublattices, [1, 2]):
- assert_equal(l.norbs, n)
+ assert l.norbs == n
# should raise ValueError for # of norbs different to length of `basis`
- assert_raises(ValueError, lattice.general, id_mat, id_mat, norbs=[])
- assert_raises(ValueError, lattice.general, id_mat, id_mat, norbs=[1, 2, 3])
+ raises(ValueError, lattice.general, id_mat, id_mat, norbs=[])
+ raises(ValueError, lattice.general, id_mat, id_mat, norbs=[1, 2, 3])
# TypeError if Monatomic lattice
- assert_raises(TypeError, lattice.general, id_mat, norbs=[])
+ raises(TypeError, lattice.general, id_mat, norbs=[])
# should raise ValueError if norbs not an integer
- assert_raises(ValueError, lattice.general, id_mat, norbs=1.5)
- assert_raises(ValueError, lattice.general, id_mat, id_mat, norbs=1.5)
- assert_raises(ValueError, lattice.general, id_mat, id_mat, norbs=[1.5, 1.5])
+ raises(ValueError, lattice.general, id_mat, norbs=1.5)
+ raises(ValueError, lattice.general, id_mat, id_mat, norbs=1.5)
+ raises(ValueError, lattice.general, id_mat, id_mat, norbs=[1.5, 1.5])
# test that lattices with different norbs are compared `not equal`
lat = lattice.general(id_mat, basis=id_mat, norbs=None)
lat1 = lattice.general(id_mat, basis=id_mat, norbs=1)
lat2 = lattice.general(id_mat, basis=id_mat, norbs=2)
- assert_not_equal(lat, lat1)
- assert_not_equal(lat, lat2)
- assert_not_equal(lat1, lat2)
+ assert lat != lat1
+ assert lat != lat2
+ assert lat1 != lat2
diff --git a/kwant/tests/test_plotter.py b/kwant/tests/test_plotter.py
index 12a2286869f4ec303b5d1f45119d481ca6b5d53b..462cb2b37eabaa8710fbe3188a6c2cfb4a457024 100644
--- a/kwant/tests/test_plotter.py
+++ b/kwant/tests/test_plotter.py
@@ -8,11 +8,11 @@
import tempfile
import warnings
-import nose
import numpy as np
import kwant
from kwant import plotter
-from nose.tools import assert_raises
+import pytest
+
if plotter.mpl_enabled:
from mpl_toolkits import mplot3d
from matplotlib import pyplot
@@ -32,7 +32,7 @@ def test_importable_without_matplotlib():
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter("always")
exec(code) # Trigger the warning.
- nose.tools.assert_equal(len(w), 1)
+ assert len(w) == 1
assert issubclass(w[0].category, RuntimeWarning)
assert "only iterator-providing functions" in str(w[0].message)
@@ -89,10 +89,9 @@ def syst_3d(W=3, r1=2, r2=4, a=1, t=1.0):
return syst
+@pytest.mark.skipif(not plotter.mpl_enabled, reason="No matplotlib available.")
def test_plot():
plot = plotter.plot
- if not plotter.mpl_enabled:
- raise nose.SkipTest
syst2d = syst_2d()
syst3d = syst_3d()
color_opts = ['k', (lambda site: site.tag[0]),
@@ -138,22 +137,21 @@ def bad_transform(pos):
x, y = pos
return x, y, 0
+@pytest.mark.skipif(not plotter.mpl_enabled, reason="No matplotlib available.")
def test_map():
- if not plotter.mpl_enabled:
- raise nose.SkipTest
syst = syst_2d()
with tempfile.TemporaryFile('w+b') as out:
plotter.map(syst, lambda site: site.tag[0], pos_transform=good_transform,
file=out, method='linear', a=4, oversampling=4, cmap='flag')
- nose.tools.assert_raises(ValueError, plotter.map, syst,
- lambda site: site.tag[0],
- pos_transform=bad_transform, file=out)
+ pytest.raises(ValueError, plotter.map, syst,
+ lambda site: site.tag[0],
+ pos_transform=bad_transform, file=out)
with warnings.catch_warnings():
warnings.simplefilter("ignore")
plotter.map(syst.finalized(), range(len(syst.sites())),
file=out)
- nose.tools.assert_raises(ValueError, plotter.map, syst,
- range(len(syst.sites())), file=out)
+ pytest.raises(ValueError, plotter.map, syst,
+ range(len(syst.sites())), file=out)
def test_mask_interpolate():
@@ -170,7 +168,7 @@ def test_mask_interpolate():
assert issubclass(w[-1].category, RuntimeWarning)
assert "coinciding" in str(w[-1].message)
- assert_raises(ValueError, plotter.mask_interpolate,
- coords, np.ones(len(coords)))
- assert_raises(ValueError, plotter.mask_interpolate,
- coords, np.ones(2 * len(coords)))
+ pytest.raises(ValueError, plotter.mask_interpolate, coords,
+ np.ones(len(coords)))
+ pytest.raises(ValueError, plotter.mask_interpolate, coords, np.ones(2 *
+ len(coords)))
diff --git a/kwant/tests/test_rmt.py b/kwant/tests/test_rmt.py
index 8f9d48f38c8882d67e0d35fc8d58cc88338aa5e0..3cad147fd15fc28078af1dc59e2fe683b37312ab 100644
--- a/kwant/tests/test_rmt.py
+++ b/kwant/tests/test_rmt.py
@@ -8,7 +8,7 @@
import numpy as np
from scipy import stats
-from nose.tools import assert_raises
+from pytest import raises
from kwant import rmt
assert_allclose = np.testing.assert_allclose
@@ -18,7 +18,7 @@ def test_gaussian_symmetries():
for n in (5, 8, 100, 200):
for sym in rmt.sym_list:
if sym not in ('A', 'D', 'AI') and n % 2:
- assert_raises(ValueError, rmt.gaussian, 5, sym)
+ raises(ValueError, rmt.gaussian, 5, sym)
continue
h = rmt.gaussian(n, sym)
if rmt.t(sym):
@@ -53,7 +53,7 @@ def test_circular():
sy = np.kron(np.identity(n // 2), [[0, 1j], [-1j, 0]])
for sym in rmt.sym_list:
if rmt.t(sym) == -1 or rmt.p(sym) == -1:
- assert_raises(ValueError, rmt.circular, 5, sym)
+ raises(ValueError, rmt.circular, 5, sym)
s = rmt.circular(n, sym)
assert_allclose(np.dot(s, s.T.conj()), np.identity(n), atol=1e-9,
err_msg='Unitarity broken in ' + sym)
diff --git a/kwant/tests/test_system.py b/kwant/tests/test_system.py
index 6a5d5f299846ab2cc7fa0942ac7508b7fe4de372..f90a3b1c2fde84bb02e045f9f7d1abdc682bef2b 100644
--- a/kwant/tests/test_system.py
+++ b/kwant/tests/test_system.py
@@ -6,9 +6,9 @@
# the file AUTHORS.rst at the top-level directory of this distribution and at
# http://kwant-project.org/authors.
+from pytest import raises
import numpy as np
from scipy import sparse
-from nose.tools import assert_raises
import kwant
def test_hamiltonian_submatrix():
@@ -67,17 +67,17 @@ def test_hamiltonian_submatrix():
syst3 = syst2.precalculate(.1, what='modes')
smatrix2 = kwant.smatrix(syst3, .1).data
np.testing.assert_almost_equal(smatrix, smatrix2)
- assert_raises(ValueError, kwant.solvers.default.greens_function, syst3, 0.2)
+ raises(ValueError, kwant.solvers.default.greens_function, syst3, 0.2)
# Test for shape errors.
syst[chain(0), chain(2)] = np.array([[1, 2]])
syst2 = syst.finalized()
- assert_raises(ValueError, syst2.hamiltonian_submatrix)
- assert_raises(ValueError, syst2.hamiltonian_submatrix, sparse=True)
+ raises(ValueError, syst2.hamiltonian_submatrix)
+ raises(ValueError, syst2.hamiltonian_submatrix, sparse=True)
syst[chain(0), chain(2)] = 1
syst2 = syst.finalized()
- assert_raises(ValueError, syst2.hamiltonian_submatrix)
- assert_raises(ValueError, syst2.hamiltonian_submatrix, sparse=True)
+ raises(ValueError, syst2.hamiltonian_submatrix)
+ raises(ValueError, syst2.hamiltonian_submatrix, sparse=True)
# Test for passing parameters to hamiltonian matrix elements
def onsite(site, p1, p2=0):
diff --git a/pytest.ini b/pytest.ini
new file mode 100644
index 0000000000000000000000000000000000000000..a77b6256e5588bd007946c35beef09cc2689a122
--- /dev/null
+++ b/pytest.ini
@@ -0,0 +1,2 @@
+[pytest]
+testpaths = kwant
diff --git a/setup.cfg b/setup.cfg
index 7f75bb2cb15abd764ce8fbf1559123ba58157ac2..35a7a0dda67ae9f6560e99d604b5cf97e2d7f783 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -2,3 +2,6 @@
tag_build =
tag_date = 0
tag_svn_revision = 0
+
+[aliases]
+test=pytest
diff --git a/setup.py b/setup.py
index 0d3d79b46254deed5317ac22615670460ef063e4..196030ccbf574799c92a39357f67913b6619583d 100755
--- a/setup.py
+++ b/setup.py
@@ -475,14 +475,14 @@ def main():
url="http://kwant-project.org/",
license="BSD",
packages=find_packages('.'),
- test_suite = 'nose.collector',
cmdclass={'build': kwant_build,
'sdist': kwant_sdist,
'build_ext': kwant_build_ext,
'build_tut': kwant_build_tut},
ext_modules=ext_modules(extensions()),
include_dirs=include_dirs,
- setup_requires=['numpy > 1.6.1', 'nose >= 1.0'],
+ setup_requires=['numpy > 1.6.1', 'pytest-runner >= 2.7'],
+ tests_require=['pytest >= 2.6.3'],
install_requires=['numpy > 1.6.1', 'scipy >= 0.9', 'tinyarray'],
extras_require={'plotting': 'matplotlib >= 1.2'},
classifiers=[c.strip() for c in CLASSIFIERS.split('\n')])