Merge pull request #321 from dean0x7d/pytest

Port test suite to pytest

example/example-keep-alive.cpp → tests/test_keep_alive.cpp

 /*
-    example/example-keep-alive.cpp -- keep_alive modifier (pybind11's version
+    tests/test_keep_alive.cpp -- keep_alive modifier (pybind11's version
     of Boost.Python's with_custodian_and_ward / with_custodian_and_ward_postcall)
 
     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"
 
 class Child {
 public:

tests/test_keep_alive.py

+import gc
+
+
+def test_keep_alive_argument(capture):
+    from pybind11_tests import Parent, Child
+
+    with capture:
+        p = Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.addChild(Child())
+        gc.collect()
+    assert capture == """
+        Allocating child.
+        Releasing child.
+    """
+    with capture:
+        del p
+        gc.collect()
+    assert capture == "Releasing parent."
+
+    with capture:
+        p = Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.addChildKeepAlive(Child())
+        gc.collect()
+    assert capture == "Allocating child."
+    with capture:
+        del p
+        gc.collect()
+    assert capture == """
+        Releasing parent.
+        Releasing child.
+    """
+
+
+def test_keep_alive_return_value(capture):
+    from pybind11_tests import Parent
+
+    with capture:
+        p = Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.returnChild()
+        gc.collect()
+    assert capture == """
+        Allocating child.
+        Releasing child.
+    """
+    with capture:
+        del p
+        gc.collect()
+    assert capture == "Releasing parent."
+
+    with capture:
+        p = Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.returnChildKeepAlive()
+        gc.collect()
+    assert capture == "Allocating child."
+    with capture:
+        del p
+        gc.collect()
+    assert capture == """
+        Releasing parent.
+        Releasing child.
+    """
+
+
+def test_return_none(capture):
+    from pybind11_tests import Parent
+
+    with capture:
+        p = Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.returnNullChildKeepAliveChild()
+        gc.collect()
+    assert capture == ""
+    with capture:
+        del p
+        gc.collect()
+    assert capture == "Releasing parent."
+
+    with capture:
+        p = Parent()
+    assert capture == "Allocating parent."
+    with capture:
+        p.returnNullChildKeepAliveParent()
+        gc.collect()
+    assert capture == ""
+    with capture:
+        del p
+        gc.collect()
+    assert capture == "Releasing parent."
+

example/example-arg-keywords-and-defaults.cpp → tests/test_kwargs_and_defaults.cpp

 /*
-    example/example-arg-keywords-and-defaults.cpp -- keyword arguments and default values
+    tests/test_kwargs_and_defaults.cpp -- keyword arguments and default values
 
     Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
 
@@ -7,16 +7,17 @@
     BSD-style license that can be found in the LICENSE file.
 */
 
-#include "example.h"
+#include "pybind11_tests.h"
 #include <pybind11/stl.h>
 
-void kw_func(int x, int y) { std::cout << "kw_func(x=" << x << ", y=" << y << ")" << std::endl; }
+std::string kw_func(int x, int y) { return "x=" + std::to_string(x) + ", y=" + std::to_string(y); }
 
-void kw_func4(const std::vector<int> &entries) {
-    std::cout << "kw_func4: ";
+std::string kw_func4(const std::vector<int> &entries) {
+    std::string ret = "{";
     for (int i : entries)
-        std::cout << i << " ";
-    std::cout << endl;
+        ret += std::to_string(i) + " ";
+    ret.back() = '}';
+    return ret;
 }
 
 py::object call_kw_func(py::function f) {
@@ -26,18 +27,12 @@ py::object call_kw_func(py::function f) {
     return f(*args, **kwargs);
 }
 
-void args_function(py::args args) {
-    for (size_t it=0; it<args.size(); ++it)
-        std::cout << "got argument: " << py::object(args[it]) << std::endl;
+py::tuple args_function(py::args args) {
+    return args;
 }
 
-void args_kwargs_function(py::args args, py::kwargs kwargs) {
-    for (auto item : args)
-        std::cout << "got argument: " << item << std::endl;
-    if (kwargs) {
-        for (auto item : kwargs)
-            std::cout << "got keyword argument: " << item.first << " -> " << item.second << std::endl;
-    }
+py::tuple args_kwargs_function(py::args args, py::kwargs kwargs) {
+    return py::make_tuple(args, kwargs);
 }
 
 struct KWClass {

tests/test_kwargs_and_defaults.py

+import pytest
+from pybind11_tests import (kw_func0, kw_func1, kw_func2, kw_func3, kw_func4, call_kw_func,
+                            args_function, args_kwargs_function, kw_func_udl, kw_func_udl_z,
+                            KWClass)
+
+
+def test_function_signatures(doc):
+    assert doc(kw_func0) == "kw_func0(arg0: int, arg1: int) -> str"
+    assert doc(kw_func1) == "kw_func1(x: int, y: int) -> str"
+    assert doc(kw_func2) == "kw_func2(x: int=100, y: int=200) -> str"
+    assert doc(kw_func3) == "kw_func3(data: str='Hello world!') -> None"
+    assert doc(kw_func4) == "kw_func4(myList: List[int]=[13, 17]) -> str"
+    assert doc(kw_func_udl) == "kw_func_udl(x: int, y: int=300) -> str"
+    assert doc(kw_func_udl_z) == "kw_func_udl_z(x: int, y: int=0) -> str"
+    assert doc(args_function) == "args_function(*args) -> tuple"
+    assert doc(args_kwargs_function) == "args_kwargs_function(*args, **kwargs) -> tuple"
+    assert doc(KWClass.foo0) == "foo0(self: m.KWClass, arg0: int, arg1: float) -> None"
+    assert doc(KWClass.foo1) == "foo1(self: m.KWClass, x: int, y: float) -> None"
+
+
+def test_named_arguments(msg):
+    assert kw_func0(5, 10) == "x=5, y=10"
+
+    assert kw_func1(5, 10) == "x=5, y=10"
+    assert kw_func1(5, y=10) == "x=5, y=10"
+    assert kw_func1(y=10, x=5) == "x=5, y=10"
+
+    assert kw_func2() == "x=100, y=200"
+    assert kw_func2(5) == "x=5, y=200"
+    assert kw_func2(x=5) == "x=5, y=200"
+    assert kw_func2(y=10) == "x=100, y=10"
+    assert kw_func2(5, 10) == "x=5, y=10"
+    assert kw_func2(x=5, y=10) == "x=5, y=10"
+
+    with pytest.raises(TypeError) as excinfo:
+        # noinspection PyArgumentList
+        kw_func2(x=5, y=10, z=12)
+    assert msg(excinfo.value) == """
+        Incompatible function arguments. The following argument types are supported:
+            1. (x: int=100, y: int=200) -> str
+            Invoked with:
+    """
+
+    assert kw_func4() == "{13 17}"
+    assert kw_func4(myList=[1, 2, 3]) == "{1 2 3}"
+
+    assert kw_func_udl(x=5, y=10) == "x=5, y=10"
+    assert kw_func_udl_z(x=5) == "x=5, y=0"
+
+
+def test_arg_and_kwargs():
+    assert call_kw_func(kw_func2) == "x=1234, y=5678"
+
+    args = 'arg1_value', 'arg2_value', 3
+    assert args_function(*args) == args
+
+    args = 'a1', 'a2'
+    kwargs = dict(arg3='a3', arg4=4)
+    assert args_kwargs_function(*args, **kwargs) == (args, kwargs)

example/example-methods-and-attributes.cpp → tests/test_methods_and_attributes.cpp

 /*
-    example/example-methods-and-attributes.cpp -- constructors, deconstructors, attribute access,
+    tests/test_methods_and_attributes.cpp -- constructors, deconstructors, attribute access,
     __str__, argument and return value conventions
 
     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"
 
 class ExampleMandA {
 public:

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,11 +8,11 @@
     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;
+std::string submodule_func() {
+    return "submodule_func()";
 }
 
 class A {

tests/test_modules.py

+
+def test_nested_modules():
+    import pybind11_tests
+    from pybind11_tests.submodule import submodule_func
+
+    assert pybind11_tests.__name__ == "pybind11_tests"
+    assert pybind11_tests.submodule.__name__ == "pybind11_tests.submodule"
+
+    assert submodule_func() == "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,8 @@
   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__))
@@ -141,29 +138,48 @@ py::array_t<StringStruct, 0> create_string_array(bool non_empty) {
 }
 
 template <typename S>
-void print_recarray(py::array_t<S, 0> arr) {
-    auto req = arr.request();
-    auto ptr = static_cast<S*>(req.ptr);
-    for (size_t i = 0; i < req.size; i++)
-        std::cout << ptr[i] << std::endl;
+py::list print_recarray(py::array_t<S, 0> arr) {
+    const auto req = arr.request();
+    const auto ptr = static_cast<S*>(req.ptr);
+    auto l = py::list();
+    for (size_t i = 0; i < req.size; i++) {
+        std::stringstream ss;
+        ss << ptr[i];
+        l.append(py::str(ss.str()));
+    }
+    return l;
 }
 
-void print_format_descriptors() {
-    std::cout << py::format_descriptor<SimpleStruct>::format() << std::endl;
-    std::cout << py::format_descriptor<PackedStruct>::format() << std::endl;
-    std::cout << py::format_descriptor<NestedStruct>::format() << std::endl;
-    std::cout << py::format_descriptor<PartialStruct>::format() << std::endl;
-    std::cout << py::format_descriptor<PartialNestedStruct>::format() << std::endl;
-    std::cout << py::format_descriptor<StringStruct>::format() << std::endl;
+py::list print_format_descriptors() {
+    const auto fmts = {
+        py::format_descriptor<SimpleStruct>::format(),
+        py::format_descriptor<PackedStruct>::format(),
+        py::format_descriptor<NestedStruct>::format(),
+        py::format_descriptor<PartialStruct>::format(),
+        py::format_descriptor<PartialNestedStruct>::format(),
+        py::format_descriptor<StringStruct>::format()
+    };
+    auto l = py::list();
+    for (const auto &fmt : fmts) {
+        l.append(py::cast(fmt));
+    }
+    return l;
 }
 
-void print_dtypes() {
-    std::cout << (std::string) py::dtype::of<SimpleStruct>().str() << std::endl;
-    std::cout << (std::string) py::dtype::of<PackedStruct>().str() << std::endl;
-    std::cout << (std::string) py::dtype::of<NestedStruct>().str() << std::endl;
-    std::cout << (std::string) py::dtype::of<PartialStruct>().str() << std::endl;
-    std::cout << (std::string) py::dtype::of<PartialNestedStruct>().str() << std::endl;
-    std::cout << (std::string) py::dtype::of<StringStruct>().str() << std::endl;
+py::list print_dtypes() {
+    const auto dtypes = {
+        py::dtype::of<SimpleStruct>().str(),
+        py::dtype::of<PackedStruct>().str(),
+        py::dtype::of<NestedStruct>().str(),
+        py::dtype::of<PartialStruct>().str(),
+        py::dtype::of<PartialNestedStruct>().str(),
+        py::dtype::of<StringStruct>().str()
+    };
+    auto l = py::list();
+    for (const auto &s : dtypes) {
+        l.append(s);
+    }
+    return l;
 }
 
 py::array_t<int32_t, 0> test_array_ctors(int i) {

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():
+    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)
+
+    assert print_format_descriptors() == [
+        "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():
+    from pybind11_tests import print_dtypes, test_dtype_ctors, test_dtype_methods
+
+    assert print_dtypes() == [
+        "{'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():
+    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:
+            assert print_rec_simple(arr) == [
+                "s:0,0,0",
+                "s:1,1,1.5",
+                "s:0,2,3"
+            ]
+        else:
+            assert print_rec_packed(arr) == [
+                "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)
+    assert print_rec_nested(arr) == [
+        "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():
+    from pybind11_tests import create_string_array, print_string_array
+
+    arr = create_string_array(True)
+    assert str(arr.dtype) == "[('a', 'S3'), ('b', 'S3')]"
+    assert print_string_array(arr) == [
+        "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>) { return "Int branch taken."; });
+    m.def("selective_func", [](py::array_t<float, py::array::c_style>) { return "Float branch taken."; });
+    m.def("selective_func", [](py::array_t<std::complex<float>, py::array::c_style>) { return "Complex float branch taken."; });
 }

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():
+    from pybind11_tests import selective_func
+
+    assert selective_func(np.array([1], dtype=np.int32)) == "Int branch taken."
+    assert selective_func(np.array([1.0], dtype=np.float32)) == "Float branch taken."
+    assert selective_func(np.array([1.0j], dtype=np.complex64)) == "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>
 
@@ -38,21 +38,21 @@ void init_ex_opaque_types(py::module &m) {
         .def_readwrite("stringList", &ClassWithSTLVecProperty::stringList);
 
     m.def("print_opaque_list", [](const StringList &l) {
-        std::cout << "Opaque list: [";
+        std::string ret = "Opaque list: [";
         bool first = true;
         for (auto entry : l) {
             if (!first)
-                std::cout << ", ";
-            std::cout << entry;
+                ret += ", ";
+            ret += entry;
             first = false;
         }
-        std::cout << "]" << std::endl;
+        return ret + "]";
     });
 
     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("get_void_ptr_value", [](void *ptr) { return reinterpret_cast<std::intptr_t>(ptr); });
     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("get_null_str_value", [](char *ptr) { return reinterpret_cast<std::intptr_t>(ptr); });
 
     m.def("return_unique_ptr", []() -> std::unique_ptr<StringList> {
         StringList *result = new StringList();

tests/test_opaque_types.py

+import pytest
+
+
+def test_string_list():
+    from pybind11_tests import StringList, ClassWithSTLVecProperty, print_opaque_list
+
+    l = StringList()
+    l.push_back("Element 1")
+    l.push_back("Element 2")
+    assert print_opaque_list(l) == "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()
+    assert print_opaque_list(l) == "Opaque list: [Element 1]"
+
+    cvp = ClassWithSTLVecProperty()
+    assert print_opaque_list(cvp.stringList) == "Opaque list: []"
+
+    cvp.stringList = l
+    cvp.stringList.push_back("Element 3")
+    assert print_opaque_list(cvp.stringList) == "Opaque list: [Element 1, Element 3]"
+
+
+def test_pointers(msg):
+    from pybind11_tests import (return_void_ptr, get_void_ptr_value, ExampleMandA,
+                                print_opaque_list, return_null_str, get_null_str_value,
+                                return_unique_ptr, ConstructorStats)
+
+    assert get_void_ptr_value(return_void_ptr()) == 0x1234
+    assert get_void_ptr_value(ExampleMandA())  # Should also work for other C++ types
+    assert ConstructorStats.get(ExampleMandA).alive() == 0
+
+    with pytest.raises(TypeError) as excinfo:
+        get_void_ptr_value([1, 2, 3])  # This should not work
+    assert msg(excinfo.value) == """
+        Incompatible function arguments. The following argument types are supported:
+            1. (arg0: capsule) -> int
+            Invoked with: [1, 2, 3]
+    """
+
+    assert return_null_str() is None
+    assert get_null_str_value(return_null_str()) is not None
+
+    ptr = return_unique_ptr()
+    assert "StringList" in repr(ptr)
+    assert print_opaque_list(ptr) == "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

tests/test_python_types.py

+import pytest
+
+from pybind11_tests import ExamplePythonTypes, ConstructorStats
+
+
+def test_static():
+    ExamplePythonTypes.value = 15
+    assert ExamplePythonTypes.value == 15
+    assert ExamplePythonTypes.value2 == 5
+
+    with pytest.raises(AttributeError) as excinfo:
+        ExamplePythonTypes.value2 = 15
+    assert str(excinfo.value) == "can't set attribute"
+
+
+def test_instance(capture):
+    with pytest.raises(TypeError) as excinfo:
+        ExamplePythonTypes()
+    assert str(excinfo.value) == "pybind11_tests.ExamplePythonTypes: No constructor defined!"
+
+    instance = ExamplePythonTypes.new_instance()
+
+    with capture:
+        dict_result = instance.get_dict()
+        dict_result['key2'] = 'value2'
+        instance.print_dict(dict_result)
+    assert capture.unordered == """
+        key: key, value=value
+        key: key2, value=value2
+    """
+    with capture:
+        dict_result = instance.get_dict_2()
+        dict_result['key2'] = 'value2'
+        instance.print_dict_2(dict_result)
+    assert capture.unordered == """
+        key: key, value=value
+        key: key2, value=value2
+    """
+    with capture:
+        set_result = instance.get_set()
+        set_result.add('key3')
+        instance.print_set(set_result)
+    assert capture.unordered == """
+        key: key1
+        key: key2
+        key: key3
+    """
+    with capture:
+        set_result = instance.get_set2()
+        set_result.add('key3')
+        instance.print_set_2(set_result)
+    assert capture.unordered == """
+        key: key1
+        key: key2
+        key: key3
+    """
+    with capture:
+        list_result = instance.get_list()
+        list_result.append('value2')
+        instance.print_list(list_result)
+    assert capture.unordered == """
+        Entry at positon 0: value
+        list item 0: overwritten
+        list item 1: value2
+    """
+    with capture:
+        list_result = instance.get_list_2()
+        list_result.append('value2')
+        instance.print_list_2(list_result)
+    assert capture.unordered == """
+        list item 0: value
+        list item 1: value2
+    """
+    array_result = instance.get_array()
+    assert array_result == ['array entry 1', 'array entry 2']
+    with capture:
+        instance.print_array(array_result)
+    assert capture.unordered == """
+        array item 0: array entry 1
+        array item 1: array entry 2
+    """
+    with pytest.raises(RuntimeError) as excinfo:
+        instance.throw_exception()
+    assert str(excinfo.value) == "This exception was intentionally thrown."
+
+    assert instance.pair_passthrough((True, "test")) == ("test", True)
+    assert instance.tuple_passthrough((True, "test", 5)) == (5, "test", True)
+
+    assert instance.get_bytes_from_string().decode() == "foo"
+    assert instance.get_bytes_from_str().decode() == "bar"
+    assert instance.get_str_from_string().encode().decode() == "baz"
+    assert instance.get_str_from_bytes().encode().decode() == "boo"
+
+    class A(object):
+        def __str__(self):
+            return "this is a str"
+
+        def __repr__(self):
+            return "this is a repr"
+
+    with capture:
+        instance.test_print(A())
+    assert capture == """
+        this is a str
+        this is a repr
+    """
+
+    cstats = ConstructorStats.get(ExamplePythonTypes)
+    assert cstats.alive() == 1
+    del instance
+    assert cstats.alive() == 0
+
+
+def test_docs(doc):
+    assert doc(ExamplePythonTypes) == "Example 2 documentation"
+    assert doc(ExamplePythonTypes.get_dict) == """
+        get_dict(self: m.ExamplePythonTypes) -> dict
+
+        Return a Python dictionary
+    """
+    assert doc(ExamplePythonTypes.get_dict_2) == """
+        get_dict_2(self: m.ExamplePythonTypes) -> Dict[str, str]
+
+        Return a C++ dictionary
+    """
+    assert doc(ExamplePythonTypes.get_list) == """
+        get_list(self: m.ExamplePythonTypes) -> list
+
+        Return a Python list
+    """
+    assert doc(ExamplePythonTypes.get_list_2) == """
+        get_list_2(self: m.ExamplePythonTypes) -> List[str]
+
+        Return a C++ list
+    """
+    assert doc(ExamplePythonTypes.get_dict) == """
+        get_dict(self: m.ExamplePythonTypes) -> dict
+
+        Return a Python dictionary
+    """
+    assert doc(ExamplePythonTypes.get_set) == """
+        get_set(self: m.ExamplePythonTypes) -> set
+
+        Return a Python set
+    """
+    assert doc(ExamplePythonTypes.get_set2) == """
+        get_set2(self: m.ExamplePythonTypes) -> Set[str]
+
+        Return a C++ set
+    """
+    assert doc(ExamplePythonTypes.get_array) == """
+        get_array(self: m.ExamplePythonTypes) -> List[str[2]]
+
+        Return a C++ array
+    """
+    assert doc(ExamplePythonTypes.print_dict) == """
+        print_dict(self: m.ExamplePythonTypes, arg0: dict) -> None
+
+        Print entries of a Python dictionary
+    """
+    assert doc(ExamplePythonTypes.print_dict_2) == """
+        print_dict_2(self: m.ExamplePythonTypes, arg0: Dict[str, str]) -> None
+
+        Print entries of a C++ dictionary
+    """
+    assert doc(ExamplePythonTypes.print_set) == """
+        print_set(self: m.ExamplePythonTypes, arg0: set) -> None
+
+        Print entries of a Python set
+    """
+    assert doc(ExamplePythonTypes.print_set_2) == """
+        print_set_2(self: m.ExamplePythonTypes, arg0: Set[str]) -> None
+
+        Print entries of a C++ set
+    """
+    assert doc(ExamplePythonTypes.print_list) == """
+        print_list(self: m.ExamplePythonTypes, arg0: list) -> None
+
+        Print entries of a Python list
+    """
+    assert doc(ExamplePythonTypes.print_list_2) == """
+        print_list_2(self: m.ExamplePythonTypes, arg0: List[str]) -> None
+
+        Print entries of a C++ list
+    """
+    assert doc(ExamplePythonTypes.print_array) == """
+        print_array(self: m.ExamplePythonTypes, arg0: List[str[2]]) -> None
+
+        Print entries of a C++ array
+    """
+    assert doc(ExamplePythonTypes.pair_passthrough) == """
+        pair_passthrough(self: m.ExamplePythonTypes, arg0: Tuple[bool, str]) -> Tuple[str, bool]
+
+        Return a pair in reversed order
+    """
+    assert doc(ExamplePythonTypes.tuple_passthrough) == """
+        tuple_passthrough(self: m.ExamplePythonTypes, arg0: Tuple[bool, str, int]) -> Tuple[int, str, bool]
+
+        Return a triple in reversed order
+    """
+    assert doc(ExamplePythonTypes.throw_exception) == """
+        throw_exception(self: m.ExamplePythonTypes) -> None
+
+        Throw an exception
+    """
+    assert doc(ExamplePythonTypes.new_instance) == """
+        new_instance() -> m.ExamplePythonTypes
+
+        Return an instance
+    """
+
+
+def test_module():
+    import pybind11_tests
+
+    assert pybind11_tests.__name__ == "pybind11_tests"
+    assert ExamplePythonTypes.__name__ == "ExamplePythonTypes"
+    assert ExamplePythonTypes.__module__ == "pybind11_tests"
+    assert ExamplePythonTypes.get_set.__name__ == "get_set"
+    assert ExamplePythonTypes.get_set.__module__ == "pybind11_tests"