-/* $Id$ */
-
/***
- This file is part of polypaudio.
-
- polypaudio is free software; you can redistribute it and/or modify
+ This file is part of PulseAudio.
+
+ 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.
-
- polypaudio is distributed in the hope that it will be useful, but
+
+ PulseAudio is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
-
+
You should have received a copy of the GNU Lesser General Public License
- along with polypaudio; if not, write to the Free Software
+ along with PulseAudio; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
USA.
***/
#endif
#include <stdlib.h>
-#include <assert.h>
#include <stdio.h>
+#include <signal.h>
+
+#include <check.h>
+
+#include <pulsecore/memblockq.h>
+#include <pulsecore/log.h>
+#include <pulsecore/macro.h>
+#include <pulsecore/strbuf.h>
+#include <pulsecore/core-util.h>
+
+#include <pulse/xmalloc.h>
+
+static const char *fixed[] = {
+ "1122444411441144__22__11______3333______________________________",
+ "__________________3333__________________________________________"
+};
+static const char *manual[] = {
+ "1122444411441144__22__11______3333______________________________",
+ "__________________3333______________________________"
+};
+
+static void dump_chunk(const pa_memchunk *chunk, pa_strbuf *buf) {
+ size_t n;
+ void *q;
+ char *e;
+
+ fail_unless(chunk != NULL);
+
+ q = pa_memblock_acquire(chunk->memblock);
+ for (e = (char*) q + chunk->index, n = 0; n < chunk->length; n++, e++) {
+ fprintf(stderr, "%c", *e);
+ pa_strbuf_putc(buf, *e);
+ }
+ pa_memblock_release(chunk->memblock);
+}
-#include <polypcore/memblockq.h>
-#include <polypcore/log.h>
+static void dump(pa_memblockq *bq, int n) {
+ pa_memchunk out;
+ pa_strbuf *buf;
+ char *str;
-int main(int argc, char *argv[]) {
+ pa_assert(bq);
+
+ /* First let's dump this as fixed block */
+ fprintf(stderr, "FIXED >");
+ pa_memblockq_peek_fixed_size(bq, 64, &out);
+ buf = pa_strbuf_new();
+ dump_chunk(&out, buf);
+ pa_memblock_unref(out.memblock);
+ str = pa_strbuf_tostring_free(buf);
+ fail_unless(pa_streq(str, fixed[n]));
+ pa_xfree(str);
+ fprintf(stderr, "<\n");
+
+ /* Then let's dump the queue manually */
+ fprintf(stderr, "MANUAL>");
+
+ buf = pa_strbuf_new();
+ for (;;) {
+ if (pa_memblockq_peek(bq, &out) < 0)
+ break;
+
+ dump_chunk(&out, buf);
+ pa_memblock_unref(out.memblock);
+ pa_memblockq_drop(bq, out.length);
+ }
+ str = pa_strbuf_tostring_free(buf);
+ fail_unless(pa_streq(str, manual[n]));
+ pa_xfree(str);
+ fprintf(stderr, "<\n");
+}
+
+START_TEST (memblockq_test) {
int ret;
+
+ pa_mempool *p;
pa_memblockq *bq;
pa_memchunk chunk1, chunk2, chunk3, chunk4;
- pa_memblock *silence;
+ pa_memchunk silence;
+ pa_sample_spec ss = {
+ .format = PA_SAMPLE_S16LE,
+ .rate = 48000,
+ .channels = 1
+ };
+
+ pa_log_set_level(PA_LOG_DEBUG);
+
+ p = pa_mempool_new(false, 0);
+
+ silence.memblock = pa_memblock_new_fixed(p, (char*) "__", 2, 1);
+ fail_unless(silence.memblock != NULL);
+
+ silence.index = 0;
+ silence.length = pa_memblock_get_length(silence.memblock);
- pa_log_set_maximal_level(PA_LOG_DEBUG);
-
- silence = pa_memblock_new_fixed((char*) "__", 2, 1, NULL);
- assert(silence);
+ bq = pa_memblockq_new("test memblockq", 0, 200, 10, &ss, 4, 4, 40, &silence);
+ fail_unless(bq != NULL);
- bq = pa_memblockq_new(0, 40, 10, 2, 4, 4, silence, NULL);
- assert(bq);
+ chunk1.memblock = pa_memblock_new_fixed(p, (char*) "11", 2, 1);
+ fail_unless(chunk1.memblock != NULL);
- chunk1.memblock = pa_memblock_new_fixed((char*) "AA", 2, 1, NULL);
chunk1.index = 0;
chunk1.length = 2;
- assert(chunk1.memblock);
-
- chunk2.memblock = pa_memblock_new_fixed((char*) "TTBB", 4, 1, NULL);
+
+ chunk2.memblock = pa_memblock_new_fixed(p, (char*) "XX22", 4, 1);
+ fail_unless(chunk2.memblock != NULL);
+
chunk2.index = 2;
chunk2.length = 2;
- assert(chunk2.memblock);
- chunk3.memblock = pa_memblock_new_fixed((char*) "ZZZZ", 4, 1, NULL);
+ chunk3.memblock = pa_memblock_new_fixed(p, (char*) "3333", 4, 1);
+ fail_unless(chunk3.memblock != NULL);
+
chunk3.index = 0;
chunk3.length = 4;
- assert(chunk3.memblock);
- chunk4.memblock = pa_memblock_new_fixed((char*) "KKKKKKKK", 8, 1, NULL);
+ chunk4.memblock = pa_memblock_new_fixed(p, (char*) "44444444", 8, 1);
+ fail_unless(chunk4.memblock != NULL);
+
chunk4.index = 0;
chunk4.length = 8;
- assert(chunk4.memblock);
ret = pa_memblockq_push(bq, &chunk1);
- assert(ret == 0);
-
- ret = pa_memblockq_push(bq, &chunk1);
- assert(ret == 0);
-
- ret = pa_memblockq_push(bq, &chunk2);
- assert(ret == 0);
-
+ fail_unless(ret == 0);
+
ret = pa_memblockq_push(bq, &chunk2);
- assert(ret == 0);
+ fail_unless(ret == 0);
- pa_memblockq_seek(bq, -6, 0);
ret = pa_memblockq_push(bq, &chunk3);
- assert(ret == 0);
+ fail_unless(ret == 0);
+
+ ret = pa_memblockq_push(bq, &chunk4);
+ fail_unless(ret == 0);
- pa_memblockq_seek(bq, -2, 0);
+ pa_memblockq_seek(bq, -6, 0, true);
ret = pa_memblockq_push(bq, &chunk3);
- assert(ret == 0);
+ fail_unless(ret == 0);
+
+ pa_memblockq_seek(bq, -2, 0, true);
+ ret = pa_memblockq_push(bq, &chunk1);
+ fail_unless(ret == 0);
- pa_memblockq_seek(bq, -10, 0);
+ pa_memblockq_seek(bq, -10, 0, true);
ret = pa_memblockq_push(bq, &chunk4);
- assert(ret == 0);
+ fail_unless(ret == 0);
- pa_memblockq_seek(bq, 10, 0);
+ pa_memblockq_seek(bq, 10, 0, true);
ret = pa_memblockq_push(bq, &chunk1);
- assert(ret == 0);
+ fail_unless(ret == 0);
- pa_memblockq_seek(bq, -6, 0);
+ pa_memblockq_seek(bq, -6, 0, true);
ret = pa_memblockq_push(bq, &chunk2);
- assert(ret == 0);
+ fail_unless(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);
+ fail_unless(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);
+ fail_unless(ret == 0);
+ pa_memblockq_seek(bq, -2, 0, true);
chunk3.index += 2;
chunk3.length -= 2;
-
ret = pa_memblockq_push(bq, &chunk3);
- assert(ret == 0);
-
- printf(">");
+ fail_unless(ret == 0);
- pa_memblockq_shorten(bq, 6);
-
- for (;;) {
- pa_memchunk out;
- char *e;
- size_t n;
-
- if (pa_memblockq_peek(bq, &out) < 0)
- break;
+ pa_memblockq_seek(bq, 30, PA_SEEK_RELATIVE, true);
- for (e = (char*) out.memblock->data + out.index, n = 0; n < out.length; n++)
- printf("%c", *e);
+ dump(bq, 0);
+
+ pa_memblockq_rewind(bq, 52);
+
+ dump(bq, 1);
- pa_memblock_unref(out.memblock);
- pa_memblockq_drop(bq, &out, out.length);
- }
-
- printf("<\n");
-
pa_memblockq_free(bq);
- pa_memblock_unref(silence);
+ pa_memblock_unref(silence.memblock);
pa_memblock_unref(chunk1.memblock);
pa_memblock_unref(chunk2.memblock);
pa_memblock_unref(chunk3.memblock);
pa_memblock_unref(chunk4.memblock);
-
- return 0;
+
+ pa_mempool_free(p);
+}
+END_TEST
+
+int main(int argc, char *argv[]) {
+ int failed = 0;
+ Suite *s;
+ TCase *tc;
+ SRunner *sr;
+
+ s = suite_create("Memblock Queue");
+ tc = tcase_create("memblockq");
+ tcase_add_test(tc, memblockq_test);
+ suite_add_tcase(s, tc);
+
+ sr = srunner_create(s);
+ srunner_run_all(sr, CK_NORMAL);
+ failed = srunner_ntests_failed(sr);
+ srunner_free(sr);
+
+ return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
}