gstreamer 2.2.5-x86-mingw32 → 3.0.0-x86-mingw32

data/vendor/local/include/gstreamer-1.0/gst/audio/gstaudiosink.h

@@ -66,7 +66,7 @@ struct _GstAudioSink {
  * @unprepare: Undo operations done in prepare.
  * @close: Close the device.
  * @write: Write data to the device.
- * @delay: Return how many samples are still in the device. This is used to
+ * @delay: Return how many frames are still in the device. This is used to
  *         drive the synchronisation.
  * @reset: Returns as quickly as possible from a write and flush any pending
  *         samples from the device.
@@ -88,7 +88,7 @@ struct _GstAudioSinkClass {
   gboolean (*close)     (GstAudioSink *sink);
   /* write samples to the device */
   gint     (*write)     (GstAudioSink *sink, gpointer data, guint length);
-  /* get number of samples queued in the device */
+  /* get number of frames queued in the device */
   guint    (*delay)     (GstAudioSink *sink);
   /* reset the audio device, unblock from a write */
   void     (*reset)     (GstAudioSink *sink);

data/vendor/local/include/gstreamer-1.0/gst/audio/gstaudiosrc.h

@@ -65,7 +65,7 @@ struct _GstAudioSrc {
  * @unprepare: undo the configuration
  * @close: close the device
  * @read: read samples from the audio device
- * @delay: the number of samples queued in the device
+ * @delay: the number of frames queued in the device
  * @reset: unblock a read to the device and reset.
  *
  * #GstAudioSrc class. Override the vmethod to implement
@@ -87,7 +87,7 @@ struct _GstAudioSrcClass {
   /* read samples from the device */
   guint    (*read)      (GstAudioSrc *src, gpointer data, guint length,
       GstClockTime *timestamp);
-  /* get number of samples queued in the device */
+  /* get number of frames queued in the device */
   guint    (*delay)     (GstAudioSrc *src);
   /* reset the audio device, unblock from a write */
   void     (*reset)     (GstAudioSrc *src);

data/vendor/local/include/gstreamer-1.0/gst/base/gstadapter.h

@@ -63,6 +63,7 @@ gpointer                gst_adapter_take                (GstAdapter *adapter, gs
 GstBuffer*              gst_adapter_take_buffer         (GstAdapter *adapter, gsize nbytes);
 GList*                  gst_adapter_take_list           (GstAdapter *adapter, gsize nbytes);
 GstBuffer *             gst_adapter_take_buffer_fast    (GstAdapter *adapter, gsize nbytes);
+GstBufferList *         gst_adapter_take_buffer_list    (GstAdapter *adapter, gsize nbytes);
 gsize                   gst_adapter_available           (GstAdapter *adapter);
 gsize                   gst_adapter_available_fast      (GstAdapter *adapter);
 

data/vendor/local/include/gstreamer-1.0/gst/base/gstbaseparse.h

@@ -156,6 +156,7 @@ typedef struct _GstBaseParsePrivate GstBaseParsePrivate;
  * The opaque #GstBaseParse data structure.
  */
 struct _GstBaseParse {
+  /*< public >*/
   GstElement     element;
 
   /*< protected >*/
@@ -182,8 +183,10 @@ struct _GstBaseParse {
  * @stop:           Optional.
  *                  Called when the element stops processing.
  *                  Allows closing external resources.
- * @set_sink_caps:  allows the subclass to be notified of the actual caps set.
- * @get_sink_caps:  allows the subclass to do its own sink get caps if needed.
+ * @set_sink_caps:  Optional.
+ *                  Allows the subclass to be notified of the actual caps set.
+ * @get_sink_caps:  Optional.
+ *                  Allows the subclass to do its own sink get caps if needed.
  * @handle_frame:   Parses the input data into valid frames as defined by subclass
  *                  which should be passed to gst_base_parse_finish_frame().
  *                  The frame's input buffer is guaranteed writable,
@@ -222,8 +225,7 @@ struct _GstBaseParse {
  *                   parent to let the default handler run (Since 1.2)
  *
  * Subclasses can override any of the available virtual methods or not, as
- * needed. At minimum @check_valid_frame and @parse_frame needs to be
- * overridden.
+ * needed. At minimum @handle_frame needs to be overridden.
  */
 struct _GstBaseParseClass {
   GstElementClass parent_class;

data/vendor/local/include/gstreamer-1.0/gst/base/gstbasesrc.h

@@ -127,7 +127,8 @@ struct _GstBaseSrc {
  * @get_times: Given a buffer, return the start and stop time when it
  *    should be pushed out. The base class will sync on the clock using
  *    these times.
- * @get_size: Return the total size of the resource, in the configured format.
+ * @get_size: Return the total size of the resource, in the format set by
+ *     gst_base_src_set_format().
  * @is_seekable: Check if the source can seek
  * @prepare_seek_segment: Prepare the #GstSegment that will be passed to the
  *   #GstBaseSrcClass.do_seek() vmethod for executing a seek
@@ -190,7 +191,8 @@ struct _GstBaseSrcClass {
   void          (*get_times)    (GstBaseSrc *src, GstBuffer *buffer,
                                  GstClockTime *start, GstClockTime *end);
 
-  /* get the total size of the resource in bytes */
+  /* get the total size of the resource in the format set by
+   * gst_base_src_set_format() */
   gboolean      (*get_size)     (GstBaseSrc *src, guint64 *size);
 
   /* check if the resource is seekable */

data/vendor/local/include/gstreamer-1.0/gst/base/gstbasetransform.h

@@ -90,11 +90,14 @@ struct _GstBaseTransform {
   /* MT-protected (with STREAM_LOCK) */
   gboolean       have_segment;
   GstSegment     segment;
+  /* Default submit_input_buffer places the buffer here,
+   * for consumption by the generate_output method: */
+  GstBuffer      *queued_buf;
 
   /*< private >*/
   GstBaseTransformPrivate *priv;
 
-  gpointer       _gst_reserved[GST_PADDING_LARGE];
+  gpointer       _gst_reserved[GST_PADDING_LARGE-1];
 };
 
 /**
@@ -189,7 +192,23 @@ struct _GstBaseTransform {
  *                  of the outgoing buffer.
  * @transform_ip:   Required if the element operates in-place.
  *                  Transform the incoming buffer in-place.
- *
+ * @submit_input_buffer: Function which accepts a new input buffer and pre-processes it.
+ *                  The default implementation performs caps (re)negotiation, then
+ *                  QoS if needed, and places the input buffer into the @queued_buf
+ *                  member variable. If the buffer is dropped due to QoS, it returns
+ *                  GST_BASE_TRANSFORM_FLOW_DROPPED. If this input buffer is not
+ *                  contiguous with any previous input buffer, then @is_discont
+ *                  is set to #TRUE. (Since 1.6)
+ * @generate_output: Called after each new input buffer is submitted repeatedly
+ *                   until it either generates an error or fails to generate an output
+ *                   buffer. The default implementation takes the contents of the
+ *                   @queued_buf variable, generates an output buffer if needed
+ *                   by calling the class @prepare_output_buffer, and then
+ *                   calls either @transform or @transform_ip. Elements that don't
+ *                   do 1-to-1 transformations on input to output buffers can either
+ *                   return GST_BASE_TRANSFORM_FLOW_DROPPED or simply not generate
+ *                   an output buffer until they are ready to do so. (Since 1.6)
+ *                   
  * Subclasses can override any of the available virtual methods or not, as
  * needed. At minimum either @transform or @transform_ip need to be overridden.
  * If the element can overwrite the input data with the results (data is of the
@@ -258,8 +277,11 @@ struct _GstBaseTransformClass {
                                  GstBuffer *outbuf);
   GstFlowReturn (*transform_ip) (GstBaseTransform *trans, GstBuffer *buf);
 
+  GstFlowReturn (*submit_input_buffer) (GstBaseTransform *trans, gboolean is_discont, GstBuffer *input);
+  GstFlowReturn (*generate_output) (GstBaseTransform *trans, GstBuffer **outbuf);
+
   /*< private >*/
-  gpointer       _gst_reserved[GST_PADDING_LARGE];
+  gpointer       _gst_reserved[GST_PADDING_LARGE - 2];
 };
 
 GType           gst_base_transform_get_type         (void);
@@ -293,6 +315,8 @@ void            gst_base_transform_get_allocator    (GstBaseTransform *trans,
 
 void		gst_base_transform_reconfigure_sink (GstBaseTransform *trans);
 void		gst_base_transform_reconfigure_src  (GstBaseTransform *trans);
+gboolean gst_base_transform_update_src_caps (GstBaseTransform *trans,
+                                             GstCaps *updated_caps);
 G_END_DECLS
 
 #endif /* __GST_BASE_TRANSFORM_H__ */

data/vendor/local/include/gstreamer-1.0/gst/base/gstbytereader.h

@@ -52,6 +52,14 @@ void            gst_byte_reader_free            (GstByteReader *reader);
 
 void            gst_byte_reader_init            (GstByteReader *reader, const guint8 *data, guint size);
 
+gboolean        gst_byte_reader_peek_sub_reader (GstByteReader * reader,
+                                                 GstByteReader * sub_reader,
+                                                 guint           size);
+
+gboolean        gst_byte_reader_get_sub_reader  (GstByteReader * reader,
+                                                 GstByteReader * sub_reader,
+                                                 guint           size);
+
 gboolean        gst_byte_reader_set_pos         (GstByteReader *reader, guint pos);
 guint           gst_byte_reader_get_pos         (const GstByteReader *reader);
 
@@ -141,6 +149,12 @@ guint           gst_byte_reader_masked_scan_uint32 (const GstByteReader * reader
                                                     guint32               pattern,
                                                     guint                 offset,
                                                     guint                 size);
+guint           gst_byte_reader_masked_scan_uint32_peek (const GstByteReader * reader,
+                                                         guint32 mask,
+                                                         guint32 pattern,
+                                                         guint offset,
+                                                         guint size,
+                                                         guint32 * value);
 
 /**
  * GST_BYTE_READER_INIT:
@@ -449,13 +463,39 @@ _gst_byte_reader_init_inline (GstByteReader * reader, const guint8 * data, guint
   reader->byte = 0;
 }
 
+static inline gboolean
+_gst_byte_reader_peek_sub_reader_inline (GstByteReader * reader,
+    GstByteReader * sub_reader, guint size)
+{
+  g_return_val_if_fail (reader != NULL, FALSE);
+  g_return_val_if_fail (sub_reader != NULL, FALSE);
+
+  if (_gst_byte_reader_get_remaining_unchecked (reader) < size)
+    return FALSE;
+
+  sub_reader->data = reader->data + reader->byte;
+  sub_reader->byte = 0;
+  sub_reader->size = size;
+  return TRUE;
+}
+
+static inline gboolean
+_gst_byte_reader_get_sub_reader_inline (GstByteReader * reader,
+    GstByteReader * sub_reader, guint size)
+{
+  if (!_gst_byte_reader_peek_sub_reader_inline (reader, sub_reader, size))
+    return FALSE;
+  gst_byte_reader_skip_unchecked (reader, size);
+  return TRUE;
+}
+
 static inline gboolean
 _gst_byte_reader_dup_data_inline (GstByteReader * reader, guint size, guint8 ** val)
 {
   g_return_val_if_fail (reader != NULL, FALSE);
   g_return_val_if_fail (val != NULL, FALSE);
 
-  if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
+  if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_unchecked (reader) < size))
     return FALSE;
 
   *val = gst_byte_reader_dup_data_unchecked (reader, size);
@@ -468,7 +508,7 @@ _gst_byte_reader_get_data_inline (GstByteReader * reader, guint size, const guin
   g_return_val_if_fail (reader != NULL, FALSE);
   g_return_val_if_fail (val != NULL, FALSE);
 
-  if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
+  if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_unchecked (reader) < size))
     return FALSE;
 
   *val = gst_byte_reader_get_data_unchecked (reader, size);
@@ -481,7 +521,7 @@ _gst_byte_reader_peek_data_inline (const GstByteReader * reader, guint size, con
   g_return_val_if_fail (reader != NULL, FALSE);
   g_return_val_if_fail (val != NULL, FALSE);
 
-  if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_inline (reader) < size))
+  if (G_UNLIKELY (size > reader->size || _gst_byte_reader_get_remaining_unchecked (reader) < size))
     return FALSE;
 
   *val = gst_byte_reader_peek_data_unchecked (reader);

data/vendor/local/include/gstreamer-1.0/gst/base/gstcollectpads.h

@@ -103,6 +103,31 @@ typedef enum {
  */
 #define GST_COLLECT_PADS_STATE_UNSET(data,flag)      (GST_COLLECT_PADS_STATE (data) &= ~(flag))
 
+/**
+ * GST_COLLECT_PADS_DTS:
+ * @data: A #GstCollectData.
+ *
+ * Returns the DTS that has been converted to running time when using
+ * gst_collect_pads_clip_running_time(). Unlike the value saved into
+ * the buffer, this value is of type gint64 and may be negative. This allow
+ * properly handling streams with frame reordering where the first DTS may
+ * be negative. If the initial DTS was not set, this value will be
+ * set to %G_MININT64.
+ *
+ * Since: 1.6
+ */
+#define GST_COLLECT_PADS_DTS(data)                   (((GstCollectData *) data)->ABI.abi.dts)
+
+/**
+ * GST_COLLECT_PADS_DTS_IS_VALID:
+ * @data: A #GstCollectData.
+ *
+ * Check if running DTS value store is valid.
+ *
+ * Since: 1.6
+ */
+#define GST_COLLECT_PADS_DTS_IS_VALID(data)          (GST_CLOCK_STIME_IS_VALID (GST_COLLECT_PADS_DTS (data)))
+
 /**
  * GstCollectData:
  * @collect: owner #GstCollectPads
@@ -110,6 +135,8 @@ typedef enum {
  * @buffer: currently queued buffer.
  * @pos: position in the buffer
  * @segment: last segment received.
+ * @dts: the signed version of the DTS converted to running time. To access
+ *       this memeber, use %GST_COLLECT_PADS_DTS macro. (Since 1.6)
  *
  * Structure used by the collect_pads.
  */
@@ -129,7 +156,14 @@ struct _GstCollectData
 
   GstCollectDataPrivate *priv;
 
-  gpointer _gst_reserved[GST_PADDING];
+  union {
+    struct {
+      /*< public >*/
+      gint64 dts;
+      /*< private >*/
+    } abi;
+    gpointer _gst_reserved[GST_PADDING];
+  } ABI;
 };
 
 /**
@@ -363,7 +397,7 @@ void            gst_collect_pads_set_waiting   (GstCollectPads *pads, GstCollect
 
 /* convenience helper */
 GstFlowReturn	gst_collect_pads_clip_running_time (GstCollectPads * pads,
-					            GstCollectData * cdata,
+                                                    GstCollectData * cdata,
                                                     GstBuffer * buf, GstBuffer ** outbuf,
                                                     gpointer user_data);
 

data/vendor/local/include/gstreamer-1.0/gst/base/gstflowcombiner.h

@@ -47,10 +47,17 @@ void              gst_flow_combiner_free (GstFlowCombiner * combiner);
 
 GstFlowReturn     gst_flow_combiner_update_flow (GstFlowCombiner * combiner, GstFlowReturn fret);
 
+GstFlowReturn     gst_flow_combiner_update_pad_flow (GstFlowCombiner * combiner, GstPad * pad,
+                                                     GstFlowReturn fret);
+
 void              gst_flow_combiner_add_pad    (GstFlowCombiner * combiner, GstPad * pad);
 
 void              gst_flow_combiner_remove_pad (GstFlowCombiner * combiner, GstPad * pad);
 
+void              gst_flow_combiner_clear (GstFlowCombiner * combiner);
+
+void              gst_flow_combiner_reset (GstFlowCombiner * combiner);
+
 GType             gst_flow_combiner_get_type (void);
 
 G_END_DECLS

data/vendor/local/include/gstreamer-1.0/gst/base/gstpushsrc.h

@@ -51,6 +51,22 @@ struct _GstPushSrc {
   gpointer _gst_reserved[GST_PADDING];
 };
 
+/**
+ * GstPushSrcClass:
+ * @parent_class: Element parent class
+ * @create: Ask the subclass to create a buffer. The subclass decides which
+ *          size this buffer should be. Other then that, refer to
+ *          #GstBaseSrc<!-- -->.create() for more details. If this method is
+ *          not implemented, @alloc followed by @fill will be called.
+ * @alloc: Ask the subclass to allocated a buffer. The subclass decides which
+ *         size this buffer should be. The default implementation will create
+ *         a new buffer from the negotiate allcoator.
+ * @fill: Ask the subclass to fill the buffer with data.
+ *
+ * Subclasses can override any of the available virtual methods or not, as
+ * needed. At the minimum, the @fill method should be overridden to produce
+ * buffers.
+ */
 struct _GstPushSrcClass {
   GstBaseSrcClass parent_class;
 

data/vendor/local/include/gstreamer-1.0/gst/basecamerabinsrc/gstbasecamerasrc.h

@@ -34,6 +34,7 @@
 #include "gstcamerabinpreview.h"
 
 G_BEGIN_DECLS
+
 #define GST_TYPE_BASE_CAMERA_SRC \
   (gst_base_camera_src_get_type())
 #define GST_BASE_CAMERA_SRC(obj) \
@@ -140,4 +141,6 @@ void gst_base_camera_src_finish_capture (GstBaseCameraSrc *self);
 void gst_base_camera_src_post_preview (GstBaseCameraSrc *self, GstSample * sample);
 // XXX add methods to get/set img capture and vid capture caps..
 
+G_END_DECLS
+
 #endif /* __GST_BASE_CAMERA_SRC_H__ */

data/vendor/local/include/gstreamer-1.0/gst/check/gstcheck.h

@@ -107,12 +107,27 @@ void gst_check_setup_events (GstPad * srcpad, GstElement * element,
 void gst_check_setup_events_with_stream_id (GstPad * srcpad,
     GstElement * element, GstCaps * caps, GstFormat format,
     const gchar * stream_id);
+void gst_check_objects_destroyed_on_unref (gpointer object_to_unref, gpointer first_object, ...)
+  G_GNUC_NULL_TERMINATED;
+void gst_check_object_destroyed_on_unref (gpointer object_to_unref);
 
 #define fail_unless_message_error(msg, domain, code)            \
 gst_check_message_error (msg, GST_MESSAGE_ERROR,                \
   GST_ ## domain ## _ERROR, GST_ ## domain ## _ERROR_ ## code)
 #define assert_message_error(m, d, c) fail_unless_message_error(m, d, c)
 
+#ifdef GST_CHECK_TEST_ENVIRONMENT_BEACON
+#define GST_DO_CHECK_TEST_ENVIRONMENT \
+G_STMT_START {                        \
+  if (g_getenv (GST_CHECK_TEST_ENVIRONMENT_BEACON) == NULL) \
+    fail ("Test environment not set up correctly! Expected environment " \
+       "variable '%s' to be set.", GST_CHECK_TEST_ENVIRONMENT_BEACON); \
+} G_STMT_END
+
+#else
+#define GST_DO_CHECK_TEST_ENVIRONMENT /* nothing to check */
+#endif
+
 /**
  * GST_START_TEST:
  * @__testname: test function name
@@ -128,6 +143,7 @@ gst_check_message_error (msg, GST_MESSAGE_ERROR,                \
 static void __testname (int __i__)\
 {\
   GST_DEBUG ("test start"); \
+  GST_DO_CHECK_TEST_ENVIRONMENT; \
   tcase_fn_start (""# __testname, __FILE__, __LINE__);
 
 #define GST_END_TEST GST_LOG ("cleaning up tasks"); \
@@ -497,7 +513,7 @@ G_STMT_START {                                                  \
   g_usleep (1);                                                 \
 } G_STMT_END;
 
-#define THREAD_TEST_RUNNING()   (_gst_check_threads_running == TRUE)
+#define THREAD_TEST_RUNNING()   (!!_gst_check_threads_running)
 
 /* additional assertions */
 #define ASSERT_CRITICAL(code)                                   \
@@ -505,8 +521,9 @@ G_STMT_START {                                                  \
   _gst_check_expecting_log = TRUE;                              \
   _gst_check_raised_critical = FALSE;                           \
   code;                                                         \
-  _fail_unless (_gst_check_raised_critical, __FILE__, __LINE__, \
-                "Expected g_critical, got nothing", NULL);      \
+  if (!_gst_check_raised_critical)                              \
+    _ck_assert_failed (__FILE__, __LINE__,                      \
+        "Expected g_critical, got nothing", NULL);              \
   _gst_check_expecting_log = FALSE;                             \
 } G_STMT_END
 
@@ -515,8 +532,9 @@ G_STMT_START {                                                  \
   _gst_check_expecting_log = TRUE;                              \
   _gst_check_raised_warning = FALSE;                            \
   code;                                                         \
-  _fail_unless (_gst_check_raised_warning, __FILE__, __LINE__,  \
-                "Expected g_warning, got nothing", NULL);       \
+  if (!_gst_check_raised_warning)                               \
+    _ck_assert_failed (__FILE__, __LINE__,                      \
+        "Expected g_warning, got nothing", NULL);               \
   _gst_check_expecting_log = FALSE;                             \
 } G_STMT_END
 
@@ -560,7 +578,7 @@ G_STMT_START {                                                  \
 } G_STMT_END
 
 #define ASSERT_SET_STATE(element, state, ret)                   \
-fail_unless (gst_element_set_state (element,                    \
+fail_unless (gst_element_set_state (GST_ELEMENT(element),       \
   state) == ret,                                                \
   "could not change state to " #state);
 

data/vendor/local/include/gstreamer-1.0/gst/check/internal-check.h

@@ -15,8 +15,8 @@
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
- * Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
- * Boston, MA 02110-1301, USA.
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
  */
 
 #ifndef CHECK_H
@@ -25,38 +25,9 @@
 #include <stddef.h>
 #include <string.h>
 
-/* Check: a unit test framework for C
-
-   Check is a unit test framework for C. It features a simple
-   interface for defining unit tests, putting little in the way of the
-   developer. Tests are run in a separate address space, so Check can
-   catch both assertion failures and code errors that cause
-   segmentation faults or other signals. The output from unit tests
-   can be used within source code editors and IDEs.
-
-   Unit tests are created with the START_TEST/END_TEST macro
-   pair. The fail_unless and fail macros are used for creating
-   checks within unit tests; the mark_point macro is useful for
-   trapping the location of signals and/or early exits.
-
-
-   Test cases are created with tcase_create, unit tests are added
-   with tcase_add_test
-
-
-   Suites are created with suite_create; test cases are added
-   with suite_add_tcase
-
-   Suites are run through an SRunner, which is created with
-   srunner_create. Additional suites can be added to an SRunner with
-   srunner_add_suite. An SRunner is freed with srunner_free, which also
-   frees all suites added to the runner. 
-
-   Use srunner_run_all to run a suite and print results.
-
+/*
    Macros and functions starting with _ (underscore) are internal and
    may change without notice. You have been warned!.
-
 */
 
 
@@ -65,7 +36,6 @@
 #define CK_CPPEND }
 CK_CPPSTART
 #endif
-
 #if defined(__GNUC__) && defined(__GNUC_MINOR__)
 #define GCC_VERSION_AT_LEAST(major, minor) \
 ((__GNUC__ > (major)) || \
@@ -73,346 +43,1200 @@ CK_CPPSTART
 #else
 #define GCC_VERSION_AT_LEAST(major, minor) 0
 #endif
-
 #if GCC_VERSION_AT_LEAST(2,95)
 #define CK_ATTRIBUTE_UNUSED __attribute__ ((unused))
 #else
-#define CK_ATTRIBUTE_UNUSED              
+#define CK_ATTRIBUTE_UNUSED
 #endif /* GCC 2.95 */
-
+#if GCC_VERSION_AT_LEAST(2,5)
+#define CK_ATTRIBUTE_NORETURN __attribute__ ((noreturn))
+#else
+#define CK_ATTRIBUTE_NORETURN
+#endif /* GCC 2.5 */
 #include <sys/types.h>
-
-/* Used to create the linker script for hiding lib-local symbols. Shall
-   be put directly in front of the exported symbol. */
+/*
+ * Used to create the linker script for hiding lib-local symbols. Shall
+ * be put directly in front of the exported symbol.
+ */
 #define CK_EXPORT
-
+/*
+ * Used for MSVC to create the export attribute
+ * CK_DLL_EXP is defined during the compilation of the library
+ * on the command line.
+ */
+#ifndef CK_DLL_EXP
+#define CK_DLL_EXP
+#endif
 /* check version numbers */
-  
 #define CHECK_MAJOR_VERSION (0)
 #define CHECK_MINOR_VERSION (9)
-#define CHECK_MICRO_VERSION (8)
-
-extern int CK_EXPORT check_major_version;
-extern int CK_EXPORT check_minor_version;
-extern int CK_EXPORT check_micro_version;
+#define CHECK_MICRO_VERSION (14)
+CK_DLL_EXP extern int CK_EXPORT check_major_version;
+CK_DLL_EXP extern int CK_EXPORT check_minor_version;
+CK_DLL_EXP extern int CK_EXPORT check_micro_version;
 
 #ifndef NULL
 #define NULL ((void*)0)
 #endif
 
-/* opaque type for a test case
-
-   A TCase represents a test case.  Create with tcase_create, free
-   with tcase_free.  For the moment, test cases can only be run
-   through a suite
+/**
+ * Type for a test case
+ *
+ * A TCase represents a test case.  Create with tcase_create, free
+ * with tcase_free.  For the moment, test cases can only be run
+ * through a suite
 */
-typedef struct TCase TCase; 
+typedef struct TCase TCase;
 
-/* type for a test function */
+/**
+ * Type for a test function
+ */
 typedef void (*TFun) (int);
 
-/* type for a setup/teardown function */
+/**
+ * Type for a setup/teardown function
+ */
 typedef void (*SFun) (void);
- 
-/* Opaque type for a test suite */
+
+/**
+ * Type for a test suite
+ */
 typedef struct Suite Suite;
- 
-/* Creates a test suite with the given name */
-Suite * CK_EXPORT suite_create (const char *name);
 
-/* Add a test case to a suite */
-void CK_EXPORT suite_add_tcase (Suite *s, TCase *tc);
+/**
+ * Creates a test suite with the given name.
+ *
+ * Create a suite, which will contain test cases. Once
+ * created, use suite_add_tcase() to add test cases.
+ * When finished, create a suite runner from the
+ * suite using srunner_create()
+ *
+ * @param name name of the suite
+ *
+ * @return suite
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP Suite *CK_EXPORT suite_create (const char *name);
+
+/**
+ * Determines whether a given test suite contains a case named after a
+ * given string.
+ *
+ * @param s suite to check
+ * @param tcname test case to look for
+ *
+ * @return 1 iff the given test case is within the given suite;
+ *          0 otherwise
+ *
+ * @since 0.9.9
+ */
+CK_DLL_EXP int CK_EXPORT suite_tcase (Suite * s, const char *tcname);
+
+/**
+ * Add a test case to a suite
+ *
+ * @param s suite to add test case to
+ * @param tc test case to add to suite
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP void CK_EXPORT suite_add_tcase (Suite * s, TCase * tc);
 
-/* Create a test case */
-TCase * CK_EXPORT tcase_create (const char *name);
+/**
+ * Create a test case.
+ *
+ * Once created, tests can be added with the tcase_add_test()
+ * function, and the test case assigned to a suite with the
+ * suite_add_tcase() function.
+ *
+ * @param name name of the test case
+ *
+ * @return test case containing no tests
+ *
+ * @since 0.6.0
+ * */
+CK_DLL_EXP TCase *CK_EXPORT tcase_create (const char *name);
 
-/* Add a test function to a test case (macro version) */
+/**
+ * Add a test function to a test case
+ *
+ * @param tc test case to add test to
+ * @param tf test function to add to test case
+ *
+ * @since 0.6.0
+ * */
 #define tcase_add_test(tc,tf) tcase_add_test_raise_signal(tc,tf,0)
 
-/* Add a test function with signal handling to a test case (macro version) */
+/**
+ * Add a test function with signal handling to a test case
+ *
+ * The added test is expected to terminate by throwing the given signal
+ *
+ * @param tc test case to add test to
+ * @param tf test function to add to test case
+ * @param signal expected signal for test function to throw in order for
+ *                the test to be considered passing
+ *
+ * @since 0.9.2
+ * */
 #define tcase_add_test_raise_signal(tc,tf,signal) \
    _tcase_add_test((tc),(tf),"" # tf "",(signal), 0, 0, 1)
 
-/* Add a test function with an expected exit value to a test case (macro version) */
+/**
+ * Add a test function with an expected exit value to a test case
+ *
+ * The added test is expected to terminate by exiting with the given value
+ *
+ * @param tc test case to add test to
+ * @param tf test function to add to test case
+ * @param expected_exit_value exit value for test function to return in
+ *                             order for the test to be considered passing
+ *
+ * @since 0.9.7
+ */
 #define tcase_add_exit_test(tc, tf, expected_exit_value) \
   _tcase_add_test((tc),(tf),"" # tf "",0,(expected_exit_value),0,1)
 
-/* Add a looping test function to a test case (macro version)
-
-   The test will be called in a for(i = s; i < e; i++) loop with each
-   iteration being executed in a new context. The loop variable 'i' is
-   available in the test.
+/**
+ * Add a looping test function to a test case
+ *
+ * The test will be called in a for(i = s; i < e; i++) loop with each
+ * iteration being executed in a new context. The loop variable 'i' is
+ * available in the test.
+ *
+ * @param tc test case to add test to
+ * @param tf function to add to test case
+ * @param s starting index for value "i" in test
+ * @param e ending index for value "i" in test
+ *
+ * @since 0.9.4
  */
 #define tcase_add_loop_test(tc,tf,s,e) \
   _tcase_add_test((tc),(tf),"" # tf "",0,0,(s),(e))
- 
-/* Signal version of loop test.  
-   FIXME: add a test case; this is untested as part of Check's tests.
+
+/**
+ * Add a looping test function with signal handling to a test case
+ *
+ * The test will be called in a for(i = s; i < e; i++) loop with each
+ * iteration being executed in a new context. The loop variable 'i' is
+ * available in the test.
+ *
+ * The added test is expected to terminate by throwing the given signal
+ *
+ * @param tc test case to add test to
+ * @param tf function to add to test case
+ * @param signal expected signal for test function to throw in order for
+ *                the test to be considered passing
+ * @param s starting index for value "i" in test
+ * @param e ending index for value "i" in test
+ *
+ * @since 0.9.5
  */
 #define tcase_add_loop_test_raise_signal(tc,tf,signal,s,e) \
   _tcase_add_test((tc),(tf),"" # tf "",(signal),0,(s),(e))
 
-/* allowed exit value version of loop test. */
+/**
+ * Add a looping test function with an expected exit value to a test case
+ *
+ * The test will be called in a for(i = s; i < e; i++) loop with each
+ * iteration being executed in a new context. The loop variable 'i' is
+ * available in the test.
+ *
+ * The added test is expected to terminate by exiting with the given value
+ *
+ * @param tc test case to add test to
+ * @param tf function to add to test case
+ * @param expected_exit_value exit value for test function to return in
+ *                             order for the test to be considered passing
+ * @param s starting index for value "i" in test
+ * @param e ending index for value "i" in test
+ *
+ * @since 0.9.7
+ */
 #define tcase_add_loop_exit_test(tc,tf,expected_exit_value,s,e) \
   _tcase_add_test((tc),(tf),"" # tf "",0,(expected_exit_value),(s),(e))
 
 /* Add a test function to a test case
   (function version -- use this when the macro won't work
 */
-void CK_EXPORT _tcase_add_test (TCase *tc, TFun tf, const char *fname, int _signal, int allowed_exit_value, int start, int end);
-
-/* Add unchecked fixture setup/teardown functions to a test case
+CK_DLL_EXP void CK_EXPORT _tcase_add_test (TCase * tc, TFun tf,
+    const char *fname, int _signal, int allowed_exit_value, int start, int end);
 
-   If unchecked fixture functions are run at the start and end of the
-   test case, and not before and after unit tests. Note that unchecked
-   setup/teardown functions are not run in a separate address space,
-   like test functions, and so must not exit or signal (e.g.,
-   segfault)
+/**
+ * Add unchecked fixture setup/teardown functions to a test case
+ *
+ * Unchecked fixture functions are run at the start and end of the
+ * test case, and not before and after unit tests. Further,
+ * unchecked fixture functions are not run in a separate address space,
+ * like test functions, and so must not exit or signal (e.g.,
+ * segfault).
+ *
+ * Also, when run in CK_NOFORK mode, unchecked fixture functions may
+ * lead to different unit test behavior if unit tests change data
+ * setup by the fixture functions.
+ *
+ * Note that if a setup function fails, the remaining setup functions
+ * will be omitted, as will the test case and the teardown functions.
+ * If a teardown function fails the remaining teardown functins will be
+ * omitted.
+ *
+ * @param tc test case to add unchecked fixture setup/teardown to
+ * @param setup function to add to be executed before the test case;
+ *               if NULL no setup function is added
+ * @param teardown function to add to be executed after the test case;
+ *               if NULL no teardown function is added
+ * @since 0.8.0
+ */
+CK_DLL_EXP void CK_EXPORT tcase_add_unchecked_fixture (TCase * tc, SFun setup,
+    SFun teardown);
 
-   Also, when run in CK_NOFORK mode, unchecked fixture functions may
-   lead to different unit test behavior IF unit tests change data
-   setup by the fixture functions.
+/**
+ * Add checked fixture setup/teardown functions to a test case
+ *
+ * Checked fixture functions are run before and after each unit test inside
+ * of the address space of the test. Thus, if using CK_FORK
+ * mode the separate process running the unit test will survive signals
+ * or unexpected exits in the fixture function. Also, if the setup
+ * function is idempotent, unit test behavior will be the same in
+ * CK_FORK and CK_NOFORK modes.
+ *
+ * However, since fixture functions are run before and after each unit
+ * test, they should not be expensive code.
+ *
+ * Note that if a setup function fails, the remaining setup functions
+ * will be omitted, as will the test and the teardown functions. If a
+ * teardown function fails the remaining teardown functins will be
+ * omitted.
+ *
+ * @param tc test case to add checked fixture setup/teardown to
+ * @param setup function to add to be executed before each unit test in
+ *               the test case;  if NULL no setup function is added
+ * @param teardown function to add to be executed after each unit test in
+ *               the test case; if NULL no teardown function is added
+ *
+ * @since 0.8.0
 */
-void CK_EXPORT tcase_add_unchecked_fixture (TCase *tc, SFun setup, SFun teardown);
-
-/* Add fixture setup/teardown functions to a test case
-
-   Checked fixture functions are run before and after unit
-   tests. Unlike unchecked fixture functions, checked fixture
-   functions are run in the same separate address space as the test
-   program, and thus the test function will survive signals or
-   unexpected exits in the fixture function. Also, IF the setup
-   function is idempotent, unit test behavior will be the same in
-   CK_FORK and CK_NOFORK modes.
-
-   However, since fixture functions are run before and after each unit
-   test, they should not be expensive code.
+CK_DLL_EXP void CK_EXPORT tcase_add_checked_fixture (TCase * tc, SFun setup,
+    SFun teardown);
 
-*/ 
-void CK_EXPORT tcase_add_checked_fixture (TCase *tc, SFun setup, SFun teardown);
+/**
+ * Set the timeout for all tests in a test case.
+ *
+ * A test that lasts longer than the timeout (in seconds) will be killed
+ * and thus fail with an error.
+ *
+ * If not set, the default timeout is one assigned at compile time. If
+ * the environment variable CK_DEFAULT_TIMEOUT is defined and no timeout
+ * is set, the value in the environment variable is used.
+ *
+ * @param tc test case to assign timeout to
+ * @param timeout to use, in seconds. If the value contains a decimal
+ *                 portion, but no high resolution timer is available,
+ *                 the value is rounded up to the nearest second.
+ *
+ * @since 0.9.2
+ */
+CK_DLL_EXP void CK_EXPORT tcase_set_timeout (TCase * tc, double timeout);
 
-/* Set the timeout for all tests in a test case. A test that lasts longer
-   than the timeout (in seconds) will be killed and thus fail with an error.
-   The timeout can also be set globaly with the environment variable
-   CK_DEFAULT_TIMEOUT, the specific setting always takes precedence.
-*/
-void CK_EXPORT tcase_set_timeout (TCase *tc, int timeout);
- 
 /* Internal function to mark the start of a test function */
-void CK_EXPORT tcase_fn_start (const char *fname, const char *file, int line);
+CK_DLL_EXP void CK_EXPORT tcase_fn_start (const char *fname, const char *file,
+    int line);
 
-/* Start a unit test with START_TEST(unit_name), end with END_TEST
-   One must use braces within a START_/END_ pair to declare new variables
-*/ 
+/**
+ * Start a unit test with START_TEST(unit_name), end with END_TEST.
+ *
+ * One must use braces within a START_/END_ pair to declare new variables
+ *
+ * @since 0.6.0
+ */
 #define START_TEST(__testname)\
 static void __testname (int _i CK_ATTRIBUTE_UNUSED)\
 {\
   tcase_fn_start (""# __testname, __FILE__, __LINE__);
 
-/* End a unit test */
+/**
+ *  End a unit test
+ *
+ * @since 0.6.0
+ */
 #define END_TEST }
 
-/* Fail the test case unless expr is true */
-/* The space before the comma sign before ## is essential to be compatible
-   with gcc 2.95.3 and earlier.
-*/
-#define fail_unless(expr, ...)\
-        _fail_unless(expr, __FILE__, __LINE__,\
-        "Assertion '"#expr"' failed" , ## __VA_ARGS__, NULL)
-
-/* Fail the test case if expr is true */
-/* The space before the comma sign before ## is essential to be compatible
-   with gcc 2.95.3 and earlier.
-*/
+/*
+ * Fail the test case unless expr is false
+ *
+ * This call is deprecated.
+ */
+#define fail_unless ck_assert_msg
 
-/* FIXME: these macros may conflict with C89 if expr is 
-   FIXME:   strcmp (str1, str2) due to excessive string length. */
+/*
+ * Fail the test case if expr is false
+ *
+ * This call is deprecated.
+ *
+ * NOTE: The space before the comma sign before ## is essential to be compatible
+ * with gcc 2.95.3 and earlier.
+ * FIXME: these macros may conflict with C89 if expr is
+ * FIXME:   strcmp (str1, str2) due to excessive string length.
+ */
 #define fail_if(expr, ...)\
-        _fail_unless(!(expr), __FILE__, __LINE__,\
-        "Failure '"#expr"' occured" , ## __VA_ARGS__, NULL)
+  (expr) ? \
+     _ck_assert_failed(__FILE__, __LINE__, "Failure '"#expr"' occurred" , ## __VA_ARGS__, NULL) \
+     : _mark_point(__FILE__, __LINE__)
 
-/* Always fail */
-#define fail(...) _fail_unless(0, __FILE__, __LINE__, "Failed", __VA_ARGS__, NULL)
+/*
+ * Fail the test
+ *
+ * This call is deprecated.
+ */
+#define fail ck_abort_msg
 
-/* Non macro version of #fail_unless, with more complicated interface */
-void CK_EXPORT _fail_unless (int result, const char *file,
-                             int line, const char *expr, ...);
+/*
+ * This is called whenever an assertion fails.
+ * Note that it only has the noreturn modifier when
+ * using fork. If fork is unavailable, the function
+ * calls longjmp() when a test assertion fails. Marking
+ * the function as noreturn causes gcc to make assumptions
+ * which are not valid, as longjmp() is like a return.
+ */
+#if 0
+CK_DLL_EXP void CK_EXPORT
+_ck_assert_failed (const char *file, int line, const char *expr, ...)
+    CK_ATTRIBUTE_NORETURN;
+#else
+CK_DLL_EXP void CK_EXPORT _ck_assert_failed (const char *file, int line,
+    const char *expr, ...);
+#endif
 
-/* New check fail API. */
-#define ck_abort() ck_abort_msg(NULL)
-#define ck_abort_msg fail
-#define ck_assert(C) ck_assert_msg(C, NULL)
-#define ck_assert_msg fail_unless
+/**
+ * Fail the test if expression is false
+ *
+ * @param expr expression to evaluate
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.6
+ */
+#define ck_assert(expr) ck_assert_msg(expr, NULL)
 
-/* Integer comparsion macros with improved output compared to fail_unless(). */
-/* O may be any comparion operator. */
-#define _ck_assert_int(X, O, Y) ck_assert_msg((X) O (Y), "Assertion '"#X#O#Y"' failed: "#X"==%d, "#Y"==%d", X, Y) 
-#define ck_assert_int_eq(X, Y) _ck_assert_int(X, ==, Y) 
-#define ck_assert_int_ne(X, Y) _ck_assert_int(X, !=, Y) 
+/* The space before the comma sign before ## is essential to be compatible
+   with gcc 2.95.3 and earlier.
+*/
+/**
+ * Fail the test if the expression is false; print message on failure
+ *
+ * @param expr expression to evaluate
+ * @param ... message to print (in printf format) if expression is false
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.6
+ */
+#define ck_assert_msg(expr, ...) \
+  (expr) ? \
+     _mark_point(__FILE__, __LINE__) : \
+     _ck_assert_failed(__FILE__, __LINE__, "Assertion '"#expr"' failed" , ## __VA_ARGS__, NULL)
 
-/* String comparsion macros with improved output compared to fail_unless() */
-#define _ck_assert_str(C, X, O, Y) ck_assert_msg(C, "Assertion '"#X#O#Y"' failed: "#X"==\"%s\", "#Y"==\"%s\"", X, Y) 
-#define ck_assert_str_eq(X, Y) _ck_assert_str(!strcmp(X, Y), X, ==, Y)
-#define ck_assert_str_ne(X, Y) _ck_assert_str(strcmp(X, Y), X, !=, Y)
+/**
+ * Unconditionally fail the test
+ *
+ * @note Once called, the remaining of the test is aborted
+ *
+ * @since 0.9.6
+ */
+#define ck_abort() ck_abort_msg(NULL)
+/**
+ * Unconditionally fail the test; print a message
+ *
+ * @param ... message to print (in printf format)
+ *
+ * @note Once called, the remaining of the test is aborted
+ *
+ * @since 0.9.6
+ */
+#define ck_abort_msg(...) _ck_assert_failed(__FILE__, __LINE__, "Failed" , ## __VA_ARGS__, NULL)
+
+/* Signed and unsigned integer comparison macros with improved output compared to ck_assert(). */
+/* OP may be any comparison operator. */
+#define _ck_assert_int(X, OP, Y) do { \
+  gint64 _ck_x = (X); \
+  gint64 _ck_y = (Y); \
+  ck_assert_msg(_ck_x OP _ck_y, "Assertion '%s' failed: " \
+      "%s==%" G_GINT64_FORMAT ", %s==%" G_GINT64_FORMAT, #X#OP#Y, #X, _ck_x, #Y, _ck_y); \
+} while (0)
+
+/**
+ * Check two signed integers to determine if X==Y
+ *
+ * If not X==Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.6
+ */
+#define ck_assert_int_eq(X, Y) _ck_assert_int(X, ==, Y)
+/**
+ * Check two signed integers to determine if X!=Y
+ *
+ * If not X!=Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.6
+ */
+#define ck_assert_int_ne(X, Y) _ck_assert_int(X, !=, Y)
+/**
+ * Check two signed integers to determine if X<Y
+ *
+ * If not X<Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_int_lt(X, Y) _ck_assert_int(X, <, Y)
+/**
+ * Check two signed integers to determine if X<=Y
+ *
+ * If not X<=Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_int_le(X, Y) _ck_assert_int(X, <=, Y)
+/**
+ * Check two signed integers to determine if X>Y
+ *
+ * If not X>Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_int_gt(X, Y) _ck_assert_int(X, >, Y)
+/**
+ * Check two signed integers to determine if X>=Y
+ *
+ * If not X>=Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_int_ge(X, Y) _ck_assert_int(X, >=, Y)
+
+#define _ck_assert_uint(X, OP, Y) do { \
+  guint64 _ck_x = (X); \
+  guint64 _ck_y = (Y); \
+  ck_assert_msg(_ck_x OP _ck_y, "Assertion '%s' failed: " \
+      "%s==%" G_GUINT64_FORMAT ", %s==%" G_GUINT64_FORMAT, #X#OP#Y, #X, _ck_x, #Y, _ck_y); \
+} while (0)
+/**
+ * Check two unsigned integers to determine if X==Y
+ *
+ * If not X==Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_uint_eq(X, Y) _ck_assert_uint(X, ==, Y)
+/**
+ * Check two unsigned integers to determine if X!=Y
+ *
+ * If not X!=Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_uint_ne(X, Y) _ck_assert_uint(X, !=, Y)
+/**
+ * Check two unsigned integers to determine if X<Y
+ *
+ * If not X<Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_uint_lt(X, Y) _ck_assert_uint(X, <, Y)
+/**
+ * Check two unsigned integers to determine if X<=Y
+ *
+ * If not X<=Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_uint_le(X, Y) _ck_assert_uint(X, <=, Y)
+/**
+ * Check two unsigned integers to determine if X>Y
+ *
+ * If not X>Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_uint_gt(X, Y) _ck_assert_uint(X, >, Y)
+/**
+ * Check two unsigned integers to determine if X>=Y
+ *
+ * If not X>=Y, the test fails.
+ *
+ * @param X signed integer
+ * @param Y signed integer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_uint_ge(X, Y) _ck_assert_uint(X, >=, Y)
+
+/* String comparison macros with improved output compared to ck_assert() */
+/* OP might be any operator that can be used in '0 OP strcmp(X,Y)' comparison */
+/* The x and y parameter swap in strcmp() is needed to handle >, >=, <, <= operators */
+#define _ck_assert_str(X, OP, Y) do { \
+  const char* _ck_x = (X); \
+  const char* _ck_y = (Y); \
+  ck_assert_msg(0 OP strcmp(_ck_y, _ck_x), \
+    "Assertion '%s' failed: %s==\"%s\", %s==\"%s\"", #X#OP#Y, #X, _ck_x, #Y, _ck_y); \
+} while (0)
+/**
+ * Check two strings to determine if 0==strcmp(X,Y)
+ *
+ * If not 0==strcmp(X,Y), the test fails.
+ *
+ * @param X string
+ * @param Y string to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.6
+ */
+#define ck_assert_str_eq(X, Y) _ck_assert_str(X, ==, Y)
+/**
+ * Check two strings to determine if 0!=strcmp(X,Y)
+ *
+ * If not 0!=strcmp(X,Y), the test fails.
+ *
+ * @param X string
+ * @param Y string to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.6
+ */
+#define ck_assert_str_ne(X, Y) _ck_assert_str(X, !=, Y)
+/**
+ * Check two strings to determine if 0<strcmp(X,Y), (e.g. strcmp(X,Y)>0)
+ *
+ * If not 0<strcmp(X,Y), the test fails.
+ *
+ * @param X string
+ * @param Y string to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_str_lt(X, Y) _ck_assert_str(X, <, Y)
+/**
+ * Check two strings to determine if 0<=strcmp(X,Y) (e.g. strcmp(X,Y)>=0)
+ *
+ * If not 0<=strcmp(X,Y), the test fails.
+ *
+ * @param X string
+ * @param Y string to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_str_le(X, Y) _ck_assert_str(X, <=, Y)
+/**
+ * Check two strings to determine if 0<strcmp(X,Y) (e.g. strcmp(X,Y)>0)
+ *
+ * If not 0<strcmp(X,Y), the test fails.
+ *
+ * @param X string
+ * @param Y string to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_str_gt(X, Y) _ck_assert_str(X, >, Y)
+/**
+ * Check two strings to determine if 0>=strcmp(X,Y) (e.g. strcmp(X,Y)<=0)
+ *
+ * If not 0>=strcmp(X,Y), the test fails.
+ *
+ * @param X string
+ * @param Y string to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_str_ge(X, Y) _ck_assert_str(X, >=, Y)
+
+/* Pointer comparison macros with improved output compared to ck_assert(). */
+/* OP may only be == or !=  */
+#define _ck_assert_ptr(X, OP, Y) do { \
+  const void* _ck_x = (X); \
+  const void* _ck_y = (Y); \
+  ck_assert_msg(_ck_x OP _ck_y, "Assertion '%s' failed: %s==%#x, %s==%#x", #X#OP#Y, #X, _ck_x, #Y, _ck_y); \
+} while (0)
+
+/**
+ * Check if two pointers are equal.
+ *
+ * If the two passed pointers are not equal, the test
+ * fails.
+ *
+ * @param X pointer
+ * @param Y pointer to compare against X
+ *
+ * @note If the check fails, the remaining of the test is aborted
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_ptr_eq(X, Y) _ck_assert_ptr(X, ==, Y)
 
+/**
+ * Check if two pointers are not.
+ *
+ * If the two passed pointers are equal, the test fails.
+ *
+ * @param X pointer
+ * @param Y pointer to compare against X
+ *
+ * @since 0.9.10
+ */
+#define ck_assert_ptr_ne(X, Y) _ck_assert_ptr(X, !=, Y)
 
-/* Mark the last point reached in a unit test
-   (useful for tracking down where a segfault, etc. occurs)
+/**
+ * Mark the last point reached in a unit test.
+ *
+ * If the test throws a signal or exits, the location noted with the
+ * failure is the last location of a ck_assert*() or ck_abort() call.
+ * Use mark_point() to record intermediate locations (useful for tracking down
+ * crashes or exits).
+ *
+ * @since 0.6.0
 */
 #define mark_point() _mark_point(__FILE__,__LINE__)
 
 /* Non macro version of #mark_point */
-void CK_EXPORT _mark_point (const char *file, int line);
-
-/* Result of a test */
-enum test_result {
-  CK_TEST_RESULT_INVALID, /* Default value; should not encounter this */
-  CK_PASS, /* Test passed*/
-  CK_FAILURE, /* Test completed but failed */
-  CK_ERROR /* Test failed to complete
-	      (unexpected signal or non-zero early exit) */ 
+CK_DLL_EXP void CK_EXPORT _mark_point (const char *file, int line);
+
+/**
+ * Enum describing the possible results of a test
+ */
+enum test_result
+{
+  CK_TEST_RESULT_INVALID,       /**< Default value; should not encounter this */
+  CK_PASS,                      /**< Test passed */
+  CK_FAILURE,                   /**< Test completed but failed */
+  CK_ERROR                      /**< Test failed to complete
+                                   (unexpected signal or non-zero early exit) */
 };
 
-/* Specifies the how much output an SRunner should produce */
-enum print_output {
-  CK_SILENT, /* No output */
-  CK_MINIMAL, /* Only summary output */
-  CK_NORMAL, /* All failed tests */
-  CK_VERBOSE, /* All tests */
-  CK_ENV, /* Look at environment var */
+/**
+ * Enum specifying the verbosity of output a SRunner should produce
+ */
+enum print_output
+{
+  CK_SILENT,                    /**< No output */
+  CK_MINIMAL,                   /**< Only summary output */
+  CK_NORMAL,                    /**< All failed tests */
+  CK_VERBOSE,                   /**< All tests */
+  CK_ENV,                       /**< Look at environment var CK_VERBOSITY
+                                     for what verbosity to use, which can be
+                                     either "silent", "minimal", "normal",
+                                     or "verbose". If the environment variable
+                                     is not set, then CK_NORMAL will be used.*/
 #if 0
-  CK_SUBUNIT, /* Run as a subunit child process */
+  CK_SUBUNIT,                   /**< Run as a subunit child process */
 #endif
-  CK_LAST
+  CK_LAST                       /**< Not a valid option */
 };
 
-/* Holds state for a running of a test suite */
+/**
+ * Holds state for a running of a test suite
+ */
 typedef struct SRunner SRunner;
 
-/* Opaque type for a test failure */
+/**
+ * Opaque type for a test failure
+ */
 typedef struct TestResult TestResult;
 
-/* accessors for tr fields */
-enum ck_result_ctx {
-  CK_CTX_INVALID, /* Default value; should not encounter this */
-  CK_CTX_SETUP,
-  CK_CTX_TEST,
-  CK_CTX_TEARDOWN
+/**
+ * Enum representing the types of contexts for a test
+ */
+enum ck_result_ctx
+{
+  CK_CTX_INVALID,               /**< Default value; should not encounter this */
+  CK_CTX_SETUP,                 /**< Setup before a test */
+  CK_CTX_TEST,                  /**< Body of test itself */
+  CK_CTX_TEARDOWN               /**< Teardown after a test */
 };
 
-/* Type of result */
-int CK_EXPORT tr_rtype (TestResult *tr);
-/* Context in which the result occurred */ 
-enum ck_result_ctx CK_EXPORT tr_ctx (TestResult *tr); 
-/* Failure message */
-const char * CK_EXPORT tr_msg (TestResult *tr);
-/* Line number at which failure occured */
-int CK_EXPORT tr_lno (TestResult *tr);
-/* File name at which failure occured */
-const char * CK_EXPORT tr_lfile (TestResult *tr);
-/* Test case in which unit test was run */
-const char * CK_EXPORT tr_tcname (TestResult *tr);
-
-/* Creates an SRunner for the given suite */
-SRunner * CK_EXPORT srunner_create (Suite *s);
-
-/* Adds a Suite to an SRunner */
-void CK_EXPORT srunner_add_suite (SRunner *sr, Suite *s);
-
-/* Frees an SRunner, all suites added to it and all contained test cases */
-void CK_EXPORT srunner_free (SRunner *sr);
-
- 
-/* Test running */
-
-/* Runs an SRunner, printing results as specified (see enum print_output) */
-void CK_EXPORT srunner_run_all (SRunner *sr, enum print_output print_mode);
-
- 
-/* Next functions are valid only after the suite has been
-   completely run, of course */
-
-/* Number of failed tests in a run suite. Includes failures + errors */
-int CK_EXPORT srunner_ntests_failed (SRunner *sr);
-
-/* Total number of tests run in a run suite */
-int CK_EXPORT srunner_ntests_run (SRunner *sr);
-
-/* Return an array of results for all failures
-  
-   Number of failures is equal to srunner_nfailed_tests.  Memory for
-   the array is malloc'ed and must be freed, but individual TestResults
-   must not
-*/
-TestResult ** CK_EXPORT srunner_failures (SRunner *sr);
+/**
+ * Retrieve type of result that the given test result represents.
+ *
+ * This is a member of test_result, and can represent a
+ * pass, failure, or error.
+ *
+ * @param tr test result to retrieve result from
+ *
+ * @return result of given test
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP int CK_EXPORT tr_rtype (TestResult * tr);
+
+/**
+ * Retrieve context in which the result occurred for the given test result.
+ *
+ * The types of contents include the test setup, teardown, or the
+ * body of the test itself.
+ *
+ * @param tr test result to retrieve context from
+ *
+ * @return context to which the given test result applies
+ *
+ * @since 0.8.0
+ */
+CK_DLL_EXP enum ck_result_ctx CK_EXPORT tr_ctx (TestResult * tr);
+
+/**
+ * Retrieve failure message from test result, if applicable.
+ *
+ * @return pointer to a message, if one exists. NULL otherwise.
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP const char *CK_EXPORT tr_msg (TestResult * tr);
+
+/**
+ * Retrieve line number at which a failure occurred, if applicable.
+ *
+ * @return If the test resulted in a failure, returns the line number
+ *          that the failure occurred on; otherwise returns -1.
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP int CK_EXPORT tr_lno (TestResult * tr);
 
-/* Return an array of results for all run tests
+/**
+ * Retrieve file name at which a failure occurred, if applicable.
+ *
+ * @return If the test resulted in a failure, returns a string
+ *          containing the name of the file where the failure
+ *          occurred; otherwise returns NULL.
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP const char *CK_EXPORT tr_lfile (TestResult * tr);
 
-   Number of results is equal to srunner_ntests_run, and excludes
-   failures due to setup function failure.
+/**
+ * Retrieve test case name in which a failure occurred, if applicable.
+ *
+ * @return If the test resulted in a failure, returns a string
+ *          containing the name of the test suite where the failure
+ *          occurred; otherwise returns NULL.
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP const char *CK_EXPORT tr_tcname (TestResult * tr);
 
-   Memory is malloc'ed and must be freed, but individual TestResults
-   must not
-*/  
-TestResult ** CK_EXPORT srunner_results (SRunner *sr);
+/**
+ * Creates a suite runner for the given suite.
+ *
+ * Once created, additional suites can be added to the
+ * suite runner using srunner_add_suite(), and the suite runner can be
+ * run with srunner_run_all(). Once finished, the suite runner
+ * must be freed with srunner_free().
+ *
+ * @param s suite to generate a suite runner for
+ *
+ * @return suite runner for the given suite
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP SRunner *CK_EXPORT srunner_create (Suite * s);
 
- 
-/* Printing */
+/**
+ * Add an additional suite to a suite runner.
+ *
+ * The first suite in a suite runner is always added in srunner_create().
+ * This call adds additional suites to a suite runner.
+ *
+ * @param sr suite runner to add the given suite
+ * @param s suite to add to the given suite runner
+ *
+ * @since 0.7.0
+ */
+CK_DLL_EXP void CK_EXPORT srunner_add_suite (SRunner * sr, Suite * s);
 
-/* Print the results contained in an SRunner */
-void CK_EXPORT srunner_print (SRunner *sr, enum print_output print_mode);
-  
-  
-/* Set a log file to which to write during test running.
+/**
+ * Frees a suite runner, including all contained suite and test cases.
+ *
+ * This call is responsible for freeing all resources related to a
+ * suite runner and all contained suites and test cases. Suite and
+ * test cases need not be freed individually, as this call handles that.
+ *
+ * @param sr suite runner to free
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP void CK_EXPORT srunner_free (SRunner * sr);
 
-  Log file setting is an initialize only operation -- it should be
-  done immediatly after SRunner creation, and the log file can't be
-  changed after being set.
+/**
+ * Runs a suite runner and all contained suite, printing results to
+ * stdout as specified by the print_mode.
+ *
+ * In addition to running all suites, if the suite runner has been
+ * configured to output to a log, that is also performed.
+ *
+ * Note that if the CK_RUN_CASE and/or CK_RUN_SUITE environment variables
+ * are defined, then only the named suite and/or test case is run.
+ *
+ * @param sr suite runner to run all suites from
+ * @param print_mode the verbosity in which to report results to stdout
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP void CK_EXPORT srunner_run_all (SRunner * sr,
+    enum print_output print_mode);
+
+/**
+ * Run a specific suite or test case from a suite runner, printing results
+ * to stdout as specified by the print_mode.
+ *
+ * In addition to running any applicable suites or test cases, if the
+ * suite runner has been configured to output to a log, that is also
+ * performed.
+ *
+ * @param sr suite runner where the given suite or test case must be
+ * @param sname suite name to run. A NULL means "any suite".
+ * @param tcname test case name to run. A NULL means "any test case"
+ * @param print_mode the verbosity in which to report results to stdout
+ *
+ * @since 0.9.9
+ */
+CK_DLL_EXP void CK_EXPORT srunner_run (SRunner * sr, const char *sname,
+    const char *tcname, enum print_output print_mode);
+
+
+/**
+ * Retrieve the number of failed tests executed by a suite runner.
+ *
+ * This value represents both test failures and errors.
+ *
+ * @param sr suite runner to query for all failed tests
+ *
+ * @return number of test failures and errors found by the suite runner
+ *
+ * @since 0.6.1
+ */
+CK_DLL_EXP int CK_EXPORT srunner_ntests_failed (SRunner * sr);
+
+/**
+ * Retrieve the total number of tests run by a suite runner.
+ *
+ * @param sr suite runner to query for all tests run
+ *
+ * @return number of all tests run by the suite runner
+ *
+ * @since 0.6.1
+ */
+CK_DLL_EXP int CK_EXPORT srunner_ntests_run (SRunner * sr);
+
+/**
+ * Return an array of results for all failures found by a suite runner.
+ *
+ * Number of results is equal to srunner_nfailed_tests().
+ *
+ * Information about individual results can be queried using:
+ * tr_rtype(), tr_ctx(), tr_msg(), tr_lno(), tr_lfile(), and tr_tcname().
+ *
+ * Memory is malloc'ed and must be freed; however free the entire structure
+ * instead of individual test cases.
+ *
+ * @param sr suite runner to retrieve results from
+ *
+ * @return array of TestResult objects
+ *
+ * @since 0.6.0
+ */
+CK_DLL_EXP TestResult **CK_EXPORT srunner_failures (SRunner * sr);
+
+/**
+ * Return an array of results for all tests run by a suite runner.
+ *
+ * Number of results is equal to srunner_ntests_run(), and excludes
+ * failures due to setup function failure.
+ *
+ * Information about individual results can be queried using:
+ * tr_rtype(), tr_ctx(), tr_msg(), tr_lno(), tr_lfile(), and tr_tcname().
+ *
+ * Memory is malloc'ed and must be freed; however free the entire structure
+ * instead of individual test cases.
+ *
+ * @param sr suite runner to retrieve results from
+ *
+ * @return array of TestResult objects
+ *
+ * @since 0.6.1
 */
-void CK_EXPORT srunner_set_log (SRunner *sr, const char *fname);
+CK_DLL_EXP TestResult **CK_EXPORT srunner_results (SRunner * sr);
 
-/* Does the SRunner have a log file? */
-int CK_EXPORT srunner_has_log (SRunner *sr);
+/**
+ * Print the results contained in an SRunner to stdout.
+ *
+ * @param sr suite runner to print results for to stdout
+ * @param print_mode the print_output (verbosity) to use to report
+ *         the result
+ *
+ * @since 0.7.0
+ */
+CK_DLL_EXP void CK_EXPORT srunner_print (SRunner * sr,
+    enum print_output print_mode);
 
-/* Return the name of the log file, or NULL if none */
-const char * CK_EXPORT srunner_log_fname (SRunner *sr);
+/**
+ * Set the suite runner to output the result in log format to the
+ * given file.
+ *
+ * Note: log file setting is an initialize only operation -- it should
+ * be done immediately after SRunner creation, and the log file can't be
+ * changed after being set.
+ *
+ * This setting does not conflict with the other log output types;
+ * all logging types can occur concurrently if configured.
+ *
+ * @param sr suite runner to log results of in log format
+ * @param fname file name to output log results to
+ *
+ * @since 0.7.1
+*/
+CK_DLL_EXP void CK_EXPORT srunner_set_log (SRunner * sr, const char *fname);
 
-/* Set a xml file to which to write during test running.
+/**
+ * Checks if the suite runner is assigned a file for log output.
+ *
+ * @param sr suite runner to check
+ *
+ * @return 1 iff the suite runner currently is configured to output
+ *         in log format; 0 otherwise
+ *
+ * @since 0.7.1
+ */
+CK_DLL_EXP int CK_EXPORT srunner_has_log (SRunner * sr);
 
-  XML file setting is an initialize only operation -- it should be
-  done immediatly after SRunner creation, and the XML file can't be
-  changed after being set.
+/**
+ * Retrieves the name of the currently assigned file
+ * for log output, if any exists.
+ *
+ * @return the name of the log file, or NULL if none is configured
+ *
+ * @since 0.7.1
+ */
+CK_DLL_EXP const char *CK_EXPORT srunner_log_fname (SRunner * sr);
+
+/**
+ * Set the suite runner to output the result in XML format to the
+ * given file.
+ *
+ * Note: XML file setting is an initialize only operation -- it should
+ * be done immediately after SRunner creation, and the XML file can't be
+ * changed after being set.
+ *
+ * This setting does not conflict with the other log output types;
+ * all logging types can occur concurrently if configured.
+ *
+ * @param sr suite runner to log results of in XML format
+ * @param fname file name to output XML results to
+ *
+ * @since 0.9.1
 */
-void CK_EXPORT srunner_set_xml (SRunner *sr, const char *fname);
+CK_DLL_EXP void CK_EXPORT srunner_set_xml (SRunner * sr, const char *fname);
+
+/**
+ * Checks if the suite runner is assigned a file for XML output.
+ *
+ * @param sr suite runner to check
+ *
+ * @return 1 iff the suite runner currently is configured to output
+ *         in XML format; 0 otherwise
+ *
+ * @since 0.9.1
+ */
+CK_DLL_EXP int CK_EXPORT srunner_has_xml (SRunner * sr);
 
-/* Does the SRunner have an XML log file? */
-int CK_EXPORT srunner_has_xml (SRunner *sr);
+/**
+ * Retrieves the name of the currently assigned file
+ * for XML output, if any exists.
+ *
+ * @return the name of the XML file, or NULL if none is configured
+ *
+ * @since 0.9.1
+ */
+CK_DLL_EXP const char *CK_EXPORT srunner_xml_fname (SRunner * sr);
 
-/* Return the name of the XML file, or NULL if none */
-const char * CK_EXPORT srunner_xml_fname (SRunner *sr);
+/**
+ * Set the suite runner to output the result in TAP format to the
+ * given file.
+ *
+ * Note: TAP file setting is an initialize only operation -- it should
+ * be done immediately after SRunner creation, and the TAP file can't be
+ * changed after being set.
+ *
+ * This setting does not conflict with the other log output types;
+ * all logging types can occur concurrently if configured.
+ *
+ * @param sr suite runner to log results of in TAP format
+ * @param fname file name to output TAP results to
+ *
+ * @since 0.9.12
+*/
+CK_DLL_EXP void CK_EXPORT srunner_set_tap (SRunner * sr, const char *fname);
 
+/**
+ * Checks if the suite runner is assigned a file for TAP output.
+ *
+ * @param sr suite runner to check
+ *
+ * @return 1 iff the suite runner currently is configured to output
+ *         in TAP format; 0 otherwise
+ *
+ * @since 0.9.12
+ */
+CK_DLL_EXP int CK_EXPORT srunner_has_tap (SRunner * sr);
 
-/* Control forking */
-enum fork_status {
-  CK_FORK_GETENV, /* look in the environment for CK_FORK */
-  CK_FORK,        /* call fork to run tests */
-  CK_NOFORK       /* don't call fork */
+/**
+ * Retrieves the name of the currently assigned file
+ * for TAP output, if any exists.
+ *
+ * @return the name of the TAP file, or NULL if none is configured
+ *
+ * @since 0.9.12
+ */
+CK_DLL_EXP const char *CK_EXPORT srunner_tap_fname (SRunner * sr);
+
+/**
+ * Enum describing the current fork usage.
+ */
+enum fork_status
+{
+  CK_FORK_GETENV,               /**< look in the environment for CK_FORK */
+  CK_FORK,                      /**< call fork to run tests */
+  CK_NOFORK                     /**< don't call fork */
 };
- 
-/* Get the current fork status */
-enum fork_status CK_EXPORT srunner_fork_status (SRunner *sr);
 
-/* Set the current fork status */
-void CK_EXPORT srunner_set_fork_status (SRunner *sr, enum fork_status fstat); 
-  
-/* Fork in a test and make sure messaging and tests work. */
-pid_t CK_EXPORT check_fork(void);
+/**
+ * Retrieve the current fork status for the given suite runner
+ *
+ * @param sr suite runner to check fork status of
+ *
+ * @since 0.8.0
+ */
+CK_DLL_EXP enum fork_status CK_EXPORT srunner_fork_status (SRunner * sr);
 
-/* Wait for the pid and exit. If pid is zero, just exit. */
-void CK_EXPORT check_waitpid_and_exit(pid_t pid);
+/**
+ * Set the fork status for a given suite runner.
+ *
+ * The default fork status is CK_FORK_GETENV, which will look
+ * for the CK_FORK environment variable, which can be set to
+ * "yes" or "no". If the environment variable is not present,
+ * CK_FORK will be used if fork() is available on the system,
+ * otherwise CK_NOFORK is used.
+ *
+ * If set to CK_FORK or CK_NOFORK, the environment variable
+ * if defined is ignored.
+ *
+ * @param sr suite runner to assign the fork status to
+ * @param fstat fork status to assign
+ *
+ * @since 0.8.0
+ */
+CK_DLL_EXP void CK_EXPORT srunner_set_fork_status (SRunner * sr,
+    enum fork_status fstat);
 
-#ifdef __cplusplus 
+/**
+ * Invoke fork() during a test and assign the child to the same
+ * process group that the rest of the test case uses.
+ *
+ * One can invoke fork() directly during a test; however doing so
+ * may not guarantee that any children processes are destroyed once
+ * the test finishes. Once a test has completed, all processes in
+ * the process group will be killed; using this wrapper will prevent
+ * orphan processes.
+ *
+ * @return On success, the PID of the child process is returned in
+ *          the parent, and 0 is returned in the child.  On failure,
+ *          an error will be printed and exit() invoked.
+ *
+ * @since 0.9.3
+ */
+CK_DLL_EXP pid_t CK_EXPORT check_fork (void);
+
+/**
+ * Wait for the pid and exit.
+ *
+ * This is to be used in conjunction with check_fork(). When called,
+ * will wait for the given process to terminate. If the process
+ * exited without error, exit(EXIT_SUCCESS) is invoked; otherwise
+ * exit(EXIT_FAILURE) is invoked.
+ *
+ * @param pid process to wait for, created by check_fork()
+ *
+ * @since 0.9.3
+ */
+CK_DLL_EXP void CK_EXPORT
+check_waitpid_and_exit (pid_t pid)
+    CK_ATTRIBUTE_NORETURN;
+
+#ifdef __cplusplus
 CK_CPPEND
 #endif
-
 #endif /* CHECK_H */