{

Y(int v) : test_class<1>(v) {}

Y& operator=(Y const& rhs) { x = rhs.x; return *this; }

bool q;

{

VarBase(std::string name_) : name(name_) {}

std::string const name;

std::string get_name1() const { return name; }

{

Var(std::string name_) : VarBase(name_), value(), name2(name.c_str()), y(6) {}

std::string const& get_name2() const { return name; }

float value;

char const* name2;

Y y;

static int static1;

static Y static2;

{

trivial() : value(123) {}

double value;

{

class_<trivial>("trivial")

.add_property("property", make_getter(&trivial::value, return_value_policy<return_by_value>()))

.def_readonly("readonly", &trivial::value)

;

class_< Color3 >("Color3", init< const Color3 & >())

.def_readonly("BLACK", &Color3::black) // line 17

;

{

using namespace boost_python_test;

class_<X>("X", init<int>())

.def("value", &X::value)

.def("set", &X::set)

.def_readonly("x", &X::x)

.add_property("fair_value", get_fair_value)

;

class_<Y>("Y", init<int>())

.def("value", &Y::value)

.def("set", &Y::set)

.def_readwrite("x", &Y::x)

.def_readwrite("q", &Y::q)

;

class_<Var>("Var", init<std::string>())

.def_readonly("name", &Var::name)

.def_readonly("name2", &Var::name2)

.def_readwrite("value", &Var::value)

.def_readonly("y", &Var::y)

// Test return_by_value for plain values and for

// pointers... return_by_value was implemented as a

// side-effect of implementing data member support, so it made

// sense to add the test here.

.def("get_name1", &Var::get_name1, return_value_policy<return_by_value>())

.def("get_name2", &Var::get_name2, return_value_policy<return_by_value>())

.add_property("name3", &Var::get_name1)

// Test static data members

.def_readonly("ro1a", &Var::static1)

.def_readonly("ro1b", Var::static1)

.def_readwrite("rw1a", &Var::static1)

.def_readwrite("rw1b", Var::static1)

.def_readonly("ro2a", &Var::static2)

.def_readonly("ro2b", Var::static2)

.def_readwrite("rw2a", &Var::static2)

.def_readwrite("rw2b", Var::static2)

;