diff --git a/src/backend/engine/scheduler-diagnostics.hpp b/src/backend/engine/scheduler-diagnostics.hpp
index 470a1ea7d..efa01a85d 100644
--- a/src/backend/engine/scheduler-diagnostics.hpp
+++ b/src/backend/engine/scheduler-diagnostics.hpp
@@ -56,7 +56,7 @@ namespace engine {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * Render engine diagnostic facility. Creating an instance
    * will activate additional tracing and diagnostic facilities
    * within the scheduler implementation; results may be investigated
diff --git a/src/backend/enginefacade.hpp b/src/backend/enginefacade.hpp
index 7cbf698e8..64717e567 100644
--- a/src/backend/enginefacade.hpp
+++ b/src/backend/enginefacade.hpp
@@ -32,7 +32,7 @@
 namespace backend {
   
   
-  /******************************************************************
+  /**************************************************************//**
    * Interface to the backend layer (render engine subsystem):
    * Global access point for starting the render engine subsystem and
    * for defining the public interface(s) for talking with the engine.
diff --git a/src/backend/media-access-facade.hpp b/src/backend/media-access-facade.hpp
index e3a4b124b..6ec32c9a7 100644
--- a/src/backend/media-access-facade.hpp
+++ b/src/backend/media-access-facade.hpp
@@ -42,7 +42,7 @@ namespace backend {
   struct ChanDesc;
   
   
-  /******************************************************************
+  /**************************************************************//**
    * Interface to the backend layer:
    * provides functions for querying (opening) a media file,
    * detecting the channels or streams found within this file etc. 
diff --git a/src/backend/netnodefacade.hpp b/src/backend/netnodefacade.hpp
index 17ceb60de..83b0d7be5 100644
--- a/src/backend/netnodefacade.hpp
+++ b/src/backend/netnodefacade.hpp
@@ -32,7 +32,7 @@
 namespace backend {
   
   
-  /******************************************************************
+  /**************************************************************//**
    * Interface to the backend layer (renderfarm node):
    * Global access point for starting a server listening on a TCP port
    * and accepting render tasks. Possibly such a server could also
diff --git a/src/backend/scriptrunnerfacade.hpp b/src/backend/scriptrunnerfacade.hpp
index d54087497..7ace30927 100644
--- a/src/backend/scriptrunnerfacade.hpp
+++ b/src/backend/scriptrunnerfacade.hpp
@@ -32,7 +32,7 @@
 namespace backend {
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * Interface to the backend layer (script runner):
    * Global access point for starting a script within Lumiera application
    * context. 
diff --git a/src/backend/thread-wrapper.hpp b/src/backend/thread-wrapper.hpp
index 6ce1aaa02..1ccad35ca 100644
--- a/src/backend/thread-wrapper.hpp
+++ b/src/backend/thread-wrapper.hpp
@@ -53,7 +53,7 @@ namespace backend {
   
   
   
-  /****************************************************************************
+  /************************************************************************//**
    * A thin convenience wrapper for dealing with threads,
    * as implemented by the threadpool in the backend (based on pthread).
    * Using this wrapper...
diff --git a/src/common/interface-facade-link.hpp b/src/common/interface-facade-link.hpp
index 27c0826c9..4e91f16b8 100644
--- a/src/common/interface-facade-link.hpp
+++ b/src/common/interface-facade-link.hpp
@@ -65,7 +65,7 @@ namespace facade {
   using lib::Literal;
   
   
-  /************************************************************************
+  /********************************************************************//**
    * simple access-frontend to the implementation of a service (C++ only).
    * Usually, an instance of Accessor is placed as static member right into
    * the facade interface used to access the service. This implementation
diff --git a/src/common/subsystem-runner.hpp b/src/common/subsystem-runner.hpp
index 6cbd3495a..35205d823 100644
--- a/src/common/subsystem-runner.hpp
+++ b/src/common/subsystem-runner.hpp
@@ -64,7 +64,7 @@ namespace lumiera {
   }
   
   
-  /*****************************************************************************
+  /*************************************************************************//**
    * Implementation helper for managing execution of a collection of subsystems,
    * which may depend on one another and execute in parallel. Properties of the
    * subsystems are available through Subsys object refs, which act as handle.
diff --git a/src/gui/display-service.hpp b/src/gui/display-service.hpp
index 1c5cda79f..78463d1c3 100644
--- a/src/gui/display-service.hpp
+++ b/src/gui/display-service.hpp
@@ -72,7 +72,7 @@ namespace gui {
   
   
   
-  /********************************************************************
+  /****************************************************************//**
    * Actual implementation of a single displayer slot. Internally,
    * it is connected via the Glib::Dispatcher for outputting frames 
    * to a viewer widget, which executes within the GTK event thread.
@@ -109,7 +109,7 @@ namespace gui {
   
   
   
-  /******************************************************
+  /**************************************************//**
    * Actual implementation of the DisplayService.
    * Creating an instance of this class automatically
    * registers the interface lumieraorg_Display with
diff --git a/src/gui/guifacade.hpp b/src/gui/guifacade.hpp
index 27de18a35..5c8b5a31c 100644
--- a/src/gui/guifacade.hpp
+++ b/src/gui/guifacade.hpp
@@ -51,7 +51,7 @@ namespace gui {
   
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * Global access point for loading and starting up the Lumiera GTK GUI
    * and for controlling the GUI lifecycle. The implementation part of
    * this class also is responsible for making the "business" interface
diff --git a/src/gui/guistart.cpp b/src/gui/guistart.cpp
index 8905c7858..61c0b81ad 100644
--- a/src/gui/guistart.cpp
+++ b/src/gui/guistart.cpp
@@ -79,7 +79,7 @@ namespace gui {
   
   namespace { // implementation details
     
-    /******************************************************************************
+    /**************************************************************************//**
      * Implement the necessary steps for actually making the Lumiera Gui available.
      * Open the business interface(s) and start up the GTK GUI main event loop.
      */
diff --git a/src/gui/notification-service.hpp b/src/gui/notification-service.hpp
index 427ec045d..fda5144d7 100644
--- a/src/gui/notification-service.hpp
+++ b/src/gui/notification-service.hpp
@@ -49,7 +49,7 @@ namespace gui {
   
   
   
-  /******************************************************
+  /**************************************************//**
    * Actual implementation of the GuiNotification service
    * within the Lumiera GTK GUI. Creating an instance of
    * this class automatically registers the interface
diff --git a/src/include/config-facade.h b/src/include/config-facade.h
index a65bd986b..6beb6b95a 100644
--- a/src/include/config-facade.h
+++ b/src/include/config-facade.h
@@ -55,7 +55,7 @@ namespace lumiera {
   using std::string;
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * C++ wrapper for convenient access to the Lumiera config system.
    * 
    * @warning Config system not fully implemented yet. Thus for now
diff --git a/src/include/display-facade.h b/src/include/display-facade.h
index 66089287e..1b729430a 100644
--- a/src/include/display-facade.h
+++ b/src/include/display-facade.h
@@ -60,7 +60,7 @@
 namespace lumiera {
   
   
-  /******************************************************************
+  /**************************************************************//**
    * Interface for outputting frames to an (already allocated) viewer
    * or display. The viewer is addressed by an "slot" handle, which the 
    * client receives from some other public interface. This reflects
diff --git a/src/include/dummy-player-facade.h b/src/include/dummy-player-facade.h
index b964d42ed..ed59818c4 100644
--- a/src/include/dummy-player-facade.h
+++ b/src/include/dummy-player-facade.h
@@ -48,7 +48,7 @@ namespace proc   {
 namespace lumiera {
     
     
-    /******************************************************************
+    /**************************************************************//**
      * Experimental Interface Proc-Layer (or maybe the backend?): 
      * Global access point for starting a dummy playback, generating
      * some test image data for the GUI to display in a viewer window.
diff --git a/src/include/guinotification-facade.h b/src/include/guinotification-facade.h
index 7e10bcbd0..22104f76d 100644
--- a/src/include/guinotification-facade.h
+++ b/src/include/guinotification-facade.h
@@ -49,7 +49,7 @@ namespace gui {
   using std::string;
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * Global access point to push state update and notification of events
    * from the lower layers into the Lumiera GUI. Typically, this happens
    * asynchronously and triggered by events within the lower layers.
diff --git a/src/include/interfaceproxy.hpp b/src/include/interfaceproxy.hpp
index 0469da8f9..05c6ead6c 100644
--- a/src/include/interfaceproxy.hpp
+++ b/src/include/interfaceproxy.hpp
@@ -89,7 +89,7 @@ namespace facade {
   LUMIERA_ERROR_DECLARE(FACADE_LIFECYCLE);  
 
 
-  /*********************************************************************
+  /*****************************************************************//**
    * access-frontend to the implementation of a service.
    * Usually, an instance of Accessor is placed as static member
    * right into the facade interface used to access the service.
diff --git a/src/include/play-facade.h b/src/include/play-facade.h
index 0e9126f0f..7b281518d 100644
--- a/src/include/play-facade.h
+++ b/src/include/play-facade.h
@@ -59,7 +59,7 @@ namespace lumiera {
   using std::tr1::weak_ptr;
     
     
-    /******************************************************************
+    /**************************************************************//**
      * Interface to the Player subsystem of Lumiera (Proc-Layer).
      * Global access point for starting playback and render processes,
      * calculating media data by running the render engine.
diff --git a/src/lib/error.hpp b/src/lib/error.hpp
index 6ae3479cf..14872b710 100644
--- a/src/lib/error.hpp
+++ b/src/lib/error.hpp
@@ -232,7 +232,7 @@ namespace lumiera {
   
 } // namespace lumiera
 
-/******************************************************
+/**************************************************//**
  * convenience shortcut for a sequence of catch blocks
  * just logging and consuming an error. Typically
  * this sequence will be used within destructors,
@@ -255,7 +255,7 @@ namespace lumiera {
 
 
 
-/******************************************************
+/**************************************************//**
  * if NoBug is used, redefine some macros 
  * to rather throw Lumiera Errors instead of aborting
  */
diff --git a/src/lib/hash-indexed.hpp b/src/lib/hash-indexed.hpp
index d20b0203b..5a74975ee 100644
--- a/src/lib/hash-indexed.hpp
+++ b/src/lib/hash-indexed.hpp
@@ -123,7 +123,7 @@ namespace lib {
   
   
   
-  /************************************************************
+  /********************************************************//**
    * A Mixin to add a private ID type to the target class,
    * together with storage to hold an instance of this ID,
    * getter and setter, and a templated version of the ID type
diff --git a/src/lib/meta/function-erasure.hpp b/src/lib/meta/function-erasure.hpp
index f2ed457e4..33a8c27b6 100644
--- a/src/lib/meta/function-erasure.hpp
+++ b/src/lib/meta/function-erasure.hpp
@@ -72,7 +72,7 @@ namespace meta{
   
   
   
-  /******************************************************
+  /**************************************************//**
    * Generic wrapper carrying a function object
    * while hiding the actual function signature
    * - create it using a function ref or pointer
diff --git a/src/lib/singleton-ref.hpp b/src/lib/singleton-ref.hpp
index 089ae8579..a7550da41 100644
--- a/src/lib/singleton-ref.hpp
+++ b/src/lib/singleton-ref.hpp
@@ -51,7 +51,7 @@ namespace lib {
   
   namespace singleton {
   
-    /***************************************
+    /***********************************//**
      * Detail/Policy class specifying
      * how the SingletonRef can be accessed
      */
@@ -96,7 +96,7 @@ namespace lib {
   
   
   
-  /*************************************************************
+  /*********************************************************//**
    * Helper template providing singleton access without managing
    * object creation and lifecycle. Just the access to the
    * implementation instance is handled: on creation, access is
diff --git a/src/lib/sync.hpp b/src/lib/sync.hpp
index b4381b48b..332817ccf 100644
--- a/src/lib/sync.hpp
+++ b/src/lib/sync.hpp
@@ -396,7 +396,7 @@ namespace lib {
   using sync::RecursiveLock_Waitable;
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * Facility for monitor object based locking.
    * To be attached either on a per class base or per object base.
    * Typically, the client class will inherit from this template (but it
diff --git a/src/proc/asset/category.hpp b/src/proc/asset/category.hpp
index b0da8e796..32f8a75a3 100644
--- a/src/proc/asset/category.hpp
+++ b/src/proc/asset/category.hpp
@@ -55,7 +55,7 @@ namespace asset {
     , META
     };
   
-  /*************************************
+  /************************************************************************************//**
    * Tree like classification of Assets.
    * By virtue of the Category, Assets can be organised in nested bins (folders).
    * This includes the distinction of different kinds of Assets, like Audio, Video, Effects...
diff --git a/src/proc/engine/calc-stream.hpp b/src/proc/engine/calc-stream.hpp
index e945afad3..9713b4491 100644
--- a/src/proc/engine/calc-stream.hpp
+++ b/src/proc/engine/calc-stream.hpp
@@ -72,7 +72,7 @@ namespace engine{
   
   
   
-  /*********************************************************
+  /*****************************************************//**
    * A calculation stream groups and abstracts a series of
    * calculation jobs, delivering frames into the configured
    * OutputSlot in a timely fashion. Behind the scenes, this
diff --git a/src/proc/engine/diagnostic-buffer-provider.hpp b/src/proc/engine/diagnostic-buffer-provider.hpp
index 4f45764db..18636d7dc 100644
--- a/src/proc/engine/diagnostic-buffer-provider.hpp
+++ b/src/proc/engine/diagnostic-buffer-provider.hpp
@@ -53,7 +53,7 @@ namespace engine {
   class TrackingHeapBlockProvider;
   
   
-  /********************************************************************
+  /****************************************************************//**
    * Helper for unit tests: Buffer provider reference implementation.
    * 
    * @todo write type comment
diff --git a/src/proc/engine/engine-diagnostics.hpp b/src/proc/engine/engine-diagnostics.hpp
index 6d761997a..26c93bcfb 100644
--- a/src/proc/engine/engine-diagnostics.hpp
+++ b/src/proc/engine/engine-diagnostics.hpp
@@ -68,7 +68,7 @@ namespace engine{
   
   
   
-  /******************************************************
+  /**************************************************//**
    * Render engine diagnostic facility. Creating an instance
    * will activate additional tracing facilities within the
    * render engine; results may be investigated through
diff --git a/src/proc/engine/engine-service-mock.hpp b/src/proc/engine/engine-service-mock.hpp
index 33b0c5e2b..bb43e466f 100644
--- a/src/proc/engine/engine-service-mock.hpp
+++ b/src/proc/engine/engine-service-mock.hpp
@@ -76,7 +76,7 @@ namespace engine{
   
   
   
-  /****************************************************************
+  /************************************************************//**
    * Variant of the render engine, reconfigured for mock operation.
    * Especially, this setup leaves out most of the actual Lumiera
    * engine's implementation facilities. There is no scheduler
diff --git a/src/proc/engine/engine-service.hpp b/src/proc/engine/engine-service.hpp
index cc094f5d9..1bc4a3f55 100644
--- a/src/proc/engine/engine-service.hpp
+++ b/src/proc/engine/engine-service.hpp
@@ -85,7 +85,7 @@ namespace engine{
   
   
   
-  /******************************************************
+  /**************************************************//**
    * A service to schedule series of calculations,
    * delivering the rendered data into an external output
    * sink in a timely fashion. Actually the CalculationStream
@@ -108,7 +108,7 @@ namespace engine{
       
       
     public:
-      /*************************************************************
+      /*********************************************************//**
        * Quality-of-Service definition for an Render Engine usage.
        * This strategy defines how to decide between conflicting goals like
        * - timely delivery
diff --git a/src/proc/engine/worker/dummy-tick.hpp b/src/proc/engine/worker/dummy-tick.hpp
index 91dc5e868..317ff4301 100644
--- a/src/proc/engine/worker/dummy-tick.hpp
+++ b/src/proc/engine/worker/dummy-tick.hpp
@@ -53,7 +53,7 @@ namespace node {
   
   
   
-  /************************************************************
+  /********************************************************//**
    * Tick generating service for a periodic callback,
    * with adjustable frequency. Quick'n dirty implementation!
    */
diff --git a/src/proc/engine/worker/tick-service.hpp b/src/proc/engine/worker/tick-service.hpp
index 1237727e3..038ef83fd 100644
--- a/src/proc/engine/worker/tick-service.hpp
+++ b/src/proc/engine/worker/tick-service.hpp
@@ -53,7 +53,7 @@ namespace node {
   
   
   
-  /************************************************************
+  /********************************************************//**
    * Tick generating service for a periodic callback,
    * with adjustable frequency. Quick'n dirty implementation!
    */
diff --git a/src/proc/facade.hpp b/src/proc/facade.hpp
index 0f9e227d8..1f030ef99 100644
--- a/src/proc/facade.hpp
+++ b/src/proc/facade.hpp
@@ -43,7 +43,7 @@
 namespace proc {
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * Global access point for the services implemented by the Proc-Layer.
    * 
    * @todo this is a dummy placeholder as of 1/2009. Currently, there
diff --git a/src/proc/mobject/session/placement-index.cpp b/src/proc/mobject/session/placement-index.cpp
index 8b12ece8f..db2d55b5e 100644
--- a/src/proc/mobject/session/placement-index.cpp
+++ b/src/proc/mobject/session/placement-index.cpp
@@ -102,7 +102,7 @@ namespace session {
   typedef PlacementIndex::ID ID;
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * Storage and implementation backing the PlacementIndex
    * - #placementTab_ is an hashtable mapping IDs to Placement + Scope
    * - #scopeTab_ is an reverse association serving to keep track of 
diff --git a/src/proc/play/dummy-play-connection.hpp b/src/proc/play/dummy-play-connection.hpp
index 24c6d21a9..45ca8048a 100644
--- a/src/proc/play/dummy-play-connection.hpp
+++ b/src/proc/play/dummy-play-connection.hpp
@@ -210,7 +210,7 @@ namespace play {
   }
 
   
-  /********************************************************************
+  /****************************************************************//**
    * Framework for dummy playback and rendering.
    * A DummyPlayConnection provides a coherent set of placeholders,
    * allowing to start a data producing process while leaving out
diff --git a/src/proc/play/dummy-player-service.hpp b/src/proc/play/dummy-player-service.hpp
index 8e93222af..f46b2f7da 100644
--- a/src/proc/play/dummy-player-service.hpp
+++ b/src/proc/play/dummy-player-service.hpp
@@ -69,7 +69,7 @@ namespace proc {
     
     
     
-    /********************************************************************
+    /****************************************************************//**
      * Actual implementation of a single (dummy) playback process.
      * The DummyPlayerService (see below) maintains a collection of such
      * actively running playback processes, while the client code gets
@@ -117,7 +117,7 @@ namespace proc {
     
     
     
-    /******************************************************
+    /**************************************************//**
      * Actual implementation of the DummyPlayer service.
      * Creating an instance of this class automatically
      * registers the interface lumieraorg_DummyPlayer with
diff --git a/src/proc/play/output-director.hpp b/src/proc/play/output-director.hpp
index 56e2cb431..8547f34aa 100644
--- a/src/proc/play/output-director.hpp
+++ b/src/proc/play/output-director.hpp
@@ -64,7 +64,7 @@ namespace play {
   
   
   
-  /******************************************************
+  /**************************************************//**
    * Management of external Output connections.
    * 
    * @todo write Type comment
diff --git a/src/proc/play/output-manager.hpp b/src/proc/play/output-manager.hpp
index 696350e1a..7858f09e5 100644
--- a/src/proc/play/output-manager.hpp
+++ b/src/proc/play/output-manager.hpp
@@ -58,7 +58,7 @@ namespace play {
   
   
   
-  /******************************************************
+  /**************************************************//**
    * Management of external Output connections.
    * 
    * @todo need a concrete implementation
diff --git a/src/proc/play/output-slot.hpp b/src/proc/play/output-slot.hpp
index f98c20426..98a514f1d 100644
--- a/src/proc/play/output-slot.hpp
+++ b/src/proc/play/output-slot.hpp
@@ -95,7 +95,7 @@ namespace play {
   
   
   
-  /********************************************************************************
+  /****************************************************************************//**
    * Interface: Generic output sink.
    * An OutputSlot represents the possibility to send data through multiple
    * channels to some kind of external sink (video in GUI window, video full screen,
diff --git a/src/proc/play/play-controller.hpp b/src/proc/play/play-controller.hpp
index 03db62378..a6910209d 100644
--- a/src/proc/play/play-controller.hpp
+++ b/src/proc/play/play-controller.hpp
@@ -48,7 +48,7 @@ namespace play {
   using std::string;
   
   
-  /********************************************************************
+  /****************************************************************//**
    * TODO do we still need that??????
    * Isn't lumiera::Play::Controller already sufficient?
    */
diff --git a/src/proc/play/play-process.hpp b/src/proc/play/play-process.hpp
index afdedb3c9..2e80459eb 100644
--- a/src/proc/play/play-process.hpp
+++ b/src/proc/play/play-process.hpp
@@ -111,7 +111,7 @@ namespace play {
   typedef std::vector<Feed>         OutputFeeds;
     
   
-  /******************************************************
+  /**************************************************//**
    * Playback/Render process within the Lumiera Player.
    * This is a top-level implementation entity, created
    * by the PlayService when \em performing a timeline
diff --git a/src/proc/play/play-service.hpp b/src/proc/play/play-service.hpp
index daa494122..491bee8fb 100644
--- a/src/proc/play/play-service.hpp
+++ b/src/proc/play/play-service.hpp
@@ -83,7 +83,7 @@ namespace play {
   
   
   
-  /******************************************************
+  /**************************************************//**
    * Implementation access point: Player subsystem.
    * The PlayService is the primary way for clients to
    * get into using Lumiera's Play/Output Subsystem.
diff --git a/src/proc/play/timings.hpp b/src/proc/play/timings.hpp
index e2cf02a8e..b8bf55390 100644
--- a/src/proc/play/timings.hpp
+++ b/src/proc/play/timings.hpp
@@ -85,7 +85,7 @@ namespace play {
   
   
   
-  /*****************************************************************************
+  /*************************************************************************//**
    * Generic frame timing specification. Defines the expected delivery interval,
    * optionally also the expected quality-of-service (urgency).
    * 
diff --git a/tests/core/backend/engine/job-hash-test.cpp b/tests/core/backend/engine/job-hash-test.cpp
index 5318728b1..e73002cc3 100644
--- a/tests/core/backend/engine/job-hash-test.cpp
+++ b/tests/core/backend/engine/job-hash-test.cpp
@@ -39,7 +39,7 @@ namespace test {
   
   
   
-  /***************************************************************************
+  /**********************************************************************//**
    * @test verify the basic properties of the job and job descriptor struct;
    *       especially verify that job data is passed properly back to the
    *       closure and that a identity can be constructed based on a
diff --git a/tests/core/backend/engine/scheduler-interface-test.cpp b/tests/core/backend/engine/scheduler-interface-test.cpp
index af250a669..46704ad20 100644
--- a/tests/core/backend/engine/scheduler-interface-test.cpp
+++ b/tests/core/backend/engine/scheduler-interface-test.cpp
@@ -62,7 +62,7 @@ namespace test {
   typedef SchedulerFrontend::JobTransaction JobTransaction;
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test verify and demonstrate the organisation of the high-level interface
    *       for defining jobs to be invoked by the scheduler.
    *       
diff --git a/tests/core/backend/media-access-mock-test.cpp b/tests/core/backend/media-access-mock-test.cpp
index 674bbe494..d71613ef5 100644
--- a/tests/core/backend/media-access-mock-test.cpp
+++ b/tests/core/backend/media-access-mock-test.cpp
@@ -44,7 +44,7 @@ namespace test {
   
   
   
-  /********************************************************************************
+  /****************************************************************************//**
    * @test inject a Mock object replacing the backend_interface::MediaAccessFacade.
    *       Verify if the Mock object behaves as expected when calling the Facade.
    */
diff --git a/tests/core/proc/asset/asset-category-test.cpp b/tests/core/proc/asset/asset-category-test.cpp
index 218d3e9e5..71addafeb 100644
--- a/tests/core/proc/asset/asset-category-test.cpp
+++ b/tests/core/proc/asset/asset-category-test.cpp
@@ -43,7 +43,7 @@ namespace test {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test checking the properties of Asset Category structs.
    *       They are included in the Asset::Ident identification tuple
    *       of Assets and can be used to organize Assets into a tree
diff --git a/tests/core/proc/asset/basicpipetest.cpp b/tests/core/proc/asset/basicpipetest.cpp
index d35dfa781..dbc0efadf 100644
--- a/tests/core/proc/asset/basicpipetest.cpp
+++ b/tests/core/proc/asset/basicpipetest.cpp
@@ -51,7 +51,7 @@ namespace test  {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test basic properties of Pipe (structural) Assets.
    *       <ul><li>created by referral</li>
    *           <li>access existing pipe by referral</li>
diff --git a/tests/core/proc/asset/compoundmediatest.cpp b/tests/core/proc/asset/compoundmediatest.cpp
index d75274d80..b63ce29f6 100644
--- a/tests/core/proc/asset/compoundmediatest.cpp
+++ b/tests/core/proc/asset/compoundmediatest.cpp
@@ -42,7 +42,7 @@ namespace test {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * Verifying the special operations available for compound media assets
    * comprised of several elementary media assets.
    */
diff --git a/tests/core/proc/asset/create-asset-test.cpp b/tests/core/proc/asset/create-asset-test.cpp
index b4967313c..d13b5fe43 100644
--- a/tests/core/proc/asset/create-asset-test.cpp
+++ b/tests/core/proc/asset/create-asset-test.cpp
@@ -45,7 +45,7 @@ namespace test {
 
 
 
-  /***********************************************************************
+  /*******************************************************************//**
    * @test creating new Assets and registering them with the AssetManager.
    * @see  proc_interface::AssetManager#reg
    */
diff --git a/tests/core/proc/asset/deleteassettest.cpp b/tests/core/proc/asset/deleteassettest.cpp
index 89dddd42b..c8b4bc50c 100644
--- a/tests/core/proc/asset/deleteassettest.cpp
+++ b/tests/core/proc/asset/deleteassettest.cpp
@@ -37,7 +37,7 @@ namespace test {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test deleting an Asset includes removing all dependent Assets
    *       and all MObjects relying on these. Especially this means
    *       breaking all links between the involved Objects, so the
diff --git a/tests/core/proc/asset/dependent-assets-test.cpp b/tests/core/proc/asset/dependent-assets-test.cpp
index 8cde4bf97..8d8a198b8 100644
--- a/tests/core/proc/asset/dependent-assets-test.cpp
+++ b/tests/core/proc/asset/dependent-assets-test.cpp
@@ -43,7 +43,7 @@ namespace test {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test the handling of Assets dependent on other Assets and the
    *       enabling/disabling of Assets.
    * @see  asset::Asset
diff --git a/tests/core/proc/asset/entry-id-test.cpp b/tests/core/proc/asset/entry-id-test.cpp
index 7c3fcd41d..dd1c8a867 100644
--- a/tests/core/proc/asset/entry-id-test.cpp
+++ b/tests/core/proc/asset/entry-id-test.cpp
@@ -66,7 +66,7 @@ namespace test {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test proof-of-concept test for a combined symbolic and hash based ID.
    *       - create some symbolic IDs 
    *       - check default assignment works properly
diff --git a/tests/core/proc/asset/identityofassetstest.cpp b/tests/core/proc/asset/identityofassetstest.cpp
index 1d583a9e1..226b472c5 100644
--- a/tests/core/proc/asset/identityofassetstest.cpp
+++ b/tests/core/proc/asset/identityofassetstest.cpp
@@ -45,7 +45,7 @@ namespace test {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test creating several Assets and checking object identity,
    *       detection of duplicates and version handling.
    * @see  proc_interface::AssetManager#reg
diff --git a/tests/core/proc/asset/makecliptest.cpp b/tests/core/proc/asset/makecliptest.cpp
index 8dddd3d13..96ab4a367 100644
--- a/tests/core/proc/asset/makecliptest.cpp
+++ b/tests/core/proc/asset/makecliptest.cpp
@@ -47,7 +47,7 @@ namespace test {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test creating a Clip MObject and an associated Clip Asset from 
    *       a given asset::Media.
    * @see  asset::Media#createClip
diff --git a/tests/core/proc/asset/mediastructurequerytest.cpp b/tests/core/proc/asset/mediastructurequerytest.cpp
index 14f7aeb9f..4f6397e84 100644
--- a/tests/core/proc/asset/mediastructurequerytest.cpp
+++ b/tests/core/proc/asset/mediastructurequerytest.cpp
@@ -41,7 +41,7 @@ namespace test {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * This test documents the Interface used by MediaFactory when loading
    * media files for querying Lumiera's backend layer for information
    * on how the media file is structured.
diff --git a/tests/core/proc/asset/meta/time-grid-basics-test.cpp b/tests/core/proc/asset/meta/time-grid-basics-test.cpp
index 8833036e5..e5627d3f0 100644
--- a/tests/core/proc/asset/meta/time-grid-basics-test.cpp
+++ b/tests/core/proc/asset/meta/time-grid-basics-test.cpp
@@ -61,7 +61,7 @@ namespace test {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test build some simple time grids and verify their behaviour
    *       for quantising (grid aligning) time values.
    * 
diff --git a/tests/core/proc/asset/orderingofassetstest.cpp b/tests/core/proc/asset/orderingofassetstest.cpp
index 702e40b56..849bc9890 100644
--- a/tests/core/proc/asset/orderingofassetstest.cpp
+++ b/tests/core/proc/asset/orderingofassetstest.cpp
@@ -44,7 +44,7 @@ namespace test {
   
   
   
-  /******************************************************
+  /**************************************************//**
    * @test validate the equality and order relations of 
    *       Asset::Ident and Asset objects.
    * @note a known problem is that only Asset smart ptrs
diff --git a/tests/core/proc/asset/typed-id-test.cpp b/tests/core/proc/asset/typed-id-test.cpp
index 23fb0af84..7cde1351f 100644
--- a/tests/core/proc/asset/typed-id-test.cpp
+++ b/tests/core/proc/asset/typed-id-test.cpp
@@ -99,7 +99,7 @@ namespace test {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test outline of an instance registration and accounting service.
    *       The service is self-contained and supports automatic registration
    *       and deregistration. The instance access is configurable on a 
diff --git a/tests/core/proc/control/argument-tuple-accept-test.cpp b/tests/core/proc/control/argument-tuple-accept-test.cpp
index 75d80c318..a5ac9f4dd 100644
--- a/tests/core/proc/control/argument-tuple-accept-test.cpp
+++ b/tests/core/proc/control/argument-tuple-accept-test.cpp
@@ -91,7 +91,7 @@ namespace test    {
   
   
   
-  /*************************************************************
+  /*********************************************************//**
    * @test Build a test object, which accepts a bind(...) call
    *       with specifically typed arguments.
    *       
diff --git a/tests/core/proc/control/command-argument-test.cpp b/tests/core/proc/control/command-argument-test.cpp
index 9d9efd0b7..b72516988 100644
--- a/tests/core/proc/control/command-argument-test.cpp
+++ b/tests/core/proc/control/command-argument-test.cpp
@@ -186,7 +186,7 @@ namespace test    {
   
   typedef lib::ScopedPtrVect<CmdClosure> ArgTuples;
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test Check storage handling of the command parameters and state memento.
    *
    * @see  control::CommandArgumentHolder
diff --git a/tests/core/proc/control/command-basic-test.cpp b/tests/core/proc/control/command-basic-test.cpp
index 1e6a3d20a..5150bdd9f 100644
--- a/tests/core/proc/control/command-basic-test.cpp
+++ b/tests/core/proc/control/command-basic-test.cpp
@@ -68,7 +68,7 @@ namespace test    {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test basic usage of the Proc-Layer command dispatch system.
    *       Shows how to define a simple command inline and how to
    *       trigger execution and UNDO. Verifies the command action
diff --git a/tests/core/proc/control/command-binding-test.cpp b/tests/core/proc/control/command-binding-test.cpp
index 7f42dc3bc..e20b61747 100644
--- a/tests/core/proc/control/command-binding-test.cpp
+++ b/tests/core/proc/control/command-binding-test.cpp
@@ -42,7 +42,7 @@ namespace test    {
   
   
   
-  /*****************************************************************************
+  /*************************************************************************//**
    * @test coverage for some specific situations when binding command arguments.
    * 
    * @todo add more test cases...
diff --git a/tests/core/proc/control/command-clone-builder-test.cpp b/tests/core/proc/control/command-clone-builder-test.cpp
index 18458e830..8bd90d901 100644
--- a/tests/core/proc/control/command-clone-builder-test.cpp
+++ b/tests/core/proc/control/command-clone-builder-test.cpp
@@ -52,7 +52,7 @@ namespace test    {
   
   
   
-  /********************************************************************************
+  /****************************************************************************//**
    * @test check creation of a command implementation clone from top level,
    *       without disclosing specific type information about the involved closure.
    *       This includes verifying sane allocation management.
diff --git a/tests/core/proc/control/command-equality-test.cpp b/tests/core/proc/control/command-equality-test.cpp
index cf60a738e..220d19ad7 100644
--- a/tests/core/proc/control/command-equality-test.cpp
+++ b/tests/core/proc/control/command-equality-test.cpp
@@ -90,7 +90,7 @@ namespace test    {
   
   
   
-  /*****************************************************************************************
+  /*************************************************************************************//**
    * @test cover command equality detection. Two commands are deemed equivalent, if they
    *       - build on the same Mutation functors
    *       - are either both incomplete or
diff --git a/tests/core/proc/control/command-mutation-test.cpp b/tests/core/proc/control/command-mutation-test.cpp
index 6d82a684e..d93f4a70a 100644
--- a/tests/core/proc/control/command-mutation-test.cpp
+++ b/tests/core/proc/control/command-mutation-test.cpp
@@ -69,7 +69,7 @@ namespace test    {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * Verify the behaviour of the type erased closure, which is used
    * by Proc-Layer commands to implement the capturing and later
    * re-invocation of a function.
diff --git a/tests/core/proc/control/command-registry-test.cpp b/tests/core/proc/control/command-registry-test.cpp
index 31719a197..0b4aff494 100644
--- a/tests/core/proc/control/command-registry-test.cpp
+++ b/tests/core/proc/control/command-registry-test.cpp
@@ -51,7 +51,7 @@ namespace test    {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test verify sane behaviour of the relevant operations on the CommandRegistry
    *       interface. Add/remove a command instance to the index, allocate an
    *       CommandImpl frame and verify it is removed properly on ref count zero.
diff --git a/tests/core/proc/control/command-use1-test.cpp b/tests/core/proc/control/command-use1-test.cpp
index d854d7f0d..827e49481 100644
--- a/tests/core/proc/control/command-use1-test.cpp
+++ b/tests/core/proc/control/command-use1-test.cpp
@@ -49,7 +49,7 @@ namespace test    {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test command usage aspects I: defining commands in various ways,
    *       then re-accessing those definitions, create instances,
    *       invoke them and undo the effect. Clean up finally.
diff --git a/tests/core/proc/control/command-use2-test.cpp b/tests/core/proc/control/command-use2-test.cpp
index 32eb80edc..54b1d2687 100644
--- a/tests/core/proc/control/command-use2-test.cpp
+++ b/tests/core/proc/control/command-use2-test.cpp
@@ -71,7 +71,7 @@ namespace test    {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test command usage aspects II: patterns of invoking commands.
    * 
    * @todo this test is still on hold, as the non-trivial patterns aren't implemented as of 10/09
diff --git a/tests/core/proc/control/command-use3-test.cpp b/tests/core/proc/control/command-use3-test.cpp
index a5ca90d9b..82f581822 100644
--- a/tests/core/proc/control/command-use3-test.cpp
+++ b/tests/core/proc/control/command-use3-test.cpp
@@ -60,7 +60,7 @@ namespace test    {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test command usage aspects III: elaborate handling patterns, like e.g.
    *       asynchronous or repeated invocation and command sequence bundles.
    *
diff --git a/tests/core/proc/control/handling-pattern-basics-test.cpp b/tests/core/proc/control/handling-pattern-basics-test.cpp
index f63c81f00..7edaabeb1 100644
--- a/tests/core/proc/control/handling-pattern-basics-test.cpp
+++ b/tests/core/proc/control/handling-pattern-basics-test.cpp
@@ -55,7 +55,7 @@ namespace test    {
   
   
   
-  /**********************************************************************************
+  /******************************************************************************//**
    * @test operate and verify a simple dummy command handling pattern.
    * @note this test covers mainly the behaviour of a handling pattern as a concept,
    *       not so much the behaviour of the (standard) handling pattern implementations.
diff --git a/tests/core/proc/control/handling-pattern-standard-impl-test.cpp b/tests/core/proc/control/handling-pattern-standard-impl-test.cpp
index 356d63be1..90c8db025 100644
--- a/tests/core/proc/control/handling-pattern-standard-impl-test.cpp
+++ b/tests/core/proc/control/handling-pattern-standard-impl-test.cpp
@@ -83,7 +83,7 @@ namespace test    {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test verify correct behaviour of all the command handling patterns
    *       provided by the default configuration of a lumiera session.
    *       - executing quasi synchronous
diff --git a/tests/core/proc/control/memento-tie-test.cpp b/tests/core/proc/control/memento-tie-test.cpp
index ad1f587aa..919c70727 100644
--- a/tests/core/proc/control/memento-tie-test.cpp
+++ b/tests/core/proc/control/memento-tie-test.cpp
@@ -65,7 +65,7 @@ namespace test    {
   
   
   
-  /*****************************************************************************************
+  /*************************************************************************************//**
    * @test Verify the state capturing mechanism (memento), which is used to implement
    * the Undo() functionality for Proc-Layer commands. Bind an undo function and a state
    * capturing function and wire up both to store and retrieve a memento value. 
diff --git a/tests/core/proc/engine/buff-table-test.cpp b/tests/core/proc/engine/buff-table-test.cpp
index 42576dddf..53a534fdb 100644
--- a/tests/core/proc/engine/buff-table-test.cpp
+++ b/tests/core/proc/engine/buff-table-test.cpp
@@ -122,7 +122,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test create a random pattern of recursive invocations, each
    *       allocating a chunk out of a global buffer table storage.
    *       After returning, each allocation should be cleanly
diff --git a/tests/core/proc/engine/buffer-metadata-key-test.cpp b/tests/core/proc/engine/buffer-metadata-key-test.cpp
index 768016628..93449ae07 100644
--- a/tests/core/proc/engine/buffer-metadata-key-test.cpp
+++ b/tests/core/proc/engine/buffer-metadata-key-test.cpp
@@ -155,7 +155,7 @@ namespace test  {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test verify calculation and relations of Buffer metadata type keys.
    *       These are used internally within the standard implementation
    *       of BufferProvider to keep track of various kinds of buffers,
diff --git a/tests/core/proc/engine/buffer-metadata-test.cpp b/tests/core/proc/engine/buffer-metadata-test.cpp
index e745689b9..dfa58fe65 100644
--- a/tests/core/proc/engine/buffer-metadata-test.cpp
+++ b/tests/core/proc/engine/buffer-metadata-test.cpp
@@ -74,7 +74,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test verify the properties of the BufferMetadata records used
    *       internally within BufferProvider to attach additional
    *       organisational data to the exposed buffers.
diff --git a/tests/core/proc/engine/buffer-provider-protocol-test.cpp b/tests/core/proc/engine/buffer-provider-protocol-test.cpp
index 91344b12b..af53d51e3 100644
--- a/tests/core/proc/engine/buffer-provider-protocol-test.cpp
+++ b/tests/core/proc/engine/buffer-provider-protocol-test.cpp
@@ -61,7 +61,7 @@ namespace test  {
   }
   
   
-  /******************************************************************************
+  /**************************************************************************//**
    * @test verify and demonstrate the usage cycle of data buffers for the engine
    *       based on the BufferProvider interface. This is kind of a "dry run"
    *       for documentation purposes, because the BufferProvider implementation
diff --git a/tests/core/proc/engine/calc-stream-test.cpp b/tests/core/proc/engine/calc-stream-test.cpp
index 9175d1fb2..7b4272d6a 100644
--- a/tests/core/proc/engine/calc-stream-test.cpp
+++ b/tests/core/proc/engine/calc-stream-test.cpp
@@ -45,7 +45,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test detailed coverage of the various CalcStream flavours
    *       supported by the render engine interface.
    * 
diff --git a/tests/core/proc/engine/dispatcher-interface-test.cpp b/tests/core/proc/engine/dispatcher-interface-test.cpp
index c4867e91f..20869f5b2 100644
--- a/tests/core/proc/engine/dispatcher-interface-test.cpp
+++ b/tests/core/proc/engine/dispatcher-interface-test.cpp
@@ -143,7 +143,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test document and verify the engine::Dispatcher interface, used
    *       to translate a CalcStream into individual node jobs.
    *       This test covers the definition of the interface itself,
diff --git a/tests/core/proc/engine/engine-interface-test.cpp b/tests/core/proc/engine/engine-interface-test.cpp
index 7f7b6ea59..d4c138240 100644
--- a/tests/core/proc/engine/engine-interface-test.cpp
+++ b/tests/core/proc/engine/engine-interface-test.cpp
@@ -63,7 +63,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test cover the basic service exposed at the engine interface:
    *       create a calculation stream and verify the translation
    *       into individual jobs.
diff --git a/tests/core/proc/engine/node-basic-test.cpp b/tests/core/proc/engine/node-basic-test.cpp
index 1c69d3443..9bdb388e2 100644
--- a/tests/core/proc/engine/node-basic-test.cpp
+++ b/tests/core/proc/engine/node-basic-test.cpp
@@ -71,7 +71,7 @@ namespace test  {
   }
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test basic render node properties and behaviour.
    */
   class NodeBasic_test : public Test
diff --git a/tests/core/proc/engine/node-fabrication-test.cpp b/tests/core/proc/engine/node-fabrication-test.cpp
index 98ee47e51..15caeb7c5 100644
--- a/tests/core/proc/engine/node-fabrication-test.cpp
+++ b/tests/core/proc/engine/node-fabrication-test.cpp
@@ -39,7 +39,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test creating and wiring various kinds of render nodes.
    */
   class NodeFabrication_test : public Test
diff --git a/tests/core/proc/engine/node-operation-test.cpp b/tests/core/proc/engine/node-operation-test.cpp
index fd6425029..196671e5b 100644
--- a/tests/core/proc/engine/node-operation-test.cpp
+++ b/tests/core/proc/engine/node-operation-test.cpp
@@ -39,7 +39,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test check render node operation modes and collaboration.
    */
   class NodeOperation_test : public Test
diff --git a/tests/core/proc/engine/node-source-test.cpp b/tests/core/proc/engine/node-source-test.cpp
index 171d17384..af7dc179e 100644
--- a/tests/core/proc/engine/node-source-test.cpp
+++ b/tests/core/proc/engine/node-source-test.cpp
@@ -39,7 +39,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test the source reading render node.
    */
   class NodeSource_test : public Test
diff --git a/tests/core/proc/engine/testframe-test.cpp b/tests/core/proc/engine/testframe-test.cpp
index 5b6f62990..157d1a69f 100644
--- a/tests/core/proc/engine/testframe-test.cpp
+++ b/tests/core/proc/engine/testframe-test.cpp
@@ -56,7 +56,7 @@ namespace test  {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test verify test helper for engine tests: a dummy data frame.
    *       TestFrame instances can be created right away, without any
    *       external library dependencies. A test frame is automatically
diff --git a/tests/core/proc/engine/tracking-heap-block-provider-test.cpp b/tests/core/proc/engine/tracking-heap-block-provider-test.cpp
index 311a647d3..79aa9ffd2 100644
--- a/tests/core/proc/engine/tracking-heap-block-provider-test.cpp
+++ b/tests/core/proc/engine/tracking-heap-block-provider-test.cpp
@@ -66,7 +66,7 @@ namespace test  {
   }
   
   
-  /**********************************************************************
+  /******************************************************************//**
    * @test verify a test support facility, used to write mock components
    *       to test the lumiera engine. The TrackingHeapBlockProvider is a
    *       braindead implementation of the BufferProvider interface: it just
diff --git a/tests/core/proc/mobject/builder/buildertooltest.cpp b/tests/core/proc/mobject/builder/buildertooltest.cpp
index 97d6a0e30..c550f7b59 100644
--- a/tests/core/proc/mobject/builder/buildertooltest.cpp
+++ b/tests/core/proc/mobject/builder/buildertooltest.cpp
@@ -94,7 +94,7 @@ namespace test    {
       
       
       
-      /*************************************************************************************
+      /*********************************************************************************//**
        * @test the generic visitor pattern specialised for treating MObjects in the builder.
        * Besides using existing MObject types (at the moment session::Clip),
        * we create a yet-unknown new MObject subclass. When passing such to any
diff --git a/tests/core/proc/mobject/builder/buildsegmenttest.cpp b/tests/core/proc/mobject/builder/buildsegmenttest.cpp
index ba074f761..f72edd70e 100644
--- a/tests/core/proc/mobject/builder/buildsegmenttest.cpp
+++ b/tests/core/proc/mobject/builder/buildsegmenttest.cpp
@@ -40,7 +40,7 @@ namespace test {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test the builder core functionality: create a render pipeline
    *       for a given segment of the Session/Timeline.
    */
diff --git a/tests/core/proc/mobject/builder/fixture-change-detector-test.cpp b/tests/core/proc/mobject/builder/fixture-change-detector-test.cpp
index a07a47761..1f0397242 100644
--- a/tests/core/proc/mobject/builder/fixture-change-detector-test.cpp
+++ b/tests/core/proc/mobject/builder/fixture-change-detector-test.cpp
@@ -82,7 +82,7 @@ namespace test  {
   
   
   
-  /*********************************************************************************
+  /*****************************************************************************//**
    * @test TODO blubb
    *       
    * @see  mobject::builder::FixtureChangeDetector
diff --git a/tests/core/proc/mobject/builder/model-port-registry-test.cpp b/tests/core/proc/mobject/builder/model-port-registry-test.cpp
index 9052db807..c769e802b 100644
--- a/tests/core/proc/mobject/builder/model-port-registry-test.cpp
+++ b/tests/core/proc/mobject/builder/model-port-registry-test.cpp
@@ -90,7 +90,7 @@ namespace test  {
   
   
   
-  /*********************************************************************************
+  /*****************************************************************************//**
    * @test create a standalone model port registry to verify the behaviour of
    *       model ports, accessed through reference handles. This test provides an
    *       example setup detached from the real usage situation within the builder.
diff --git a/tests/core/proc/mobject/builder/segmentation-datastructure-test.cpp b/tests/core/proc/mobject/builder/segmentation-datastructure-test.cpp
index c09b3a70f..6bf35fbd8 100644
--- a/tests/core/proc/mobject/builder/segmentation-datastructure-test.cpp
+++ b/tests/core/proc/mobject/builder/segmentation-datastructure-test.cpp
@@ -82,7 +82,7 @@ namespace test  {
   
   
   
-  /*********************************************************************************
+  /*****************************************************************************//**
    * @test TODO blubb
    *       
    * @see  mobject::builder::FixtureChangeDetector
diff --git a/tests/core/proc/mobject/controller/rendersegmenttest.cpp b/tests/core/proc/mobject/controller/rendersegmenttest.cpp
index 6f0bfc538..5aaa1b7b5 100644
--- a/tests/core/proc/mobject/controller/rendersegmenttest.cpp
+++ b/tests/core/proc/mobject/controller/rendersegmenttest.cpp
@@ -40,7 +40,7 @@ namespace test {
   
   
   
-  /********************************************************************
+  /****************************************************************//**
    * @test create a render process from a given segment of the Session.
    *       Basically this includes cooperation of all parts of the
    *       Lumiera Proc Layer. For a prepared test-Session we invoke the
diff --git a/tests/core/proc/mobject/mobject-interface-test.cpp b/tests/core/proc/mobject/mobject-interface-test.cpp
index 85db4d6ca..4890f8648 100644
--- a/tests/core/proc/mobject/mobject-interface-test.cpp
+++ b/tests/core/proc/mobject/mobject-interface-test.cpp
@@ -68,7 +68,7 @@ namespace test    {
   typedef TestPlacement<DummyMO> PDummy;
   
   
-  /*********************************************************************************
+  /*****************************************************************************//**
    * @test cover the common behaviour of all MObjects. 
    * @note the MObject interface is still very preliminary (as of 10/10).
    *       It is expected to support some kind of metadata and object serialisation
diff --git a/tests/core/proc/mobject/mobject-ref-test.cpp b/tests/core/proc/mobject/mobject-ref-test.cpp
index 4c01859f8..78b735d07 100644
--- a/tests/core/proc/mobject/mobject-ref-test.cpp
+++ b/tests/core/proc/mobject/mobject-ref-test.cpp
@@ -84,7 +84,7 @@ namespace test    {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test properties and behaviour of the external reference-mechanism for
    *       MObjects placed into the session. We create a simple, simulated
    *       "session" (no real session datastructure) and a mock PlacementIndex.
diff --git a/tests/core/proc/mobject/output-mapping-test.cpp b/tests/core/proc/mobject/output-mapping-test.cpp
index 5bd75c464..d4d89c6e0 100644
--- a/tests/core/proc/mobject/output-mapping-test.cpp
+++ b/tests/core/proc/mobject/output-mapping-test.cpp
@@ -45,7 +45,7 @@ namespace test {
   typedef asset::ID<Pipe> PID;
   
   
-  /*********************************************************************************
+  /*****************************************************************************//**
    * @test create a synthetic / example mapping to verify generic mapping behaviour.
    *       We're creating a custom mapping type here, for this test only: The
    *       struct DummyDef provides a "definition context" for this custom mapping
diff --git a/tests/core/proc/mobject/placement-basic-test.cpp b/tests/core/proc/mobject/placement-basic-test.cpp
index 1eccec30a..eb274bbef 100644
--- a/tests/core/proc/mobject/placement-basic-test.cpp
+++ b/tests/core/proc/mobject/placement-basic-test.cpp
@@ -48,7 +48,7 @@ namespace test    {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test basic behaviour of Placements and access to MObjects.
    * @see  mobject::Placement
    * @see  mobject::MObject#create
diff --git a/tests/core/proc/mobject/placement-hierarchy-test.cpp b/tests/core/proc/mobject/placement-hierarchy-test.cpp
index 4e38405a5..bc2272a98 100644
--- a/tests/core/proc/mobject/placement-hierarchy-test.cpp
+++ b/tests/core/proc/mobject/placement-hierarchy-test.cpp
@@ -55,7 +55,7 @@ namespace test    {
   using lumiera::error::LUMIERA_ERROR_ASSERTION;
   
   
-  /***************************************************************************************
+  /***********************************************************************************//**
    * @test creating placements specifically typed, forming an hierarchy of placement types
    *       which loosely mirrors the hierarchy of the pointee types. Assignments between
    *       placement of differing type, while still sharing ownership.
diff --git a/tests/core/proc/mobject/placement-object-identity-test.cpp b/tests/core/proc/mobject/placement-object-identity-test.cpp
index e31662d08..a0c8a1252 100644
--- a/tests/core/proc/mobject/placement-object-identity-test.cpp
+++ b/tests/core/proc/mobject/placement-object-identity-test.cpp
@@ -52,7 +52,7 @@ namespace test    {
   
 
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test verify correct handling of object identity. Create test objects,
    *       add placements to a dummy index/session, then create PlacementRef
    *       and MObjectRef handles. Finally do cross comparisons.
diff --git a/tests/core/proc/mobject/placement-ref-test.cpp b/tests/core/proc/mobject/placement-ref-test.cpp
index f57d509e6..37f40cf6f 100644
--- a/tests/core/proc/mobject/placement-ref-test.cpp
+++ b/tests/core/proc/mobject/placement-ref-test.cpp
@@ -51,7 +51,7 @@ namespace test    {
   typedef PlacementMO::ID P_ID;
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test properties and behaviour of the reference-mechanism for Placements.
    *       We create an mock placement index and install it to be used
    *       by all PlacementRef instances while conducting this test.
diff --git a/tests/core/proc/mobject/session/addcliptest.cpp b/tests/core/proc/mobject/session/addcliptest.cpp
index 4e57950a3..b2f823fc6 100644
--- a/tests/core/proc/mobject/session/addcliptest.cpp
+++ b/tests/core/proc/mobject/session/addcliptest.cpp
@@ -44,7 +44,7 @@ namespace test {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test adding an test clip to the Model/Session.
    * @see  mobject::session::Clip
    * @see  mobject::Session
diff --git a/tests/core/proc/mobject/session/defs-manager-impl-test.cpp b/tests/core/proc/mobject/session/defs-manager-impl-test.cpp
index 76de4e6b3..3171728a8 100644
--- a/tests/core/proc/mobject/session/defs-manager-impl-test.cpp
+++ b/tests/core/proc/mobject/session/defs-manager-impl-test.cpp
@@ -81,7 +81,7 @@ namespace test    {
   
   
   
-  /************************************************************************
+  /********************************************************************//**
    * @test verify some general assumptions regarding implementation details
    *       of the the defaults manager.
    * @see  DefsManager_test for the "big picture"
diff --git a/tests/core/proc/mobject/session/defs-manager-test.cpp b/tests/core/proc/mobject/session/defs-manager-test.cpp
index efea24df3..1a14abfa2 100644
--- a/tests/core/proc/mobject/session/defs-manager-test.cpp
+++ b/tests/core/proc/mobject/session/defs-manager-test.cpp
@@ -71,7 +71,7 @@ namespace test    {
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test basic behaviour of the defaults manager ("the big picture")
    *       - retrieving a "default" object repeatedly
    *       - retrieving a more constrained "default" object
diff --git a/tests/core/proc/mobject/session/defs-registry-impl-test.cpp b/tests/core/proc/mobject/session/defs-registry-impl-test.cpp
index 65f59d856..3ab595ac5 100644
--- a/tests/core/proc/mobject/session/defs-registry-impl-test.cpp
+++ b/tests/core/proc/mobject/session/defs-registry-impl-test.cpp
@@ -95,7 +95,7 @@ namespace test    {
   
   
   
-  /************************************************************************
+  /********************************************************************//**
    * @test build an registry table (just for this test) configured for
    *       some artificial test Types. Register some entries and verify
    *       the intended behaviour of the storage structure.
diff --git a/tests/core/proc/mobject/session/deletecliptest.cpp b/tests/core/proc/mobject/session/deletecliptest.cpp
index 2738462e7..fcbb07137 100644
--- a/tests/core/proc/mobject/session/deletecliptest.cpp
+++ b/tests/core/proc/mobject/session/deletecliptest.cpp
@@ -50,7 +50,7 @@ namespace test    {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test removing a test clip from the Session/Model.
    * @see  mobject::session::Clip
    * @see  mobject::Session
diff --git a/tests/core/proc/mobject/session/placement-index-query-test.cpp b/tests/core/proc/mobject/session/placement-index-query-test.cpp
index dff06b1b9..64c1f3cfa 100644
--- a/tests/core/proc/mobject/session/placement-index-query-test.cpp
+++ b/tests/core/proc/mobject/session/placement-index-query-test.cpp
@@ -48,7 +48,7 @@ namespace test    {
   using std::endl;
   
   
-  /****************************************************************************
+  /************************************************************************//**
    * @test accessing the PlacementIndex through the generic query interface,
    *       for discovering scope contents and containing scope.
    *       
diff --git a/tests/core/proc/mobject/session/placement-index-test.cpp b/tests/core/proc/mobject/session/placement-index-test.cpp
index 0cdb18d66..216ff8dc7 100644
--- a/tests/core/proc/mobject/session/placement-index-test.cpp
+++ b/tests/core/proc/mobject/session/placement-index-test.cpp
@@ -52,7 +52,7 @@ namespace test    {
   typedef PlacementIndex& Idx;
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test basic behaviour of the index mechanism used to keep track
    *       of individual Placements as added to the current Session.
    * @see  mobject::Placement
diff --git a/tests/core/proc/mobject/session/placement-scope-test.cpp b/tests/core/proc/mobject/session/placement-scope-test.cpp
index f507673a6..068d01eff 100644
--- a/tests/core/proc/mobject/session/placement-scope-test.cpp
+++ b/tests/core/proc/mobject/session/placement-scope-test.cpp
@@ -61,7 +61,7 @@ namespace test    {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test basic behaviour of the nested placement search scopes.
    *       Using a pseudo-session (actually just a PlacementIndex),
    *       this test creates some nested scopes and then...
diff --git a/tests/core/proc/mobject/session/query-focus-stack-test.cpp b/tests/core/proc/mobject/session/query-focus-stack-test.cpp
index 161a4b194..5a58fe445 100644
--- a/tests/core/proc/mobject/session/query-focus-stack-test.cpp
+++ b/tests/core/proc/mobject/session/query-focus-stack-test.cpp
@@ -41,7 +41,7 @@ namespace test    {
   using lumiera::error::LUMIERA_ERROR_INVALID;
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test behaviour of the stack of focus location paths.
    *       Basically this is just a stack, but has a somewhat unusual behaviour
    *       on pop(), as it considers the (intrusive) ref-count maintained within
diff --git a/tests/core/proc/mobject/session/query-focus-test.cpp b/tests/core/proc/mobject/session/query-focus-test.cpp
index fa73cab30..7c433d481 100644
--- a/tests/core/proc/mobject/session/query-focus-test.cpp
+++ b/tests/core/proc/mobject/session/query-focus-test.cpp
@@ -55,7 +55,7 @@ namespace test    {
   using std::endl;
   
   
-  /***********************************************************************************
+  /*******************************************************************************//**
    * @test handling of current query focus when navigating a system of nested scopes.
    *       Using a pseudo-session (actually just a PlacementIndex), this test
    *       accesses some nested scopes and then checks moving the "current scope".
diff --git a/tests/core/proc/mobject/session/query-resolver-test.cpp b/tests/core/proc/mobject/session/query-resolver-test.cpp
index 6920833a3..c6db78ddf 100644
--- a/tests/core/proc/mobject/session/query-resolver-test.cpp
+++ b/tests/core/proc/mobject/session/query-resolver-test.cpp
@@ -182,7 +182,7 @@ namespace test{
   
   
   
-  /***********************************************************************************
+  /*******************************************************************************//**
    * @test verify the mechanism for issuing typed queries through a generic interface,
    *       without disclosing the facility actually answering those queries. 
    *       Results are to be retrieved through a Lumiera Forward Iterator.
diff --git a/tests/core/proc/mobject/session/rebuildfixturetest.cpp b/tests/core/proc/mobject/session/rebuildfixturetest.cpp
index 6a12a3bfe..30a382269 100644
--- a/tests/core/proc/mobject/session/rebuildfixturetest.cpp
+++ b/tests/core/proc/mobject/session/rebuildfixturetest.cpp
@@ -45,7 +45,7 @@ namespace test    {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test (re)building the ExplicitPlacement objects from the objects
    *       placed into the Session/Model.
    * @see  mobject::session::Fixture
diff --git a/tests/core/proc/mobject/session/scope-path-test.cpp b/tests/core/proc/mobject/session/scope-path-test.cpp
index e54fed27a..fc28c689f 100644
--- a/tests/core/proc/mobject/session/scope-path-test.cpp
+++ b/tests/core/proc/mobject/session/scope-path-test.cpp
@@ -50,7 +50,7 @@ namespace test    {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test properties and behaviour of the path of nested scopes.
    *       Using a pseudo-session (actually just a PlacementIndex),
    *       this test  creates some nested scopes, builds scope paths
diff --git a/tests/core/proc/mobject/session/scope-query-test.cpp b/tests/core/proc/mobject/session/scope-query-test.cpp
index 3dd98d7ba..aa3b09f25 100644
--- a/tests/core/proc/mobject/session/scope-query-test.cpp
+++ b/tests/core/proc/mobject/session/scope-query-test.cpp
@@ -79,7 +79,7 @@ namespace test    {
   
   
   
-  /**********************************************************************************************
+  /******************************************************************************************//**
    * @test how to discover contents or location of a container-like part of the high-level model.
    *       As this container-like object is just a concept and actually implemented by the
    *       PlacementIndex, this means querying the index for elements registered with
diff --git a/tests/core/proc/mobject/session/session-element-query-test.cpp b/tests/core/proc/mobject/session/session-element-query-test.cpp
index 03c2fa1ef..54dc65b5b 100644
--- a/tests/core/proc/mobject/session/session-element-query-test.cpp
+++ b/tests/core/proc/mobject/session/session-element-query-test.cpp
@@ -73,7 +73,7 @@ namespace test    {
   
   
   
-  /**********************************************************************************************
+  /******************************************************************************************//**
    * @test cover the part of the session API allowing to retrieve specific elements by query.
    *       - This test first picks an object from the test session, where the filter predicate
    *         utilises the specific MObject subclass (here DummyMO).
diff --git a/tests/core/proc/mobject/session/session-element-tracker-test.cpp b/tests/core/proc/mobject/session/session-element-tracker-test.cpp
index d9f417593..bd236cf3d 100644
--- a/tests/core/proc/mobject/session/session-element-tracker-test.cpp
+++ b/tests/core/proc/mobject/session/session-element-tracker-test.cpp
@@ -92,7 +92,7 @@ namespace test    {
   using asset::AssetManager;
   
   
-  /********************************************************************************
+  /****************************************************************************//**
    * @test verify the tracking of special session/model elements, to be exposed
    *       through an self-contained interface module on the session API.
    *       The basic element-tracking mechanism uses a simple (vector based)
diff --git a/tests/core/proc/mobject/session/session-modify-parts-test.cpp b/tests/core/proc/mobject/session/session-modify-parts-test.cpp
index f3dd290ff..155c1e6a9 100644
--- a/tests/core/proc/mobject/session/session-modify-parts-test.cpp
+++ b/tests/core/proc/mobject/session/session-modify-parts-test.cpp
@@ -65,7 +65,7 @@ namespace test    {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test perform the most important structural modifications on a session and
    *       verify they're carried out properly. 
    *       - attaching tracks
diff --git a/tests/core/proc/mobject/session/session-service-access-test.cpp b/tests/core/proc/mobject/session/session-service-access-test.cpp
index 3944ff04d..bd6925202 100644
--- a/tests/core/proc/mobject/session/session-service-access-test.cpp
+++ b/tests/core/proc/mobject/session/session-service-access-test.cpp
@@ -279,7 +279,7 @@ namespace test    {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * Verify the access mechanism both to the pubic session API and
    * to implementation level APIs used by Proc-Layer internals.
    * 
diff --git a/tests/core/proc/mobject/session/session-structure-test.cpp b/tests/core/proc/mobject/session/session-structure-test.cpp
index 448209662..7a68ac14e 100644
--- a/tests/core/proc/mobject/session/session-structure-test.cpp
+++ b/tests/core/proc/mobject/session/session-structure-test.cpp
@@ -49,7 +49,7 @@ namespace test    {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test access the current session and verify the correct
    *       structure of the most important components: The session
    *       contains an Sequence, we can get at the Fixture, we have at least
diff --git a/tests/core/proc/mobject/session/sessionmanagertest.cpp b/tests/core/proc/mobject/session/sessionmanagertest.cpp
index add0e8493..fff7544be 100644
--- a/tests/core/proc/mobject/session/sessionmanagertest.cpp
+++ b/tests/core/proc/mobject/session/sessionmanagertest.cpp
@@ -39,7 +39,7 @@ namespace session {
 namespace test    {
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * Check the session management operations provided by mobject::session::Session
    * This includes accessing the current Session (somewhat a singleton).
    * @todo load a Mock session
diff --git a/tests/core/proc/mobject/session/timeline-sequence-handling-test.cpp b/tests/core/proc/mobject/session/timeline-sequence-handling-test.cpp
index 943ec415c..8f5023361 100644
--- a/tests/core/proc/mobject/session/timeline-sequence-handling-test.cpp
+++ b/tests/core/proc/mobject/session/timeline-sequence-handling-test.cpp
@@ -58,7 +58,7 @@ namespace test    {
   using lumiera::Query;
   
   
-  /********************************************************************************
+  /****************************************************************************//**
    * @test verify retrieval and instance management of the top level facade objects
    *       as integrated with the session and high-level model. Both sequences and
    *       timelines are at the same time structural assets and act as facades
diff --git a/tests/core/proc/play/diagnostic-output-slot.hpp b/tests/core/proc/play/diagnostic-output-slot.hpp
index fcd15300d..657a5de4d 100644
--- a/tests/core/proc/play/diagnostic-output-slot.hpp
+++ b/tests/core/proc/play/diagnostic-output-slot.hpp
@@ -261,7 +261,7 @@ namespace play {
   
   
   
-  /********************************************************************
+  /****************************************************************//**
    * Helper for unit tests: Mock output sink.
    * Complete implementation of the OutputSlot interface, with some
    * additional stipulations to support unit testing.
diff --git a/tests/core/proc/play/dummy-play-connection-test.cpp b/tests/core/proc/play/dummy-play-connection-test.cpp
index 18143a563..c9e0f1777 100644
--- a/tests/core/proc/play/dummy-play-connection-test.cpp
+++ b/tests/core/proc/play/dummy-play-connection-test.cpp
@@ -48,7 +48,7 @@ namespace test {
   typedef DummyPlayConnection<PlayTestFrames_Strategy> DummyPlayer;
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test verify the OutputSlot interface and base implementation
    *       by performing full data exchange cycle. This is a
    *       kind of "dry run" for documentation purposes,
diff --git a/tests/core/proc/play/output-slot-protocol-test.cpp b/tests/core/proc/play/output-slot-protocol-test.cpp
index d63428175..ca921f448 100644
--- a/tests/core/proc/play/output-slot-protocol-test.cpp
+++ b/tests/core/proc/play/output-slot-protocol-test.cpp
@@ -40,7 +40,7 @@ namespace test {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test verify the OutputSlot interface and base implementation
    *       by performing full data exchange cycle. This is a
    *       kind of "dry run" for documentation purposes,
diff --git a/tests/core/proc/play/timing-constraints-test.cpp b/tests/core/proc/play/timing-constraints-test.cpp
index f63b0114d..99b890798 100644
--- a/tests/core/proc/play/timing-constraints-test.cpp
+++ b/tests/core/proc/play/timing-constraints-test.cpp
@@ -50,7 +50,7 @@ namespace test {
 //typedef DummyPlayConnection<PlayTestFrames_Strategy> DummyPlayer;
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test document and verify the definition and combining of
    *       timing constraints for playback and rendering.
    */
diff --git a/tests/library/advice/advice-basics-test.cpp b/tests/library/advice/advice-basics-test.cpp
index 0a3bbece4..e5a65e532 100644
--- a/tests/library/advice/advice-basics-test.cpp
+++ b/tests/library/advice/advice-basics-test.cpp
@@ -92,7 +92,7 @@ namespace test {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test proof-of-concept for the Advice collaboration.
    *       Advice allows data exchange without coupling the participants tightly.
    *       This test demonstrates the basic expected behaviour in a simple but
diff --git a/tests/library/advice/advice-binding-pattern-test.cpp b/tests/library/advice/advice-binding-pattern-test.cpp
index dadbc33bf..b55ddfa49 100644
--- a/tests/library/advice/advice-binding-pattern-test.cpp
+++ b/tests/library/advice/advice-binding-pattern-test.cpp
@@ -45,7 +45,7 @@ namespace test  {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test the pattern matching machinery used to find an Advice solution.
    *       Each advice::Provision and advice::Request specifies a binding, used
    *       to discern various pieces of advice. Whenever patterns on the two sides
diff --git a/tests/library/advice/advice-configuration-test.cpp b/tests/library/advice/advice-configuration-test.cpp
index 7a42ea4e5..2b011c96b 100644
--- a/tests/library/advice/advice-configuration-test.cpp
+++ b/tests/library/advice/advice-configuration-test.cpp
@@ -61,7 +61,7 @@ namespace test {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test this is a collection of tests to cover the configuration options
    *       available as policy arguments when establishing the collaboration.
    *       - default advice values, or blocking or throwing
diff --git a/tests/library/advice/advice-index-test.cpp b/tests/library/advice/advice-index-test.cpp
index 8bbf232ea..8eaf0bf11 100644
--- a/tests/library/advice/advice-index-test.cpp
+++ b/tests/library/advice/advice-index-test.cpp
@@ -126,7 +126,7 @@ namespace test {
   
   
   
-  /******************************************************************************************
+  /**************************************************************************************//**
    * @test the Advice system uses an index datastructure to support matching the bindings
    *       to get pairs of participants to connect by an individual advice channel.
    *       
diff --git a/tests/library/advice/advice-multiplicity-test.cpp b/tests/library/advice/advice-multiplicity-test.cpp
index 22e217459..c0dda990b 100644
--- a/tests/library/advice/advice-multiplicity-test.cpp
+++ b/tests/library/advice/advice-multiplicity-test.cpp
@@ -61,7 +61,7 @@ namespace test {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test stress test for the Advice system:
    *       Concurrently add a multitude of advice provisions and check correct
    *       matching and dispatch of all advice.
diff --git a/tests/library/advice/advice-situations-test.cpp b/tests/library/advice/advice-situations-test.cpp
index 5e920e645..6729d6c0c 100644
--- a/tests/library/advice/advice-situations-test.cpp
+++ b/tests/library/advice/advice-situations-test.cpp
@@ -62,7 +62,7 @@ namespace test {
   
   
   
-  /******************************************************************************************
+  /**************************************************************************************//**
    * @test documentation of the fundamental usage scenarios envisioned in the Advice concept.
    *       This test will be augmented and completed as the Lumiera application matures.
    * 
diff --git a/tests/library/allocation-cluster-test.cpp b/tests/library/allocation-cluster-test.cpp
index 4e765b41c..cf1294d43 100644
--- a/tests/library/allocation-cluster-test.cpp
+++ b/tests/library/allocation-cluster-test.cpp
@@ -144,7 +144,7 @@ namespace test {
   
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    *  @test verify the proper workings of our custom allocation scheme
    *        managing families of interconnected objects for the segments
    *        of the low-level model.
diff --git a/tests/library/bool-checkable-test.cpp b/tests/library/bool-checkable-test.cpp
index 41175202c..c4f51b83a 100644
--- a/tests/library/bool-checkable-test.cpp
+++ b/tests/library/bool-checkable-test.cpp
@@ -66,7 +66,7 @@ namespace test{
   
   
   
-  /**********************************************************
+  /******************************************************//**
    * @test verify the implementation of a validity check,
    *       to be accessed as an implicit conversion to bool.
    *       
diff --git a/tests/library/custom-shared-ptr-test.cpp b/tests/library/custom-shared-ptr-test.cpp
index 9a8a2c1df..879cae8b2 100644
--- a/tests/library/custom-shared-ptr-test.cpp
+++ b/tests/library/custom-shared-ptr-test.cpp
@@ -63,7 +63,7 @@ namespace test{
     };
   
   
-  /****************************************************************
+  /************************************************************//**
    * @test assure correct behaviour of lumiera's custom shared-ptr,
    *       including ADL of operators, shared ownership, typing
    *       and ordering
diff --git a/tests/library/del-stash-test.cpp b/tests/library/del-stash-test.cpp
index 48c4f9823..5a157d1c8 100644
--- a/tests/library/del-stash-test.cpp
+++ b/tests/library/del-stash-test.cpp
@@ -90,7 +90,7 @@ namespace test{
   
   
   
-  /****************************************************************************
+  /************************************************************************//**
    * @test create a bunch of objects with varying type and size, memorising
    *       how to kill them properly. Verify everyone is dead after mass-kill.
    *       Use a checksum not only to verify the number of objects created and
diff --git a/tests/library/dependency-factory-test.cpp b/tests/library/dependency-factory-test.cpp
index ad091989a..cc99532ef 100644
--- a/tests/library/dependency-factory-test.cpp
+++ b/tests/library/dependency-factory-test.cpp
@@ -82,7 +82,7 @@ namespace test{
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test verify the various modes of creating dependencies.
    *       - standard case is singleton creation
    *       - configuration of a specific subclass for the singleton
diff --git a/tests/library/diagnostic-context-test.cpp b/tests/library/diagnostic-context-test.cpp
index 2e4edfd11..55374ed8b 100644
--- a/tests/library/diagnostic-context-test.cpp
+++ b/tests/library/diagnostic-context-test.cpp
@@ -68,7 +68,7 @@ namespace test{
   
   
   
-  /**********************************************************************************
+  /******************************************************************************//**
    * @test verify a diagnostic facility to collect and access contextual information.
    *       DiagnosticContext frames are placed into automatic storage (as local
    *       variable within some function scope). Based on thread-local storage,
diff --git a/tests/library/exceptionerrortest.cpp b/tests/library/exceptionerrortest.cpp
index 2fa28bbc8..f19259b99 100644
--- a/tests/library/exceptionerrortest.cpp
+++ b/tests/library/exceptionerrortest.cpp
@@ -54,7 +54,7 @@ namespace lumiera {
     LUMIERA_EXCEPTION_DECLARE (DerivedError, error::External,  LUMIERA_ERROR_DERIVED);
     
     
-    /**********************************************************
+    /******************************************************//**
      * Some aspects of C++ exception handling.
      * Not to be confused with the basic C-style error value 
      * mechanism used by the low-level parts of the backend.
diff --git a/tests/library/format-helper-test.cpp b/tests/library/format-helper-test.cpp
index f223510af..c625cadea 100644
--- a/tests/library/format-helper-test.cpp
+++ b/tests/library/format-helper-test.cpp
@@ -46,7 +46,7 @@ namespace test {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test verifies the proper working of some string-formatting helper functions.
    *       - util::str() provides a failsafe to-String conversion, preferring
    *         an built-in conversion, falling back to just a mangled type string.
diff --git a/tests/library/format-string-test.cpp b/tests/library/format-string-test.cpp
index ec3c3e5cc..4b2c58aad 100644
--- a/tests/library/format-string-test.cpp
+++ b/tests/library/format-string-test.cpp
@@ -44,7 +44,7 @@ namespace test {
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test verifies our front-end for printf-style format string based formatting.
    *       - the implementation is based on boost::format
    *       - we create a wrapper-object on-the fly, which is able to hold
diff --git a/tests/library/functor-util-test.cpp b/tests/library/functor-util-test.cpp
index 16f0753a8..e6b8bb7ef 100644
--- a/tests/library/functor-util-test.cpp
+++ b/tests/library/functor-util-test.cpp
@@ -54,7 +54,7 @@ namespace test {
   
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * @test verify some aspects of the functor-util's behaviour.
    *       At times, this is just a scrapbook for new ideas....
    */
diff --git a/tests/library/hash-generator-test.cpp b/tests/library/hash-generator-test.cpp
index ee9a87525..1d35d9e8b 100644
--- a/tests/library/hash-generator-test.cpp
+++ b/tests/library/hash-generator-test.cpp
@@ -44,7 +44,7 @@ namespace test{
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test cover various detail aspects regarding hash value generation
    *       - weakness of boost::hash
    *       
diff --git a/tests/library/hash-indexed-test.cpp b/tests/library/hash-indexed-test.cpp
index 00281767d..a5d52c124 100644
--- a/tests/library/hash-indexed-test.cpp
+++ b/tests/library/hash-indexed-test.cpp
@@ -57,7 +57,7 @@ namespace test{
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test proof-of-concept test for a generic hash based and typed ID struct.
    *       - check the various ctors 
    *       - check default assignment works properly
diff --git a/tests/library/helloworldtest.cpp b/tests/library/helloworldtest.cpp
index c54c87440..d94b90fdb 100644
--- a/tests/library/helloworldtest.cpp
+++ b/tests/library/helloworldtest.cpp
@@ -34,7 +34,7 @@ using util::isnil;
 namespace lumiera{
 namespace test   {
   
-  /******************************************
+  /**************************************//**
    * Hellooooooo the world is just a test
    * @test demo of using the test framework
    */
diff --git a/tests/library/hierarchy-orientation-indicator-test.cpp b/tests/library/hierarchy-orientation-indicator-test.cpp
index 1162ccdb9..41d3b9e78 100644
--- a/tests/library/hierarchy-orientation-indicator-test.cpp
+++ b/tests/library/hierarchy-orientation-indicator-test.cpp
@@ -323,7 +323,7 @@ namespace test {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test describing and rebuilding a tree structure
    *       while visiting the tree in depth first order.
    *       To keep track of the level changes during that navigation,
diff --git a/tests/library/item-wrapper-test.cpp b/tests/library/item-wrapper-test.cpp
index ba0ec5442..efeae1a22 100644
--- a/tests/library/item-wrapper-test.cpp
+++ b/tests/library/item-wrapper-test.cpp
@@ -92,7 +92,7 @@ namespace test{
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test use the ItemWrapper to define inline-storage holding values,
    *       pointers and references. Verify correct behaviour in each case,
    *       including (self)assignment, empty check, invalid dereferentiation.
diff --git a/tests/library/iter-adapter-stl-test.cpp b/tests/library/iter-adapter-stl-test.cpp
index c4aafff4a..021fe0108 100644
--- a/tests/library/iter-adapter-stl-test.cpp
+++ b/tests/library/iter-adapter-stl-test.cpp
@@ -70,7 +70,7 @@ namespace test{
   
   
   
-  /************************************************************************
+  /********************************************************************//**
    * @test verify some of the adapters to expose typical container
    *       usage patterns as Lumiera Forward Iterators.
    *       - distinct values from a sequence
diff --git a/tests/library/iter-adapter-test.cpp b/tests/library/iter-adapter-test.cpp
index 82b67f614..599633e75 100644
--- a/tests/library/iter-adapter-test.cpp
+++ b/tests/library/iter-adapter-test.cpp
@@ -168,7 +168,7 @@ namespace test{
   
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * @test set up example implementations based on the iterator-adapter
    *       templates and verify the behaviour in accordance to the
    *       concept "lumiera forward iterator"
diff --git a/tests/library/iter-explorer-test.cpp b/tests/library/iter-explorer-test.cpp
index 9b4e136fc..9d49bd6bd 100644
--- a/tests/library/iter-explorer-test.cpp
+++ b/tests/library/iter-explorer-test.cpp
@@ -188,7 +188,7 @@ namespace test{
   
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * @test use a simple source iterator yielding numbers
    *       to build various functional evaluation structures,
    *       based on the IterExplorer template.
diff --git a/tests/library/iter-queue-test.cpp b/tests/library/iter-queue-test.cpp
index 157a8b2c8..b0a09a091 100644
--- a/tests/library/iter-queue-test.cpp
+++ b/tests/library/iter-queue-test.cpp
@@ -42,7 +42,7 @@ namespace test{
   
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * @test cover an easy to use queue, built as convenience wrapper
    *       on top of \c std::deque and allowing element retrieval
    *       by iteration.
diff --git a/tests/library/iter-source-test.cpp b/tests/library/iter-source-test.cpp
index 046333fbf..d806d5318 100644
--- a/tests/library/iter-source-test.cpp
+++ b/tests/library/iter-source-test.cpp
@@ -139,7 +139,7 @@ namespace test{
   
   
   
-  /******************************************************************
+  /**************************************************************//**
    *  @test create some (opaque) data sources,
    *        and then pull the data out by iteration.
    *        Demonstrates simple usage of the IterSource interface
diff --git a/tests/library/iter-stack-test.cpp b/tests/library/iter-stack-test.cpp
index 9802b84f8..5a35e4280 100644
--- a/tests/library/iter-stack-test.cpp
+++ b/tests/library/iter-stack-test.cpp
@@ -45,7 +45,7 @@ namespace test{
   
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * @test cover behaviour of a convenience class built by using a
    *       \c std::deque as "state core" of an Lumiera IterStateWrapper.
    *       - iterable according to the Lumiera Forward Iterator concept
diff --git a/tests/library/itertools-test.cpp b/tests/library/itertools-test.cpp
index 226e7376b..93c767659 100644
--- a/tests/library/itertools-test.cpp
+++ b/tests/library/itertools-test.cpp
@@ -82,7 +82,7 @@ namespace test{
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    *  @test build combined and filtering iterators with the help of lib::IterTool.
    *        Check correct behaviour of the resulting iterators and
    *        verify they fulfil the Lumiera Forward Iterator concept
diff --git a/tests/library/linked-elements-test.cpp b/tests/library/linked-elements-test.cpp
index 63655aa62..a2efdce5e 100644
--- a/tests/library/linked-elements-test.cpp
+++ b/tests/library/linked-elements-test.cpp
@@ -171,7 +171,7 @@ namespace test{
   
   
   
-  /********************************************************************
+  /****************************************************************//**
    *  @test cover our custom single linked list template,
    *        in combination with Lumiera Forward Iterators
    *        and the usage of a custom allocator.
diff --git a/tests/library/maybe-value-test.cpp b/tests/library/maybe-value-test.cpp
index 28e778269..824d84821 100644
--- a/tests/library/maybe-value-test.cpp
+++ b/tests/library/maybe-value-test.cpp
@@ -75,7 +75,7 @@ namespace test{
   
   
   
-  /***************************************************************************************
+  /***********************************************************************************//**
    * @test Investigate various situations of using a Maybe value or option monad.
    * @note this is a testbed for experiments for the time being 11/2011
    * 
diff --git a/tests/library/meta/config-flags-test.cpp b/tests/library/meta/config-flags-test.cpp
index 6b97e0dd8..f97b8870b 100644
--- a/tests/library/meta/config-flags-test.cpp
+++ b/tests/library/meta/config-flags-test.cpp
@@ -123,7 +123,7 @@ cout << "__________________________\n" \
   
   
   
-  /**************************************************************************
+  /**********************************************************************//**
    * @test check the handling of types representing a specific configuration.
    *       Basically, this is a bitset like feature, but working on types
    *       instead of runtime values. The Goal is to detect automatically
diff --git a/tests/library/meta/duck-detector-test.cpp b/tests/library/meta/duck-detector-test.cpp
index 7eade48ed..78a4c5469 100644
--- a/tests/library/meta/duck-detector-test.cpp
+++ b/tests/library/meta/duck-detector-test.cpp
@@ -59,7 +59,7 @@ namespace test{
   
   
   
-  /***********************************************************************************
+  /*******************************************************************************//**
    * @test verify building predicates to detect properties of a type at compile time.
    *       Especially, this allows us to detect if a type in question
    *       - has a nested type with a specific name
diff --git a/tests/library/meta/function-closure-test.cpp b/tests/library/meta/function-closure-test.cpp
index a3809bdb8..9c27b8e8f 100644
--- a/tests/library/meta/function-closure-test.cpp
+++ b/tests/library/meta/function-closure-test.cpp
@@ -98,7 +98,7 @@ namespace test {
   using func::apply;
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * @test building a function closure for a given function or functor,
    *       while arguments are passed in as tuple
    *       - accessing signatures as typelists
diff --git a/tests/library/meta/function-composition-test.cpp b/tests/library/meta/function-composition-test.cpp
index 45a50a047..1fd9db847 100644
--- a/tests/library/meta/function-composition-test.cpp
+++ b/tests/library/meta/function-composition-test.cpp
@@ -124,7 +124,7 @@ namespace test {
   
   
   
-  /******************************************************************************
+  /**************************************************************************//**
    * @test this test covers some extensions and variations on function closures:
    *       - partial application of a function, returning a partial closure
    *       - variation: binding an arbitrary term, might even be a nested binder
diff --git a/tests/library/meta/function-erasure-test.cpp b/tests/library/meta/function-erasure-test.cpp
index 8a3db77cb..807390291 100644
--- a/tests/library/meta/function-erasure-test.cpp
+++ b/tests/library/meta/function-erasure-test.cpp
@@ -54,7 +54,7 @@ namespace test {
   struct BuildEmptyFunctor<Efun> { typedef function<long(int,char)> Type; };
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test Create specifically typed functor objects and then wrap them
    *       into common holder objects, thereby discarding the specific
    *       signature type information. Later on, the concrete functor
diff --git a/tests/library/meta/generator-combinations-test.cpp b/tests/library/meta/generator-combinations-test.cpp
index ec3d7a03e..48aaed0d6 100644
--- a/tests/library/meta/generator-combinations-test.cpp
+++ b/tests/library/meta/generator-combinations-test.cpp
@@ -92,7 +92,7 @@ namespace test {
   
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * @test check utilities for generating case combinations.
    *       - verify the Cartesian product is built properly
    *       - instantiate a two-parameter test template
diff --git a/tests/library/meta/generator-test.cpp b/tests/library/meta/generator-test.cpp
index 96646c46e..2e5978660 100644
--- a/tests/library/meta/generator-test.cpp
+++ b/tests/library/meta/generator-test.cpp
@@ -109,7 +109,7 @@ namespace test {
   typedef InstantiateChained<TheTypes,DoIt, BaseImpl>  NumberBabbler;
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * @test check the helpers for dealing with lists-of-types.
    *       Build an interface and an implementation class
    *       by inheriting template instantiations
diff --git a/tests/library/meta/iterable-classification-test.cpp b/tests/library/meta/iterable-classification-test.cpp
index 1dd45a6b2..00108c385 100644
--- a/tests/library/meta/iterable-classification-test.cpp
+++ b/tests/library/meta/iterable-classification-test.cpp
@@ -78,7 +78,7 @@ namespace test {
   
   
   
-  /***********************************************************************************
+  /*******************************************************************************//**
    * @test verify the (static) classification/detection of iterables.
    *       Currently (1/10) we're able to detect the following
    *       - a STL like container with \c begin() and \c end()
diff --git a/tests/library/meta/meta-utils-test.cpp b/tests/library/meta/meta-utils-test.cpp
index 50aa87a4c..8cadb5699 100644
--- a/tests/library/meta/meta-utils-test.cpp
+++ b/tests/library/meta/meta-utils-test.cpp
@@ -39,7 +39,7 @@ namespace test {
   
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * @test verify basic type trait and metaprogramming helpers.
    *       - marker types to tell which overload the compiler picks
    *       - simple trait to detect the possibility of a string conversion
diff --git a/tests/library/meta/type-tuple-test.cpp b/tests/library/meta/type-tuple-test.cpp
index 0bfa8e3a9..a2e158ae1 100644
--- a/tests/library/meta/type-tuple-test.cpp
+++ b/tests/library/meta/type-tuple-test.cpp
@@ -70,7 +70,7 @@ namespace test {
   
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * @test Cover various aspects of the type tuple.
    *       Check the metaprogramming behaviour...
    *       - build a tuple type from an existing typelist
diff --git a/tests/library/meta/typelist-manip-test.cpp b/tests/library/meta/typelist-manip-test.cpp
index 46e3f784b..5d8cc3974 100644
--- a/tests/library/meta/typelist-manip-test.cpp
+++ b/tests/library/meta/typelist-manip-test.cpp
@@ -78,7 +78,7 @@ namespace test {
       
       
       
-      /*************************************************************************
+      /*********************************************************************//**
        * @test check utilities for manipulating lists-of-types.
        *       - build an list of constant-wrapper-types and
        *         print them for debugging purpose.
diff --git a/tests/library/meta/typelist-test.cpp b/tests/library/meta/typelist-test.cpp
index 80081fe67..b32c19df7 100644
--- a/tests/library/meta/typelist-test.cpp
+++ b/tests/library/meta/typelist-test.cpp
@@ -67,7 +67,7 @@ namespace test {
       
       typedef Chain<TheList,Zero> AssembledClass;
       
-      /*************************************************************************
+      /*********************************************************************//**
        * @test try out Loki-style typelist metaprogramming.
        *       Assembles a Class definition from parts specified as collection
        *       of types. The elementary building block has an talking ctor, so
diff --git a/tests/library/meta/typelist-util-test.cpp b/tests/library/meta/typelist-util-test.cpp
index 576167a40..55de3474b 100644
--- a/tests/library/meta/typelist-util-test.cpp
+++ b/tests/library/meta/typelist-util-test.cpp
@@ -42,7 +42,7 @@ namespace test {
   
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * @test verify the simple helpers for working with lists-of-types.
    *       These are simple metafunctions to count the number of elements,
    *       calculate the maximum size or check for inclusion.
diff --git a/tests/library/meta/typeseq-manip-test.cpp b/tests/library/meta/typeseq-manip-test.cpp
index 0874eae9f..0330e4b11 100644
--- a/tests/library/meta/typeseq-manip-test.cpp
+++ b/tests/library/meta/typeseq-manip-test.cpp
@@ -79,7 +79,7 @@ namespace test {
   
   
   
-  /**************************************************************************
+  /**********************************************************************//**
    * @test check the basic utilities for manipulating (fixed) type sequences.
    *       - re-build an sequence from a type list
    *       - prepend a type to a given type sequence
diff --git a/tests/library/multifact-argument-test.cpp b/tests/library/multifact-argument-test.cpp
index 6c1760150..0ce4dd76f 100644
--- a/tests/library/multifact-argument-test.cpp
+++ b/tests/library/multifact-argument-test.cpp
@@ -81,7 +81,7 @@ namespace test{
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test define a MultiFact (factory with dynamic registration),
    *       which accepts additional arguments and passes them
    *       through to the registered factory function(s).
diff --git a/tests/library/multifact-test.cpp b/tests/library/multifact-test.cpp
index 89495f0b3..5bd7b3185 100644
--- a/tests/library/multifact-test.cpp
+++ b/tests/library/multifact-test.cpp
@@ -95,7 +95,7 @@ namespace test{
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test verify simple setup of the MultiFact template.
    *       Define a hierarchy of test dummy objects, in order to
    *       register them automatically for creation through a suitable
diff --git a/tests/library/null-value-test.cpp b/tests/library/null-value-test.cpp
index 57eb6085b..af67e8ba9 100644
--- a/tests/library/null-value-test.cpp
+++ b/tests/library/null-value-test.cpp
@@ -61,7 +61,7 @@ namespace test{
   
   
   
-  /***************************************************************************************
+  /***********************************************************************************//**
    * @test Access "NIL values" just by type, verify these are actually singletons
    *       and are indeed created on demand.
    * 
diff --git a/tests/library/opaque-holder-test.cpp b/tests/library/opaque-holder-test.cpp
index 1b95f8471..95a69d968 100644
--- a/tests/library/opaque-holder-test.cpp
+++ b/tests/library/opaque-holder-test.cpp
@@ -105,7 +105,7 @@ namespace test{
   
   
   
-  /**********************************************************************************
+  /******************************************************************************//**
    *  @test use the OpaqueHolder inline buffer to handle objects of a family of types
    *        through a common interface, without being forced to use heap storage
    *        or a custom allocator.
diff --git a/tests/library/opaque-unchecked-buffer-test.cpp b/tests/library/opaque-unchecked-buffer-test.cpp
index 50e3de2e0..6b6b74cd3 100644
--- a/tests/library/opaque-unchecked-buffer-test.cpp
+++ b/tests/library/opaque-unchecked-buffer-test.cpp
@@ -123,7 +123,7 @@ namespace test{
   
   
   
-  /**********************************************************************************
+  /******************************************************************************//**
    *  @test use an inline buffer to place objects of a subclass, without any checks.
    *        InPlaceBuffer only provides minimal service, to be covered here, 
    *        including automatic dtor invocation and smart-ptr style access.
diff --git a/tests/library/optional-ref-test.cpp b/tests/library/optional-ref-test.cpp
index 5bfb5128a..c061fb686 100644
--- a/tests/library/optional-ref-test.cpp
+++ b/tests/library/optional-ref-test.cpp
@@ -39,7 +39,7 @@ namespace test{
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test verify a reference-like wrapper class,
    *       used to provide a switchable link to an already existing object.
    *       - bottom ref can be detected by bool check
diff --git a/tests/library/polymorphic-value-test.cpp b/tests/library/polymorphic-value-test.cpp
index dfe2ed686..6da5cd81f 100644
--- a/tests/library/polymorphic-value-test.cpp
+++ b/tests/library/polymorphic-value-test.cpp
@@ -161,7 +161,7 @@ namespace test{
   
   
   
-  /**********************************************************************************
+  /******************************************************************************//**
    *  @test build a bunch of PolymorphicValue objects. Handle them like copyable
    *        value objects, without knowing the exact implementation type; moreover
    *        execute implementation internals only disclosed to the concrete subtype.
diff --git a/tests/library/query-text-test.cpp b/tests/library/query-text-test.cpp
index 56070f5c0..83473a81c 100644
--- a/tests/library/query-text-test.cpp
+++ b/tests/library/query-text-test.cpp
@@ -49,7 +49,7 @@ namespace test{
   
   
   
-  /*******************************************************************************
+  /***************************************************************************//**
    * @test cover basic properties of the generic syntactical query representation.
    *       - build from query string
    *       
diff --git a/tests/library/query/query-utils-test.cpp b/tests/library/query/query-utils-test.cpp
index 12098a448..d6773efdb 100644
--- a/tests/library/query/query-utils-test.cpp
+++ b/tests/library/query/query-utils-test.cpp
@@ -56,7 +56,7 @@ namespace test{
   
   
   
-  /************************************************************************
+  /********************************************************************//**
    * @test check the various small helpers and utilities we utilise
    *       for dealing with ConfigQuery 
    */
diff --git a/tests/library/ref-array-test.cpp b/tests/library/ref-array-test.cpp
index b0127167f..52734cd60 100644
--- a/tests/library/ref-array-test.cpp
+++ b/tests/library/ref-array-test.cpp
@@ -94,7 +94,7 @@ namespace test{
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test build several wrappers, each based on a different storage,
    * all providing RefArray access to a given vector. The rationale
    * for RefArray is to expose just the interface: the data structure
diff --git a/tests/library/scoped-collection-test.cpp b/tests/library/scoped-collection-test.cpp
index c2408d7dc..6a9f6ecfe 100644
--- a/tests/library/scoped-collection-test.cpp
+++ b/tests/library/scoped-collection-test.cpp
@@ -92,7 +92,7 @@ namespace test{
   typedef ScopedCollection<Dummy, sizeof(SubDummy)> CollD;
   
   
-  /********************************************************************
+  /****************************************************************//**
    *  @test ScopedCollection manages a fixed set of objects, but these
    *        child objects are noncopyable, may be polymorphic, an can
    *        be created either all at once or chunk wise. The API is
diff --git a/tests/library/scoped-holder-test.cpp b/tests/library/scoped-holder-test.cpp
index 3815d86a3..bfc2e93ef 100644
--- a/tests/library/scoped-holder-test.cpp
+++ b/tests/library/scoped-holder-test.cpp
@@ -49,7 +49,7 @@ namespace test{
   typedef ScopedPtrHolder<Dummy> PtrHolderD;
   
   
-  /**********************************************************************************
+  /******************************************************************************//**
    *  @test ScopedHolder and ScopedPtrHolder are initially empty and copyable.
    *        After taking ownership, they prohibit copy operations, manage the
    *        lifecycle of the contained object and provide smart-ptr like access.
diff --git a/tests/library/scoped-holder-transfer-test.cpp b/tests/library/scoped-holder-transfer-test.cpp
index add399caa..f7c9a2e22 100644
--- a/tests/library/scoped-holder-transfer-test.cpp
+++ b/tests/library/scoped-holder-transfer-test.cpp
@@ -92,7 +92,7 @@ namespace test {
   
   
   
-  /**********************************************************************************
+  /******************************************************************************//**
    *  @test growing a vector containing noncopyable objects wrapped into ScopedHolder
    *        instances. This requires the use of a custom allocator, invoking a
    *        \c transfer_control() function to be provided for the concrete
diff --git a/tests/library/scoped-ptrvect-test.cpp b/tests/library/scoped-ptrvect-test.cpp
index b1d7fe62f..98b197485 100644
--- a/tests/library/scoped-ptrvect-test.cpp
+++ b/tests/library/scoped-ptrvect-test.cpp
@@ -41,7 +41,7 @@ namespace test{
   typedef ScopedPtrVect<Dummy> VectD;
   
   
-  /********************************************************************
+  /****************************************************************//**
    *  @test ScopedPtrVect manages the lifecycle of a number of objects.
    *        The API is similar to a vector and allows for element access
    *        and iteration. Individual elements can be detached and thus
diff --git a/tests/library/search-path-splitter-test.cpp b/tests/library/search-path-splitter-test.cpp
index b9d1b1396..ac0510bac 100644
--- a/tests/library/search-path-splitter-test.cpp
+++ b/tests/library/search-path-splitter-test.cpp
@@ -37,7 +37,7 @@ namespace lib {
 namespace test {
   
   
-  /******************************************************
+  /**************************************************//**
    * @test verify splitting a search path specification
    *       and retrieving the components by iteration.
    *       Embedded \c $ORIGIN tokens get resolved
diff --git a/tests/library/simple-allocator-test.cpp b/tests/library/simple-allocator-test.cpp
index ea239d26d..891a9020a 100644
--- a/tests/library/simple-allocator-test.cpp
+++ b/tests/library/simple-allocator-test.cpp
@@ -79,7 +79,7 @@ namespace test{
   
   
   
-  /***************************************************************************************
+  /***********************************************************************************//**
    * @test cover the basic operations of a custom allocator, delegating to mpool.
    *       The SimpleAllocator doesn't provide any ref-counting or tracking facilities,
    *       nor does he support bulk de-allocation. The advantage over using std::allocator
diff --git a/tests/library/singleton-subclass-test.cpp b/tests/library/singleton-subclass-test.cpp
index a747cb796..18945e890 100644
--- a/tests/library/singleton-subclass-test.cpp
+++ b/tests/library/singleton-subclass-test.cpp
@@ -82,7 +82,7 @@ namespace test{
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test specialised variant of the Singleton Factory, for creating
    *       subclasses (implementation classes) without coupling the
    *       caller to the concrete class type.
diff --git a/tests/library/singleton-test.cpp b/tests/library/singleton-test.cpp
index a4086f7bd..01ac049d1 100644
--- a/tests/library/singleton-test.cpp
+++ b/tests/library/singleton-test.cpp
@@ -69,7 +69,7 @@ namespace test{
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test implement a Singleton class using our Singleton Template.
    * Expected results: single instance created in static memory,
    * single instance properly destroyed, no memory leaks.
diff --git a/tests/library/singleton-testmock-test.cpp b/tests/library/singleton-testmock-test.cpp
index f20b26808..2e1a777fb 100644
--- a/tests/library/singleton-testmock-test.cpp
+++ b/tests/library/singleton-testmock-test.cpp
@@ -105,7 +105,7 @@ namespace test{
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test inject a Mock object into the Singleton Factory,
    *       to be returned and used in place of the original object.
    *       This test covers the full usage cycle: first access the
diff --git a/tests/library/streamtypebasicstest.cpp b/tests/library/streamtypebasicstest.cpp
index be18f6e59..c0deaa898 100644
--- a/tests/library/streamtypebasicstest.cpp
+++ b/tests/library/streamtypebasicstest.cpp
@@ -41,7 +41,7 @@ namespace test_format {
   typedef StreamType::ImplFacade const& ImplType;
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test check the basic workings of the stream type handling.
    *       create some stream implementation data, build a 
    *       StreamType::ImplFacade from this, and derive a prototype
diff --git a/tests/library/streamtypelifecycletest.cpp b/tests/library/streamtypelifecycletest.cpp
index 7c0dc63b3..fcfcf164a 100644
--- a/tests/library/streamtypelifecycletest.cpp
+++ b/tests/library/streamtypelifecycletest.cpp
@@ -59,7 +59,7 @@ namespace test_format {
   
   
   
-  /*******************************************************************
+  /***************************************************************//**
    * @test check the stream type registration lifecycle. 
    *       Any internal or external component (plugin) can extend
    *       the Proc Layer's registry of media stream types.
diff --git a/tests/library/sub-id-test.cpp b/tests/library/sub-id-test.cpp
index 6794c92d5..0bf9ad77e 100644
--- a/tests/library/sub-id-test.cpp
+++ b/tests/library/sub-id-test.cpp
@@ -67,7 +67,7 @@ namespace test{
   
   
   
-  /****************************************************************************
+  /************************************************************************//**
    * @test for now (9/09) this is a playground for shaping a vague design idea
    *       - base types and casts 
    *       - exploring some extensions
diff --git a/tests/library/subsystem-runner-test.cpp b/tests/library/subsystem-runner-test.cpp
index 725ce6413..fd0d536c2 100644
--- a/tests/library/subsystem-runner-test.cpp
+++ b/tests/library/subsystem-runner-test.cpp
@@ -250,7 +250,7 @@ namespace test  {
     
     
     
-    /**************************************************************************
+    /**********************************************************************//**
      * @test managing start and stop of several dependent "subsystems"
      *       under various conditions. Using mock-subsystems, which actually
      *       spawn a thread and finish by themselves and generally behave sane.
diff --git a/tests/library/symbol-hashtable-test.cpp b/tests/library/symbol-hashtable-test.cpp
index 801e65518..dd0e8ccfb 100644
--- a/tests/library/symbol-hashtable-test.cpp
+++ b/tests/library/symbol-hashtable-test.cpp
@@ -57,7 +57,7 @@ namespace test{
   typedef std::tr1::unordered_map< Symbol, string, hash<Symbol> > HTable;
   
   
-  /*************************************************************
+  /*********************************************************//**
    * @test build a hashtable using Symbol objects as Keys.
    *       Especially this verifies picking up a customised
    *       hash implementation via ADL
diff --git a/tests/library/symbol-test.cpp b/tests/library/symbol-test.cpp
index 89d1b4cd1..46a2295f0 100644
--- a/tests/library/symbol-test.cpp
+++ b/tests/library/symbol-test.cpp
@@ -41,7 +41,7 @@ namespace lib {
 namespace test{
   
   
-  /**********************************************************
+  /******************************************************//**
    * @test properties of Symbol data type. Currently this is
    *       just a thin wrapper for a const char *
    * @todo this test is very much WIP, as the implementation
diff --git a/tests/library/sync-classlock-test.cpp b/tests/library/sync-classlock-test.cpp
index 3f8010e12..8eace7879 100644
--- a/tests/library/sync-classlock-test.cpp
+++ b/tests/library/sync-classlock-test.cpp
@@ -62,7 +62,7 @@ namespace test {
   
   
   
-  /**************************************************************************
+  /**********************************************************************//**
    * @test check proper handling of class (not instance)-based Monitor locks.
    * Because no instance is available in this case, a hidden storage for the
    * Monitor object needs to be provided in a way safe for use even in the
diff --git a/tests/library/sync-locking-test.cpp b/tests/library/sync-locking-test.cpp
index 6bc9d7614..84c0c41df 100644
--- a/tests/library/sync-locking-test.cpp
+++ b/tests/library/sync-locking-test.cpp
@@ -159,7 +159,7 @@ namespace test{
   
   
   
-  /**********************************************************************
+  /******************************************************************//**
    * @test create multiple threads, all concurrently trying to increment
    * a number of counters with random steps and random pauses. Without
    * locking, the likely result will be differing counters.
diff --git a/tests/library/sync-timedwait-test.cpp b/tests/library/sync-timedwait-test.cpp
index 6632a10ad..998606d02 100644
--- a/tests/library/sync-timedwait-test.cpp
+++ b/tests/library/sync-timedwait-test.cpp
@@ -50,7 +50,7 @@ namespace test{
   
   
   
-  /********************************************************************************
+  /****************************************************************************//**
    * @test timeout feature on condition wait as provided by pthread and accessible
    *       via the object monitor based locking/waiting mechanism. Without creating
    *       multiple threads, we engage into a blocking wait, which aborts due to
diff --git a/tests/library/sync-waiting-test.cpp b/tests/library/sync-waiting-test.cpp
index c86306548..96ba49b55 100644
--- a/tests/library/sync-waiting-test.cpp
+++ b/tests/library/sync-waiting-test.cpp
@@ -118,7 +118,7 @@ namespace test{
   
   
   
-  /****************************************************************************
+  /************************************************************************//**
    * @test concurrent waiting and notification, implemented via object monitor.
    * This test covers the second part of the monitor pattern, which builds upon
    * the locking part, additionally using an embedded condition. We provide
diff --git a/tests/library/test/test-helper-test.cpp b/tests/library/test/test-helper-test.cpp
index 498331b78..96537de14 100644
--- a/tests/library/test/test-helper-test.cpp
+++ b/tests/library/test/test-helper-test.cpp
@@ -61,7 +61,7 @@ namespace test{
   int dontThrow() { return 2+2; }
   
   
-  /*************************************************
+  /*********************************************//**
    * verifies the proper working of helper functions
    * frequently used within the Lumiera testsuite.
    * @see test-helper.hpp
diff --git a/tests/library/test/testoptiontest.cpp b/tests/library/test/testoptiontest.cpp
index 8bb517604..3646148f8 100644
--- a/tests/library/test/testoptiontest.cpp
+++ b/tests/library/test/testoptiontest.cpp
@@ -32,7 +32,7 @@ using std::endl;
 
 namespace test {
   
-  /****************************************************************
+  /************************************************************//**
    * invokes the TestOption parser for various example commandlines
    * @test for test::TestOption, parsing of commandline options
    * @see test::Suite
diff --git a/tests/library/thread-local-test.cpp b/tests/library/thread-local-test.cpp
index 114ba4c05..4cbd895c3 100644
--- a/tests/library/thread-local-test.cpp
+++ b/tests/library/thread-local-test.cpp
@@ -82,7 +82,7 @@ namespace test{
   
   
   
-  /**************************************************************************
+  /**********************************************************************//**
    * @test use a wrapper to simplify handling of thread-local data.
    *       Create some threads, each referring to another piece of data
    *       through the "same" wrapper instance.
diff --git a/tests/library/thread-wrapper-join-test.cpp b/tests/library/thread-wrapper-join-test.cpp
index 30b655cdd..5b3d108cb 100644
--- a/tests/library/thread-wrapper-join-test.cpp
+++ b/tests/library/thread-wrapper-join-test.cpp
@@ -48,7 +48,7 @@ namespace test {
   }
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test use the Lumiera backend to create some new threads, additionally
    *       synchronising with these child threads and waiting for termination.
    * 
diff --git a/tests/library/thread-wrapper-test.cpp b/tests/library/thread-wrapper-test.cpp
index 42d3a2b0e..acdd5389d 100644
--- a/tests/library/thread-wrapper-test.cpp
+++ b/tests/library/thread-wrapper-test.cpp
@@ -112,7 +112,7 @@ namespace backend {
     
     
     
-    /**************************************************************************
+    /**********************************************************************//**
      * @test use the Lumiera backend to create some new threads, utilising the
      *       lumiera::Thread wrapper for binding to an arbitrary operation
      *       and passing the appropriate context.
diff --git a/tests/library/time/digxel-configurations-test.cpp b/tests/library/time/digxel-configurations-test.cpp
index 9ff75ac50..1481b5ce7 100644
--- a/tests/library/time/digxel-configurations-test.cpp
+++ b/tests/library/time/digxel-configurations-test.cpp
@@ -48,7 +48,7 @@ namespace test{
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test verify correctness of the predefined standard Digxels.
    *       Some widely used standard configurations, including
    *       - default Digxel for int and double values
diff --git a/tests/library/time/digxel-test.cpp b/tests/library/time/digxel-test.cpp
index 7f610ae6b..dab6738d2 100644
--- a/tests/library/time/digxel-test.cpp
+++ b/tests/library/time/digxel-test.cpp
@@ -134,7 +134,7 @@ namespace test{
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test verify correct behaviour of an display "Digxel":
    *       A self-contained numeric element to support building displays.
    *       - build a Digxel
diff --git a/tests/library/time/format-support-test.cpp b/tests/library/time/format-support-test.cpp
index f8353204c..b1f90465d 100644
--- a/tests/library/time/format-support-test.cpp
+++ b/tests/library/time/format-support-test.cpp
@@ -32,7 +32,7 @@ namespace test {
   
   
   
-  /********************************************************
+  /****************************************************//**
    * @test check how support for a specific timecode format
    *       can be enabled and detected. Actually this test
    *       verifies a simple metaprogramming facility,
diff --git a/tests/library/time/quantiser-basics-test.cpp b/tests/library/time/quantiser-basics-test.cpp
index 0313ab2ca..dbcfa695a 100644
--- a/tests/library/time/quantiser-basics-test.cpp
+++ b/tests/library/time/quantiser-basics-test.cpp
@@ -54,7 +54,7 @@ namespace test{
   
   
   
-  /********************************************************
+  /****************************************************//**
    * @test cover the basic Quantiser API.
    * This test uses a standalone quantiser implementation
    * to demonstrate and verify the basic behaviour
diff --git a/tests/library/time/time-basics-test.cpp b/tests/library/time/time-basics-test.cpp
index 30cdaed10..7e5ef6dd8 100644
--- a/tests/library/time/time-basics-test.cpp
+++ b/tests/library/time/time-basics-test.cpp
@@ -48,7 +48,7 @@ namespace test{
   using time::FSecs;
   
   
-  /********************************************
+  /****************************************//**
    * @test sanity check of basic Time handling.
    */
   class TimeBasics_test : public Test
diff --git a/tests/library/time/time-control-test.cpp b/tests/library/time/time-control-test.cpp
index f7db3039f..182cb8018 100644
--- a/tests/library/time/time-control-test.cpp
+++ b/tests/library/time/time-control-test.cpp
@@ -115,7 +115,7 @@ namespace test{
   
   
   
-  /***********************************************************************
+  /*******************************************************************//**
    * @test use the time::Control to push a sequence of modifications to
    *       various time entities; in all cases, a suitable change should
    *       be imposed to the target and then a notification signal
diff --git a/tests/library/time/time-formats-test.cpp b/tests/library/time/time-formats-test.cpp
index 0222a1eeb..fef32a278 100644
--- a/tests/library/time/time-formats-test.cpp
+++ b/tests/library/time/time-formats-test.cpp
@@ -67,7 +67,7 @@ namespace test{
   
   
   
-  /********************************************************
+  /****************************************************//**
    * @test verify handling of grid aligned timecode values.
    *       - full cycle from parsing to formatting
    *       - mutating the components of timecode
diff --git a/tests/library/time/time-mutation-test.cpp b/tests/library/time/time-mutation-test.cpp
index 32730824f..eef879f35 100644
--- a/tests/library/time/time-mutation-test.cpp
+++ b/tests/library/time/time-mutation-test.cpp
@@ -57,7 +57,7 @@ namespace test{
   
   
   
-  /****************************************************************
+  /************************************************************//**
    * @test cover all basic cases for mutating a time specification.
    *       - change to a given value
    *       - change by an offset
diff --git a/tests/library/time/time-parsing-test.cpp b/tests/library/time/time-parsing-test.cpp
index 24ada115c..ddb2acd4f 100644
--- a/tests/library/time/time-parsing-test.cpp
+++ b/tests/library/time/time-parsing-test.cpp
@@ -92,7 +92,7 @@ namespace test{
   
   
   
-  /********************************************************
+  /****************************************************//**
    * @test parse textual time specifications given
    *       in the supported timecode formats
    */
diff --git a/tests/library/time/time-quantisation-test.cpp b/tests/library/time/time-quantisation-test.cpp
index 9cda288d3..617a8d620 100644
--- a/tests/library/time/time-quantisation-test.cpp
+++ b/tests/library/time/time-quantisation-test.cpp
@@ -50,7 +50,7 @@ namespace test{
   using proc::asset::meta::TimeGrid;
   
   
-  /********************************************************
+  /****************************************************//**
    * @test verify handling of quantised time values.
    *       - the simple usage, just referring to an 
    *         predefined grid by name
diff --git a/tests/library/time/time-value-test.cpp b/tests/library/time/time-value-test.cpp
index 59d71b7c2..552202fd9 100644
--- a/tests/library/time/time-value-test.cpp
+++ b/tests/library/time/time-value-test.cpp
@@ -44,7 +44,7 @@ namespace time{
 namespace test{
   
   
-  /********************************************************
+  /****************************************************//**
    * @test verify handling of time values, time intervals.
    *       - creating times and time intervals
    *       - comparisons
diff --git a/tests/library/typed-allocation-manager-test.cpp b/tests/library/typed-allocation-manager-test.cpp
index bd1b2261f..3b46b240a 100644
--- a/tests/library/typed-allocation-manager-test.cpp
+++ b/tests/library/typed-allocation-manager-test.cpp
@@ -70,7 +70,7 @@ namespace test{
   
   
   
-  /***************************************************************************************
+  /***********************************************************************************//**
    * @test cover the basic implementation of a custom allocator, delegating to mpool.
    *       TypedAllocationManager is a base class, used e.g. to build the CommandRegistry.
    * 
diff --git a/tests/library/typed-counter-test.cpp b/tests/library/typed-counter-test.cpp
index ad0735e44..f2548492a 100644
--- a/tests/library/typed-counter-test.cpp
+++ b/tests/library/typed-counter-test.cpp
@@ -299,7 +299,7 @@ namespace test{
   
   
   
-  /***************************************************************************************
+  /***********************************************************************************//**
    * @test build multiple sets of type-based contexts and run a simple counting operation
    *       in each of them concurrently. Check the proper allocation of type-IDs in each
    *       context and verify correct counting operation by checksum.
diff --git a/tests/library/util-collection-test.cpp b/tests/library/util-collection-test.cpp
index dd98144b6..65e773715 100644
--- a/tests/library/util-collection-test.cpp
+++ b/tests/library/util-collection-test.cpp
@@ -72,7 +72,7 @@ namespace test {
   
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * @test verify some convenience shortcuts and helpers dealing
    * with Collections and sequences (Iterators).
    * - metafunctions to distinguish STL containers and Lumiera Iterators
diff --git a/tests/library/util-floordiv-test.cpp b/tests/library/util-floordiv-test.cpp
index 256498cef..ba2c75822 100644
--- a/tests/library/util-floordiv-test.cpp
+++ b/tests/library/util-floordiv-test.cpp
@@ -90,7 +90,7 @@ namespace test {
   
   
   
-  /**********************************************************************
+  /******************************************************************//**
    * @test Evaluate a custom built integer floor function.
    *       Also known as Knuth's floor division.
    *       This function is crucial for Lumiera's rule of quantisation
diff --git a/tests/library/util-floorwrap-test.cpp b/tests/library/util-floorwrap-test.cpp
index 7e66cc10b..20b16e69f 100644
--- a/tests/library/util-floorwrap-test.cpp
+++ b/tests/library/util-floorwrap-test.cpp
@@ -46,7 +46,7 @@ namespace test {
   
   
   
-  /***************************************************************************
+  /***********************************************************************//**
    * @test Verify a custom built integer scale division and wrapping function.
    *       This function is relevant for decimating values into a given scale,
    *       like splitting time measurements in hours, minutes, seconds etc.
diff --git a/tests/library/util-foreach-test.cpp b/tests/library/util-foreach-test.cpp
index e9eb3f54c..2b60a8295 100644
--- a/tests/library/util-foreach-test.cpp
+++ b/tests/library/util-foreach-test.cpp
@@ -108,7 +108,7 @@ namespace test {
   
   
   
-  /*********************************************************************
+  /*****************************************************************//**
    * @test Invoking an operation for each element of a collection.
    *       Covers the various flavours of these convenience helpers:
    *       They might operate either on a STL container (providing 
diff --git a/tests/library/vector-transfer-test.cpp b/tests/library/vector-transfer-test.cpp
index 6a4e8974d..143594342 100644
--- a/tests/library/vector-transfer-test.cpp
+++ b/tests/library/vector-transfer-test.cpp
@@ -114,7 +114,7 @@ namespace test {
   
   
   
-  /**********************************************************************************
+  /******************************************************************************//**
    *  @test growing (re-allocating) a vector with noncopyable objects, with the
    *        help of a special Allocator and a custom \c transfer_control operation
    *        provided by the contained objects. The idea is to allow some special
diff --git a/tests/library/visitingtoolconcept.cpp b/tests/library/visitingtoolconcept.cpp
index f9d7158f3..31fab12fd 100644
--- a/tests/library/visitingtoolconcept.cpp
+++ b/tests/library/visitingtoolconcept.cpp
@@ -395,7 +395,7 @@ namespace lumiera {
       
       
       
-      /*************************************************************************
+      /*********************************************************************//**
        * @test build and run some common cases for developing and verifying
        *       ichthyo's implementation concept for the Visitor Pattern.
        *       Defines a hierarchy of test classes to check the following cases
diff --git a/tests/library/visitingtoolextendedtest.cpp b/tests/library/visitingtoolextendedtest.cpp
index 06d21cba3..755cae2d0 100644
--- a/tests/library/visitingtoolextendedtest.cpp
+++ b/tests/library/visitingtoolextendedtest.cpp
@@ -133,7 +133,7 @@ namespace test2  {
   
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * @test more esoteric corner cases of our visitor lib implementation.
    *       Defines a hierarchy of test classes, which mix two different
    *       kinds of "visitable" by two disjoint tool base classes. One
diff --git a/tests/library/visitingtooltest.cpp b/tests/library/visitingtooltest.cpp
index 7da240e75..b852ce2c3 100644
--- a/tests/library/visitingtooltest.cpp
+++ b/tests/library/visitingtooltest.cpp
@@ -95,7 +95,7 @@ namespace test1 {
   
   
   
-  /*************************************************************************
+  /*********************************************************************//**
    * @test our lib implementation of the visitor pattern.
    *       Defines a hierarchy of test classes to check the following cases
    *       - calling the correct visiting tool specialised function
diff --git a/tests/operation/bugs/hello-bug-test.cpp b/tests/operation/bugs/hello-bug-test.cpp
index bf7c33748..b015f43e3 100644
--- a/tests/operation/bugs/hello-bug-test.cpp
+++ b/tests/operation/bugs/hello-bug-test.cpp
@@ -33,7 +33,7 @@ namespace lumiera{
 namespace test   {
   
   
-  /******************************************
+  /**************************************//**
    * @todo come up with some more bugs
    * @test cover known regressions
    */