Convert tests to gtests.

1 files changed, 71 insertions, 77 deletions

diff --git a/test/test_sanity.cpp b/test/test_sanity.cpp
index 5d56a90..0423636 100644
--- a/test/test_sanity.cpp
+++ b/test/test_sanity.cpp
@@ -4,16 +4,13 @@
  * This program is made available under an ISC-style license.  See the
  * accompanying file LICENSE for details.
  */
-#ifdef NDEBUG
-#undef NDEBUG
-#endif
 #define _XOPEN_SOURCE 600
 #include "cubeb/cubeb.h"
-#include <assert.h>
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
 #include "common.h"
+#include "gtest/gtest.h"
 
 #define BEGIN_TEST fprintf(stderr, "START %s\n", __func__)
 #define END_TEST fprintf(stderr, "END %s\n", __func__)
@@ -41,7 +38,7 @@ static int delay_callback;
 static long
 test_data_callback(cubeb_stream * stm, void * user_ptr, const void * /*inputbuffer*/, void * outputbuffer, long nframes)
 {
-  assert(stm && user_ptr == &dummy && outputbuffer && nframes > 0);
+  EXPECT_TRUE(stm && user_ptr == &dummy && outputbuffer && nframes > 0);
 #if (defined(_WIN32) || defined(__WIN32__))
   memset(outputbuffer, 0, nframes * sizeof(float));
 #else
@@ -70,11 +67,11 @@ test_init_destroy_context(void)
   BEGIN_TEST;
 
   r = cubeb_init(&ctx, "test_sanity");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
 
   backend_id = cubeb_get_backend_id(ctx);
-  assert(backend_id);
+  ASSERT_TRUE(backend_id);
 
   fprintf(stderr, "Backend: %s\n", backend_id);
 
@@ -90,13 +87,13 @@ test_init_destroy_multiple_contexts(void)
   int r;
   cubeb * ctx[4];
   int order[4] = {2, 0, 3, 1};
-  assert(ARRAY_LENGTH(ctx) == ARRAY_LENGTH(order));
+  ASSERT_TRUE(ARRAY_LENGTH(ctx) == ARRAY_LENGTH(order));
 
   BEGIN_TEST;
 
   for (i = 0; i < ARRAY_LENGTH(ctx); ++i) {
     r = cubeb_init(&ctx[i], NULL);
-    assert(r == 0 && ctx[i]);
+    ASSERT_TRUE(r == 0 && ctx[i]);
   }
 
   /* destroy in a different order */
@@ -118,7 +115,7 @@ test_context_variables(void)
   BEGIN_TEST;
 
   r = cubeb_init(&ctx, "test_context_variables");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
   params.channels = STREAM_CHANNELS;
   params.format = STREAM_FORMAT;
@@ -127,15 +124,15 @@ test_context_variables(void)
   params.stream_type = CUBEB_STREAM_TYPE_MUSIC;
 #endif
   r = cubeb_get_min_latency(ctx, params, &value);
-  assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
+  ASSERT_TRUE(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
   if (r == CUBEB_OK) {
-    assert(value > 0);
+    ASSERT_TRUE(value > 0);
   }
 
   r = cubeb_get_preferred_sample_rate(ctx, &value);
-  assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
+  ASSERT_TRUE(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
   if (r == CUBEB_OK) {
-    assert(value > 0);
+    ASSERT_TRUE(value > 0);
   }
 
   cubeb_destroy(ctx);
@@ -154,7 +151,7 @@ test_init_destroy_stream(void)
   BEGIN_TEST;
 
   r = cubeb_init(&ctx, "test_sanity");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
@@ -165,7 +162,7 @@ test_init_destroy_stream(void)
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_data_callback, test_state_callback, &dummy);
-  assert(r == 0 && stream);
+  ASSERT_TRUE(r == 0 && stream);
 
   cubeb_stream_destroy(stream);
   cubeb_destroy(ctx);
@@ -185,7 +182,7 @@ test_init_destroy_multiple_streams(void)
   BEGIN_TEST;
 
   r = cubeb_init(&ctx, "test_sanity");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
@@ -197,8 +194,8 @@ test_init_destroy_multiple_streams(void)
   for (i = 0; i < ARRAY_LENGTH(stream); ++i) {
     r = cubeb_stream_init(ctx, &stream[i], "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                           test_data_callback, test_state_callback, &dummy);
-    assert(r == 0);
-    assert(stream[i]);
+    ASSERT_TRUE(r == 0);
+    ASSERT_TRUE(stream[i]);
   }
 
   for (i = 0; i < ARRAY_LENGTH(stream); ++i) {
@@ -221,7 +218,7 @@ test_configure_stream(void)
   BEGIN_TEST;
 
   r = cubeb_init(&ctx, "test_sanity");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
@@ -232,13 +229,13 @@ test_configure_stream(void)
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_data_callback, test_state_callback, &dummy);
-  assert(r == 0 && stream);
+  ASSERT_TRUE(r == 0 && stream);
 
   r = cubeb_stream_set_volume(stream, 1.0f);
-  assert(r == 0 || r == CUBEB_ERROR_NOT_SUPPORTED);
+  ASSERT_TRUE(r == 0 || r == CUBEB_ERROR_NOT_SUPPORTED);
 
   r = cubeb_stream_set_panning(stream, 0.0f);
-  assert(r == 0 || r == CUBEB_ERROR_NOT_SUPPORTED);
+  ASSERT_TRUE(r == 0 || r == CUBEB_ERROR_NOT_SUPPORTED);
 
   cubeb_stream_destroy(stream);
   cubeb_destroy(ctx);
@@ -257,7 +254,7 @@ test_init_start_stop_destroy_multiple_streams(int early, int delay_ms)
   BEGIN_TEST;
 
   r = cubeb_init(&ctx, "test_sanity");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
@@ -269,11 +266,11 @@ test_init_start_stop_destroy_multiple_streams(int early, int delay_ms)
   for (i = 0; i < ARRAY_LENGTH(stream); ++i) {
     r = cubeb_stream_init(ctx, &stream[i], "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                           test_data_callback, test_state_callback, &dummy);
-    assert(r == 0);
-    assert(stream[i]);
+    ASSERT_TRUE(r == 0);
+    ASSERT_TRUE(stream[i]);
     if (early) {
       r = cubeb_stream_start(stream[i]);
-      assert(r == 0);
+      ASSERT_TRUE(r == 0);
     }
   }
 
@@ -281,7 +278,7 @@ test_init_start_stop_destroy_multiple_streams(int early, int delay_ms)
   if (!early) {
     for (i = 0; i < ARRAY_LENGTH(stream); ++i) {
       r = cubeb_stream_start(stream[i]);
-      assert(r == 0);
+      ASSERT_TRUE(r == 0);
     }
   }
 
@@ -292,14 +289,14 @@ test_init_start_stop_destroy_multiple_streams(int early, int delay_ms)
   if (!early) {
     for (i = 0; i < ARRAY_LENGTH(stream); ++i) {
       r = cubeb_stream_stop(stream[i]);
-      assert(r == 0);
+      ASSERT_TRUE(r == 0);
     }
   }
 
   for (i = 0; i < ARRAY_LENGTH(stream); ++i) {
     if (early) {
       r = cubeb_stream_stop(stream[i]);
-      assert(r == 0);
+      ASSERT_TRUE(r == 0);
     }
     cubeb_stream_destroy(stream[i]);
   }
@@ -318,7 +315,7 @@ test_init_destroy_multiple_contexts_and_streams(void)
   cubeb_stream * stream[8];
   cubeb_stream_params params;
   size_t streams_per_ctx = ARRAY_LENGTH(stream) / ARRAY_LENGTH(ctx);
-  assert(ARRAY_LENGTH(ctx) * streams_per_ctx == ARRAY_LENGTH(stream));
+  ASSERT_TRUE(ARRAY_LENGTH(ctx) * streams_per_ctx == ARRAY_LENGTH(stream));
 
   BEGIN_TEST;
 
@@ -331,13 +328,13 @@ test_init_destroy_multiple_contexts_and_streams(void)
 
   for (i = 0; i < ARRAY_LENGTH(ctx); ++i) {
     r = cubeb_init(&ctx[i], "test_sanity");
-    assert(r == 0 && ctx[i]);
+    ASSERT_TRUE(r == 0 && ctx[i]);
 
     for (j = 0; j < streams_per_ctx; ++j) {
       r = cubeb_stream_init(ctx[i], &stream[i * streams_per_ctx + j], "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                             test_data_callback, test_state_callback, &dummy);
-      assert(r == 0);
-      assert(stream[i * streams_per_ctx + j]);
+      ASSERT_TRUE(r == 0);
+      ASSERT_TRUE(stream[i * streams_per_ctx + j]);
     }
   }
 
@@ -363,7 +360,7 @@ test_basic_stream_operations(void)
   BEGIN_TEST;
 
   r = cubeb_init(&ctx, "test_sanity");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
@@ -374,25 +371,25 @@ test_basic_stream_operations(void)
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_data_callback, test_state_callback, &dummy);
-  assert(r == 0 && stream);
+  ASSERT_TRUE(r == 0 && stream);
 
   /* position and volume before stream has started */
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0 && position == 0);
+  ASSERT_TRUE(r == 0 && position == 0);
 
   r = cubeb_stream_start(stream);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
 
   /* position and volume after while stream running */
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
 
   r = cubeb_stream_stop(stream);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
 
   /* position and volume after stream has stopped */
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
 
   cubeb_stream_destroy(stream);
   cubeb_destroy(ctx);
@@ -415,7 +412,7 @@ test_stream_position(void)
   total_frames_written = 0;
 
   r = cubeb_init(&ctx, "test_sanity");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
@@ -426,44 +423,44 @@ test_stream_position(void)
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_data_callback, test_state_callback, &dummy);
-  assert(r == 0 && stream);
+  ASSERT_TRUE(r == 0 && stream);
 
   /* stream position should not advance before starting playback */
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0 && position == 0);
+  ASSERT_TRUE(r == 0 && position == 0);
 
   delay(500);
 
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0 && position == 0);
+  ASSERT_TRUE(r == 0 && position == 0);
 
   /* stream position should advance during playback */
   r = cubeb_stream_start(stream);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
 
   /* XXX let start happen */
   delay(500);
 
   /* stream should have prefilled */
-  assert(total_frames_written > 0);
+  ASSERT_TRUE(total_frames_written > 0);
 
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
   last_position = position;
 
   delay(500);
 
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0);
-  assert(position >= last_position);
+  ASSERT_TRUE(r == 0);
+  ASSERT_TRUE(position >= last_position);
   last_position = position;
 
   /* stream position should not exceed total frames written */
   for (i = 0; i < 5; ++i) {
     r = cubeb_stream_get_position(stream, &position);
-    assert(r == 0);
-    assert(position >= last_position);
-    assert(position <= total_frames_written);
+    ASSERT_TRUE(r == 0);
+    ASSERT_TRUE(position >= last_position);
+    ASSERT_TRUE(position <= total_frames_written);
     last_position = position;
     delay(500);
   }
@@ -472,35 +469,35 @@ test_stream_position(void)
    * stopping the stream.  */
   for (i = 0; i < 5; ++i) {
     r = cubeb_stream_stop(stream);
-    assert(r == 0);
+    ASSERT_TRUE(r == 0);
     r = cubeb_stream_get_position(stream, &position);
-    assert(r == 0);
-    assert(last_position < position);
+    ASSERT_TRUE(r == 0);
+    ASSERT_TRUE(last_position < position);
     last_position = position;
     delay(500);
     r = cubeb_stream_start(stream);
-    assert(r == 0);
+    ASSERT_TRUE(r == 0);
     delay(500);
   }
 
-  assert(last_position != 0);
+  ASSERT_TRUE(last_position != 0);
 
   /* stream position should not advance after stopping playback */
   r = cubeb_stream_stop(stream);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
 
   /* XXX allow stream to settle */
   delay(500);
 
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
   last_position = position;
 
   delay(500);
 
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0);
-  assert(position == last_position);
+  ASSERT_TRUE(r == 0);
+  ASSERT_TRUE(position == last_position);
 
   cubeb_stream_destroy(stream);
   cubeb_destroy(ctx);
@@ -514,13 +511,13 @@ static int got_drain;
 static long
 test_drain_data_callback(cubeb_stream * stm, void * user_ptr, const void * /*inputbuffer*/, void * outputbuffer, long nframes)
 {
-  assert(stm && user_ptr == &dummy && outputbuffer && nframes > 0);
+  EXPECT_TRUE(stm && user_ptr == &dummy && outputbuffer && nframes > 0);
   if (do_drain == 1) {
     do_drain = 2;
     return 0;
   }
   /* once drain has started, callback must never be called again */
-  assert(do_drain != 2);
+  EXPECT_TRUE(do_drain != 2);
 #if (defined(_WIN32) || defined(__WIN32__))
   memset(outputbuffer, 0, nframes * sizeof(float));
 #else
@@ -534,7 +531,7 @@ void
 test_drain_state_callback(cubeb_stream * /*stm*/, void * /*user_ptr*/, cubeb_state state)
 {
   if (state == CUBEB_STATE_DRAINED) {
-    assert(!got_drain);
+    ASSERT_TRUE(!got_drain);
     got_drain = 1;
   }
 }
@@ -553,7 +550,7 @@ test_drain(void)
   total_frames_written = 0;
 
   r = cubeb_init(&ctx, "test_sanity");
-  assert(r == 0 && ctx);
+  ASSERT_TRUE(r == 0 && ctx);
 
   params.format = STREAM_FORMAT;
   params.rate = STREAM_RATE;
@@ -564,10 +561,10 @@ test_drain(void)
 
   r = cubeb_stream_init(ctx, &stream, "test", NULL, NULL, NULL, &params, STREAM_LATENCY,
                         test_drain_data_callback, test_drain_state_callback, &dummy);
-  assert(r == 0 && stream);
+  ASSERT_TRUE(r == 0 && stream);
 
   r = cubeb_stream_start(stream);
-  assert(r == 0);
+  ASSERT_TRUE(r == 0);
 
   delay(500);
 
@@ -575,22 +572,22 @@ test_drain(void)
 
   for (;;) {
     r = cubeb_stream_get_position(stream, &position);
-    assert(r == 0);
+    ASSERT_TRUE(r == 0);
     if (got_drain) {
       break;
     } else {
-      assert(position <= total_frames_written);
+      ASSERT_TRUE(position <= total_frames_written);
     }
     delay(500);
   }
 
   r = cubeb_stream_get_position(stream, &position);
-  assert(r == 0);
-  assert(got_drain);
+  ASSERT_TRUE(r == 0);
+  ASSERT_TRUE(got_drain);
 
   // Really, we should be able to rely on position reaching our final written frame, but
   // for now let's make sure it doesn't continue beyond that point.
-  //assert(position <= total_frames_written);
+  //ASSERT_TRUE(position <= total_frames_written);
 
   cubeb_stream_destroy(stream);
   cubeb_destroy(ctx);
@@ -625,8 +622,7 @@ int is_windows_7()
 #endif
 }
 
-int
-main(int /*argc*/, char * /*argv*/[])
+TEST(sanity, main)
 {
   test_init_destroy_context();
   test_init_destroy_multiple_contexts();
@@ -664,6 +660,4 @@ main(int /*argc*/, char * /*argv*/[])
   test_stream_destroy_pending_drain();
 */
   printf("\n");
-
-  return 0;
 }