Simplify tests by replacing output capture with asserts where possible

The C++ part of the test code is modified to achieve this. As a result,
this kind of test:

```python
with capture:
    kw_func1(5, y=10)
assert capture == "kw_func(x=5, y=10)"
```

can be replaced with a simple:

`assert kw_func1(5, y=10) == "x=5, y=10"`

tests/test_callbacks.py

@@ -1,70 +1,51 @@
 import pytest
 
 
-def test_inheritance(capture, msg):
-    from pybind11_tests import Pet, Dog, Rabbit, dog_bark, pet_print
+def test_inheritance(msg):
+    from pybind11_tests import Pet, Dog, Rabbit, dog_bark, pet_name_species
 
     roger = Rabbit('Rabbit')
     assert roger.name() + " is a " + roger.species() == "Rabbit is a parrot"
-    with capture:
-        pet_print(roger)
-    assert capture == "Rabbit is a parrot"
+    assert pet_name_species(roger) == "Rabbit is a parrot"
 
     polly = Pet('Polly', 'parrot')
     assert polly.name() + " is a " + polly.species() == "Polly is a parrot"
-    with capture:
-        pet_print(polly)
-    assert capture == "Polly is a parrot"
+    assert pet_name_species(polly) == "Polly is a parrot"
 
     molly = Dog('Molly')
     assert molly.name() + " is a " + molly.species() == "Molly is a dog"
-    with capture:
-        pet_print(molly)
-    assert capture == "Molly is a dog"
+    assert pet_name_species(molly) == "Molly is a dog"
 
-    with capture:
-        dog_bark(molly)
-    assert capture == "Woof!"
+    assert dog_bark(molly) == "Woof!"
 
     with pytest.raises(TypeError) as excinfo:
         dog_bark(polly)
     assert msg(excinfo.value) == """
         Incompatible function arguments. The following argument types are supported:
-            1. (arg0: m.Dog) -> None
+            1. (arg0: m.Dog) -> str
             Invoked with: <m.Pet object at 0>
     """
 
 
-def test_callbacks(capture):
+def test_callbacks():
     from functools import partial
     from pybind11_tests import (test_callback1, test_callback2, test_callback3,
                                 test_callback4, test_callback5)
 
     def func1():
-        print('Callback function 1 called!')
+        return "func1"
 
     def func2(a, b, c, d):
-        print('Callback function 2 called : {}, {}, {}, {}'.format(a, b, c, d))
-        return d
+        return "func2", a, b, c, d
 
     def func3(a):
-        print('Callback function 3 called : {}'.format(a))
+        return "func3({})".format(a)
 
-    with capture:
-        assert test_callback1(func1) is False
-    assert capture == "Callback function 1 called!"
-    with capture:
-        assert test_callback2(func2) == 5
-    assert capture == "Callback function 2 called : Hello, x, True, 5"
-    with capture:
-        assert test_callback1(partial(func2, "Hello", "from", "partial", "object")) is False
-    assert capture == "Callback function 2 called : Hello, from, partial, object"
-    with capture:
-        assert test_callback1(partial(func3, "Partial object with one argument")) is False
-    assert capture == "Callback function 3 called : Partial object with one argument"
-    with capture:
-        test_callback3(lambda i: i + 1)
-    assert capture == "func(43) = 44"
+    assert test_callback1(func1) == "func1"
+    assert test_callback2(func2) == ("func2", "Hello", "x", True, 5)
+    assert test_callback1(partial(func2, 1, 2, 3, 4)) == ("func2", 1, 2, 3, 4)
+    assert test_callback1(partial(func3, "partial")) == "func3(partial)"
+    assert test_callback3(lambda i: i + 1) == "func(43) = 44"
 
     f = test_callback4()
     assert f(43) == 44
@@ -82,49 +63,27 @@ def test_lambda_closure_cleanup():
     assert cstats.move_constructions >= 1
 
 
-def test_cpp_function_roundtrip(capture):
+def test_cpp_function_roundtrip():
     """Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer"""
     from pybind11_tests import dummy_function, dummy_function2, test_dummy_function, roundtrip
 
-    with capture:
-        test_dummy_function(dummy_function)
-    assert capture == """
-        argument matches dummy_function
-        eval(1) = 2
-    """
-    with capture:
-        test_dummy_function(roundtrip(dummy_function))
-    assert capture == """
-        roundtrip..
-        argument matches dummy_function
-        eval(1) = 2
-    """
-    with capture:
-        assert roundtrip(None) is None
-    assert capture == "roundtrip (got None).."
-    with capture:
-        test_dummy_function(lambda x: x + 2)
-    assert capture == """
-        could not convert to a function pointer.
-        eval(1) = 3
-    """
+    assert test_dummy_function(dummy_function) == "matches dummy_function: eval(1) = 2"
+    assert test_dummy_function(roundtrip(dummy_function)) == "matches dummy_function: eval(1) = 2"
+    assert roundtrip(None, expect_none=True) is None
+    assert test_dummy_function(lambda x: x + 2) == "can't convert to function pointer: eval(1) = 3"
 
-    with capture:
-        with pytest.raises(TypeError) as excinfo:
-            test_dummy_function(dummy_function2)
-        assert "Incompatible function arguments" in str(excinfo.value)
-    assert capture == "could not convert to a function pointer."
+    with pytest.raises(TypeError) as excinfo:
+        test_dummy_function(dummy_function2)
+    assert "Incompatible function arguments" in str(excinfo.value)
 
-    with capture:
-        with pytest.raises(TypeError) as excinfo:
-            test_dummy_function(lambda x, y: x + y)
-        assert any(s in str(excinfo.value) for s in ("missing 1 required positional argument",
-                                                     "takes exactly 2 arguments"))
-    assert capture == "could not convert to a function pointer."
+    with pytest.raises(TypeError) as excinfo:
+        test_dummy_function(lambda x, y: x + y)
+    assert any(s in str(excinfo.value) for s in ("missing 1 required positional argument",
+                                                 "takes exactly 2 arguments"))
 
 
 def test_function_signatures(doc):
     from pybind11_tests import test_callback3, test_callback4
 
-    assert doc(test_callback3) == "test_callback3(arg0: Callable[[int], int]) -> None"
+    assert doc(test_callback3) == "test_callback3(arg0: Callable[[int], int]) -> str"
     assert doc(test_callback4) == "test_callback4() -> Callable[[int], int]"