Le 27/01/2010 17:34, David Abrahams a écrit :
I'm not sure exactly what "enable the unit tests" means in this case.
Can you be explicit and/or preferably provide an illustrative patch?
As I'm a complete bjam noob, I made an attempt that is certainly clumsy
and/or inelegant.
The idea would be to conditionally compile/run the test, the condition
being the current toolset is in a given set of toolsets (currently only
'msvc' toolset).
In the attached patch, I conditionnally define
'BOOST_PYTHON_TEST_ENABLE' on 'msvc' toolset, and I modified the tests
to use calling conventions only if 'BOOST_PYTHON_TEST_ENABLE' if defined.
I suppose that there's a way to instruct bjam to conditionally
compile/run a test, that would be more clear, and would prevent to
change the tests.
What do you think ?
Cheers,
Nicolas.
Index: calling_conventions.cpp
===================================================================
--- calling_conventions.cpp (revision 59329)
+++ calling_conventions.cpp (working copy)
@@ -79,52 +79,60 @@
namespace BOOST_PP_CAT(test, TESTED_CALLING_CONVENTION) {
- long TESTED_CALLING_CONVENTION f_0()
+# if defined(BOOST_PYTHON_TEST_ENABLE)
+# define ACTUAL_CALLING_CONVENTION TESTED_CALLING_CONVENTION
+# else
+ // we explicitly revert calling convention to default, as we are testing an
+ // unsupported compiler
+# define ACTUAL_CALLING_CONVENTION
+# endif // defined(BOOST_PYTHON_TEST_ENABLE)
+
+ long ACTUAL_CALLING_CONVENTION f_0()
{
return 17041L;
}
- long TESTED_CALLING_CONVENTION f_1(long a)
+ long ACTUAL_CALLING_CONVENTION f_1(long a)
{
return a;
}
- long TESTED_CALLING_CONVENTION f_2(long a, long b)
+ long ACTUAL_CALLING_CONVENTION f_2(long a, long b)
{
return a + 10 * b;
}
- long TESTED_CALLING_CONVENTION f_3(long a, long b, long c)
+ long ACTUAL_CALLING_CONVENTION f_3(long a, long b, long c)
{
return a + 10 * b + 100 * c;
}
- long TESTED_CALLING_CONVENTION f_4(long a, long b, long c, long d)
+ long ACTUAL_CALLING_CONVENTION f_4(long a, long b, long c, long d)
{
return a + 10 * b + 100 * c + 1000 * d;
}
- long TESTED_CALLING_CONVENTION f_5(long a, long b, long c, long d, long e)
+ long ACTUAL_CALLING_CONVENTION f_5(long a, long b, long c, long d, long e)
{
return a + 10 * b + 100 * c + 1000 * d + 10000 * e;
}
- long TESTED_CALLING_CONVENTION f_6(long a, long b, long c, long d, long e,
long f)
+ long ACTUAL_CALLING_CONVENTION f_6(long a, long b, long c, long d, long e,
long f)
{
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f;
}
- long TESTED_CALLING_CONVENTION f_7(long a, long b, long c, long d, long e,
long f, long g)
+ long ACTUAL_CALLING_CONVENTION f_7(long a, long b, long c, long d, long e,
long f, long g)
{
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f +
1000000 * g;
}
- long TESTED_CALLING_CONVENTION f_8(long a, long b, long c, long d, long e,
long f, long g, long h)
+ long ACTUAL_CALLING_CONVENTION f_8(long a, long b, long c, long d, long e,
long f, long g, long h)
{
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f +
1000000 * g + 10000000 * h;
}
- long TESTED_CALLING_CONVENTION f_9(long a, long b, long c, long d, long e,
long f, long g, long h, long i)
+ long ACTUAL_CALLING_CONVENTION f_9(long a, long b, long c, long d, long e,
long f, long g, long h, long i)
{
return a + 10 * b + 100 * c + 1000 * d + 10000 * e + 100000 * f +
1000000 * g + 10000000 * h + 100000000 * i;
}
Index: calling_conventions_mf.cpp
===================================================================
--- calling_conventions_mf.cpp (revision 59329)
+++ calling_conventions_mf.cpp (working copy)
@@ -79,38 +79,46 @@
namespace BOOST_PP_CAT(test, TESTED_CALLING_CONVENTION) {
+# if defined(BOOST_PYTHON_TEST_ENABLE)
+# define ACTUAL_CALLING_CONVENTION TESTED_CALLING_CONVENTION
+# else
+ // we explicitly revert calling convention to default, as we are testing an
+ // unsupported compiler
+# define ACTUAL_CALLING_CONVENTION
+# endif // defined(BOOST_PYTHON_TEST_ENABLE)
+
struct X
{
mutable unsigned int hash;
X(): hash(0) {}
- void TESTED_CALLING_CONVENTION f0() { f1(17); }
- void TESTED_CALLING_CONVENTION g0() const { g1(17); }
+ void ACTUAL_CALLING_CONVENTION f0() { f1(17); }
+ void ACTUAL_CALLING_CONVENTION g0() const { g1(17); }
- void TESTED_CALLING_CONVENTION f1(int a1) { hash = (hash * 17041 + a1) %
32768; }
- void TESTED_CALLING_CONVENTION g1(int a1) const { hash = (hash * 17041 +
a1 * 2) % 32768; }
+ void ACTUAL_CALLING_CONVENTION f1(int a1) { hash = (hash * 17041 + a1) %
32768; }
+ void ACTUAL_CALLING_CONVENTION g1(int a1) const { hash = (hash * 17041 +
a1 * 2) % 32768; }
- void TESTED_CALLING_CONVENTION f2(int a1, int a2) { f1(a1); f1(a2); }
- void TESTED_CALLING_CONVENTION g2(int a1, int a2) const { g1(a1); g1(a2); }
+ void ACTUAL_CALLING_CONVENTION f2(int a1, int a2) { f1(a1); f1(a2); }
+ void ACTUAL_CALLING_CONVENTION g2(int a1, int a2) const { g1(a1); g1(a2); }
- void TESTED_CALLING_CONVENTION f3(int a1, int a2, int a3) { f2(a1, a2);
f1(a3); }
- void TESTED_CALLING_CONVENTION g3(int a1, int a2, int a3) const { g2(a1,
a2); g1(a3); }
+ void ACTUAL_CALLING_CONVENTION f3(int a1, int a2, int a3) { f2(a1, a2);
f1(a3); }
+ void ACTUAL_CALLING_CONVENTION g3(int a1, int a2, int a3) const { g2(a1,
a2); g1(a3); }
- void TESTED_CALLING_CONVENTION f4(int a1, int a2, int a3, int a4) { f3(a1,
a2, a3); f1(a4); }
- void TESTED_CALLING_CONVENTION g4(int a1, int a2, int a3, int a4) const {
g3(a1, a2, a3); g1(a4); }
+ void ACTUAL_CALLING_CONVENTION f4(int a1, int a2, int a3, int a4) { f3(a1,
a2, a3); f1(a4); }
+ void ACTUAL_CALLING_CONVENTION g4(int a1, int a2, int a3, int a4) const {
g3(a1, a2, a3); g1(a4); }
- void TESTED_CALLING_CONVENTION f5(int a1, int a2, int a3, int a4, int a5)
{ f4(a1, a2, a3, a4); f1(a5); }
- void TESTED_CALLING_CONVENTION g5(int a1, int a2, int a3, int a4, int a5)
const { g4(a1, a2, a3, a4); g1(a5); }
+ void ACTUAL_CALLING_CONVENTION f5(int a1, int a2, int a3, int a4, int a5)
{ f4(a1, a2, a3, a4); f1(a5); }
+ void ACTUAL_CALLING_CONVENTION g5(int a1, int a2, int a3, int a4, int a5)
const { g4(a1, a2, a3, a4); g1(a5); }
- void TESTED_CALLING_CONVENTION f6(int a1, int a2, int a3, int a4, int a5,
int a6) { f5(a1, a2, a3, a4, a5); f1(a6); }
- void TESTED_CALLING_CONVENTION g6(int a1, int a2, int a3, int a4, int a5,
int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); }
+ void ACTUAL_CALLING_CONVENTION f6(int a1, int a2, int a3, int a4, int a5,
int a6) { f5(a1, a2, a3, a4, a5); f1(a6); }
+ void ACTUAL_CALLING_CONVENTION g6(int a1, int a2, int a3, int a4, int a5,
int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); }
- void TESTED_CALLING_CONVENTION f7(int a1, int a2, int a3, int a4, int a5,
int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); }
- void TESTED_CALLING_CONVENTION g7(int a1, int a2, int a3, int a4, int a5,
int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); }
+ void ACTUAL_CALLING_CONVENTION f7(int a1, int a2, int a3, int a4, int a5,
int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); }
+ void ACTUAL_CALLING_CONVENTION g7(int a1, int a2, int a3, int a4, int a5,
int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); }
- void TESTED_CALLING_CONVENTION f8(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); }
- void TESTED_CALLING_CONVENTION g8(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); }
+ void ACTUAL_CALLING_CONVENTION f8(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); }
+ void ACTUAL_CALLING_CONVENTION g8(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); }
};
} // namespace BOOST_PP_CAT(test, TESTED_CALLING_CONVENTION)
Index: Jamfile.v2
===================================================================
--- Jamfile.v2 (revision 59329)
+++ Jamfile.v2 (working copy)
@@ -184,8 +184,18 @@
# bpl-test bienstman5 ;
# }
-[ bpl-test calling_conventions ]
-[ bpl-test calling_conventions_mf ]
+[ bpl-test calling_conventions
+ : # files
+ : # requirements
+ # additional calling conventions are currently only tests on msvc compilers
+ <toolset>msvc:<define>BOOST_PYTHON_TEST_ENABLE
+]
+[ bpl-test calling_conventions_mf
+ : # files
+ : # requirements
+ # additional calling conventions are currently only tests on msvc compilers
+ <toolset>msvc:<define>BOOST_PYTHON_TEST_ENABLE
+]
# --- unit tests of library components ---
_______________________________________________
Cplusplus-sig mailing list
Cplusplus-sig@python.org
http://mail.python.org/mailman/listinfo/cplusplus-sig
