text: // Copyright (c) 2004 Daniel Wallin and Arvid Norberg
  
  // Permission is hereby granted, free of charge, to any person obtaining a
  // copy of this software and associated documentation files (the "Software"),
  // to deal in the Software without restriction, including without limitation
  // the rights to use, copy, modify, merge, publish, distribute, sublicense,
  // and/or sell copies of the Software, and to permit persons to whom the
  // Software is furnished to do so, subject to the following conditions:
  
  // The above copyright notice and this permission notice shall be included
  // in all copies or substantial portions of the Software.
  
  // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
  // ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
  // TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  // PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
  // SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
  // ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
  // OR OTHER DEALINGS IN THE SOFTWARE.
  
  #include "test.hpp"
  #include <luabind/luabind.hpp>
  
  namespace
  {
  	int f() { return 1; }
  	int f_(int a) { return 2; }
  	int f__(int a) { return 3; }
  	int g() { return 4; }
  	int g_(int)	{ return 5; }
  	int h() { return 6; }
  
  	struct test_class : counted_type<test_class>
  	{
  		test_class()
  			: test(1)
  		{}
  		int test;
  	};
  
  	struct test_class2 : counted_type<test_class2>
  	{
  		test_class2() {}
  		int string_string(string_class const& s1, string_class const& s2)
  		{ return 1; }
  	};
  
  }
  
  void test_scope()
  {
      COUNTER_GUARD(test_class);
      COUNTER_GUARD(test_class2);
  
  	lua_state L;
  
  	using namespace luabind;
  
  	module(L)
  	[
  		class_<test_class2>("test_class2")
  				.def(constructor<>())
  				.def("string_string", &test_class2::string_string)
  	];
  
  	module(L, "test")
  	[
  		class_<test_class>("test_class")
  			.def(constructor<>())
  			.def_readonly("test", &test_class::test)
  			.scope
  			[
  				def("inner_fun", &f)
  			]
              .def("inner_fun2", &f) // this should become static
  			.enum_("vals")
  			[
  				value("val1", 1),
  				value("val2", 2)
  			],
  
  		def("f", &f),
  		def("f", &f_),
  
  		namespace_("inner")
  		[
  			def("g", &g),
  			def("f", &f__)
  		],
  
  		namespace_("inner")
  		[
  			def("g", &g_)
  		]
  
  	];
  
  	module(L, "test")
  	[
  		namespace_("inner")
  		[
  			def("h", &h)
  		]
  	];
  
  
  	DOSTRING(L, "assert(test.f() == 1)");
  	DOSTRING(L, "assert(test.f(3) == 2)");
  	DOSTRING(L, "assert(test.test_class.inner_fun() == 1)");
      DOSTRING(L,
  		"a = test.test_class()\n"
  		"assert(a.test == 1)");
  	DOSTRING(L, "assert(a.inner_fun2() == 1)"); // free function
      DOSTRING(L,
  		"b = test.test_class.val2\n"
  		"assert(b == 2)");
  	DOSTRING(L, "assert(test.inner.g() == 4)");
  	DOSTRING(L, "assert(test.inner.g(7) == 5)");
  	DOSTRING(L, "assert(test.inner.f(4) == 3)");
  	DOSTRING(L, "assert(test.inner.h() == 6)");
  }
  
  