tests: More useful output of make check

[pulseaudio] / src / tests / memblockq-test.c

diff --git a/src/tests/memblockq-test.c b/src/tests/memblockq-test.c
index c53945b44c02b1d83b1a287f157db3a1aa6cb29b..51e17176e5df07bab58f64cab4abc10e106e8323 100644 (file)
--- a/src/tests/memblockq-test.c
+++ b/src/tests/memblockq-test.c
@@ -3,7 +3,7 @@
 
   PulseAudio is free software; you can redistribute it and/or modify
   it under the terms of the GNU Lesser General Public License as published
-  by the Free Software Foundation; either version 2 of the License,
+  by the Free Software Foundation; either version 2.1 of the License,
   or (at your option) any later version.
 
   PulseAudio is distributed in the hope that it will be useful, but
@@ -22,35 +22,51 @@
 #endif
 
 #include <stdlib.h>
-#include <assert.h>
 #include <stdio.h>
 #include <signal.h>
 
 #include <pulsecore/memblockq.h>
 #include <pulsecore/log.h>
+#include <pulsecore/macro.h>
+
+static void dump_chunk(const pa_memchunk *chunk) {
+    size_t n;
+    void *q;
+    char *e;
+
+    pa_assert(chunk);
+
+    q = pa_memblock_acquire(chunk->memblock);
+    for (e = (char*) q + chunk->index, n = 0; n < chunk->length; n++, e++)
+        fprintf(stderr, "%c", *e);
+    pa_memblock_release(chunk->memblock);
+}
 
 static void dump(pa_memblockq *bq) {
-    printf(">");
+    pa_memchunk out;
 
-    for (;;) {
-        pa_memchunk out;
-        char *e;
-        size_t n;
-        void *q;
+    pa_assert(bq);
 
+    /* First let's dump this as fixed block */
+    fprintf(stderr, "FIXED >");
+    pa_memblockq_peek_fixed_size(bq, 64, &out);
+    dump_chunk(&out);
+    pa_memblock_unref(out.memblock);
+    fprintf(stderr, "<\n");
+
+    /* Then let's dump the queue manually */
+    fprintf(stderr, "MANUAL>");
+
+    for (;;) {
         if (pa_memblockq_peek(bq, &out) < 0)
             break;
 
-        q = pa_memblock_acquire(out.memblock);
-        for (e = (char*) q + out.index, n = 0; n < out.length; n++)
-            printf("%c", *e);
-        pa_memblock_release(out.memblock);
-
+        dump_chunk(&out);
         pa_memblock_unref(out.memblock);
         pa_memblockq_drop(bq, out.length);
     }
 
-    printf("<\n");
+    fprintf(stderr, "<\n");
 }
 
 int main(int argc, char *argv[]) {
@@ -60,38 +76,37 @@ int main(int argc, char *argv[]) {
     pa_memblockq *bq;
     pa_memchunk chunk1, chunk2, chunk3, chunk4;
     pa_memchunk silence;
+    pa_sample_spec ss = {
+        .format = PA_SAMPLE_S16LE,
+        .rate = 48000,
+        .channels = 1
+    };
 
-    pa_log_set_maximal_level(PA_LOG_DEBUG);
+    pa_log_set_level(PA_LOG_DEBUG);
 
     p = pa_mempool_new(FALSE, 0);
 
-    silence.memblock = pa_memblock_new_fixed(p, (char*)  "__", 2, 1);
-    assert(silence.memblock);
+    pa_assert_se(silence.memblock = pa_memblock_new_fixed(p, (char*) "__", 2, 1));
     silence.index = 0;
     silence.length = pa_memblock_get_length(silence.memblock);
 
-    bq = pa_memblockq_new(0, 40, 10, 2, 4, 4, 40, &silence);
-    assert(bq);
+    pa_assert_se(bq = pa_memblockq_new("test memblockq", 0, 200, 10, &ss, 4, 4, 40, &silence));
 
-    chunk1.memblock = pa_memblock_new_fixed(p, (char*) "11", 2, 1);
+    pa_assert_se(chunk1.memblock = pa_memblock_new_fixed(p, (char*) "11", 2, 1));
     chunk1.index = 0;
     chunk1.length = 2;
-    assert(chunk1.memblock);
 
-    chunk2.memblock = pa_memblock_new_fixed(p, (char*) "XX22", 4, 1);
+    pa_assert_se(chunk2.memblock = pa_memblock_new_fixed(p, (char*) "XX22", 4, 1));
     chunk2.index = 2;
     chunk2.length = 2;
-    assert(chunk2.memblock);
 
-    chunk3.memblock = pa_memblock_new_fixed(p, (char*) "3333", 4, 1);
+    pa_assert_se(chunk3.memblock = pa_memblock_new_fixed(p, (char*) "3333", 4, 1));
     chunk3.index = 0;
     chunk3.length = 4;
-    assert(chunk3.memblock);
 
-    chunk4.memblock = pa_memblock_new_fixed(p, (char*) "44444444", 8, 1);
+    pa_assert_se(chunk4.memblock = pa_memblock_new_fixed(p, (char*) "44444444", 8, 1));
     chunk4.index = 0;
     chunk4.length = 8;
-    assert(chunk4.memblock);
 
     ret = pa_memblockq_push(bq, &chunk1);
     assert(ret == 0);
@@ -105,45 +120,45 @@ int main(int argc, char *argv[]) {
     ret = pa_memblockq_push(bq, &chunk4);
     assert(ret == 0);
 
-    pa_memblockq_seek(bq, -6, 0);
+    pa_memblockq_seek(bq, -6, 0, TRUE);
     ret = pa_memblockq_push(bq, &chunk3);
     assert(ret == 0);
 
-    pa_memblockq_seek(bq, -2, 0);
+    pa_memblockq_seek(bq, -2, 0, TRUE);
     ret = pa_memblockq_push(bq, &chunk1);
     assert(ret == 0);
 
-    pa_memblockq_seek(bq, -10, 0);
+    pa_memblockq_seek(bq, -10, 0, TRUE);
     ret = pa_memblockq_push(bq, &chunk4);
     assert(ret == 0);
 
-    pa_memblockq_seek(bq, 10, 0);
+    pa_memblockq_seek(bq, 10, 0, TRUE);
 
     ret = pa_memblockq_push(bq, &chunk1);
     assert(ret == 0);
 
-    pa_memblockq_seek(bq, -6, 0);
+    pa_memblockq_seek(bq, -6, 0, TRUE);
     ret = pa_memblockq_push(bq, &chunk2);
     assert(ret == 0);
 
     /* Test splitting */
-    pa_memblockq_seek(bq, -12, 0);
+    pa_memblockq_seek(bq, -12, 0, TRUE);
     ret = pa_memblockq_push(bq, &chunk1);
     assert(ret == 0);
 
-    pa_memblockq_seek(bq, 20, 0);
+    pa_memblockq_seek(bq, 20, 0, TRUE);
 
     /* Test merging */
     ret = pa_memblockq_push(bq, &chunk3);
     assert(ret == 0);
-    pa_memblockq_seek(bq, -2, 0);
+    pa_memblockq_seek(bq, -2, 0, TRUE);
 
     chunk3.index += 2;
     chunk3.length -= 2;
     ret = pa_memblockq_push(bq, &chunk3);
     assert(ret == 0);
 
-    pa_memblockq_seek(bq, 30, PA_SEEK_RELATIVE);
+    pa_memblockq_seek(bq, 30, PA_SEEK_RELATIVE, TRUE);
 
     dump(bq);