#define TEST_ONE_THINGY(CLS,OUTPUT) test_One_Thingy<CLS>( #CLS, OUTPUT );

void test_all_thingies()
{
    TEST_ONE_THINGY( Thingy1, "Thingy1 expected output" );
    TEST_ONE_THINGY( Thingy2, "Thingy2 expected output" );
    TEST_ONE_THINGY( Thingy3, "Thingy3 expected output" );
    TEST_ONE_THINGY( Thingy4, "Thingy4 expected output" );
}

template< class T >
void test_One_Thingy( std::string class_name, std::string expected_output )
{
    T thingy;
    thingy.doSomething();
    TEST_ASSERT_CLS( class_name, thingy.getOutput() == expected_output );
}

#include "hshgtest.h"
#include <iostream>
#include <sstream>

struct ClsA
{
	const char* str() const { return "My name is A"; }
};

struct ClsB
{
	const char* str() const { return "My name is B"; }
};

struct ClsC
{
	const char* str() const { return "My Name is C"; }
};

struct ClsD
{
	const char* str() const { return "My name is D"; }
};

namespace
{

template< class T >
inline std::string SuffixType( const std::string& in )
{
	std::ostringstream s;
	s << in << " : " << typeid( T ).name();
	return s.str();
}

#define TEST_ASSERT_TEMPL( t, x ) HSHGTest::TestAssert( x, SuffixType< t >( #x ).c_str(), __FILE__, __LINE__)

template< class T >
void ClassTest( const std::string& expect )
{
	T test;
	TEST_ASSERT_TEMPL( T, expect == test.str() );
}

void testall()
{
	ClassTest< ClsA >( "My name is A" );
	ClassTest< ClsB >( "My name is B" );
	ClassTest< ClsC >( "My name is C" );
	ClassTest< ClsD >( "My name is D" );
}

}

HSHG_BEGIN_TESTS
HSHG_TEST_ENTRY( testall )
HSHG_END_TESTS

HSHG_TEST_MAIN

‘Reasons against’ can be rebutted fairly fast. The thing with templates is that they are ‘real code’, so you can’t use any preprocessor code in the template function to distinguish different instantiations.

Assuming that TEST_ASSERT is a macro that makes use of __FILE__ and __LINE__ for its helpful diagnostic, the obvious way is to make a more configurable macro which does essentially the same thing, but allows you to specify the file and line. For example, make TEST_ASSERT_FL macro so that these two lines are equivalent.
TEST_ASSERT_FL( x, __FILE__, __LINE__ )
TEST_ASSERT( x )

Then, change the signature of test_One_Thingy as follows.
template void test_One_Thingy( const std::string& ex, const char* file, unsigned int line )

And have it use the new macro.
TEST_ASSERT_FL( thingy.getOutput() == expected_output, file, line );

Then create a new macro.
#defined TEST_ONE_THINGY( cls, expect ) test_One_Thingy( expect, __FILE__, __LINE__ )

void test_all_thingies()
{
TEST_ONE_THINGY( ClassA, “Thingy1 expected output” );
TEST_ONE_THINGY( ClassB, “Thingy2 expected output” );
TEST_ONE_THINGY( ClassC, “Thingy3 expected output” );
TEST_ONE_THINGY( ClassD, “Thingy4 expected output” );
}

File and line now give you which class caused the failure, at the expense of not telling you the file and line of the template code where the actual test is. (This may not matter much if the template code only has a single assert macro.)

Now the funky way :) .

Assuming you have a TestAssert underlying function on which the TEST_ASSERT macro is built…

template
inline std::string SuffixType( const std::string& in )
{
std::ostringstream s;
s ( #x ).c_str(), __FILE__, __LINE__)

template
void test_One_Thingy( const std::string& expected_output )
{
T thingy;
thingy.doSomething();
TEST_ASSERT_TEMPL( T, thingy.getOutput() == expected_output );
}

Warning! The type suffix is not guaranteed to be human readable.