Patrick M?zard wrote:

However, it does not work with typedefed types. Here is a new example :

//********************* #include using boost::unit_test::test_suite;

namespace testns {

typedef std::pair Test;

std::ostream& operator<<(std::ostream& o, Test const& t) { return o<

Try writing: namespace std { std::ostream& operator<<(std::ostream& o, std::pair const& t) { return o<

Vladimir Prus wrote:

Patrick M?zard wrote:

[...]

I think defining operator<< in the same namespace as the class 'Test' is the only way. Otherwise, it won't be found by ADL and ADL is the only way to boost.test to find your operator<<.

...

Note these workaround do not work or cannot be applied if the type is declared by a typedef. In this case, I have to define again the operator in namespace boost.test_tools.tt_detail.

If the type is declared by a typedef:

typedef foo::C C2;

you can define the operator<< in the 'foo' namespace, and that should work.

That is very unfortunate. Is there no way to have the operator<< lookup occur in the scope of the call to BOOST_CHECK_EQUAL, by moving the wrap_stringstream logic and the call to operator<< into the macro itself ? Cheers, Ian

Gennadiy Rozental writes:

You have several choices

1. You could define operator<< in namespace foo

It does not work because of the typedef (see below). Please see my first answer to Vladimir. It works if it is defined in namespace std:: however.

2. You could use BOOST_TEST_DONT_PRINT_LOG_VALUE(your type) on global scope to prevent values of this type being printed at all

Okay, but since I am the one writing the tests, I would simply use BOOST_CHECK().

3. You could write struct C2 : foo::C {}; And unless you use non-default constructor it will work.

Maybe, but it seems much more work just to use BOOST_CHECK_EQUAL(). I could understand the anonymous namespace and typedefs have issues with ADL and there are workaround to be found. For those interested with ADL rules, I finally got an old post from llewely on comp.lang.c+.moderated on a similar problem stating that (look for "Re: stream iterators and operator<< " in google.groups): <quote> A typedef name is not a type. The occurance of a typedef name in a scope does not add that scope to consideration in argument-dependent lookup. [3.4.2/2] Unqualified lookup does not occur because inside the definition of the function called by '*it = *v.begin()', operator<< is used for a function call. Instead, argument-dependent lookup is used. [3.4.2/1] Argument dependent lookup will lookup names in the classes and namespaces associated with the argument types. pair is a template-id, and defined at namespace scope in namespace std, with arguments int,int, which have no associated namespaces or classes, so the only associated namespace is std. [3.4.2/2, bullet 8] I believe both compilers are conforming in this respect. Some notes: If you move the operator<< into namespace std, it will be found during argument-dependent lookup (I tested with gcc 3.2.1), except for the caveat that one is not allowed to add overloads to namespace std. If you change 'typedef pair Type' to 'typedef pair', where Foo is in the global namespace, the operator<< will also be found. </quote> Personnaly, I would stick with declaring the operator<< in std:: for the moment. That's ugly but that's just tests after all. Maybe you could just add a documentation note on this topic. Thank you for your answer. Patrick Mézard.

Gennadiy Rozental writes:

Why do you need unnamed namespace? Remove it and it will all work.

The type being tested belongs to a library. I do not need the operator<< at the library level, only in the test for BOOST_CHECK_EQUAL support. So I define the operator at in the test scope, in an anonymous namespace because there is no need to export the symbol. That's good practice for me, maybe I am wrong ? Patrick Mézard