Changeset 215

Timestamp:

08/08/12 22:09:03 (10 months ago)

Author:

dsteffen@…

Message:

MountainLion? macosforge testsuite

Location:

trunk

Files:

• Makefile.am (modified) (1 diff)
• configure.ac (modified) (1 diff)
• testing/Makefile.am (modified) (3 diffs)
• testing/bench.mm (modified) (3 diffs)
• testing/bsdtestharness.c (modified) (7 diffs)
• testing/bsdtests.c (modified) (4 diffs)
• testing/bsdtests.h (modified) (3 diffs)
• testing/dispatch_after.c (modified) (3 diffs)
• testing/dispatch_api.c (modified) (1 diff)
• testing/dispatch_apply.c (modified) (2 diffs)
• testing/dispatch_concur.c (modified) (1 diff)
• testing/dispatch_deadname.c (modified) (6 diffs)
• testing/dispatch_drift.c (modified) (3 diffs)
• testing/dispatch_group.c (modified) (3 diffs)
• testing/dispatch_io.c (modified) (7 diffs)
• testing/dispatch_priority.c (modified) (6 diffs)
• testing/dispatch_queue_finalizer.c (modified) (1 diff)
• testing/dispatch_suspend_timer.c (modified) (1 diff)
• testing/dispatch_test.c (modified) (3 diffs)
• testing/dispatch_test.h (modified) (2 diffs)
• testing/dispatch_timer.c (modified) (3 diffs)
• testing/dispatch_timer_bit31.c (modified) (1 diff)
• testing/dispatch_timer_set_time.c (modified) (1 diff)
• testing/dispatch_transform.c (added)
• testing/dispatch_vm.c (modified) (7 diffs)

trunk/Makefile.am

@@ -10 +10 @@
         os                                              \
         private                                 \
-        src
+        src                                             \
+        testing
 
 EXTRA_DIST=                                     \

trunk/configure.ac

@@ -296 +296 @@
 # Generate Makefiles.
 #
-AC_CONFIG_FILES([Makefile dispatch/Makefile man/Makefile os/Makefile private/Makefile src/Makefile])
+AC_CONFIG_FILES([Makefile dispatch/Makefile man/Makefile os/Makefile private/Makefile src/Makefile testing/Makefile])
+
+#
+# Generate testsuite links
+#
+AC_CONFIG_LINKS([testing/dispatch:${x:+}private testing/bench.cc:testing/bench.mm testing/leaks-wrapper:testing/leaks-wrapper.sh])
+
 AC_OUTPUT

trunk/testing/Makefile.am

@@ -63 +63 @@
         dispatch_select
 
-dispatch_c99_CFLAGS=-std=c99
+dispatch_c99_CFLAGS=$(AM_CFLAGS) -std=c99
 dispatch_plusplus_SOURCES=dispatch_plusplus.cpp
 dispatch_priority2_SOURCES=dispatch_priority.c
-dispatch_priority2_CFLAGS=-DUSE_SET_TARGET_QUEUE=1
+dispatch_priority2_CPPFLAGS=$(AM_CPPFLAGS) -DUSE_SET_TARGET_QUEUE=1
 
-INCLUDES=-I$(top_builddir) -I$(top_srcdir)
+AM_CPPFLAGS=-I$(top_builddir) -I$(top_srcdir)
 
-CPPFLAGS=
-CFLAGS=-Wall -g $(MARCH_FLAGS) $(CBLOCKS_FLAGS)
-OBJCFLAGS=-Wall -g $(MARCH_FLAGS) $(CBLOCKS_FLAGS)
-CXXFLAGS=-Wall -g $(MARCH_FLAGS) $(CXXBLOCKS_FLAGS)
+AM_CFLAGS=-Wall $(MARCH_FLAGS) $(CBLOCKS_FLAGS)
+AM_OBJCFLAGS=-Wall $(MARCH_FLAGS) $(CBLOCKS_FLAGS) -fobjc-gc
+AM_CXXFLAGS=-Wall $(MARCH_FLAGS) $(CXXBLOCKS_FLAGS)
 
 LDADD=libbsdtests.la ../src/libdispatch.la
@@ -84 +83 @@
 TESTS+=                                                 \
         dispatch_cf_main                        \
+        dispatch_transform                      \
         dispatch_sync_on_main           \
         cffd
 
 dispatch_cf_main_LDFLAGS=-framework CoreFoundation
+dispatch_transform_LDFLAGS=-framework CoreFoundation -framework Security
 dispatch_sync_on_main_LDFLAGS=-framework CoreFoundation
 cffd_LDFLAGS=-framework CoreFoundation
@@ -100 +101 @@
 
 dispatch_sync_gc_SOURCES=dispatch_sync_gc.m
-dispatch_sync_gc_OBJCFLAGS=-fobjc-gc
 dispatch_sync_gc_LDFLAGS=-framework Foundation
 dispatch_apply_gc_SOURCES=dispatch_apply_gc.m
-dispatch_apply_gc_OBJCFLAGS=-fobjc-gc
 dispatch_apply_gc_LDFLAGS=-framework Foundation
 nsoperation_SOURCES=nsoperation.m
 nsoperation_LDFLAGS=-framework Foundation
-bench_SOURCES=bench.cc func.c
+nodist_bench_SOURCES=bench.cc
+bench_SOURCES=func.c
 bench_LDFLAGS=-framework Foundation
 # Workaround missing objcxx support in older autotools

trunk/testing/bench.mm

@@ -417 +417 @@
         s = mach_absolute_time();
         for (i = cnt; i; i--) {
+                global = 0;
+                asm volatile("mfence" ::: "memory");
+        }
+        print_result(s, "Store + mfence:");
+
+        s = mach_absolute_time();
+        for (i = cnt; i; i--) {
                 unsigned long _clbr;
 #ifdef __LP64__
@@ -467 +474 @@
 #endif
 
+#ifdef _ARM_ARCH_7
+        s = mach_absolute_time();
+        for (i = cnt; i; i--) {
+                asm volatile("str       %[_r], [%[_p], %[_o]]" :
+                                : [_p] "p" (&global), [_o] "M" (0), [_r] "r" (0) : "memory");
+                asm volatile("dmb ishst" : : : "memory");
+        }
+        print_result(s, "'str + dmb ishst' instructions:");
+#endif
+
+#ifdef _ARM_ARCH_7
+        s = mach_absolute_time();
+        for (i = cnt; i; i--) {
+                uintptr_t prev;
+                uint32_t t;
+                do {
+                asm volatile("ldrex     %[_r], [%[_p], %[_o]]"
+                                : [_r] "=&r" (prev) \
+                                : [_p] "p" (&global), [_o] "M" (0) : "memory");
+                asm volatile("strex     %[_t], %[_r], [%[_p], %[_o]]"
+                                : [_t] "=&r" (t) \
+                                : [_p] "p" (&global), [_o] "M" (0), [_r] "r" (0) : "memory");
+                } while (t);
+        }
+        print_result(s, "'ldrex + strex' instructions:");
+#endif
+
         s = mach_absolute_time();
         for (i = cnt; i; i--) {
@@ -528 +562 @@
         }
         print_result(s, "Atomic increment:");
+
+        {
+                global = 0;
+                volatile int32_t *g = &global;
+
+                s = mach_absolute_time();
+                for (i = cnt; i; i--) {
+                        uint32_t result;
+                        __sync_and_and_fetch(g, 1);
+                        result = *g;
+                        if (result) {
+                                abort();
+                        }
+                }
+                print_result(s, "Atomic and-and-fetch, reloading result:");
+        }
+
+        {
+                global = 0;
+                volatile int32_t *g = &global;
+
+                s = mach_absolute_time();
+                for (i = cnt; i; i--) {
+                        uint32_t result;
+                        result = __sync_and_and_fetch(g, 1);
+                        if (result) {
+                                abort();
+                        }
+                }
+                print_result(s, "Atomic and-and-fetch, using result:");
+        }
 
         global = 0;

trunk/testing/bsdtestharness.c

@@ -19 +19 @@
  */
 
-#include <mach/clock_types.h>
 #include <dispatch/dispatch.h>
 #include <assert.h>
@@ -27 +26 @@
 #include <unistd.h>
 #include <signal.h>
+#include <mach/clock_types.h>
 #include <mach-o/arch.h>
+#include <sys/resource.h>
+#include <sys/time.h>
 
 #include <bsdtests.h>
@@ -38 +40 @@
         dispatch_source_t tmp_ds;
         int res;
-        pid_t pid;
+        pid_t pid = 0;
 
         if (argc < 2) {
@@ -45 +47 @@
         }
 
+        short spawnflags = POSIX_SPAWN_START_SUSPENDED;
+#if TARGET_OS_EMBEDDED
+        spawnflags |= POSIX_SPAWN_SETEXEC;
+#endif
+
         posix_spawnattr_t attr;
         res = posix_spawnattr_init(&attr);
         assert(res == 0);
-        res = posix_spawnattr_setflags(&attr, POSIX_SPAWN_START_SUSPENDED);
+        res = posix_spawnattr_setflags(&attr, spawnflags);
         assert(res == 0);
+
+        uint64_t to = 0;
+        char *tos = getenv("BSDTEST_TIMEOUT");
+        if (tos) {
+                to = strtoul(tos, NULL, 0);
+                to *= NSEC_PER_SEC;
+        }
 
         char *arch = getenv("BSDTEST_ARCH");
@@ -67 +81 @@
         newargv[i-1] = NULL;
 
-        res = posix_spawnp(&pid, newargv[0], NULL, &attr, newargv, environ);
-        if (res) {
-                errno = res;
-                perror(newargv[0]);
-                exit(EXIT_FAILURE);
+        struct timeval tv_start;
+        gettimeofday(&tv_start, NULL);
+
+        if (spawnflags & POSIX_SPAWN_SETEXEC) {
+                pid = fork();
         }
+        if (!pid) {
+                res = posix_spawnp(&pid, newargv[0], NULL, &attr, newargv, environ);
+                if (res) {
+                        errno = res;
+                        perror(newargv[0]);
+                        exit(EXIT_FAILURE);
+                }
+        }
+
         //fprintf(stderr, "pid = %d\n", pid);
         assert(pid > 0);
@@ -82 +105 @@
         dispatch_source_set_event_handler(tmp_ds, ^{
                 int status;
-                int res2 = waitpid(pid, &status, 0);
+                struct rusage usage;
+                struct timeval tv_stop, tv_wall;
+
+                gettimeofday(&tv_stop, NULL);
+                tv_wall.tv_sec = tv_stop.tv_sec - tv_start.tv_sec;
+                tv_wall.tv_sec -= (tv_stop.tv_usec < tv_start.tv_usec);
+                tv_wall.tv_usec = abs(tv_stop.tv_usec - tv_start.tv_usec);
+
+                int res2 = wait4(pid, &status, 0, &usage);
                 assert(res2 != -1);
                 test_long("Process exited", (WIFEXITED(status) && WEXITSTATUS(status) && WEXITSTATUS(status) != 0xff) || WIFSIGNALED(status), 0);
+                printf("[PERF]\twall time: %ld.%06d\n", tv_wall.tv_sec, tv_wall.tv_usec);
+                printf("[PERF]\tuser time: %ld.%06d\n", usage.ru_utime.tv_sec, usage.ru_utime.tv_usec);
+                printf("[PERF]\tsystem time: %ld.%06d\n", usage.ru_stime.tv_sec, usage.ru_stime.tv_usec);
+                printf("[PERF]\tmax resident set size: %ld\n", usage.ru_maxrss);
+                printf("[PERF]\tpage faults: %ld\n", usage.ru_majflt);
+                printf("[PERF]\tswaps: %ld\n", usage.ru_nswap);
+                printf("[PERF]\tvoluntary context switches: %ld\n", usage.ru_nvcsw);
+                printf("[PERF]\tinvoluntary context switches: %ld\n", usage.ru_nivcsw);
                 exit((WIFEXITED(status) && WEXITSTATUS(status)) || WIFSIGNALED(status));
         });
         dispatch_resume(tmp_ds);
 
+        if (!to) {
 #if TARGET_OS_EMBEDDED
-        // Give embedded platforms a little more time.
-        uint64_t timeout = 300LL * NSEC_PER_SEC;
+                to = 180LL * NSEC_PER_SEC;
 #else
-        uint64_t timeout = 150LL * NSEC_PER_SEC;
+                to = 90LL * NSEC_PER_SEC;
 #endif
+        }
 
-        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, timeout), main_q, ^{
+        dispatch_after(dispatch_time(DISPATCH_TIME_NOW, to), main_q, ^{
                 kill(pid, SIGKILL);
-                fprintf(stderr, "Terminating unresponsive process (%0.1lfs)\n", (double)timeout/NSEC_PER_SEC);
+                fprintf(stderr, "Terminating unresponsive process (%0.1lfs)\n", (double)to / NSEC_PER_SEC);
         });
 
@@ -110 +150 @@
         dispatch_resume(tmp_ds);
 
+        if (spawnflags & POSIX_SPAWN_SETEXEC) {
+                usleep(USEC_PER_SEC/10);
+        }
         kill(pid, SIGCONT);
 

trunk/testing/bsdtests.c

@@ -128 +128 @@
 }
 
+void _test_ptr_not(const char* file, long line, const char* desc, const void* actual, const void* expected)
+{
+        _test_print(file, line, desc,
+                                (actual != expected), "%p", actual, "!%p", expected);
+}
+
+void test_ptr_not_format(const void *actual, const void* expected, const char *format, ...)
+{
+        GENERATE_DESC
+        _test_ptr_not(NULL, 0, desc, actual, expected);
+}
+
 void
 _test_uint32(const char* file, long line, const char* desc, uint32_t actual, uint32_t expected)
@@ -212 +224 @@
 
 void
+_test_long_less_than_or_equal(const char* file, long line, const char* desc, long actual, long expected_max)
+{
+        _test_print(file, line, desc, (actual <= expected_max), "%ld", actual, "<=%ld", expected_max);
+}
+
+void
+test_long_less_than_or_equal_format(long actual, long expected_max, const char* format, ...)
+{
+        GENERATE_DESC
+        _test_long_less_than_or_equal(NULL, 0, desc, actual, expected_max);
+}
+
+void
 _test_long_greater_than_or_equal(const char* file, long line, const char* desc, long actual, long expected_min)
 {
@@ -248 +273 @@
         GENERATE_DESC
         _test_double_less_than_or_equal(NULL, 0, desc, val, max_expected);
+}
+
+void
+_test_double_equal(const char* file, long line, const char* desc, double val, double expected)
+{
+        _test_print(file, line, desc, (val == expected), "%f", val, "%f", expected);
+}
+
+
+void
+test_double_equal_format(double val, double expected, const char *format, ...)
+{
+        GENERATE_DESC
+        _test_double_equal(NULL, 0, desc, val, expected);
 }
 
@@ -386 +425 @@
                 return;
         }
+
+        unsetenv("DYLD_IMAGE_SUFFIX");
+        unsetenv("DYLD_INSERT_LIBRARIES");
+        unsetenv("DYLD_LIBRARY_PATH");
 
         unsetenv("MallocStackLogging");

trunk/testing/bsdtests.h

@@ -19 +19 @@
  */
 
+#ifndef __BSD_TEST_H__
+#define __BSD_TEST_H__
+
 #include <errno.h>
 #include <mach/error.h>
 #include <CoreFoundation/CoreFoundation.h>
+
+static inline const char*
+__BASENAME__(const char *_str_)
+{
+        const char *_s_ = strrchr(_str_, '/');
+        return (_s_ ? _s_ : _str_ - 1) + 1;
+}
+#define __SOURCE_FILE__ __BASENAME__(__FILE__)
 
 __BEGIN_DECLS
@@ -48 +59 @@
  */
 void _test_ptr_null(const char* file, long line, const char* desc, const void* ptr);
-#define test_ptr_null(a,b) _test_ptr_null(__FILE__, __LINE__, a, b)
+#define test_ptr_null(a,b) _test_ptr_null(__SOURCE_FILE__, __LINE__, a, b)
 void test_ptr_null_format(void *ptr, const char *format, ...);
 
 void _test_ptr_notnull(const char* file, long line, const char* desc, const void* ptr);
-#define test_ptr_notnull(a,b) _test_ptr_notnull(__FILE__, __LINE__, a, b)
+#define test_ptr_notnull(a,b) _test_ptr_notnull(__SOURCE_FILE__, __LINE__, a, b)
 void test_ptr_notnull_format(const void *ptr, const char *format, ...) __printflike(2, 3);
 
+void _test_ptr_not(const char* file, long line, const char* desc, const void* actual, const void* expected);
+#define test_ptr_not(a, b, c) _test_ptr_not(__SOURCE_FILE__, __LINE__, a, b, c)
+void test_ptr_not_format(const void* actual, const void* expected, const char *format, ...);
+
 void _test_ptr(const char* file, long line, const char* desc, const void* actual, const void* expected);
-#define test_ptr(a,b,c) _test_ptr(__FILE__, __LINE__, a, b, c)
+#define test_ptr(a,b,c) _test_ptr(__SOURCE_FILE__, __LINE__, a, b, c)
 void test_ptr_format(const void* actual, const void* expected, const char *format, ...) __printflike(3,4);
 
 void _test_uint32(const char* file, long line, const char* desc, uint32_t actual, uint32_t expected);
-#define test_uint32(a,b,c) _test_uint32(__FILE__, __LINE__, a, b, c)
+#define test_uint32(a,b,c) _test_uint32(__SOURCE_FILE__, __LINE__, a, b, c)
 void test_uint32_format(long actual, long expected, const char *format, ...) __printflike(3,4);
 
 void _test_int32(const char* file, long line, const char* desc, int32_t actual, int32_t expected);
-#define test_int32(a,b,c) _test_int32(__FILE__, __LINE__, a, b, c)
+#define test_int32(a,b,c) _test_int32(__SOURCE_FILE__, __LINE__, a, b, c)
 void test_sint32_format(int32_t actual, int32_t expected, const char* format, ...) __printflike(3,4);
 
 void _test_long(const char* file, long line, const char* desc, long actual, long expected);
-#define test_long(a,b,c) _test_long(__FILE__, __LINE__, a, b, c)
+#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_uint64(const char* file, long line, const char* desc, uint64_t actual, uint64_t expected);
-#define test_uint64(a,b,c) _test_uint64(__FILE__, __LINE__, a, b, c)
+#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, ...);
 
 void _test_int64(const char* file, long line, const char* desc, int64_t actual, int64_t expected);
-#define test_int64(a,b,c) _test_uint64(__FILE__, __LINE__, a, b, c)
+#define test_int64(a,b,c) _test_uint64(__SOURCE_FILE__, __LINE__, a, b, c)
 void test_int64_format(int64_t actual, int64_t expected, const char* desc, ...);
 
 void _test_long_less_than(const char* file, long line, const char* desc, long actual, long max_expected);
-#define test_long_less_than(a,b,c) _test_long_less_than(__FILE__, __LINE__, a, b, c)
+#define test_long_less_than(a,b,c) _test_long_less_than(__SOURCE_FILE__, __LINE__, a, b, c)
 void test_long_less_than_format(long actual, long max_expected, const char *format, ...) __printflike(3,4);
 
+void _test_long_less_than_or_equal(const char* file, long line, const char* desc, long actual, long max_expected);
+#define test_long_less_than_or_equal(a,b,c) _test_long_less_than_or_equal(__SOURCE_FILE__, __LINE__, a, b, c)
+void test_long_less_than_or_equal_format(long actual, long max_expected, const char *format, ...) __printflike(3,4);
+
 void _test_long_greater_than_or_equal(const char* file, long line, const char* desc, long actual, long expected_min);
-#define test_long_greater_than_or_equal(a,b,c) _test_long_greater_than_or_equal(__FILE__, __LINE__, a, b, c)
+#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_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(__FILE__, __LINE__, d, v, m)
+#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);
 
 void _test_double_less_than(const char* file, long line, const char* desc, double val, double max_expected);
-#define test_double_less_than(d, v, m) _test_double_less_than(__FILE__, __LINE__, d, v, m)
+#define test_double_less_than(d, v, m) _test_double_less_than(__SOURCE_FILE__, __LINE__, d, v, m)
 void test_double_less_than_format(double val, double max_expected, const char *format, ...) __printflike(3,4);
 
+void _test_double_equal(const char* file, long line, const char* desc, double val, double expected);
+#define test_double_equal(d, v, m) _test_double_equal(__SOURCE_FILE__, __LINE__, d, v, m)
+void test_double_equal_format(double val, double expected, const char *format, ...) __printflike(3,4);
+
 void _test_errno(const char* file, long line, const char* desc, long actual, long expected);
-#define test_errno(a,b,c) _test_errno(__FILE__, __LINE__, a, b, c)
+#define test_errno(a,b,c) _test_errno(__SOURCE_FILE__, __LINE__, a, b, c)
 void test_errno_format(long actual, long expected, const char *format, ...) __printflike(3,4);
 
 void _test_mach_error(const char* file, long line, const char* desc, mach_error_t actual, mach_error_t expected);
-#define test_mach_error(a,b,c) _test_mach_error(__FILE__, __LINE__, a, b, c)
+#define test_mach_error(a,b,c) _test_mach_error(__SOURCE_FILE__, __LINE__, a, b, c)
 void test_mach_error_format(mach_error_t actual, mach_error_t expected, const char *format, ...) __printflike(3,4);
 
@@ -107 +130 @@
 
 void _test_skip(const char* file, long line, const char* desc);
-#define test_skip(m) _test_skip(__FILE__, __LINE__, m)
+#define test_skip(m) _test_skip(__SOURCE_FILE__, __LINE__, m)
 #define test_skip2(m) _test_skip("", 0, m)
 void test_skip_format(const char *format, ...) __printflike(1,2);
 
 __END_DECLS
+
+#endif /* __BSD_TEST_H__ */

trunk/testing/dispatch_after.c

@@ -51 +51 @@
                 time_a     = dispatch_time(0,   6*NSEC_PER_SEC);
                 time_a_max = dispatch_time(0,  6.5*NSEC_PER_SEC);
-                dispatch_after(time_a, dispatch_get_current_queue(), ^{
+                dispatch_after(time_a, dispatch_get_main_queue(), ^{
                         dispatch_time_t now_a = dispatch_time(0, 0);
                         test_long_less_than("can't finish faster than 5.5s", 0, now_a - time_a_min);
@@ -59 +59 @@
                         time_b     = dispatch_time(0,    2*NSEC_PER_SEC);
                         time_b_max = dispatch_time(0,  2.5*NSEC_PER_SEC);
-                        dispatch_after(time_b, dispatch_get_current_queue(), ^{
+                        dispatch_after(time_b, dispatch_get_main_queue(), ^{
                                 dispatch_time_t now_b = dispatch_time(0, 0);
                                 test_long_less_than("can't finish faster than 1.5s", 0, now_b - time_b_min);
@@ -67 +67 @@
                                 time_c     = dispatch_time(0,  0*NSEC_PER_SEC);
                                 time_c_max = dispatch_time(0,  .5*NSEC_PER_SEC);
-                                dispatch_after(time_c, dispatch_get_current_queue(), ^{
+                                dispatch_after(time_c, dispatch_get_main_queue(), ^{
                                         dispatch_time_t now_c = dispatch_time(0, 0);
                                         test_long_less_than("can't finish faster than 0s", 0, now_c - time_c_min);
                                         test_long_less_than("must finish faster than .5s", 0, time_c_max - now_c);
 
-                                        dispatch_async_f(dispatch_get_current_queue(), NULL, done);
+                                        dispatch_async_f(dispatch_get_main_queue(), NULL, done);
                                 });
                         });

trunk/testing/dispatch_api.c

@@ -34 +34 @@
 main(void)
 {
+        dispatch_queue_t q;
         dispatch_test_start("Dispatch (Public) API");
-        dispatch_queue_t q = dispatch_get_main_queue();
+        q = dispatch_get_main_queue();
         test_ptr_notnull("dispatch_get_main_queue", q);
 

trunk/testing/dispatch_apply.c

@@ -25 +25 @@
 #include <assert.h>
 #include <libkern/OSAtomic.h>
+#include <sys/types.h>
+#include <sys/sysctl.h>
 
 #include <bsdtests.h>
 #include "dispatch_test.h"
+
+static volatile int32_t busy_threads_started, busy_threads_finished;
+
+/*
+ * Keep a thread busy, spinning on the CPU.
+ */
+#if TARGET_OS_EMBEDDED
+// iPhone 4
+#define ITERS_PER_SECOND 50000000UL
+#else
+// On a 2.7 4-core i5 iMac12,2, one thread of this loop runs at ROUGHLY:
+#define ITERS_PER_SECOND 1000000000UL
+#endif
+
+/* Fiddling with j in the middle and hitting this global will hopefully keep
+ * the optimizer from cutting the whole thing out as dead code.
+ */
+static volatile unsigned int busythread_useless;
+void busythread(void *ignored)
+{
+        (void)ignored;
+        uint64_t i = 0, j = 0;
+
+        OSAtomicIncrement32(&busy_threads_started);
+
+        for(i = 0; i < 2*ITERS_PER_SECOND; i++)
+        {
+                if(i == 500000) { j -= busythread_useless; }
+                j += i;
+        }
+
+        OSAtomicIncrement32(&busy_threads_finished);
+}
+
+/*
+ * Test that dispatch_apply can make progress and finish, even if there are
+ * so many other running and unblocked workqueue threads that the apply's
+ * helper threads never get a chance to come up.
+ *
+ * <rdar://problem/10718199> dispatch_apply should not block waiting on other
+ * threads while calling thread is available
+ */
+void test_apply_contended(dispatch_queue_t dq)
+{
+        uint32_t activecpu;
+        size_t s = sizeof(activecpu);
+        sysctlbyname("hw.activecpu", &activecpu, &s, NULL, 0);
+        int tIndex, n_threads = activecpu;
+        dispatch_group_t grp = dispatch_group_create();
+
+        for(tIndex = 0; tIndex < n_threads; tIndex++) {
+                dispatch_group_async_f(grp, dq, NULL, busythread);
+        }
+
+        // Spin until all the threads have actually started
+        while(busy_threads_started < n_threads) {
+                usleep(1);
+        }
+
+        volatile __block int32_t count = 0;
+        const int32_t final = 32;
+
+        unsigned int before = busy_threads_started;
+        dispatch_apply(final, dq, ^(size_t i __attribute__((unused))) {
+                OSAtomicIncrement32(&count);
+        });
+        unsigned int after = busy_threads_finished;
+
+        test_long("contended: threads started before apply", before, n_threads);
+        test_long("contended: count", count, final);
+        test_long("contended: threads finished before apply", after, 0);
+
+        dispatch_group_wait(grp, DISPATCH_TIME_FOREVER);
+        dispatch_release(grp);
+
+}
 
 int
@@ -55 +133 @@
         test_long("nested count", count, final * final * final);
 
+        test_apply_contended(queue);
+
         test_stop();
 

trunk/testing/dispatch_concur.c

@@ -148 +148 @@
         if (c > *m) *m = c;
 
-        usleep(10000);
+        usleep(100000);
         __sync_sub_and_fetch(&concur, 1);
 }

trunk/testing/dispatch_deadname.c

@@ -33 +33 @@
 #define test_mach_assume_zero(x) ({kern_return_t _kr = (x); \
                 if (_kr) fprintf(stderr, "mach error 0x%x \"%s\": %s\n", \
-                _kr, mach_error_string(_kr), #x); _kr; })
-void
-test_mach_debug_port(mach_port_t name, const char *str)
+                _kr, mach_error_string(_kr), #x); (void)kr; })
+void
+test_mach_debug_port(mach_port_t name, const char *str, unsigned int line)
 {
         mach_port_type_t type;
@@ -41 +41 @@
         unsigned int dnreqs = 0, dnrsiz;
         kern_return_t kr = mach_port_type(mach_task_self(), name, &type);
-
         if (kr) {
-                fprintf(stderr, "machport[0x%08x] = { error(0x%x) \"%s\" }: %s\n",
-                                name, kr, mach_error_string(kr), str);
+                fprintf(stderr, "machport[0x%08x] = { error(0x%x) \"%s\" }: %s %u\n",
+                                name, kr, mach_error_string(kr), str, line);
                 return;
         }
@@ -59 +58 @@
                                 MACH_PORT_RIGHT_DEAD_NAME, &nd));
         }
-        if (type & (MACH_PORT_TYPE_RECEIVE|MACH_PORT_TYPE_SEND|
-                        MACH_PORT_TYPE_SEND_ONCE)) {
+        if (type & (MACH_PORT_TYPE_RECEIVE|MACH_PORT_TYPE_SEND)) {
                 test_mach_assume_zero(mach_port_dnrequest_info(mach_task_self(), name,
                                 &dnrsiz, &dnreqs));
@@ -72 +70 @@
                                 MACH_PORT_RECEIVE_STATUS, (void*)&status, &cnt));
                 fprintf(stderr, "machport[0x%08x] = { R(%03u) S(%03u) SO(%03u) D(%03u) "
-                                "dnreqs(%03u) nsreq(%s) pdreq(%s) srights(%s) sorights(%03u) "
-                                "qlim(%03u) msgcount(%03u) mkscount(%03u) seqno(%03u) }: %s\n",
-                                name, nr, ns, nso, nd, dnreqs, status.mps_nsrequest ? "Y":"N",
-                                status.mps_pdrequest ? "Y":"N", status.mps_srights ? "Y":"N",
-                                status.mps_sorights, status.mps_qlimit, status.mps_msgcount,
-                                status.mps_mscount, status.mps_seqno, str);
+                                "dnreqs(%03u) spreq(%s) nsreq(%s) pdreq(%s) srights(%s) "
+                                "sorights(%03u) qlim(%03u) msgcount(%03u) mkscount(%03u) "
+                                "seqno(%03u) }: %s %u\n", name, nr, ns, nso, nd, dnreqs,
+                                type & MACH_PORT_TYPE_SPREQUEST ? "Y":"N",
+                                status.mps_nsrequest ? "Y":"N", status.mps_pdrequest ? "Y":"N",
+                                status.mps_srights ? "Y":"N", status.mps_sorights,
+                                status.mps_qlimit, status.mps_msgcount, status.mps_mscount,
+                                status.mps_seqno, str, line);
         } else if (type & (MACH_PORT_TYPE_SEND|MACH_PORT_TYPE_SEND_ONCE|
                         MACH_PORT_TYPE_DEAD_NAME)) {
                 fprintf(stderr, "machport[0x%08x] = { R(%03u) S(%03u) SO(%03u) D(%03u) "
-                                "dnreqs(%03u) }: %s\n", name, nr, ns, nso, nd, dnreqs, str);
+                                "dnreqs(%03u) spreq(%s) }: %s %u\n", name, nr, ns, nso, nd,
+                                dnreqs, type & MACH_PORT_TYPE_SPREQUEST ? "Y":"N", str, line);
         } else {
-                fprintf(stderr, "machport[0x%08x] = { type(0x%08x) }: %s\n", name, type,
-                                str);
-        }
-}
-#define test_mach_debug_port(x) test_mach_debug_port(x, __func__)
+                fprintf(stderr, "machport[0x%08x] = { type(0x%08x) }: %s %u\n", name,
+                                type, str, line);
+        }
+        fflush(stderr);
+}
+#define test_mach_debug_port(x) test_mach_debug_port(x, __func__, __LINE__)
 #else
-#define test_mach_debug_port(x)
+#define test_mach_debug_port(x) (void)(x)
 #endif
 
@@ -113 +115 @@
                         test_long("DISPATCH_MACH_SEND_DEAD",
                                         dispatch_source_get_handle(ds0), mp);
+                        dispatch_source_cancel(ds0);
+                });
+                dispatch_source_set_cancel_handler(ds0, ^{
+                        kern_return_t kr = mach_port_deallocate(mach_task_self(), mp);
+                        test_mach_error("mach_port_deallocate", kr, KERN_SUCCESS);
                         dispatch_release(ds0);
                         dispatch_group_leave(g);
@@ -432 +439 @@
         dispatch_release(ds);
         test_long("DISPATCH_SOURCE_TYPE_MACH_RECV", received, 0);
+        dispatch_group_wait(g, DISPATCH_TIME_FOREVER);
 }
 

trunk/testing/dispatch_drift.c

@@ -29 +29 @@
 #include "dispatch_test.h"
 
-#if TARGET_OS_EMBEDDED
-#define ACCEPTABLE_DRIFT 0.002
-#else
 #define ACCEPTABLE_DRIFT 0.001
-#endif
 
 int
@@ -40 +36 @@
         __block uint32_t count = 0;
         __block double last_jitter = 0;
-        // 10 times a second
-        uint64_t interval = 1000000000 / 10;
+        __block double drift_sum = 0;
+        // 100 times a second
+        uint64_t interval = 1000000000 / 100;
         double interval_d = interval / 1000000000.0;
         // for 25 seconds
@@ -68 +65 @@
                 double jitter = goal - now;
                 double drift = jitter - last_jitter;
+                drift_sum += drift;
 
                 printf("%4d: jitter %f, drift %f\n", count, jitter, drift);
 
                 if (target <= ++count) {
-                        if (drift < 0) {
-                                drift = -drift;
+                        drift_sum /= count - 1;
+                        if (drift_sum < 0) {
+                                drift_sum = -drift_sum;
                         }
                         double acceptable_drift = ACCEPTABLE_DRIFT;
-                        test_double_less_than("drift", drift, acceptable_drift);
+                        test_double_less_than("drift", drift_sum, acceptable_drift);
                         test_stop();
                 }

trunk/testing/dispatch_group.c

@@ -34 +34 @@
 #endif
 
+#if TARGET_OS_EMBEDDED
+#define LOOP_COUNT 50000
+#else
+#define LOOP_COUNT 200000
+#endif
+
+static void test_group_notify(void*);
+
 dispatch_group_t
 create_group(size_t count, int delay)
@@ -58 +66 @@
 }
 
-int
-main(void)
+static void
+test_group(void *ctxt __attribute__((unused)))
 {
         long res;
-
-        dispatch_test_start("Dispatch Group");
-
         dispatch_group_t group;
 
@@ -96 +101 @@
 
         dispatch_group_notify(group, dispatch_get_main_queue(), ^{
-                dispatch_queue_t m = dispatch_get_main_queue();
-                dispatch_queue_t c = dispatch_get_current_queue();
-                test_ptr("Notification Received", m, c);
-                test_stop();
+                dispatch_test_current("Notification Received", dispatch_get_main_queue());
+                dispatch_async_f(dispatch_get_main_queue(), NULL, test_group_notify);
         });
 
         dispatch_release(group);
         group = NULL;
+}
 
+static long completed;
+
+static void
+test_group_notify2(long cycle, dispatch_group_t tested)
+{
+        static dispatch_queue_t rq, nq;
+        static dispatch_once_t once;
+        dispatch_once(&once, ^{
+                rq = dispatch_queue_create("release", 0);
+                dispatch_suspend(rq);
+                nq = dispatch_queue_create("notify", 0);
+        });
+        dispatch_resume(rq);
+
+        // n=4 works great for a 4CPU Mac Pro, this might work for a wider range of
+        // systems.
+        const int n = 1 + arc4random() % 8;
+        dispatch_group_t group = dispatch_group_create();
+        dispatch_queue_t qa[n];
+
+        dispatch_group_enter(group);
+        for (int i = 0; i < n; i++) {
+                char buf[48];
+                sprintf(buf, "T%ld-%d", cycle, i);
+                qa[i] = dispatch_queue_create(buf, 0);
+        }
+
+        __block float eh = 0;
+        for (int i = 0; i < n; i++) {
+                dispatch_queue_t q = qa[i];
+                dispatch_group_async(group, q, ^{
+                        // Seems to trigger a little more reliably with some work being
+                        // done in this block
+                        eh = sin(M_1_PI / cycle);
+                });
+        }
+        dispatch_group_leave(group);
+
+        dispatch_group_notify(group, nq, ^{
+                completed = cycle;
+                dispatch_group_leave(tested);
+        });
+
+        // Releasing qa's queues here seems to avoid the race, so we are arranging
+        // for the current iteration's queues to be released on the next iteration.
+        dispatch_sync(rq, ^{});
+        dispatch_suspend(rq);
+        for (int i = 0; i < n; i++) {
+                dispatch_queue_t q = qa[i];
+                dispatch_async(rq, ^{ dispatch_release(q); });
+        }
+        dispatch_release(group);
+}
+
+static void
+test_group_notify(void *ctxt __attribute__((unused)))
+{
+        // <rdar://problem/11445820>
+        dispatch_group_t tested = dispatch_group_create();
+        test_ptr_notnull("dispatch_group_create", tested);
+        long i;
+        for (i = 0; i < LOOP_COUNT; i++) {
+                if (!((i+1) % (LOOP_COUNT/10))) {
+                        fprintf(stderr, "#%ld\n", i+1);
+                }
+                dispatch_group_enter(tested);
+                test_group_notify2(i, tested);
+                if (dispatch_group_wait(tested, dispatch_time(DISPATCH_TIME_NOW,
+                                NSEC_PER_SEC))) {
+                        break;
+                }
+        }
+        test_long("dispatch_group_notify", i, LOOP_COUNT);
+        test_stop();
+}
+
+int
+main(void)
+{
+        dispatch_test_start("Dispatch Group");
+        dispatch_async_f(dispatch_get_main_queue(), NULL, test_group);
         dispatch_main();
 

trunk/testing/dispatch_io.c

@@ -66 +66 @@
 
 static void
-test_io_close(int with_timer)
+test_io_close(int with_timer, bool from_path)
 {
         #define chunks 4
@@ -81 +81 @@
                 test_stop();
         }
-        if (fcntl(fd, F_NOCACHE, 1)) {
-                test_errno("fcntl F_NOCACHE", errno, 0);
+        if (fcntl(fd, F_GLOBAL_NOCACHE, 1) == -1) {
+                test_errno("fcntl F_GLOBAL_NOCACHE", errno, 0);
                 test_stop();
         }
@@ -95 +95 @@
         dispatch_group_t g = dispatch_group_create();
         dispatch_group_enter(g);
-        dispatch_io_t io = dispatch_io_create(DISPATCH_IO_RANDOM, fd,
-                        dispatch_get_global_queue(0, 0), ^(int error) {
+        void (^cleanup_handler)(int error) = ^(int error) {
                 test_errno("create error", error, 0);
                 dispatch_group_leave(g);
                 close(fd);
-        });
+        };
+        dispatch_io_t io;
+        if (!from_path) {
+                io = dispatch_io_create(DISPATCH_IO_RANDOM, fd,
+                                dispatch_get_global_queue(0, 0), cleanup_handler);
+        } else {
+#if DISPATCHTEST_IO_PATH
+                io = dispatch_io_create_with_path(DISPATCH_IO_RANDOM, path, O_RDONLY, 0,
+                                dispatch_get_global_queue(0, 0), cleanup_handler);
+#endif
+        }
         dispatch_io_set_high_water(io, READSIZE);
         if (with_timer == 1) {
@@ -148 +157 @@
                 });
         }
-        dispatch_io_close(io, /* NO STOP */ 0);
+        dispatch_io_close(io, 0);
+        dispatch_io_close(io, 0);
         dispatch_io_read(io, 0, 1, dispatch_get_global_queue(0,0),
                         ^(bool done, dispatch_data_t d, int error) {
@@ -333 +343 @@
         }
         // disable caching also for extra fd opened by dispatch_io_create_with_path
-        if (fcntl(fd, F_GLOBAL_NOCACHE, 1)) {
-                test_errno("fcntl F_GLOBAL_NOCACHE failed", errno, 0);
+        if (fcntl(fd, F_GLOBAL_NOCACHE, 1) == -1) {
+                test_errno("fcntl F_GLOBAL_NOCACHE", errno, 0);
                 test_stop();
         }
@@ -477 +487 @@
 test_read_many_files(void)
 {
-        char *paths[] = {"/usr/include", NULL};
+        char *paths[] = {"/usr/lib", NULL};
         dispatch_group_t g = dispatch_group_create();
         dispatch_semaphore_t s = dispatch_semaphore_create(maxopenfiles);
@@ -665 +675 @@
         dispatch_async(dispatch_get_main_queue(), ^{
 #if DISPATCHTEST_IO
-                test_io_close(0 /* without timer */ );
-                test_io_close(1 /* with channel interval */);
-                test_io_close(2 /* with external timer */);
+                int i; bool from_path = false;
+                do {
+                        for (i = 0; i < 3; i++) {
+                                test_io_close(i, from_path);
+                        }
+#if DISPATCHTEST_IO_PATH
+                        from_path = !from_path;
+#endif
+                } while (from_path);
                 test_io_stop();
                 test_io_from_io();

trunk/testing/dispatch_priority.c

@@ -35 +35 @@
 
 #ifdef DISPATCH_QUEUE_PRIORITY_BACKGROUND // <rdar://problem/7439794>
-
-#define PRIORITIES 4
-char *labels[PRIORITIES] = { "BACKGROUND", "LOW", "DEFAULT", "HIGH" };
-int priorities[PRIORITIES] = { DISPATCH_QUEUE_PRIORITY_BACKGROUND, DISPATCH_QUEUE_PRIORITY_LOW, DISPATCH_QUEUE_PRIORITY_DEFAULT, DISPATCH_QUEUE_PRIORITY_HIGH };
-
-#else
-
-#define PRIORITIES 3
-char *labels[PRIORITIES] = { "LOW", "DEFAULT", "HIGH" };
-int priorities[PRIORITIES] = { DISPATCH_QUEUE_PRIORITY_LOW, DISPATCH_QUEUE_PRIORITY_DEFAULT, DISPATCH_QUEUE_PRIORITY_HIGH };
-
+#define USE_BACKGROUND_PRIORITY 1
+#else
+#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN
+#endif
+
+#define QUEUE_PRIORITY_PTHREAD INT_MAX
+
+#if DISPATCH_API_VERSION < 20100518 // <rdar://problem/7790099>
+#define DISPATCH_QUEUE_CONCURRENT NULL
 #endif
 
 #if TARGET_OS_EMBEDDED
-#define LOOP_COUNT 2000000
+#define LOOP_COUNT 5000000
+const int importance = 24; // priority 55
 #else
 #define LOOP_COUNT 100000000
-#endif
+const int importance = 4; // priority 35
+#endif
+
+char *labels[] = { "BACKGROUND", "LOW", "DEFAULT", "HIGH", };
+int levels[] = {
+        DISPATCH_QUEUE_PRIORITY_BACKGROUND, DISPATCH_QUEUE_PRIORITY_LOW,
+        DISPATCH_QUEUE_PRIORITY_DEFAULT, DISPATCH_QUEUE_PRIORITY_HIGH,
+};
+#define PRIORITIES (sizeof(levels)/sizeof(*levels))
 
 static union {
@@ -59 +66 @@
 } counts[PRIORITIES];
 
-#define ITERATIONS (long)(PRIORITIES * n_blocks() * 0.50)
 static volatile long iterations;
+static long total;
+static size_t prio0, priorities = PRIORITIES;
 
 int
@@ -79 +87 @@
 histogram(void)
 {
-        long total = 0;
-        size_t x,y;
-        for (y = 0; y < PRIORITIES; ++y) {
+        long completed = 0;
+        size_t x, y, i;
+        printf("\n");
+        for (y = prio0; y < prio0 + priorities; ++y) {
                 printf("%s: %ld\n", labels[y], counts[y].count);
-                total += counts[y].count;
+                completed += counts[y].count;
 
                 double fraction = (double)counts[y].count / (double)n_blocks();
@@ -93 +102 @@
         }
 
-        test_long("blocks completed", total, ITERATIONS);
-        test_long_less_than("high priority precedence", counts[0].count,
-                        counts[PRIORITIES-1].count);
+        test_long("blocks completed", completed, total);
+        for (i = prio0; i < prio0 + priorities; i++) {
+                if (levels[i] == DISPATCH_QUEUE_PRIORITY_HIGH) {
+                        test_long_less_than_or_equal("high priority precedence",
+                                        counts[i-2].count, counts[i].count);
+                }
+#if USE_BACKGROUND_PRIORITY
+                if (levels[i] == DISPATCH_QUEUE_PRIORITY_BACKGROUND) {
+                        test_long_less_than_or_equal("background priority precedence",
+                                        counts[i].count, counts[i+2].count);
+                }
+#endif
+        }
 }
 
@@ -116 +135 @@
                         usleep(100000);
                         histogram();
-                        test_stop();
-                        exit(0);
+                        dispatch_time_t delay = DISPATCH_TIME_NOW;
+                        dispatch_after(delay, dispatch_get_main_queue(), ^{
+                                test_stop();
+                        });
                 }
         }
@@ -137 +158 @@
 {
         dispatch_queue_t q[PRIORITIES];
-        int i;
-
-        iterations = ITERATIONS;
+        size_t i;
+
+#if !USE_BACKGROUND_PRIORITY
+        prio0++;
+        priorities--;
+#endif
+
+        iterations = total = (priorities * n_blocks()) * 0.50;
 
 #if USE_SET_TARGET_QUEUE
         dispatch_test_start("Dispatch Priority (Set Target Queue)");
-        for(i = 0; i < PRIORITIES; i++) {
-#if DISPATCH_API_VERSION < 20100518 // <rdar://problem/7790099>
-                q[i] = dispatch_queue_create(labels[i], NULL);
-#else
+#else
+        dispatch_test_start("Dispatch Priority");
+#endif
+
+        for (i = prio0; i < prio0 + priorities; i++) {
+                dispatch_queue_t rq = dispatch_get_global_queue(levels[i], 0);
+#if USE_SET_TARGET_QUEUE
                 q[i] = dispatch_queue_create(labels[i], DISPATCH_QUEUE_CONCURRENT);
-#endif
                 test_ptr_notnull("q[i]", q[i]);
                 assert(q[i]);
                 dispatch_suspend(q[i]);
-                dispatch_set_target_queue(q[i], dispatch_get_global_queue(priorities[i], 0));
-#if DISPATCH_API_VERSION < 20100518 // <rdar://problem/7790099>
-                dispatch_queue_set_width(q[i], LONG_MAX);
-#endif
-        }
-#else
-        dispatch_test_start("Dispatch Priority");
-        for(i = 0; i < PRIORITIES; i++) {
-                q[i] = dispatch_get_global_queue(priorities[i], 0);
-        }
-#endif
-
-        for(i = 0; i < PRIORITIES; i++) {
+                dispatch_set_target_queue(q[i], rq);
+                if (DISPATCH_QUEUE_CONCURRENT != NULL) {
+                        dispatch_queue_set_width(q[i], LONG_MAX);
+                }
+                dispatch_release(rq);
+#else
+                q[i] = rq;
+#endif
+        }
+
+        for (i = prio0; i < prio0 + priorities; i++) {
                 submit_work(q[i], &counts[i].count);
         }
 
-#if USE_SET_TARGET_QUEUE
-        for(i = 0; i < PRIORITIES; i++) {
+        for (i = prio0; i < prio0 + priorities; i++) {
                 dispatch_resume(q[i]);
                 dispatch_release(q[i]);
         }
-#endif
 
         dispatch_main();

trunk/testing/dispatch_queue_finalizer.c

@@ -70 +70 @@
 
         dispatch_set_context(q_null_context, NULL);
+        dispatch_set_finalizer_f(q_null_context, never_call);
         dispatch_release(q_null_context);
 

trunk/testing/dispatch_suspend_timer.c

@@ -46 +46 @@
 
         dispatch_queue_t main_q = dispatch_get_main_queue();
-        test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
+        //test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
 
         __block int i = 0, i_prime = 0;

trunk/testing/dispatch_test.c

@@ -20 +20 @@
 
 #include "dispatch_test.h"
+#include "bsdtests.h"
 
 #ifdef __OBJC_GC__
@@ -25 +26 @@
 #endif
 
+#include <stdlib.h>
+#include <stdio.h>
 #include <unistd.h>
 #include <sys/event.h>
 #include <assert.h>
+
+#include <dispatch/dispatch.h>
 
 void test_start(const char* desc);
@@ -57 +62 @@
         return r > 0;
 }
+
+void
+_dispatch_test_current(const char* file, long line, const char* desc, dispatch_queue_t expected)
+{
+        dispatch_queue_t actual = dispatch_get_current_queue();
+        _test_ptr(file, line, desc, actual, expected);
+}

trunk/testing/dispatch_test.h

@@ -21 +21 @@
 #include <sys/cdefs.h>
 #include <stdbool.h>
+#include <dispatch/dispatch.h>
 
 #define test_group_wait(g) do { \
@@ -35 +36 @@
 bool dispatch_test_check_evfilt_read_for_fd(int fd);
 
+void _dispatch_test_current(const char* file, long line, const char* desc, dispatch_queue_t expected);
+#define dispatch_test_current(a,b) _dispatch_test_current(__SOURCE_FILE__, __LINE__, a, b)
+
 __END_DECLS

trunk/testing/dispatch_timer.c

@@ -47 +47 @@
 
         dispatch_queue_t main_q = dispatch_get_main_queue();
-        test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
+        //test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
 
         uint64_t j;
@@ -74 +74 @@
 
         dispatch_source_t s = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, main_q);
-        dispatch_debug(s, "fresh timer:");
         test_ptr_notnull("dispatch_source_create", s);
 
@@ -81 +80 @@
         dispatch_source_set_cancel_handler(s, ^{
                 test_ptr_notnull("cancel handler run", s);
-                dispatch_debug(s, "pre release timer:");
                 dispatch_release(s);
-                dispatch_debug(s, "post release timer:");
         });
 

trunk/testing/dispatch_timer_bit31.c

@@ -35 +35 @@
 
         dispatch_queue_t main_q = dispatch_get_main_queue();
-        test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
+        //test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
 
         struct timeval start_time;

trunk/testing/dispatch_timer_set_time.c

@@ -36 +36 @@
 
         dispatch_queue_t main_q = dispatch_get_main_queue();
-        test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
+        //test_ptr("dispatch_get_main_queue", main_q, dispatch_get_current_queue());
 
         __block int i = 0;

trunk/testing/dispatch_vm.c

@@ -30 +30 @@
 
 #include <dispatch/dispatch.h>
+#include <dispatch/private.h>
 
 #include <bsdtests.h>
@@ -37 +38 @@
 
 #if TARGET_OS_EMBEDDED
-#define ALLOC_SIZE ((size_t)(1024*1024*5ul))    // 5MB
+#define ALLOC_SIZE ((size_t)(1024*1024*1ul))    // 1MB
 #define NOTIFICATIONS 1
 #else
@@ -61 +62 @@
 #define log_msg(msg, ...) \
 do { \
-        fprintf(stderr, "[%2ds] " msg, (int)(time(NULL) - initial), ## __VA_ARGS__);\
+        fprintf(stderr, "[%2ds] " msg, (int)(time(NULL) - initial), ##__VA_ARGS__);\
 } while (0)
 
@@ -103 +104 @@
 main(void)
 {
-        dispatch_test_start("Dispatch VM Pressure test"); // <rdar://problem/7000945>
+        dispatch_test_start("Dispatch VM Pressure test"); // rdar://problem/7000945
         if (!dispatch_test_check_evfilt_vm()) {
                 test_skip("EVFILT_VM not supported");
@@ -143 +144 @@
         dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC),
                         dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
-                while (handler_call_count < NOTIFICATIONS && page_count < max_page_count) {
+                while (handler_call_count < NOTIFICATIONS &&
+                                page_count < max_page_count) {
                         void *p = valloc(ALLOC_SIZE);
                         if (!p) {
@@ -164 +166 @@
                         return;
                 }
-                dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC), vm_queue, ^{
-                        test_long_less_than("VM Pressure fired", NOTIFICATIONS - 1, handler_call_count);
-                        test_long_less_than("VM Pressure stopped firing", handler_call_count, 4);
+                dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2 * NSEC_PER_SEC),
+                                vm_queue, ^{
+                        test_long_greater_than_or_equal("VM Pressure fired",
+                                        handler_call_count, NOTIFICATIONS);
+                        test_long_less_than("VM Pressure stopped firing",
+                                        handler_call_count, 4);
                         cleanup();
                 });
@@ -177 +182 @@
 main(void)
 {
-        dispatch_test_start("Dispatch VM Pressure test - No DISPATCH_SOURCE_TYPE_VM");
+        dispatch_test_start("Dispatch VM Pressure test"
+                        " - No DISPATCH_SOURCE_TYPE_VM");
         test_stop();
         return 0;