2015-07-05 18:05:44 +00:00
|
|
|
/*
|
2016-08-12 11:50:00 +00:00
|
|
|
tests/test_sequences_and_iterators.cpp -- supporting Pythons' sequence protocol, iterators,
|
2015-07-29 15:51:54 +00:00
|
|
|
etc.
|
2015-07-05 18:05:44 +00:00
|
|
|
|
2016-04-17 18:21:41 +00:00
|
|
|
Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
|
2015-07-05 18:05:44 +00:00
|
|
|
|
|
|
|
All rights reserved. Use of this source code is governed by a
|
|
|
|
BSD-style license that can be found in the LICENSE file.
|
|
|
|
*/
|
|
|
|
|
2016-08-12 11:50:00 +00:00
|
|
|
#include "pybind11_tests.h"
|
|
|
|
#include "constructor_stats.h"
|
2015-10-15 16:13:33 +00:00
|
|
|
#include <pybind11/operators.h>
|
|
|
|
#include <pybind11/stl.h>
|
2015-07-05 18:05:44 +00:00
|
|
|
|
2016-08-24 22:30:00 +00:00
|
|
|
template<typename T>
|
|
|
|
class NonZeroIterator {
|
|
|
|
const T* ptr_;
|
|
|
|
public:
|
|
|
|
NonZeroIterator(const T* ptr) : ptr_(ptr) {}
|
|
|
|
const T& operator*() const { return *ptr_; }
|
|
|
|
NonZeroIterator& operator++() { ++ptr_; return *this; }
|
|
|
|
};
|
|
|
|
|
|
|
|
class NonZeroSentinel {};
|
|
|
|
|
|
|
|
template<typename A, typename B>
|
|
|
|
bool operator==(const NonZeroIterator<std::pair<A, B>>& it, const NonZeroSentinel&) {
|
|
|
|
return !(*it).first || !(*it).second;
|
|
|
|
}
|
2016-08-12 01:22:05 +00:00
|
|
|
|
2017-02-09 22:05:33 +00:00
|
|
|
template <typename PythonType>
|
|
|
|
py::list test_random_access_iterator(PythonType x) {
|
|
|
|
if (x.size() < 5)
|
|
|
|
throw py::value_error("Please provide at least 5 elements for testing.");
|
|
|
|
|
|
|
|
auto checks = py::list();
|
|
|
|
auto assert_equal = [&checks](py::handle a, py::handle b) {
|
|
|
|
auto result = PyObject_RichCompareBool(a.ptr(), b.ptr(), Py_EQ);
|
|
|
|
if (result == -1) { throw py::error_already_set(); }
|
|
|
|
checks.append(result != 0);
|
|
|
|
};
|
|
|
|
|
|
|
|
auto it = x.begin();
|
|
|
|
assert_equal(x[0], *it);
|
|
|
|
assert_equal(x[0], it[0]);
|
|
|
|
assert_equal(x[1], it[1]);
|
|
|
|
|
|
|
|
assert_equal(x[1], *(++it));
|
|
|
|
assert_equal(x[1], *(it++));
|
|
|
|
assert_equal(x[2], *it);
|
|
|
|
assert_equal(x[3], *(it += 1));
|
|
|
|
assert_equal(x[2], *(--it));
|
|
|
|
assert_equal(x[2], *(it--));
|
|
|
|
assert_equal(x[1], *it);
|
|
|
|
assert_equal(x[0], *(it -= 1));
|
|
|
|
|
|
|
|
assert_equal(it->attr("real"), x[0].attr("real"));
|
|
|
|
assert_equal((it + 1)->attr("real"), x[1].attr("real"));
|
|
|
|
|
|
|
|
assert_equal(x[1], *(it + 1));
|
|
|
|
assert_equal(x[1], *(1 + it));
|
|
|
|
it += 3;
|
|
|
|
assert_equal(x[1], *(it - 2));
|
|
|
|
|
|
|
|
checks.append(static_cast<std::size_t>(x.end() - x.begin()) == x.size());
|
|
|
|
checks.append((x.begin() + static_cast<std::ptrdiff_t>(x.size())) == x.end());
|
|
|
|
checks.append(x.begin() < x.end());
|
|
|
|
|
|
|
|
return checks;
|
|
|
|
}
|
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
TEST_SUBMODULE(sequences_and_iterators, m) {
|
2018-05-11 18:30:15 +00:00
|
|
|
// test_sliceable
|
|
|
|
class Sliceable{
|
|
|
|
public:
|
|
|
|
Sliceable(int n): size(n) {}
|
|
|
|
int start,stop,step;
|
|
|
|
int size;
|
|
|
|
};
|
|
|
|
py::class_<Sliceable>(m,"Sliceable")
|
|
|
|
.def(py::init<int>())
|
|
|
|
.def("__getitem__",[](const Sliceable &s, py::slice slice) {
|
|
|
|
ssize_t start, stop, step, slicelength;
|
|
|
|
if (!slice.compute(s.size, &start, &stop, &step, &slicelength))
|
|
|
|
throw py::error_already_set();
|
|
|
|
int istart = static_cast<int>(start);
|
|
|
|
int istop = static_cast<int>(stop);
|
|
|
|
int istep = static_cast<int>(step);
|
|
|
|
return std::make_tuple(istart,istop,istep);
|
|
|
|
})
|
|
|
|
;
|
2016-08-24 22:30:00 +00:00
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
// test_sequence
|
|
|
|
class Sequence {
|
|
|
|
public:
|
|
|
|
Sequence(size_t size) : m_size(size) {
|
|
|
|
print_created(this, "of size", m_size);
|
|
|
|
m_data = new float[size];
|
|
|
|
memset(m_data, 0, sizeof(float) * size);
|
|
|
|
}
|
|
|
|
Sequence(const std::vector<float> &value) : m_size(value.size()) {
|
|
|
|
print_created(this, "of size", m_size, "from std::vector");
|
|
|
|
m_data = new float[m_size];
|
|
|
|
memcpy(m_data, &value[0], sizeof(float) * m_size);
|
|
|
|
}
|
|
|
|
Sequence(const Sequence &s) : m_size(s.m_size) {
|
|
|
|
print_copy_created(this);
|
|
|
|
m_data = new float[m_size];
|
|
|
|
memcpy(m_data, s.m_data, sizeof(float)*m_size);
|
|
|
|
}
|
|
|
|
Sequence(Sequence &&s) : m_size(s.m_size), m_data(s.m_data) {
|
|
|
|
print_move_created(this);
|
|
|
|
s.m_size = 0;
|
|
|
|
s.m_data = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
~Sequence() { print_destroyed(this); delete[] m_data; }
|
|
|
|
|
|
|
|
Sequence &operator=(const Sequence &s) {
|
|
|
|
if (&s != this) {
|
|
|
|
delete[] m_data;
|
|
|
|
m_size = s.m_size;
|
|
|
|
m_data = new float[m_size];
|
|
|
|
memcpy(m_data, s.m_data, sizeof(float)*m_size);
|
|
|
|
}
|
|
|
|
print_copy_assigned(this);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
Sequence &operator=(Sequence &&s) {
|
|
|
|
if (&s != this) {
|
|
|
|
delete[] m_data;
|
|
|
|
m_size = s.m_size;
|
|
|
|
m_data = s.m_data;
|
|
|
|
s.m_size = 0;
|
|
|
|
s.m_data = nullptr;
|
|
|
|
}
|
|
|
|
print_move_assigned(this);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool operator==(const Sequence &s) const {
|
|
|
|
if (m_size != s.size()) return false;
|
|
|
|
for (size_t i = 0; i < m_size; ++i)
|
|
|
|
if (m_data[i] != s[i])
|
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
bool operator!=(const Sequence &s) const { return !operator==(s); }
|
|
|
|
|
|
|
|
float operator[](size_t index) const { return m_data[index]; }
|
|
|
|
float &operator[](size_t index) { return m_data[index]; }
|
2015-07-05 18:05:44 +00:00
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
bool contains(float v) const {
|
|
|
|
for (size_t i = 0; i < m_size; ++i)
|
|
|
|
if (v == m_data[i])
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Sequence reversed() const {
|
|
|
|
Sequence result(m_size);
|
|
|
|
for (size_t i = 0; i < m_size; ++i)
|
|
|
|
result[m_size - i - 1] = m_data[i];
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
size_t size() const { return m_size; }
|
|
|
|
|
|
|
|
const float *begin() const { return m_data; }
|
|
|
|
const float *end() const { return m_data+m_size; }
|
|
|
|
|
|
|
|
private:
|
|
|
|
size_t m_size;
|
|
|
|
float *m_data;
|
|
|
|
};
|
|
|
|
py::class_<Sequence>(m, "Sequence")
|
|
|
|
.def(py::init<size_t>())
|
|
|
|
.def(py::init<const std::vector<float>&>())
|
|
|
|
/// Bare bones interface
|
|
|
|
.def("__getitem__", [](const Sequence &s, size_t i) {
|
|
|
|
if (i >= s.size()) throw py::index_error();
|
2015-07-05 18:05:44 +00:00
|
|
|
return s[i];
|
|
|
|
})
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
.def("__setitem__", [](Sequence &s, size_t i, float v) {
|
|
|
|
if (i >= s.size()) throw py::index_error();
|
2015-07-05 18:05:44 +00:00
|
|
|
s[i] = v;
|
|
|
|
})
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
.def("__len__", &Sequence::size)
|
|
|
|
/// Optional sequence protocol operations
|
|
|
|
.def("__iter__", [](const Sequence &s) { return py::make_iterator(s.begin(), s.end()); },
|
|
|
|
py::keep_alive<0, 1>() /* Essential: keep object alive while iterator exists */)
|
|
|
|
.def("__contains__", [](const Sequence &s, float v) { return s.contains(v); })
|
|
|
|
.def("__reversed__", [](const Sequence &s) -> Sequence { return s.reversed(); })
|
|
|
|
/// Slicing protocol (optional)
|
|
|
|
.def("__getitem__", [](const Sequence &s, py::slice slice) -> Sequence* {
|
2016-05-29 11:40:40 +00:00
|
|
|
size_t start, stop, step, slicelength;
|
2015-07-05 18:05:44 +00:00
|
|
|
if (!slice.compute(s.size(), &start, &stop, &step, &slicelength))
|
|
|
|
throw py::error_already_set();
|
|
|
|
Sequence *seq = new Sequence(slicelength);
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
for (size_t i = 0; i < slicelength; ++i) {
|
2015-07-05 18:05:44 +00:00
|
|
|
(*seq)[i] = s[start]; start += step;
|
|
|
|
}
|
|
|
|
return seq;
|
|
|
|
})
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
.def("__setitem__", [](Sequence &s, py::slice slice, const Sequence &value) {
|
2016-05-29 11:40:40 +00:00
|
|
|
size_t start, stop, step, slicelength;
|
2015-07-05 18:05:44 +00:00
|
|
|
if (!slice.compute(s.size(), &start, &stop, &step, &slicelength))
|
|
|
|
throw py::error_already_set();
|
2016-05-29 11:40:40 +00:00
|
|
|
if (slicelength != value.size())
|
2015-07-05 18:05:44 +00:00
|
|
|
throw std::runtime_error("Left and right hand size of slice assignment have different sizes!");
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
for (size_t i = 0; i < slicelength; ++i) {
|
2015-07-05 18:05:44 +00:00
|
|
|
s[start] = value[i]; start += step;
|
|
|
|
}
|
|
|
|
})
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
/// Comparisons
|
|
|
|
.def(py::self == py::self)
|
|
|
|
.def(py::self != py::self)
|
|
|
|
// Could also define py::self + py::self for concatenation, etc.
|
|
|
|
;
|
2016-08-12 01:22:05 +00:00
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
// test_map_iterator
|
|
|
|
// Interface of a map-like object that isn't (directly) an unordered_map, but provides some basic
|
|
|
|
// map-like functionality.
|
|
|
|
class StringMap {
|
|
|
|
public:
|
|
|
|
StringMap() = default;
|
|
|
|
StringMap(std::unordered_map<std::string, std::string> init)
|
|
|
|
: map(std::move(init)) {}
|
|
|
|
|
|
|
|
void set(std::string key, std::string val) { map[key] = val; }
|
|
|
|
std::string get(std::string key) const { return map.at(key); }
|
|
|
|
size_t size() const { return map.size(); }
|
|
|
|
private:
|
|
|
|
std::unordered_map<std::string, std::string> map;
|
|
|
|
public:
|
|
|
|
decltype(map.cbegin()) begin() const { return map.cbegin(); }
|
|
|
|
decltype(map.cend()) end() const { return map.cend(); }
|
|
|
|
};
|
|
|
|
py::class_<StringMap>(m, "StringMap")
|
|
|
|
.def(py::init<>())
|
2016-08-12 01:22:05 +00:00
|
|
|
.def(py::init<std::unordered_map<std::string, std::string>>())
|
|
|
|
.def("__getitem__", [](const StringMap &map, std::string key) {
|
|
|
|
try { return map.get(key); }
|
|
|
|
catch (const std::out_of_range&) {
|
|
|
|
throw py::key_error("key '" + key + "' does not exist");
|
|
|
|
}
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
})
|
2016-08-12 01:22:05 +00:00
|
|
|
.def("__setitem__", &StringMap::set)
|
|
|
|
.def("__len__", &StringMap::size)
|
|
|
|
.def("__iter__", [](const StringMap &map) { return py::make_key_iterator(map.begin(), map.end()); },
|
|
|
|
py::keep_alive<0, 1>())
|
|
|
|
.def("items", [](const StringMap &map) { return py::make_iterator(map.begin(), map.end()); },
|
|
|
|
py::keep_alive<0, 1>())
|
|
|
|
;
|
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
// test_generalized_iterators
|
|
|
|
class IntPairs {
|
|
|
|
public:
|
|
|
|
IntPairs(std::vector<std::pair<int, int>> data) : data_(std::move(data)) {}
|
|
|
|
const std::pair<int, int>* begin() const { return data_.data(); }
|
|
|
|
private:
|
|
|
|
std::vector<std::pair<int, int>> data_;
|
|
|
|
};
|
2016-08-24 22:30:00 +00:00
|
|
|
py::class_<IntPairs>(m, "IntPairs")
|
|
|
|
.def(py::init<std::vector<std::pair<int, int>>>())
|
|
|
|
.def("nonzero", [](const IntPairs& s) {
|
|
|
|
return py::make_iterator(NonZeroIterator<std::pair<int, int>>(s.begin()), NonZeroSentinel());
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
}, py::keep_alive<0, 1>())
|
2016-08-24 22:30:00 +00:00
|
|
|
.def("nonzero_keys", [](const IntPairs& s) {
|
|
|
|
return py::make_key_iterator(NonZeroIterator<std::pair<int, int>>(s.begin()), NonZeroSentinel());
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
}, py::keep_alive<0, 1>())
|
|
|
|
;
|
2016-08-24 22:30:00 +00:00
|
|
|
|
2016-08-12 01:22:05 +00:00
|
|
|
|
2016-04-13 21:33:00 +00:00
|
|
|
#if 0
|
|
|
|
// Obsolete: special data structure for exposing custom iterator types to python
|
|
|
|
// kept here for illustrative purposes because there might be some use cases which
|
|
|
|
// are not covered by the much simpler py::make_iterator
|
|
|
|
|
|
|
|
struct PySequenceIterator {
|
|
|
|
PySequenceIterator(const Sequence &seq, py::object ref) : seq(seq), ref(ref) { }
|
|
|
|
|
|
|
|
float next() {
|
|
|
|
if (index == seq.size())
|
|
|
|
throw py::stop_iteration();
|
|
|
|
return seq[index++];
|
|
|
|
}
|
|
|
|
|
|
|
|
const Sequence &seq;
|
|
|
|
py::object ref; // keep a reference
|
|
|
|
size_t index = 0;
|
|
|
|
};
|
|
|
|
|
2015-07-05 18:05:44 +00:00
|
|
|
py::class_<PySequenceIterator>(seq, "Iterator")
|
|
|
|
.def("__iter__", [](PySequenceIterator &it) -> PySequenceIterator& { return it; })
|
|
|
|
.def("__next__", &PySequenceIterator::next);
|
2016-04-13 21:33:00 +00:00
|
|
|
|
|
|
|
On the actual Sequence object, the iterator would be constructed as follows:
|
|
|
|
.def("__iter__", [](py::object s) { return PySequenceIterator(s.cast<const Sequence &>(), s); })
|
|
|
|
#endif
|
2017-02-08 13:31:49 +00:00
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
// test_python_iterator_in_cpp
|
2017-02-08 13:31:49 +00:00
|
|
|
m.def("object_to_list", [](py::object o) {
|
|
|
|
auto l = py::list();
|
|
|
|
for (auto item : o) {
|
|
|
|
l.append(item);
|
|
|
|
}
|
|
|
|
return l;
|
|
|
|
});
|
|
|
|
|
|
|
|
m.def("iterator_to_list", [](py::iterator it) {
|
|
|
|
auto l = py::list();
|
|
|
|
while (it != py::iterator::sentinel()) {
|
|
|
|
l.append(*it);
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
return l;
|
|
|
|
});
|
2017-02-09 11:08:14 +00:00
|
|
|
|
|
|
|
// Make sure that py::iterator works with std algorithms
|
|
|
|
m.def("count_none", [](py::object o) {
|
|
|
|
return std::count_if(o.begin(), o.end(), [](py::handle h) { return h.is_none(); });
|
|
|
|
});
|
|
|
|
|
|
|
|
m.def("find_none", [](py::object o) {
|
|
|
|
auto it = std::find_if(o.begin(), o.end(), [](py::handle h) { return h.is_none(); });
|
|
|
|
return it->is_none();
|
|
|
|
});
|
2017-02-09 22:05:33 +00:00
|
|
|
|
|
|
|
m.def("count_nonzeros", [](py::dict d) {
|
|
|
|
return std::count_if(d.begin(), d.end(), [](std::pair<py::handle, py::handle> p) {
|
|
|
|
return p.second.cast<int>() != 0;
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
m.def("tuple_iterator", &test_random_access_iterator<py::tuple>);
|
|
|
|
m.def("list_iterator", &test_random_access_iterator<py::list>);
|
|
|
|
m.def("sequence_iterator", &test_random_access_iterator<py::sequence>);
|
2017-06-07 14:52:50 +00:00
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
// test_iterator_passthrough
|
2017-06-07 14:52:50 +00:00
|
|
|
// #181: iterator passthrough did not compile
|
|
|
|
m.def("iterator_passthrough", [](py::iterator s) -> py::iterator {
|
|
|
|
return py::make_iterator(std::begin(s), std::end(s));
|
|
|
|
});
|
|
|
|
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
// test_iterator_rvp
|
2017-06-07 14:52:50 +00:00
|
|
|
// #388: Can't make iterators via make_iterator() with different r/v policies
|
|
|
|
static std::vector<int> list = { 1, 2, 3 };
|
|
|
|
m.def("make_iterator_1", []() { return py::make_iterator<py::return_value_policy::copy>(list); });
|
|
|
|
m.def("make_iterator_2", []() { return py::make_iterator<py::return_value_policy::automatic>(list); });
|
Update all remaining tests to new test styles
This udpates all the remaining tests to the new test suite code and
comment styles started in #898. For the most part, the test coverage
here is unchanged, with a few minor exceptions as noted below.
- test_constants_and_functions: this adds more overload tests with
overloads with different number of arguments for more comprehensive
overload_cast testing. The test style conversion broke the overload
tests under MSVC 2015, prompting the additional tests while looking
for a workaround.
- test_eigen: this dropped the unused functions `get_cm_corners` and
`get_cm_corners_const`--these same tests were duplicates of the same
things provided (and used) via ReturnTester methods.
- test_opaque_types: this test had a hidden dependence on ExampleMandA
which is now fixed by using the global UserType which suffices for the
relevant test.
- test_methods_and_attributes: this required some additions to UserType
to make it usable as a replacement for the test's previous SimpleType:
UserType gained a value mutator, and the `value` property is not
mutable (it was previously readonly). Some overload tests were also
added to better test overload_cast (as described above).
- test_numpy_array: removed the untemplated mutate_data/mutate_data_t:
the templated versions with an empty parameter pack expand to the same
thing.
- test_stl: this was already mostly in the new style; this just tweaks
things a bit, localizing a class, and adding some missing
`// test_whatever` comments.
- test_virtual_functions: like `test_stl`, this was mostly in the new
test style already, but needed some `// test_whatever` comments.
This commit also moves the inherited virtual example code to the end
of the file, after the main set of tests (since it is less important
than the other tests, and rather length); it also got renamed to
`test_inherited_virtuals` (from `test_inheriting_repeat`) because it
tests both inherited virtual approaches, not just the repeat approach.
2017-07-25 20:47:36 +00:00
|
|
|
}
|