Port tests to pytest

Use simple asserts and pytest's powerful introspection to make testing
simpler. This merges the old .py/.ref file pairs into simple .py files
where the expected values are right next to the code being tested.

This commit does not touch the C++ part of the code and replicates the
Python tests exactly like the old .ref-file-based approach.

tests/test_methods_and_attributes.py

+from pybind11_tests import ExampleMandA, ConstructorStats
+
+
+def test_methods_and_attributes():
+    instance1 = ExampleMandA()
+    instance2 = ExampleMandA(32)
+
+    instance1.add1(instance2)
+    instance1.add2(instance2)
+    instance1.add3(instance2)
+    instance1.add4(instance2)
+    instance1.add5(instance2)
+    instance1.add6(32)
+    instance1.add7(32)
+    instance1.add8(32)
+    instance1.add9(32)
+    instance1.add10(32)
+
+    assert str(instance1) == "ExampleMandA[value=320]"
+    assert str(instance2) == "ExampleMandA[value=32]"
+    assert str(instance1.self1()) == "ExampleMandA[value=320]"
+    assert str(instance1.self2()) == "ExampleMandA[value=320]"
+    assert str(instance1.self3()) == "ExampleMandA[value=320]"
+    assert str(instance1.self4()) == "ExampleMandA[value=320]"
+    assert str(instance1.self5()) == "ExampleMandA[value=320]"
+
+    assert instance1.internal1() == 320
+    assert instance1.internal2() == 320
+    assert instance1.internal3() == 320
+    assert instance1.internal4() == 320
+    assert instance1.internal5() == 320
+
+    assert instance1.value == 320
+    instance1.value = 100
+    assert str(instance1) == "ExampleMandA[value=100]"
+
+    cstats = ConstructorStats.get(ExampleMandA)
+    assert cstats.alive() == 2
+    del instance1, instance2
+    assert cstats.alive() == 0
+    assert cstats.values() == ["32"]
+    assert cstats.default_constructions == 1
+    assert cstats.copy_constructions == 3
+    assert cstats.move_constructions >= 1
+    assert cstats.copy_assignments == 0
+    assert cstats.move_assignments == 0

example/example-modules.cpp → tests/test_modules.cpp

 /*
-    example/example-modules.cpp -- nested modules, importing modules, and
+    tests/test_modules.cpp -- nested modules, importing modules, and
                             internal references
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -8,8 +8,8 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
-#include "constructor-stats.h"
+#include "pybind11_tests.h"
+#include "constructor_stats.h"
 
 void submodule_func() {
     std::cout << "submodule_func()" << std::endl;

tests/test_modules.py

+
+def test_nested_modules(capture):
+    import pybind11_tests
+    from pybind11_tests.submodule import submodule_func
+
+    assert pybind11_tests.__name__ == "pybind11_tests"
+    assert pybind11_tests.submodule.__name__ == "pybind11_tests.submodule"
+
+    with capture:
+        submodule_func()
+    assert capture == "submodule_func()"
+
+
+def test_reference_internal():
+    from pybind11_tests import ConstructorStats
+    from pybind11_tests.submodule import A, B
+
+    b = B()
+    assert str(b.get_a1()) == "A[1]"
+    assert str(b.a1) == "A[1]"
+    assert str(b.get_a2()) == "A[2]"
+    assert str(b.a2) == "A[2]"
+
+    b.a1 = A(42)
+    b.a2 = A(43)
+    assert str(b.get_a1()) == "A[42]"
+    assert str(b.a1) == "A[42]"
+    assert str(b.get_a2()) == "A[43]"
+    assert str(b.a2) == "A[43]"
+
+    astats, bstats = ConstructorStats.get(A), ConstructorStats.get(B)
+    assert astats.alive() == 2
+    assert bstats.alive() == 1
+    del b
+    assert astats.alive() == 0
+    assert bstats.alive() == 0
+    assert astats.values() == ['1', '2', '42', '43']
+    assert bstats.values() == []
+    assert astats.default_constructions == 0
+    assert bstats.default_constructions == 1
+    assert astats.copy_constructions == 0
+    assert bstats.copy_constructions == 0
+    # assert astats.move_constructions >= 0  # Don't invoke any
+    # assert bstats.move_constructions >= 0  # Don't invoke any
+    assert astats.copy_assignments == 2
+    assert bstats.copy_assignments == 0
+    assert astats.move_assignments == 0
+    assert bstats.move_assignments == 0
+
+
+def test_importing():
+    from pybind11_tests import OD
+    from collections import OrderedDict
+
+    assert OD is OrderedDict
+    assert str(OD([(1, 'a'), (2, 'b')])) == "OrderedDict([(1, 'a'), (2, 'b')])"

example/example-numpy-dtypes.cpp → tests/test_numpy_dtypes.cpp

 /*
-  example/example-numpy-dtypes.cpp -- Structured and compound NumPy dtypes
+  tests/test_numpy_dtypes.cpp -- Structured and compound NumPy dtypes
 
   Copyright (c) 2016 Ivan Smirnov
 
@@ -7,11 +7,9 @@
   BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
+#include "pybind11_tests.h"
 
 #include <pybind11/numpy.h>
-#include <cstdint>
-#include <iostream>
 
 #ifdef __GNUC__
 #define PYBIND11_PACKED(cls) cls __attribute__((__packed__))

tests/test_numpy_dtypes.py

+import pytest
+with pytest.suppress(ImportError):
+    import numpy as np
+
+
+def assert_equal(actual, expected_data, expected_dtype):
+    np.testing.assert_equal(actual, np.array(expected_data, dtype=expected_dtype))
+
+simple_dtype = np.dtype({'names': ['x', 'y', 'z'],
+                         'formats': ['?', 'u4', 'f4'],
+                         'offsets': [0, 4, 8]})
+packed_dtype = np.dtype([('x', '?'), ('y', 'u4'), ('z', 'f4')])
+
+
+@pytest.requires_numpy
+def test_format_descriptors(capture):
+    from pybind11_tests import get_format_unbound, print_format_descriptors
+
+    with pytest.raises(RuntimeError) as excinfo:
+        get_format_unbound()
+    assert 'unsupported buffer format' in str(excinfo.value)
+
+    with capture:
+        print_format_descriptors()
+    assert capture == """
+        T{=?:x:3x=I:y:=f:z:}
+        T{=?:x:=I:y:=f:z:}
+        T{=T{=?:x:3x=I:y:=f:z:}:a:=T{=?:x:=I:y:=f:z:}:b:}
+        T{=?:x:3x=I:y:=f:z:12x}
+        T{8x=T{=?:x:3x=I:y:=f:z:12x}:a:8x}
+        T{=3s:a:=3s:b:}
+    """
+
+
+@pytest.requires_numpy
+def test_dtype(capture):
+    from pybind11_tests import print_dtypes, test_dtype_ctors, test_dtype_methods
+
+    with capture:
+        print_dtypes()
+    assert capture == """
+        {'names':['x','y','z'], 'formats':['?','<u4','<f4'], 'offsets':[0,4,8], 'itemsize':12}
+        [('x', '?'), ('y', '<u4'), ('z', '<f4')]
+        [('a', {'names':['x','y','z'], 'formats':['?','<u4','<f4'], 'offsets':[0,4,8], 'itemsize':12}), ('b', [('x', '?'), ('y', '<u4'), ('z', '<f4')])]
+        {'names':['x','y','z'], 'formats':['?','<u4','<f4'], 'offsets':[0,4,8], 'itemsize':24}
+        {'names':['a'], 'formats':[{'names':['x','y','z'], 'formats':['?','<u4','<f4'], 'offsets':[0,4,8], 'itemsize':24}], 'offsets':[8], 'itemsize':40}
+        [('a', 'S3'), ('b', 'S3')]
+    """
+
+    d1 = np.dtype({'names': ['a', 'b'], 'formats': ['int32', 'float64'],
+                   'offsets': [1, 10], 'itemsize': 20})
+    d2 = np.dtype([('a', 'i4'), ('b', 'f4')])
+    assert test_dtype_ctors() == [np.dtype('int32'), np.dtype('float64'),
+                                  np.dtype('bool'), d1, d1, np.dtype('uint32'), d2]
+
+    assert test_dtype_methods() == [np.dtype('int32'), simple_dtype, False, True,
+                                    np.dtype('int32').itemsize, simple_dtype.itemsize]
+
+
+@pytest.requires_numpy
+def test_recarray(capture):
+    from pybind11_tests import (create_rec_simple, create_rec_packed, create_rec_nested,
+                                print_rec_simple, print_rec_packed, print_rec_nested,
+                                create_rec_partial, create_rec_partial_nested)
+
+    elements = [(False, 0, 0.0), (True, 1, 1.5), (False, 2, 3.0)]
+
+    for func, dtype in [(create_rec_simple, simple_dtype), (create_rec_packed, packed_dtype)]:
+        arr = func(0)
+        assert arr.dtype == dtype
+        assert_equal(arr, [], simple_dtype)
+        assert_equal(arr, [], packed_dtype)
+
+        arr = func(3)
+        assert arr.dtype == dtype
+        assert_equal(arr, elements, simple_dtype)
+        assert_equal(arr, elements, packed_dtype)
+
+        if dtype == simple_dtype:
+            with capture:
+                print_rec_simple(arr)
+            assert capture == """
+                s:0,0,0
+                s:1,1,1.5
+                s:0,2,3
+            """
+        else:
+            with capture:
+                print_rec_packed(arr)
+            assert capture == """
+                p:0,0,0
+                p:1,1,1.5
+                p:0,2,3
+            """
+
+    nested_dtype = np.dtype([('a', simple_dtype), ('b', packed_dtype)])
+
+    arr = create_rec_nested(0)
+    assert arr.dtype == nested_dtype
+    assert_equal(arr, [], nested_dtype)
+
+    arr = create_rec_nested(3)
+    assert arr.dtype == nested_dtype
+    assert_equal(arr, [((False, 0, 0.0), (True, 1, 1.5)),
+                       ((True, 1, 1.5), (False, 2, 3.0)),
+                       ((False, 2, 3.0), (True, 3, 4.5))], nested_dtype)
+    with capture:
+        print_rec_nested(arr)
+    assert capture == """
+        n:a=s:0,0,0;b=p:1,1,1.5
+        n:a=s:1,1,1.5;b=p:0,2,3
+        n:a=s:0,2,3;b=p:1,3,4.5
+    """
+
+    arr = create_rec_partial(3)
+    assert str(arr.dtype) == "{'names':['x','y','z'], 'formats':['?','<u4','<f4'], 'offsets':[0,4,8], 'itemsize':24}"
+    partial_dtype = arr.dtype
+    assert '' not in arr.dtype.fields
+    assert partial_dtype.itemsize > simple_dtype.itemsize
+    assert_equal(arr, elements, simple_dtype)
+    assert_equal(arr, elements, packed_dtype)
+
+    arr = create_rec_partial_nested(3)
+    assert str(arr.dtype) == "{'names':['a'], 'formats':[{'names':['x','y','z'], 'formats':['?','<u4','<f4'], 'offsets':[0,4,8], 'itemsize':24}], 'offsets':[8], 'itemsize':40}"
+    assert '' not in arr.dtype.fields
+    assert '' not in arr.dtype.fields['a'][0].fields
+    assert arr.dtype.itemsize > partial_dtype.itemsize
+    np.testing.assert_equal(arr['a'], create_rec_partial(3))
+
+
+@pytest.requires_numpy
+def test_array_constructors():
+    from pybind11_tests import test_array_ctors
+
+    data = np.arange(1, 7, dtype='int32')
+    for i in range(8):
+        np.testing.assert_array_equal(test_array_ctors(10 + i), data.reshape((3, 2)))
+        np.testing.assert_array_equal(test_array_ctors(20 + i), data.reshape((3, 2)))
+    for i in range(5):
+        np.testing.assert_array_equal(test_array_ctors(30 + i), data)
+        np.testing.assert_array_equal(test_array_ctors(40 + i), data)
+
+
+@pytest.requires_numpy
+def test_string_array(capture):
+    from pybind11_tests import create_string_array, print_string_array
+
+    arr = create_string_array(True)
+    assert str(arr.dtype) == "[('a', 'S3'), ('b', 'S3')]"
+    with capture:
+        print_string_array(arr)
+    assert capture == """
+        a='',b=''
+        a='a',b='a'
+        a='ab',b='ab'
+        a='abc',b='abc'
+    """
+    dtype = arr.dtype
+    assert arr['a'].tolist() == [b'', b'a', b'ab', b'abc']
+    assert arr['b'].tolist() == [b'', b'a', b'ab', b'abc']
+    arr = create_string_array(False)
+    assert dtype == arr.dtype
+
+
+@pytest.requires_numpy
+def test_signature(doc):
+    from pybind11_tests import create_rec_nested
+
+    assert doc(create_rec_nested) == "create_rec_nested(arg0: int) -> numpy.ndarray[NestedStruct]"

example/example-numpy-vectorize.cpp → tests/test_numpy_vectorize.cpp

 /*
-    example/example-numpy-vectorize.cpp -- auto-vectorize functions over NumPy array
+    tests/test_numpy_vectorize.cpp -- auto-vectorize functions over NumPy array
     arguments
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -8,7 +8,7 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
+#include "pybind11_tests.h"
 #include <pybind11/numpy.h>
 
 double my_func(int x, float y, double z) {
@@ -35,7 +35,7 @@ void init_ex_numpy_vectorize(py::module &m) {
     m.def("vectorized_func3", py::vectorize(my_func3));
 
     /// Numpy function which only accepts specific data types
-    m.def("selective_func", [](py::array_t<int, py::array::c_style>) { std::cout << "Int branch taken. "<< std::endl; });
-    m.def("selective_func", [](py::array_t<float, py::array::c_style>) { std::cout << "Float branch taken. "<< std::endl; });
-    m.def("selective_func", [](py::array_t<std::complex<float>, py::array::c_style>) { std::cout << "Complex float branch taken. "<< std::endl; });
+    m.def("selective_func", [](py::array_t<int, py::array::c_style>) { std::cout << "Int branch taken." << std::endl; });
+    m.def("selective_func", [](py::array_t<float, py::array::c_style>) { std::cout << "Float branch taken." << std::endl; });
+    m.def("selective_func", [](py::array_t<std::complex<float>, py::array::c_style>) { std::cout << "Complex float branch taken." << std::endl; });
 }

tests/test_numpy_vectorize.py

+import pytest
+
+with pytest.suppress(ImportError):
+    import numpy as np
+
+
+@pytest.requires_numpy
+def test_vectorize(capture):
+    from pybind11_tests import vectorized_func, vectorized_func2, vectorized_func3
+
+    assert np.isclose(vectorized_func3(np.array(3 + 7j)), [6 + 14j])
+
+    for f in [vectorized_func, vectorized_func2]:
+        with capture:
+            assert np.isclose(f(1, 2, 3), 6)
+        assert capture == "my_func(x:int=1, y:float=2, z:float=3)"
+        with capture:
+            assert np.isclose(f(np.array(1), np.array(2), 3), 6)
+        assert capture == "my_func(x:int=1, y:float=2, z:float=3)"
+        with capture:
+            assert np.allclose(f(np.array([1, 3]), np.array([2, 4]), 3), [6, 36])
+        assert capture == """
+            my_func(x:int=1, y:float=2, z:float=3)
+            my_func(x:int=3, y:float=4, z:float=3)
+        """
+        with capture:
+            a, b, c = np.array([[1, 3, 5], [7, 9, 11]]), np.array([[2, 4, 6], [8, 10, 12]]), 3
+            assert np.allclose(f(a, b, c), a * b * c)
+        assert capture == """
+            my_func(x:int=1, y:float=2, z:float=3)
+            my_func(x:int=3, y:float=4, z:float=3)
+            my_func(x:int=5, y:float=6, z:float=3)
+            my_func(x:int=7, y:float=8, z:float=3)
+            my_func(x:int=9, y:float=10, z:float=3)
+            my_func(x:int=11, y:float=12, z:float=3)
+        """
+        with capture:
+            a, b, c = np.array([[1, 2, 3], [4, 5, 6]]), np.array([2, 3, 4]), 2
+            assert np.allclose(f(a, b, c), a * b * c)
+        assert capture == """
+            my_func(x:int=1, y:float=2, z:float=2)
+            my_func(x:int=2, y:float=3, z:float=2)
+            my_func(x:int=3, y:float=4, z:float=2)
+            my_func(x:int=4, y:float=2, z:float=2)
+            my_func(x:int=5, y:float=3, z:float=2)
+            my_func(x:int=6, y:float=4, z:float=2)
+        """
+        with capture:
+            a, b, c = np.array([[1, 2, 3], [4, 5, 6]]), np.array([[2], [3]]), 2
+            assert np.allclose(f(a, b, c), a * b * c)
+        assert capture == """
+            my_func(x:int=1, y:float=2, z:float=2)
+            my_func(x:int=2, y:float=2, z:float=2)
+            my_func(x:int=3, y:float=2, z:float=2)
+            my_func(x:int=4, y:float=3, z:float=2)
+            my_func(x:int=5, y:float=3, z:float=2)
+            my_func(x:int=6, y:float=3, z:float=2)
+        """
+
+
+@pytest.requires_numpy
+def test_type_selection(capture):
+    from pybind11_tests import selective_func
+
+    with capture:
+        selective_func(np.array([1], dtype=np.int32))
+        selective_func(np.array([1.0], dtype=np.float32))
+        selective_func(np.array([1.0j], dtype=np.complex64))
+    assert capture == """
+        Int branch taken.
+        Float branch taken.
+        Complex float branch taken.
+    """
+
+
+@pytest.requires_numpy
+def test_docs(doc):
+    from pybind11_tests import vectorized_func
+
+    assert doc(vectorized_func) == "vectorized_func(arg0: numpy.ndarray[int], arg1: numpy.ndarray[float], arg2: numpy.ndarray[float]) -> object"

example/example-opaque-types.cpp → tests/test_opaque_types.cpp

 /*
-    example/example-opaque-types.cpp -- opaque types, passing void pointers
+    tests/test_opaque_types.cpp -- opaque types, passing void pointers
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
 
@@ -7,7 +7,7 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
+#include "pybind11_tests.h"
 #include <pybind11/stl.h>
 #include <vector>
 
@@ -50,9 +50,9 @@ void init_ex_opaque_types(py::module &m) {
     });
 
     m.def("return_void_ptr", []() { return (void *) 0x1234; });
-    m.def("print_void_ptr", [](void *ptr) { std::cout << "Got void ptr : 0x" << std::hex << (uint64_t) ptr << std::endl; });
+    m.def("print_void_ptr", [](void *ptr) { std::cout << "Got void ptr : 0x" << std::hex << (uint64_t) ptr << std::dec << std::endl; });
     m.def("return_null_str", []() { return (char *) nullptr; });
-    m.def("print_null_str", [](char *ptr) { std::cout << "Got null str : 0x" << std::hex << (uint64_t) ptr << std::endl; });
+    m.def("print_null_str", [](char *ptr) { std::cout << "Got null str : 0x" << std::hex << (uint64_t) ptr << std::dec << std::endl; });
 
     m.def("return_unique_ptr", []() -> std::unique_ptr<StringList> {
         StringList *result = new StringList();

tests/test_opaque_types.py

+import pytest
+
+
+def test_string_list(capture):
+    from pybind11_tests import StringList, ClassWithSTLVecProperty, print_opaque_list
+
+    l = StringList()
+    l.push_back("Element 1")
+    l.push_back("Element 2")
+    with capture:
+        print_opaque_list(l)
+    assert capture == "Opaque list: [Element 1, Element 2]"
+    assert l.back() == "Element 2"
+
+    for i, k in enumerate(l, start=1):
+        assert k == "Element {}".format(i)
+    l.pop_back()
+    with capture:
+        print_opaque_list(l)
+    assert capture == "Opaque list: [Element 1]"
+
+    cvp = ClassWithSTLVecProperty()
+    with capture:
+        print_opaque_list(cvp.stringList)
+    assert capture == "Opaque list: []"
+
+    cvp.stringList = l
+    cvp.stringList.push_back("Element 3")
+    with capture:
+        print_opaque_list(cvp.stringList)
+    assert capture == "Opaque list: [Element 1, Element 3]"
+
+
+def test_pointers(capture, msg):
+    from pybind11_tests import (return_void_ptr, print_void_ptr, ExampleMandA,
+                                print_opaque_list, return_null_str, print_null_str,
+                                return_unique_ptr, ConstructorStats)
+
+    with capture:
+        print_void_ptr(return_void_ptr())
+    assert capture == "Got void ptr : 0x1234"
+    with capture:
+        print_void_ptr(ExampleMandA())  # Should also work for other C++ types
+    assert "Got void ptr" in capture
+    assert ConstructorStats.get(ExampleMandA).alive() == 0
+
+    with pytest.raises(TypeError) as excinfo:
+        print_void_ptr([1, 2, 3])  # This should not work
+    assert msg(excinfo.value) == """
+        Incompatible function arguments. The following argument types are supported:
+            1. (arg0: capsule) -> None
+            Invoked with: [1, 2, 3]
+    """
+
+    assert return_null_str() is None
+    with capture:
+        print_null_str(return_null_str())
+    assert capture == "Got null str : 0x0"
+
+    ptr = return_unique_ptr()
+    assert "StringList" in repr(ptr)
+    with capture:
+        print_opaque_list(ptr)
+    assert capture == "Opaque list: [some value]"

example/example-operator-overloading.cpp → tests/test_operator_overloading.cpp

 /*
-    example/example-operator-overloading.cpp -- operator overloading
+    tests/test_operator_overloading.cpp -- operator overloading
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
 
@@ -7,8 +7,8 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
-#include "constructor-stats.h"
+#include "pybind11_tests.h"
+#include "constructor_stats.h"
 #include <pybind11/operators.h>
 
 class Vector2 {

tests/test_operator_overloading.py

+
+def test_operator_overloading():
+    from pybind11_tests import Vector2, Vector, ConstructorStats
+
+    v1 = Vector2(1, 2)
+    v2 = Vector(3, -1)
+    assert str(v1) == "[1.000000, 2.000000]"
+    assert str(v2) == "[3.000000, -1.000000]"
+
+    assert str(v1 + v2) == "[4.000000, 1.000000]"
+    assert str(v1 - v2) == "[-2.000000, 3.000000]"
+    assert str(v1 - 8) == "[-7.000000, -6.000000]"
+    assert str(v1 + 8) == "[9.000000, 10.000000]"
+    assert str(v1 * 8) == "[8.000000, 16.000000]"
+    assert str(v1 / 8) == "[0.125000, 0.250000]"
+    assert str(8 - v1) == "[7.000000, 6.000000]"
+    assert str(8 + v1) == "[9.000000, 10.000000]"
+    assert str(8 * v1) == "[8.000000, 16.000000]"
+    assert str(8 / v1) == "[8.000000, 4.000000]"
+
+    v1 += v2
+    v1 *= 2
+    assert str(v1) == "[8.000000, 2.000000]"
+
+    cstats = ConstructorStats.get(Vector2)
+    assert cstats.alive() == 2
+    del v1
+    assert cstats.alive() == 1
+    del v2
+    assert cstats.alive() == 0
+    assert cstats.values() == ['[1.000000, 2.000000]', '[3.000000, -1.000000]',
+                               '[4.000000, 1.000000]', '[-2.000000, 3.000000]',
+                               '[-7.000000, -6.000000]', '[9.000000, 10.000000]',
+                               '[8.000000, 16.000000]', '[0.125000, 0.250000]',
+                               '[7.000000, 6.000000]', '[9.000000, 10.000000]',
+                               '[8.000000, 16.000000]', '[8.000000, 4.000000]']
+    assert cstats.default_constructions == 0
+    assert cstats.copy_constructions == 0
+    assert cstats.move_constructions >= 10
+    assert cstats.copy_assignments == 0
+    assert cstats.move_assignments == 0

example/example-pickling.cpp → tests/test_pickling.cpp

 /*
-    example/example-pickling.cpp -- pickle support
+    tests/test_pickling.cpp -- pickle support
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
 
@@ -7,7 +7,7 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
+#include "pybind11_tests.h"
 
 class Pickleable {
 public:

tests/test_pickling.py

+try:
+    import cPickle as pickle  # Use cPickle on Python 2.7
+except ImportError:
+    import pickle
+
+from pybind11_tests import Pickleable
+
+
+def test_roundtrip():
+    p = Pickleable("test_value")
+    p.setExtra1(15)
+    p.setExtra2(48)
+
+    data = pickle.dumps(p, 2)  # Must use pickle protocol >= 2
+    p2 = pickle.loads(data)
+    assert p2.value() == p.value()
+    assert p2.extra1() == p.extra1()
+    assert p2.extra2() == p.extra2()

example/example-python-types.cpp → tests/test_python_types.cpp

 /*
-    example/example-python-types.cpp2 -- singleton design pattern, static functions and
+    tests/test_python_types.cpp -- singleton design pattern, static functions and
     variables, passing and interacting with Python types
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -8,8 +8,8 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
-#include "constructor-stats.h"
+#include "pybind11_tests.h"
+#include "constructor_stats.h"
 #include <pybind11/stl.h>
 
 #ifdef _WIN32

example/example-sequences-and-iterators.cpp → tests/test_sequences_and_iterators.cpp

 /*
-    example/example-sequences-and-iterators.cpp -- supporting Pythons' sequence protocol, iterators,
+    tests/test_sequences_and_iterators.cpp -- supporting Pythons' sequence protocol, iterators,
     etc.
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -8,8 +8,8 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
-#include "constructor-stats.h"
+#include "pybind11_tests.h"
+#include "constructor_stats.h"
 #include <pybind11/operators.h>
 #include <pybind11/stl.h>
 

tests/test_sequences_and_iterators.py

+import pytest
+
+
+def isclose(a, b, rel_tol=1e-05, abs_tol=0.0):
+    """Like to math.isclose() from Python 3.5"""
+    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
+
+
+def allclose(a_list, b_list, rel_tol=1e-05, abs_tol=0.0):
+    return all(isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol) for a, b in zip(a_list, b_list))
+
+
+def test_sequence():
+    from pybind11_tests import Sequence, ConstructorStats
+
+    cstats = ConstructorStats.get(Sequence)
+
+    s = Sequence(5)
+    assert cstats.values() == ['of size', '5']
+
+    assert "Sequence" in repr(s)
+    assert len(s) == 5
+    assert s[0] == 0 and s[3] == 0
+    assert 12.34 not in s
+    s[0], s[3] = 12.34, 56.78
+    assert 12.34 in s
+    assert isclose(s[0], 12.34) and isclose(s[3], 56.78)
+
+    rev = reversed(s)
+    assert cstats.values() == ['of size', '5']
+
+    rev2 = s[::-1]
+    assert cstats.values() == ['of size', '5']
+
+    expected = [0, 56.78, 0, 0, 12.34]
+    assert allclose(rev, expected)
+    assert allclose(rev2, expected)
+    assert rev == rev2
+
+    rev[0::2] = Sequence([2.0, 2.0, 2.0])
+    assert cstats.values() == ['of size', '3', 'from std::vector']
+
+    assert allclose(rev, [2, 56.78, 2, 0, 2])
+
+    assert cstats.alive() == 3
+    del s
+    assert cstats.alive() == 2
+    del rev
+    assert cstats.alive() == 1
+    del rev2
+    assert cstats.alive() == 0
+
+    assert cstats.values() == []
+    assert cstats.default_constructions == 0
+    assert cstats.copy_constructions == 0
+    assert cstats.move_constructions >= 1
+    assert cstats.copy_assignments == 0
+    assert cstats.move_assignments == 0
+
+
+def test_map_iterator():
+    from pybind11_tests import StringMap
+
+    m = StringMap({'hi': 'bye', 'black': 'white'})
+    assert m['hi'] == 'bye'
+    assert len(m) == 2
+    assert m['black'] == 'white'
+
+    with pytest.raises(KeyError):
+        assert m['orange']
+    m['orange'] = 'banana'
+    assert m['orange'] == 'banana'
+
+    expected = {'hi': 'bye', 'black': 'white', 'orange': 'banana'}
+    for k in m:
+        assert m[k] == expected[k]
+    for k, v in m.items():
+        assert v == expected[k]

example/example-smart-ptr.cpp → tests/test_smart_ptr.cpp

 /*
-    example/example-smart-ptr.cpp -- binding classes with custom reference counting,
+    tests/test_smart_ptr.cpp -- binding classes with custom reference counting,
     implicit conversions between types
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
@@ -8,7 +8,7 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
+#include "pybind11_tests.h"
 #include "object.h"
 
 /// Custom object with builtin reference counting (see 'object.h' for the implementation)

example/example-stl-binder-vector.cpp → tests/test_stl_binders.cpp

 /*
-    example/example-stl-binder-vector.cpp -- Usage of stl_binders functions
+    tests/test_stl_binders.cpp -- Usage of stl_binders functions
 
     Copyright (c) 2016 Sergey Lyskov
 
@@ -7,7 +7,7 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
+#include "pybind11_tests.h"
 
 #include <pybind11/stl_bind.h>