Merge pull request #290 from dgrove-oss/fix-warnings-extended-tests
Fix compilation warnings in extended test suite
diff --git a/tests/bsdtests.c b/tests/bsdtests.c
index 18b4462..09ab000 100644
--- a/tests/bsdtests.c
+++ b/tests/bsdtests.c
@@ -189,6 +189,20 @@
}
void
+_test_sizet(const char* file, long line, const char* desc, size_t actual, size_t expected)
+{
+ _test_print(file, line, desc,
+ (actual == expected), "%zd", actual, "%zd", expected);
+}
+
+void
+test_sizet_format(size_t actual, size_t expected, const char* format, ...)
+{
+ GENERATE_DESC
+ _test_sizet(NULL, 0, desc, actual, expected);
+}
+
+void
_test_uint64(const char* file, long line, const char* desc, uint64_t actual, uint64_t expected)
{
_test_print(file, line, desc,
@@ -256,6 +270,32 @@
}
void
+_test_sizet_less_than(const char* file, long line, const char* desc, size_t actual, size_t expected_max)
+{
+ _test_print(file, line, desc, (actual < expected_max), "%zd", actual, "<%zd", expected_max);
+}
+
+void
+test_sizet_less_than_format(size_t actual, size_t expected_max, const char* format, ...)
+{
+ GENERATE_DESC
+ _test_sizet_less_than(NULL, 0, desc, actual, expected_max);
+}
+
+void
+_test_sizet_less_than_or_equal(const char* file, long line, const char* desc, size_t actual, size_t expected_max)
+{
+ _test_print(file, line, desc, (actual <= expected_max), "%zd", actual, "<=%zd", expected_max);
+}
+
+void
+test_sizet_less_than_or_equal_format(size_t actual, size_t expected_max, const char* format, ...)
+{
+ GENERATE_DESC
+ _test_sizet_less_than_or_equal(NULL, 0, desc, actual, expected_max);
+}
+
+void
_test_double_less_than(const char* file, long line, const char* desc, double val, double max_expected)
{
_test_print(file, line, desc, (val < max_expected), "%f", val, "<%f", max_expected);
diff --git a/tests/bsdtests.h b/tests/bsdtests.h
index 6792e38..cfebb4f 100644
--- a/tests/bsdtests.h
+++ b/tests/bsdtests.h
@@ -91,6 +91,10 @@
#define test_long(a,b,c) _test_long(__SOURCE_FILE__, __LINE__, a, b, c)
void test_long_format(long actual, long expected, const char *format, ...) __printflike(3,4);
+void _test_sizet(const char* file, long line, const char* desc, size_t actual, size_t expected);
+#define test_sizet(a,b,c) _test_sizet(__SOURCE_FILE__, __LINE__, a, b, c)
+void test_sizet_format(size_t actual, size_t expected, const char *format, ...) __printflike(3,4);
+
void _test_uint64(const char* file, long line, const char* desc, uint64_t actual, uint64_t expected);
#define test_uint64(a,b,c) _test_uint64(__SOURCE_FILE__, __LINE__, a, b, c)
void test_uint64_format(uint64_t actual, uint64_t expected, const char* desc, ...);
@@ -111,6 +115,14 @@
#define test_long_greater_than_or_equal(a,b,c) _test_long_greater_than_or_equal(__SOURCE_FILE__, __LINE__, a, b, c)
void test_long_greater_than_or_equal_format(long actual, long expected_min, const char *format, ...) __printflike(3,4);
+void _test_sizet_less_than(const char* file, long line, const char* desc, size_t actual, size_t max_expected);
+#define test_sizet_less_than(a,b,c) _test_sizet_less_than(__SOURCE_FILE__, __LINE__, a, b, c)
+void test_sizet_less_than_format(size_t actual, size_t max_expected, const char *format, ...) __printflike(3,4);
+
+void _test_sizet_less_than_or_equal(const char* file, long line, const char* desc, size_t actual, size_t max_expected);
+#define test_sizet_less_than_or_equal(a,b,c) _test_sizet_less_than_or_equal(__SOURCE_FILE__, __LINE__, a, b, c)
+void test_sizet_less_than_or_equal_format(size_t actual, size_t max_expected, const char *format, ...) __printflike(3,4);
+
void _test_double_less_than_or_equal(const char* file, long line, const char* desc, double val, double max_expected);
#define test_double_less_than_or_equal(d, v, m) _test_double_less_than_or_equal(__SOURCE_FILE__, __LINE__, d, v, m)
void test_double_less_than_or_equal_format(double val, double max_expected, const char *format, ...) __printflike(3,4);
diff --git a/tests/dispatch_cascade.c b/tests/dispatch_cascade.c
index ad5a359..1f3cd40 100644
--- a/tests/dispatch_cascade.c
+++ b/tests/dispatch_cascade.c
@@ -37,7 +37,7 @@
char padding[64];
} indices[BLOCKS];
-size_t iterations = QUEUES * BLOCKS * 0.25;
+size_t iterations = (QUEUES * BLOCKS) / 4;
static void
noop(void *ctxt __attribute__((unused)))
@@ -57,7 +57,7 @@
exit(0);
}
-void
+static void
histogram(void)
{
size_t counts[QUEUES] = {};
@@ -92,7 +92,7 @@
}
}
-void
+static void
cascade(void* context)
{
size_t idx, *idxptr = context;
diff --git a/tests/dispatch_concur.c b/tests/dispatch_concur.c
index ac62292..e7f0226 100644
--- a/tests/dispatch_concur.c
+++ b/tests/dispatch_concur.c
@@ -101,12 +101,12 @@
if (qw > 1) {
size_t concurrency = MIN(n * workers, qw);
if (done > min_acceptable_concurrency) {
- test_long_less_than_or_equal("concurrently completed workers", done, concurrency);
+ test_sizet_less_than_or_equal("concurrently completed workers", done, concurrency);
} else {
- test_long("concurrently completed workers", done, concurrency);
+ test_sizet("concurrently completed workers", done, concurrency);
}
} else {
- test_long_less_than_or_equal("concurrently completed workers", done, 1);
+ test_sizet_less_than_or_equal("concurrently completed workers", done, 1);
}
for (i = 0, mc = mcs; i < n; i++, mc++) {
@@ -116,9 +116,9 @@
size_t expect = MIN(n, qw);
if (max_concur > min_acceptable_concurrency) {
- test_long_less_than_or_equal("max submission concurrency", max_concur, expect);
+ test_sizet_less_than_or_equal("max submission concurrency", max_concur, expect);
} else {
- test_long("max submission concurrency", max_concur, expect);
+ test_sizet("max submission concurrency", max_concur, expect);
}
dispatch_group_wait(gw, DISPATCH_TIME_FOREVER);
@@ -159,9 +159,9 @@
size_t expect = qw == 1 ? 1 : n;
if (max_concur > min_acceptable_concurrency) {
- test_long_less_than_or_equal("max sync concurrency", max_concur, expect);
+ test_sizet_less_than_or_equal("max sync concurrency", max_concur, expect);
} else {
- test_long("max sync concurrency", max_concur, expect);
+ test_sizet("max sync concurrency", max_concur, expect);
}
}
@@ -190,9 +190,9 @@
size_t expect = MIN(n, qw);
if (max_concur > min_acceptable_concurrency) {
- test_long_less_than_or_equal("max apply concurrency", max_concur, expect);
+ test_sizet_less_than_or_equal("max apply concurrency", max_concur, expect);
} else {
- test_long("max apply concurrency", max_concur, expect);
+ test_sizet("max apply concurrency", max_concur, expect);
}
}
@@ -231,19 +231,19 @@
dispatch_test_start("Dispatch Private Concurrent/Wide Queue"); // <rdar://problem/8049506&8169448&8186485>
#ifdef __linux__
- activecpu = sysconf(_SC_NPROCESSORS_ONLN);
+ activecpu = (uint32_t)sysconf(_SC_NPROCESSORS_ONLN);
#else
size_t s = sizeof(activecpu);
sysctlbyname("hw.activecpu", &activecpu, &s, NULL, 0);
#endif
size_t n = activecpu / 2 > 1 ? activecpu / 2 : 1, w = activecpu * 2;
- min_acceptable_concurrency = n;
+ min_acceptable_concurrency = (uint32_t)n;
dispatch_queue_t tq, ttq;
long qw, tqw, ttqw;
const char *ql, *tql, *ttql;
size_t qi, tqi, ttqi;
long qws[] = {
- 0, LONG_MAX, w, 1, // 0 <=> global queue
+ 0, LONG_MAX, (long)w, 1, // 0 <=> global queue
};
g = dispatch_group_create();
@@ -262,16 +262,16 @@
"queue hierarchy: %s -> %s -> %s\n",
use_group_async ? "_group" : "", ql, tql, ttql);
fflush(stdout);
- test_concur_async(n, MIN(qw, MIN(tqw, ttqw)));
+ test_concur_async(n, (size_t)MIN(qw, MIN(tqw, ttqw)));
}
fprintf(stdout, "Testing dispatch_sync on "
"queue hierarchy: %s -> %s -> %s\n", ql, tql, ttql);
fflush(stdout);
- test_concur_sync(w, MIN(qw, MIN(tqw, ttqw)));
+ test_concur_sync(w, (size_t)MIN(qw, MIN(tqw, ttqw)));
fprintf(stdout, "Testing dispatch_apply on "
"queue hierarchy: %s -> %s -> %s\n", ql, tql, ttql);
fflush(stdout);
- test_concur_apply(activecpu, MIN(qw, MIN(tqw, ttqw)));
+ test_concur_apply(activecpu, (size_t)MIN(qw, MIN(tqw, ttqw)));
dispatch_release(q);
}
dispatch_release(tq);
diff --git a/tests/dispatch_drift.c b/tests/dispatch_drift.c
index 22f82ee..a6631a8 100644
--- a/tests/dispatch_drift.c
+++ b/tests/dispatch_drift.c
@@ -48,14 +48,14 @@
uint64_t interval = 1000000000 / 100;
double interval_d = interval / 1000000000.0;
// for 25 seconds
- unsigned int target = 25 / interval_d;
+ unsigned int target = (unsigned int)(25.0 / interval_d);
dispatch_test_start("Dispatch Timer Drift");
dispatch_source_t t = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
test_ptr_notnull("dispatch_source_create", t);
- dispatch_source_set_timer(t, dispatch_time(DISPATCH_TIME_NOW, interval), interval, 0);
+ dispatch_source_set_timer(t, dispatch_time(DISPATCH_TIME_NOW, (int64_t)interval), interval, 0);
dispatch_source_set_event_handler(t, ^{
struct timeval now_tv;
diff --git a/tests/dispatch_io.c b/tests/dispatch_io.c
index b7fe378..a29cb56 100644
--- a/tests/dispatch_io.c
+++ b/tests/dispatch_io.c
@@ -52,7 +52,7 @@
#endif
#endif
-void
+static void
test_fin(void *cxt)
{
test_ptr("test_fin run", cxt, cxt);
@@ -96,7 +96,7 @@
test_errno("fstat", errno, 0);
test_stop();
}
- const size_t size = sb.st_size / chunks;
+ const size_t size = (size_t)sb.st_size / chunks;
const int expected_error = with_timer? ECANCELED : 0;
dispatch_source_t t = NULL;
dispatch_group_t g = dispatch_group_create();
@@ -142,7 +142,7 @@
for (i = 0; i < chunks; i++) {
data[i] = dispatch_data_empty;
dispatch_group_enter(g);
- dispatch_io_read(io, i * size, size, dispatch_get_global_queue(0,0),
+ dispatch_io_read(io, (off_t)(i * size), size, dispatch_get_global_queue(0,0),
^(bool done, dispatch_data_t d, int error) {
if (d) {
chunk_size[i] += dispatch_data_get_size(d);
@@ -180,16 +180,16 @@
}
for (i = 0; i < chunks; i++) {
if (with_timer) {
- test_long_less_than("chunk size", chunk_size[i], size + 1);
+ test_sizet_less_than("chunk size", chunk_size[i], size + 1);
} else {
- test_long("chunk size", chunk_size[i], size);
+ test_sizet("chunk size", chunk_size[i], size);
}
total += chunk_size[i];
}
if (with_timer) {
- test_long_less_than("total size", total, chunks * size + 1);
+ test_sizet_less_than("total size", total, chunks * size + 1);
} else {
- test_long("total size", total, chunks * size);
+ test_sizet("total size", total, chunks * size);
}
}
@@ -251,7 +251,7 @@
test_errno("fstat", errno, 0);
test_stop();
}
- const size_t siz_in = MIN(1024 * 1024, sb.st_size);
+ const size_t siz_in = MIN(1024 * 1024, (size_t)sb.st_size);
int out = mkstemp(path_out);
if (out == -1) {
@@ -283,7 +283,7 @@
dispatch_group_enter(g);
dispatch_io_read(io_in, 0, siz_in, q,
^(bool done_in, dispatch_data_t data_in, int err_in) {
- test_long_less_than("read size", dispatch_data_get_size(data_in),
+ test_sizet_less_than("read size", dispatch_data_get_size(data_in),
siz_in);
if (data_in) {
dispatch_group_enter(g);
@@ -291,11 +291,11 @@
^(bool done_out, dispatch_data_t data_out, int err_out) {
if (done_out) {
test_errno("dispatch_io_write", err_out, 0);
- test_long("remaining write size",
+ test_sizet("remaining write size",
data_out ? dispatch_data_get_size(data_out) : 0, 0);
dispatch_group_leave(g);
} else {
- test_long_less_than("remaining write size",
+ test_sizet_less_than("remaining write size",
dispatch_data_get_size(data_out), siz_in);
}
});
@@ -321,7 +321,7 @@
}
close(out);
size_t siz_cmp = dispatch_data_get_size(cmp);
- test_long("readback size", siz_cmp, siz_in);
+ test_sizet("readback size", siz_cmp, siz_in);
const void *data_buf, *cmp_buf;
dispatch_data_t data_map, cmp_map;
data_map = dispatch_data_create_map(data, &data_buf, NULL);
@@ -378,7 +378,7 @@
}
free(buffer);
close(fd);
- process_data(r);
+ process_data((size_t)r);
});
break;
case DISPATCH_READ_ON_CONCURRENT_QUEUE:
@@ -455,7 +455,7 @@
test_ptr_notnull("fts_open failed", tree);
test_stop();
}
- unsigned int files_opened = 0;
+ int files_opened = 0;
size_t size, total_size = 0;
FTSENT *node;
while ((node = fts_read(tree)) &&
@@ -465,11 +465,11 @@
} else if (node->fts_info == FTS_F) {
dispatch_group_enter(g);
dispatch_semaphore_wait(s, DISPATCH_TIME_FOREVER);
- size = node->fts_statp->st_size;
+ size = (size_t)node->fts_statp->st_size;
total_size += size;
files_opened++;
test_async_read(node->fts_path, size, option, queue, ^(size_t len){
- OSAtomicAdd32(len, bytes);
+ OSAtomicAdd32((int32_t)len, (volatile int32_t *)bytes);
dispatch_semaphore_signal(s);
dispatch_group_leave(g);
});
@@ -485,7 +485,7 @@
test_stop();
}
test_group_wait(g);
- test_long("total size", *bytes, total_size);
+ test_sizet("total size", *bytes, total_size);
return files_opened;
}
@@ -506,7 +506,7 @@
dispatch_semaphore_t s = dispatch_semaphore_create(maxopenfiles);
uint64_t start;
volatile uint32_t bytes;
- unsigned int files_read, i;
+ int files_read, i;
const dispatch_queue_t queues[] = {
[DISPATCH_ASYNC_READ_ON_CONCURRENT_QUEUE] =
@@ -546,7 +546,7 @@
l.rlim_cur = 2 * maxopenfiles + 256;
setrlimit(RLIMIT_NOFILE, &l);
}
- for (i = 0; i < sizeof(queues)/sizeof(dispatch_queue_t); ++i) {
+ for (i = 0; i < (int)(sizeof(queues)/sizeof(dispatch_queue_t)); ++i) {
fprintf(stdout, "%s:\n", names[i]);
bytes = 0;
start = mach_absolute_time();
@@ -610,7 +610,7 @@
#else
test_errno("error from write to write protected directory", err_out, EACCES);
#endif
- test_long("unwritten data", dispatch_data_get_size(data_out), 256);
+ test_sizet("unwritten data", dispatch_data_get_size(data_out), 256);
if (!err_out && done) {
test_stop();
}
@@ -661,11 +661,11 @@
^(bool done, dispatch_data_t data_out, int err_out) {
if (done) {
test_errno("dispatch_io_write", err_out, 0);
- test_long("remaining write size",
+ test_sizet("remaining write size",
data_out ? dispatch_data_get_size(data_out) : 0, 0);
dispatch_group_leave(g);
} else {
- test_long_less_than("remaining write size",
+ test_sizet_less_than("remaining write size",
dispatch_data_get_size(data_out), siz_in);
}
});
@@ -696,7 +696,7 @@
dispatch_release(io2);
test_group_wait(g);
dispatch_release(g);
- test_long("readback size", dispatch_data_get_size(data_out), siz_in);
+ test_sizet("readback size", dispatch_data_get_size(data_out), siz_in);
dispatch_release(data_out);
#endif
}
diff --git a/tests/dispatch_pingpong.c b/tests/dispatch_pingpong.c
index 8664ddb..cad975a 100644
--- a/tests/dispatch_pingpong.c
+++ b/tests/dispatch_pingpong.c
@@ -27,14 +27,14 @@
uint32_t count = 0;
const uint32_t final = 1000000; // 10M
-void
+static void
pingpongloop(dispatch_group_t group, dispatch_queue_t ping, dispatch_queue_t pong, size_t counter)
{
//printf("[%p] %s: %lu\n", (void*)(uintptr_t)pthread_self(), dispatch_queue_get_label(dispatch_get_current_queue()), counter);
if (counter < final) {
dispatch_group_async(group, pong, ^{ pingpongloop(group, pong, ping, counter+1); });
} else {
- count = counter;
+ count = (uint32_t)counter;
}
}
diff --git a/tests/dispatch_priority.c b/tests/dispatch_priority.c
index 3cbb7d9..a2eb954 100644
--- a/tests/dispatch_priority.c
+++ b/tests/dispatch_priority.c
@@ -75,14 +75,14 @@
static long total;
static size_t prio0, priorities = PRIORITIES;
-int
+static int
n_blocks(void)
{
static dispatch_once_t pred;
static int n;
dispatch_once(&pred, ^{
#ifdef __linux__
- n = sysconf(_SC_NPROCESSORS_CONF);
+ n = (int)sysconf(_SC_NPROCESSORS_CONF);
#else
size_t l = sizeof(n);
int rc = sysctlbyname("hw.ncpu", &n, &l, NULL, 0);
@@ -93,7 +93,7 @@
return n;
}
-void
+static void
histogram(void)
{
long completed = 0;
@@ -126,7 +126,7 @@
}
}
-void
+static void
cpubusy(void* context)
{
if (done) return;
@@ -152,7 +152,7 @@
}
}
-void
+static void
submit_work(dispatch_queue_t queue, void* context)
{
int i;
@@ -174,7 +174,7 @@
priorities--;
#endif
- iterations = total = (priorities * n_blocks()) * 0.50;
+ iterations = total = ((int)priorities * n_blocks()) / 2;
#if USE_SET_TARGET_QUEUE
dispatch_test_start("Dispatch Priority (Set Target Queue)");
diff --git a/tests/dispatch_read.c b/tests/dispatch_read.c
index f8a576c..9c09a06 100644
--- a/tests/dispatch_read.c
+++ b/tests/dispatch_read.c
@@ -35,7 +35,7 @@
static size_t bytes_total;
static size_t bytes_read;
-void
+static void
test_fin(void *cxt)
{
test_ptr("test_fin run", cxt, cxt);
@@ -59,7 +59,7 @@
perror(path);
exit(EXIT_FAILURE);
}
- bytes_total = sb.st_size;
+ bytes_total = (size_t)sb.st_size;
if (fcntl(infd, F_SETFL, O_NONBLOCK) != 0) {
perror(path);
@@ -74,7 +74,7 @@
dispatch_queue_t main_q = dispatch_get_main_queue();
test_ptr_notnull("dispatch_get_main_queue", main_q);
- dispatch_source_t reader = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, infd, 0, main_q);
+ dispatch_source_t reader = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ, (uintptr_t)infd, 0, main_q);
test_ptr_notnull("dispatch_source_create", reader);
assert(reader);
@@ -85,11 +85,11 @@
const ssize_t bufsiz = 1024*500; // 500 KB buffer
static char buffer[1024*500]; // 500 KB buffer
ssize_t actual = read(infd, buffer, sizeof(buffer));
- bytes_read += actual;
+ bytes_read += (size_t)actual;
printf("bytes read: %zd\n", actual);
if (actual < bufsiz) {
actual = read(infd, buffer, sizeof(buffer));
- bytes_read += actual;
+ bytes_read += (size_t)actual;
// confirm EOF condition
test_long("EOF", actual, 0);
dispatch_source_cancel(reader);
@@ -97,7 +97,7 @@
});
dispatch_source_set_cancel_handler(reader, ^{
- test_long("Bytes read", bytes_read, bytes_total);
+ test_sizet("Bytes read", bytes_read, bytes_total);
int res = close(infd);
test_errno("close", res == -1 ? errno : 0, 0);
dispatch_release(reader);
diff --git a/tests/dispatch_read2.c b/tests/dispatch_read2.c
index 1bc0ef2..398aa2c 100644
--- a/tests/dispatch_read2.c
+++ b/tests/dispatch_read2.c
@@ -47,7 +47,7 @@
#endif
#endif
-void
+static void
test_fin(void *cxt)
{
test_ptr("test_fin run", cxt, cxt);
@@ -71,7 +71,7 @@
test_stop();
}
dispatch_source_t reader = dispatch_source_create(DISPATCH_SOURCE_TYPE_READ,
- fd, 0, queue);
+ (uintptr_t)fd, 0, queue);
test_ptr_notnull("reader", reader);
__block size_t bytes_read = 0;
@@ -85,8 +85,8 @@
err = errno;
}
if (actual > 0) {
- bytes_read += actual;
- dispatch_data_t tmp_data = dispatch_data_create(buffer, actual,
+ bytes_read += (size_t)actual;
+ dispatch_data_t tmp_data = dispatch_data_create(buffer, (size_t)actual,
NULL, DISPATCH_DATA_DESTRUCTOR_FREE);
dispatch_data_t concat = dispatch_data_create_concat(data,tmp_data);
dispatch_release(tmp_data);
@@ -97,7 +97,7 @@
if (actual < bufsiz || bytes_read >= length) {
char foo[2];
actual = read(fd, foo, 2);
- bytes_read += actual;
+ bytes_read += (size_t)actual;
// confirm EOF condition
test_long("EOF", actual, 0);
dispatch_source_cancel(reader);
@@ -138,17 +138,17 @@
test_errno("fstat", errno, 0);
test_stop();
}
- size_t size = sb.st_size;
+ size_t size = (size_t)sb.st_size;
dispatch_group_t g = dispatch_group_create();
void (^b)(dispatch_data_t, int) = ^(dispatch_data_t d, int error) {
test_errno("read error", error, 0);
- test_long("dispatch data size", d ? dispatch_data_get_size(d) : 0, size);
+ test_sizet("dispatch data size", d ? dispatch_data_get_size(d) : 0, size);
if (d) {
const void *contig_buf;
size_t contig_size;
dispatch_data_t tmp = dispatch_data_create_map(d, &contig_buf,
&contig_size);
- test_long("dispatch data contig size", contig_size, size);
+ test_sizet("dispatch data contig size", contig_size, size);
if (contig_size) {
// Validate the copied buffer is similar to what we expect
char *buf = (char*)malloc(size);
@@ -208,7 +208,7 @@
}
close(in);
size_t siz_out = dispatch_data_get_size(data_in);
- test_long("read size", siz_out, siz_in);
+ test_sizet("read size", siz_out, siz_in);
dispatch_retain(data_in);
data = data_in;
dispatch_write(out, data, q, ^(dispatch_data_t data_out, int err_out) {
@@ -225,7 +225,7 @@
}
close(out);
size_t siz_cmp = dispatch_data_get_size(cmp);
- test_long("readback size", siz_cmp, siz_out);
+ test_sizet("readback size", siz_cmp, siz_out);
const void *data_buf, *cmp_buf;
dispatch_data_t data_map, cmp_map;
data_map = dispatch_data_create_map(data, &data_buf, NULL);
@@ -277,7 +277,7 @@
}
close(in);
siz_out = dispatch_data_get_size(data_in);
- test_long("read size", siz_out, siz_in);
+ test_sizet("read size", siz_out, siz_in);
dispatch_retain(data_in);
data = data_in;
dispatch_data_t data_chunks[chunks_out];
@@ -314,7 +314,7 @@
}
close(out);
size_t siz_cmp = dispatch_data_get_size(cmp);
- test_long("readback size", siz_cmp, siz_out);
+ test_sizet("readback size", siz_cmp, siz_out);
const void *data_buf, *cmp_buf;
dispatch_data_t data_map, cmp_map;
data_map = dispatch_data_create_map(data, &data_buf, NULL);
@@ -383,8 +383,8 @@
close(in);
close(*(fd+1));
test_group_wait(g);
- test_long("dispatch_read deliveries", deliveries, chunks);
- test_long("dispatch_read data size", siz_acc, siz);
+ test_sizet("dispatch_read deliveries", deliveries, chunks);
+ test_sizet("dispatch_read data size", siz_acc, siz);
close(*fd);
Block_release(b);
dispatch_release(g);
diff --git a/tests/dispatch_readsync.c b/tests/dispatch_readsync.c
index 207e60f..f01d982 100644
--- a/tests/dispatch_readsync.c
+++ b/tests/dispatch_readsync.c
@@ -126,9 +126,9 @@
}
free(mrs);
- test_long("max readers", max_readers, n);
- test_long("max writers", max_writers, 1);
- test_long("concurrent readers & writers", crw, 0);
+ test_sizet("max readers", max_readers, n);
+ test_sizet("max writers", max_writers, 1);
+ test_sizet("concurrent readers & writers", crw, 0);
}
int
@@ -138,7 +138,7 @@
uint32_t activecpu, wq_max_threads;
#ifdef __linux__
- activecpu = sysconf(_SC_NPROCESSORS_ONLN);
+ activecpu = (uint32_t)sysconf(_SC_NPROCESSORS_ONLN);
// don't want to parse /proc/sys/kernel/threads-max
wq_max_threads = activecpu * NTHREADS + 2;
#else
diff --git a/tests/dispatch_suspend_timer.c b/tests/dispatch_suspend_timer.c
index 566b039..ae2b422 100644
--- a/tests/dispatch_suspend_timer.c
+++ b/tests/dispatch_suspend_timer.c
@@ -30,7 +30,7 @@
dispatch_source_t tweedledee;
dispatch_source_t tweedledum;
-void
+static void
fini(void *cxt)
{
test_ptr_notnull("finalizer ran", cxt);
@@ -39,7 +39,7 @@
}
}
-void
+static void
test_timer(void)
{
dispatch_test_start("Dispatch Suspend Timer");
