112391Sjason@lowepower.com/* 212391Sjason@lowepower.com tests/test_pytypes.cpp -- Python type casters 312391Sjason@lowepower.com 412391Sjason@lowepower.com Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch> 512391Sjason@lowepower.com 612391Sjason@lowepower.com All rights reserved. Use of this source code is governed by a 712391Sjason@lowepower.com BSD-style license that can be found in the LICENSE file. 812391Sjason@lowepower.com*/ 912391Sjason@lowepower.com 1012391Sjason@lowepower.com#include "pybind11_tests.h" 1112391Sjason@lowepower.com 1212391Sjason@lowepower.com 1312391Sjason@lowepower.comTEST_SUBMODULE(pytypes, m) { 1412391Sjason@lowepower.com // test_list 1512391Sjason@lowepower.com m.def("get_list", []() { 1612391Sjason@lowepower.com py::list list; 1712391Sjason@lowepower.com list.append("value"); 1812391Sjason@lowepower.com py::print("Entry at position 0:", list[0]); 1912391Sjason@lowepower.com list[0] = py::str("overwritten"); 2014299Sbbruce@ucdavis.edu list.insert(0, "inserted-0"); 2114299Sbbruce@ucdavis.edu list.insert(2, "inserted-2"); 2212391Sjason@lowepower.com return list; 2312391Sjason@lowepower.com }); 2412391Sjason@lowepower.com m.def("print_list", [](py::list list) { 2512391Sjason@lowepower.com int index = 0; 2612391Sjason@lowepower.com for (auto item : list) 2712391Sjason@lowepower.com py::print("list item {}: {}"_s.format(index++, item)); 2812391Sjason@lowepower.com }); 2912391Sjason@lowepower.com 3012391Sjason@lowepower.com // test_set 3112391Sjason@lowepower.com m.def("get_set", []() { 3212391Sjason@lowepower.com py::set set; 3312391Sjason@lowepower.com set.add(py::str("key1")); 3412391Sjason@lowepower.com set.add("key2"); 3512391Sjason@lowepower.com set.add(std::string("key3")); 3612391Sjason@lowepower.com return set; 3712391Sjason@lowepower.com }); 3812391Sjason@lowepower.com m.def("print_set", [](py::set set) { 3912391Sjason@lowepower.com for (auto item : set) 4012391Sjason@lowepower.com py::print("key:", item); 4112391Sjason@lowepower.com }); 4214299Sbbruce@ucdavis.edu m.def("set_contains", [](py::set set, py::object key) { 4314299Sbbruce@ucdavis.edu return set.contains(key); 4414299Sbbruce@ucdavis.edu }); 4514299Sbbruce@ucdavis.edu m.def("set_contains", [](py::set set, const char* key) { 4614299Sbbruce@ucdavis.edu return set.contains(key); 4714299Sbbruce@ucdavis.edu }); 4812391Sjason@lowepower.com 4912391Sjason@lowepower.com // test_dict 5012391Sjason@lowepower.com m.def("get_dict", []() { return py::dict("key"_a="value"); }); 5112391Sjason@lowepower.com m.def("print_dict", [](py::dict dict) { 5212391Sjason@lowepower.com for (auto item : dict) 5312391Sjason@lowepower.com py::print("key: {}, value={}"_s.format(item.first, item.second)); 5412391Sjason@lowepower.com }); 5512391Sjason@lowepower.com m.def("dict_keyword_constructor", []() { 5612391Sjason@lowepower.com auto d1 = py::dict("x"_a=1, "y"_a=2); 5712391Sjason@lowepower.com auto d2 = py::dict("z"_a=3, **d1); 5812391Sjason@lowepower.com return d2; 5912391Sjason@lowepower.com }); 6014299Sbbruce@ucdavis.edu m.def("dict_contains", [](py::dict dict, py::object val) { 6114299Sbbruce@ucdavis.edu return dict.contains(val); 6214299Sbbruce@ucdavis.edu }); 6314299Sbbruce@ucdavis.edu m.def("dict_contains", [](py::dict dict, const char* val) { 6414299Sbbruce@ucdavis.edu return dict.contains(val); 6514299Sbbruce@ucdavis.edu }); 6612391Sjason@lowepower.com 6712391Sjason@lowepower.com // test_str 6812391Sjason@lowepower.com m.def("str_from_string", []() { return py::str(std::string("baz")); }); 6912391Sjason@lowepower.com m.def("str_from_bytes", []() { return py::str(py::bytes("boo", 3)); }); 7012391Sjason@lowepower.com m.def("str_from_object", [](const py::object& obj) { return py::str(obj); }); 7112391Sjason@lowepower.com m.def("repr_from_object", [](const py::object& obj) { return py::repr(obj); }); 7212391Sjason@lowepower.com 7312391Sjason@lowepower.com m.def("str_format", []() { 7412391Sjason@lowepower.com auto s1 = "{} + {} = {}"_s.format(1, 2, 3); 7512391Sjason@lowepower.com auto s2 = "{a} + {b} = {c}"_s.format("a"_a=1, "b"_a=2, "c"_a=3); 7612391Sjason@lowepower.com return py::make_tuple(s1, s2); 7712391Sjason@lowepower.com }); 7812391Sjason@lowepower.com 7912391Sjason@lowepower.com // test_bytes 8012391Sjason@lowepower.com m.def("bytes_from_string", []() { return py::bytes(std::string("foo")); }); 8112391Sjason@lowepower.com m.def("bytes_from_str", []() { return py::bytes(py::str("bar", 3)); }); 8212391Sjason@lowepower.com 8312391Sjason@lowepower.com // test_capsule 8412391Sjason@lowepower.com m.def("return_capsule_with_destructor", []() { 8512391Sjason@lowepower.com py::print("creating capsule"); 8612391Sjason@lowepower.com return py::capsule([]() { 8712391Sjason@lowepower.com py::print("destructing capsule"); 8812391Sjason@lowepower.com }); 8912391Sjason@lowepower.com }); 9012391Sjason@lowepower.com 9112391Sjason@lowepower.com m.def("return_capsule_with_destructor_2", []() { 9212391Sjason@lowepower.com py::print("creating capsule"); 9312391Sjason@lowepower.com return py::capsule((void *) 1234, [](void *ptr) { 9412391Sjason@lowepower.com py::print("destructing capsule: {}"_s.format((size_t) ptr)); 9512391Sjason@lowepower.com }); 9612391Sjason@lowepower.com }); 9712391Sjason@lowepower.com 9812391Sjason@lowepower.com m.def("return_capsule_with_name_and_destructor", []() { 9912391Sjason@lowepower.com auto capsule = py::capsule((void *) 1234, "pointer type description", [](PyObject *ptr) { 10012391Sjason@lowepower.com if (ptr) { 10112391Sjason@lowepower.com auto name = PyCapsule_GetName(ptr); 10212391Sjason@lowepower.com py::print("destructing capsule ({}, '{}')"_s.format( 10312391Sjason@lowepower.com (size_t) PyCapsule_GetPointer(ptr, name), name 10412391Sjason@lowepower.com )); 10512391Sjason@lowepower.com } 10612391Sjason@lowepower.com }); 10712391Sjason@lowepower.com void *contents = capsule; 10812391Sjason@lowepower.com py::print("created capsule ({}, '{}')"_s.format((size_t) contents, capsule.name())); 10912391Sjason@lowepower.com return capsule; 11012391Sjason@lowepower.com }); 11112391Sjason@lowepower.com 11212391Sjason@lowepower.com // test_accessors 11312391Sjason@lowepower.com m.def("accessor_api", [](py::object o) { 11412391Sjason@lowepower.com auto d = py::dict(); 11512391Sjason@lowepower.com 11612391Sjason@lowepower.com d["basic_attr"] = o.attr("basic_attr"); 11712391Sjason@lowepower.com 11812391Sjason@lowepower.com auto l = py::list(); 11912391Sjason@lowepower.com for (const auto &item : o.attr("begin_end")) { 12012391Sjason@lowepower.com l.append(item); 12112391Sjason@lowepower.com } 12212391Sjason@lowepower.com d["begin_end"] = l; 12312391Sjason@lowepower.com 12412391Sjason@lowepower.com d["operator[object]"] = o.attr("d")["operator[object]"_s]; 12512391Sjason@lowepower.com d["operator[char *]"] = o.attr("d")["operator[char *]"]; 12612391Sjason@lowepower.com 12712391Sjason@lowepower.com d["attr(object)"] = o.attr("sub").attr("attr_obj"); 12812391Sjason@lowepower.com d["attr(char *)"] = o.attr("sub").attr("attr_char"); 12912391Sjason@lowepower.com try { 13012391Sjason@lowepower.com o.attr("sub").attr("missing").ptr(); 13112391Sjason@lowepower.com } catch (const py::error_already_set &) { 13212391Sjason@lowepower.com d["missing_attr_ptr"] = "raised"_s; 13312391Sjason@lowepower.com } 13412391Sjason@lowepower.com try { 13512391Sjason@lowepower.com o.attr("missing").attr("doesn't matter"); 13612391Sjason@lowepower.com } catch (const py::error_already_set &) { 13712391Sjason@lowepower.com d["missing_attr_chain"] = "raised"_s; 13812391Sjason@lowepower.com } 13912391Sjason@lowepower.com 14012391Sjason@lowepower.com d["is_none"] = o.attr("basic_attr").is_none(); 14112391Sjason@lowepower.com 14212391Sjason@lowepower.com d["operator()"] = o.attr("func")(1); 14312391Sjason@lowepower.com d["operator*"] = o.attr("func")(*o.attr("begin_end")); 14412391Sjason@lowepower.com 14512391Sjason@lowepower.com // Test implicit conversion 14612391Sjason@lowepower.com py::list implicit_list = o.attr("begin_end"); 14712391Sjason@lowepower.com d["implicit_list"] = implicit_list; 14812391Sjason@lowepower.com py::dict implicit_dict = o.attr("__dict__"); 14912391Sjason@lowepower.com d["implicit_dict"] = implicit_dict; 15012391Sjason@lowepower.com 15112391Sjason@lowepower.com return d; 15212391Sjason@lowepower.com }); 15312391Sjason@lowepower.com 15412391Sjason@lowepower.com m.def("tuple_accessor", [](py::tuple existing_t) { 15512391Sjason@lowepower.com try { 15612391Sjason@lowepower.com existing_t[0] = 1; 15712391Sjason@lowepower.com } catch (const py::error_already_set &) { 15812391Sjason@lowepower.com // --> Python system error 15912391Sjason@lowepower.com // Only new tuples (refcount == 1) are mutable 16012391Sjason@lowepower.com auto new_t = py::tuple(3); 16112391Sjason@lowepower.com for (size_t i = 0; i < new_t.size(); ++i) { 16212391Sjason@lowepower.com new_t[i] = i; 16312391Sjason@lowepower.com } 16412391Sjason@lowepower.com return new_t; 16512391Sjason@lowepower.com } 16612391Sjason@lowepower.com return py::tuple(); 16712391Sjason@lowepower.com }); 16812391Sjason@lowepower.com 16912391Sjason@lowepower.com m.def("accessor_assignment", []() { 17012391Sjason@lowepower.com auto l = py::list(1); 17112391Sjason@lowepower.com l[0] = 0; 17212391Sjason@lowepower.com 17312391Sjason@lowepower.com auto d = py::dict(); 17412391Sjason@lowepower.com d["get"] = l[0]; 17512391Sjason@lowepower.com auto var = l[0]; 17612391Sjason@lowepower.com d["deferred_get"] = var; 17712391Sjason@lowepower.com l[0] = 1; 17812391Sjason@lowepower.com d["set"] = l[0]; 17912391Sjason@lowepower.com var = 99; // this assignment should not overwrite l[0] 18012391Sjason@lowepower.com d["deferred_set"] = l[0]; 18112391Sjason@lowepower.com d["var"] = var; 18212391Sjason@lowepower.com 18312391Sjason@lowepower.com return d; 18412391Sjason@lowepower.com }); 18512391Sjason@lowepower.com 18612391Sjason@lowepower.com // test_constructors 18712391Sjason@lowepower.com m.def("default_constructors", []() { 18812391Sjason@lowepower.com return py::dict( 18912391Sjason@lowepower.com "str"_a=py::str(), 19012391Sjason@lowepower.com "bool"_a=py::bool_(), 19112391Sjason@lowepower.com "int"_a=py::int_(), 19212391Sjason@lowepower.com "float"_a=py::float_(), 19312391Sjason@lowepower.com "tuple"_a=py::tuple(), 19412391Sjason@lowepower.com "list"_a=py::list(), 19512391Sjason@lowepower.com "dict"_a=py::dict(), 19612391Sjason@lowepower.com "set"_a=py::set() 19712391Sjason@lowepower.com ); 19812391Sjason@lowepower.com }); 19912391Sjason@lowepower.com 20012391Sjason@lowepower.com m.def("converting_constructors", [](py::dict d) { 20112391Sjason@lowepower.com return py::dict( 20212391Sjason@lowepower.com "str"_a=py::str(d["str"]), 20312391Sjason@lowepower.com "bool"_a=py::bool_(d["bool"]), 20412391Sjason@lowepower.com "int"_a=py::int_(d["int"]), 20512391Sjason@lowepower.com "float"_a=py::float_(d["float"]), 20612391Sjason@lowepower.com "tuple"_a=py::tuple(d["tuple"]), 20712391Sjason@lowepower.com "list"_a=py::list(d["list"]), 20812391Sjason@lowepower.com "dict"_a=py::dict(d["dict"]), 20912391Sjason@lowepower.com "set"_a=py::set(d["set"]), 21012391Sjason@lowepower.com "memoryview"_a=py::memoryview(d["memoryview"]) 21112391Sjason@lowepower.com ); 21212391Sjason@lowepower.com }); 21312391Sjason@lowepower.com 21412391Sjason@lowepower.com m.def("cast_functions", [](py::dict d) { 21512391Sjason@lowepower.com // When converting between Python types, obj.cast<T>() should be the same as T(obj) 21612391Sjason@lowepower.com return py::dict( 21712391Sjason@lowepower.com "str"_a=d["str"].cast<py::str>(), 21812391Sjason@lowepower.com "bool"_a=d["bool"].cast<py::bool_>(), 21912391Sjason@lowepower.com "int"_a=d["int"].cast<py::int_>(), 22012391Sjason@lowepower.com "float"_a=d["float"].cast<py::float_>(), 22112391Sjason@lowepower.com "tuple"_a=d["tuple"].cast<py::tuple>(), 22212391Sjason@lowepower.com "list"_a=d["list"].cast<py::list>(), 22312391Sjason@lowepower.com "dict"_a=d["dict"].cast<py::dict>(), 22412391Sjason@lowepower.com "set"_a=d["set"].cast<py::set>(), 22512391Sjason@lowepower.com "memoryview"_a=d["memoryview"].cast<py::memoryview>() 22612391Sjason@lowepower.com ); 22712391Sjason@lowepower.com }); 22812391Sjason@lowepower.com 22912391Sjason@lowepower.com m.def("get_implicit_casting", []() { 23012391Sjason@lowepower.com py::dict d; 23112391Sjason@lowepower.com d["char*_i1"] = "abc"; 23212391Sjason@lowepower.com const char *c2 = "abc"; 23312391Sjason@lowepower.com d["char*_i2"] = c2; 23412391Sjason@lowepower.com d["char*_e"] = py::cast(c2); 23512391Sjason@lowepower.com d["char*_p"] = py::str(c2); 23612391Sjason@lowepower.com 23712391Sjason@lowepower.com d["int_i1"] = 42; 23812391Sjason@lowepower.com int i = 42; 23912391Sjason@lowepower.com d["int_i2"] = i; 24012391Sjason@lowepower.com i++; 24112391Sjason@lowepower.com d["int_e"] = py::cast(i); 24212391Sjason@lowepower.com i++; 24312391Sjason@lowepower.com d["int_p"] = py::int_(i); 24412391Sjason@lowepower.com 24512391Sjason@lowepower.com d["str_i1"] = std::string("str"); 24612391Sjason@lowepower.com std::string s2("str1"); 24712391Sjason@lowepower.com d["str_i2"] = s2; 24812391Sjason@lowepower.com s2[3] = '2'; 24912391Sjason@lowepower.com d["str_e"] = py::cast(s2); 25012391Sjason@lowepower.com s2[3] = '3'; 25112391Sjason@lowepower.com d["str_p"] = py::str(s2); 25212391Sjason@lowepower.com 25312391Sjason@lowepower.com py::list l(2); 25412391Sjason@lowepower.com l[0] = 3; 25512391Sjason@lowepower.com l[1] = py::cast(6); 25612391Sjason@lowepower.com l.append(9); 25712391Sjason@lowepower.com l.append(py::cast(12)); 25812391Sjason@lowepower.com l.append(py::int_(15)); 25912391Sjason@lowepower.com 26012391Sjason@lowepower.com return py::dict( 26112391Sjason@lowepower.com "d"_a=d, 26212391Sjason@lowepower.com "l"_a=l 26312391Sjason@lowepower.com ); 26412391Sjason@lowepower.com }); 26512391Sjason@lowepower.com 26612391Sjason@lowepower.com // test_print 26712391Sjason@lowepower.com m.def("print_function", []() { 26812391Sjason@lowepower.com py::print("Hello, World!"); 26912391Sjason@lowepower.com py::print(1, 2.0, "three", true, std::string("-- multiple args")); 27012391Sjason@lowepower.com auto args = py::make_tuple("and", "a", "custom", "separator"); 27112391Sjason@lowepower.com py::print("*args", *args, "sep"_a="-"); 27212391Sjason@lowepower.com py::print("no new line here", "end"_a=" -- "); 27312391Sjason@lowepower.com py::print("next print"); 27412391Sjason@lowepower.com 27512391Sjason@lowepower.com auto py_stderr = py::module::import("sys").attr("stderr"); 27612391Sjason@lowepower.com py::print("this goes to stderr", "file"_a=py_stderr); 27712391Sjason@lowepower.com 27812391Sjason@lowepower.com py::print("flush", "flush"_a=true); 27912391Sjason@lowepower.com 28012391Sjason@lowepower.com py::print("{a} + {b} = {c}"_s.format("a"_a="py::print", "b"_a="str.format", "c"_a="this")); 28112391Sjason@lowepower.com }); 28212391Sjason@lowepower.com 28312391Sjason@lowepower.com m.def("print_failure", []() { py::print(42, UnregisteredType()); }); 28412391Sjason@lowepower.com 28512391Sjason@lowepower.com m.def("hash_function", [](py::object obj) { return py::hash(obj); }); 28614299Sbbruce@ucdavis.edu 28714299Sbbruce@ucdavis.edu m.def("test_number_protocol", [](py::object a, py::object b) { 28814299Sbbruce@ucdavis.edu py::list l; 28914299Sbbruce@ucdavis.edu l.append(a.equal(b)); 29014299Sbbruce@ucdavis.edu l.append(a.not_equal(b)); 29114299Sbbruce@ucdavis.edu l.append(a < b); 29214299Sbbruce@ucdavis.edu l.append(a <= b); 29314299Sbbruce@ucdavis.edu l.append(a > b); 29414299Sbbruce@ucdavis.edu l.append(a >= b); 29514299Sbbruce@ucdavis.edu l.append(a + b); 29614299Sbbruce@ucdavis.edu l.append(a - b); 29714299Sbbruce@ucdavis.edu l.append(a * b); 29814299Sbbruce@ucdavis.edu l.append(a / b); 29914299Sbbruce@ucdavis.edu l.append(a | b); 30014299Sbbruce@ucdavis.edu l.append(a & b); 30114299Sbbruce@ucdavis.edu l.append(a ^ b); 30214299Sbbruce@ucdavis.edu l.append(a >> b); 30314299Sbbruce@ucdavis.edu l.append(a << b); 30414299Sbbruce@ucdavis.edu return l; 30514299Sbbruce@ucdavis.edu }); 30614299Sbbruce@ucdavis.edu 30714299Sbbruce@ucdavis.edu m.def("test_list_slicing", [](py::list a) { 30814299Sbbruce@ucdavis.edu return a[py::slice(0, -1, 2)]; 30914299Sbbruce@ucdavis.edu }); 31012391Sjason@lowepower.com} 311