CI: variants (#1586)

.github/workflows/autoconf.yml

@@ -0,0 +1,86 @@
+name: Autoconf
+
+on:
+  workflow_dispatch:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}-${{ matrix.osver }}
+
+    name: "${{ matrix.os }} ${{ matrix.arch }}: ${{ matrix.compiler }}"
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu, macos]
+        arch: [amd64, i386]
+        compiler: [gcc, clang]
+
+        include:
+          - os: ubuntu
+            osver: 22.04
+          - os: macos
+            osver: 12
+          
+          - arch: i386
+            archcflags: "-m32 -msse2 -mfpmath=sse"
+
+        exclude:
+          - os: macos
+            arch: i386
+
+    steps:
+
+    # Linux - dependencies
+    - name: apt-build-deps
+      if: matrix.os == 'ubuntu'
+      run: |
+        sudo dpkg --add-architecture ${{ matrix.arch }}
+        sudo apt-get update
+        sudo apt-get install ronn kramdown python3
+    - name: apt-arch-deps
+      if: matrix.os == 'ubuntu'
+      run: "sudo apt-get install libtool-bin valgrind g++-12-multilib linux-libc-dev:${{ matrix.arch }} libpcaudio-dev:${{ matrix.arch }} libsonic-dev:${{ matrix.arch }}"
+    - name: apt-compile-clang
+      if: matrix.os == 'ubuntu' && matrix.compiler == 'clang'
+      run: sudo apt-get install clang
+
+    # MacOS - dependencies
+    - name: brew-deps
+      if: matrix.os == 'macos'
+      run: brew install libtool automake ronn OJFord/homebrew-formulae/kramdown
+    - name: brew-compile-deps
+      if: matrix.os == 'macos' && matrix.compiler == 'gcc'
+      run: brew install gcc@12
+
+    # Checkout code
+    - uses: actions/checkout@v3
+
+    # Configure
+    - name: configure
+      run: |
+        ./autogen.sh
+        chmod -x INSTALL m4/*.m4
+        [ 'x${{ matrix.compiler }}' = 'xgcc' ] && export CC="gcc-12"
+        [ 'x${{ matrix.compiler }}' = 'xgcc' ] && export CXX="g++-12"
+        [ 'x${{ matrix.compiler }}' = 'xclang' ] && export CC="clang"
+        [ 'x${{ matrix.compiler }}' = 'xclang' ] && export CXX="clang++"
+        export CFLAGS="-g -Og -fno-omit-frame-pointer ${{ matrix.archcflags }}"
+        export CXXFLAGS="-g -Og -fno-omit-frame-pointer ${{ matrix.archcflags }}"
+        ./configure
+
+    - name: config-failed-upload
+      if: ${{ failure() }}
+      uses: actions/upload-artifact@v3
+      with:
+        name: config-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.compiler }}.log
+        path: config.log
+
+    # Build and test
+    - name: build
+      run: make all-am
+    - name: test
+      run: make check

.github/workflows/ci.yml

@@ -11,13 +11,13 @@ jobs:
   build:
     runs-on: ${{ matrix.os }}-${{ matrix.osver }}
 
-    name: "${{ matrix.os }} ${{ matrix.arch }}: ${{ matrix.compiler }} + ${{ matrix.sanitizer }}"
+    name: "${{ matrix.os }} ${{ matrix.arch }}: ${{ matrix.compiler }} + ${{ matrix.config }}"
     strategy:
       fail-fast: false
       matrix:
         os: [ubuntu, macos]
         arch: [amd64, i386, aarch64, arm, riscv64]
-        sanitizer: [no, address, leak, memory, thread, undefined, valgrind]
+        config: [debug, release, release-dyn, asan, lsan, msan, tsan, ubsan, valgrind]
         compiler: [gcc, clang]
 
         include:
@@ -59,29 +59,35 @@ jobs:
             runenv: 'LD_LIBRARY_PATH=/usr/riscv64-linux-gnu/lib:$LD_LIBRARY_PATH'
             cross: yes
 
-          - sanitizer: "address"
-            sanitizer_cflags: "-fsanitize=address"
-            sanitize_env: "ASAN_OPTIONS=detect_leaks=0"
+          - config: "asan"
+            config_cflags: "-fsanitize=address"
+            config_env: "ASAN_OPTIONS=detect_leaks=0"
 
-          - sanitizer: "leak"
-            sanitizer_cflags: "-fsanitize=leak"
-            sanitize_env: "LSAN_OPTIONS=fast_unwind_on_malloc=0"
+          - config: "lsan"
+            config_cflags: "-fsanitize=leak"
+            config_env: "LSAN_OPTIONS=fast_unwind_on_malloc=0"
 
-          - sanitizer: "memory"
+          - config: "msan"
             configenv: "CC=clang CXX=clang++"
-            sanitizer_cflags: "-fsanitize=memory -fsanitize-memory-track-origins=2"
-            config: "-DUSE_LIBPCAUDIO:BOOL=OFF -DUSE_LIBSONIC:BOOL=OFF"
-            sanitize_env: "MSAN_OPTIONS=exitcode=42"
+            config_cflags: "-fsanitize=memory -fsanitize-memory-track-origins=2"
+            settings: "-DUSE_LIBPCAUDIO:BOOL=OFF -DUSE_LIBSONIC:BOOL=OFF"
+            config_env: "MSAN_OPTIONS=exitcode=42"
 
-          - sanitizer: "thread"
-            sanitizer_cflags: "-fsanitize=thread"
+          - config: "tsan"
+            config_cflags: "-fsanitize=thread"
 
-          - sanitizer: "undefined"
-            sanitizer_cflags: "-fsanitize=undefined"
-            sanitize_env: "UBSAN_OPTIONS=halt_on_error=1"
+          - config: "ubsan"
+            config_cflags: "-fsanitize=undefined"
+            config_env: "UBSAN_OPTIONS=halt_on_error=1"
 
-          - sanitizer: "valgrind"
-            sanitize_env: 'VALGRIND="valgrind --track-origins=yes --leak-check=full --error-exitcode=1"'
+          - config: "valgrind"
+            config_env: 'VALGRIND="valgrind --track-origins=yes --leak-check=full --error-exitcode=1"'
+
+          - config: "release"
+            settings: "-DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo"
+
+          - config: "release-dyn"
+            settings: "-DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo -DBUILD_SHARED_LIBS:BOOL=ON"
           
         exclude:
           - os: macos
@@ -94,83 +100,83 @@ jobs:
             arch: riscv64
 
           - os: macos
-            sanitizer: valgrind # Not supported on macOS
+            config: valgrind # Not supported on macOS
 
           - compiler: gcc
-            sanitizer: memory # Not supported by GCC
+            config: msan # Not supported by GCC
 
           - os: macos
             compiler: clang
-            sanitizer: leak # Not supported by Apple Clang
+            config: lsan # Not supported by Apple Clang
           - os: macos
             compiler: clang
-            sanitizer: memory # Not supported by Apple Clang
+            config: msan # Not supported by Apple Clang
           - os: macos
             compiler: gcc
-            sanitizer: thread # Failing on CI, should be supported?
+            config: tsan # Failing on CI, should be supported?
 
           # Valgrind is unavailable for cross-builds
           - arch: aarch64
-            sanitizer: valgrind
+            config: valgrind
           - arch: arm
-            sanitizer: valgrind
+            config: valgrind
           - arch: riscv64
-            sanitizer: valgrind
+            config: valgrind
 
           # Leak sanitizer is unavailable for cross-builds
           - arch: i386
-            sanitizer: leak
+            config: lsan
           - arch: aarch64
-            sanitizer: leak
+            config: lsan
           - arch: arm
-            sanitizer: leak
+            config: lsan
           - arch: riscv64
-            sanitizer: leak
+            config: lsan
           
           # Thread sanitizer is partially unavailable
           - arch: i386
-            sanitizer: thread
+            config: tsan
           - arch: arm
-            sanitizer: thread
+            config: tsan
           - arch: riscv64
-            sanitizer: thread
+            config: tsan
           - arch: aarch64
             compiler: clang
-            sanitizer: thread
+            config: tsan
 
           # Undefined sanitizer is partially unavailable
           - arch: riscv64
-            sanitizer: undefined
+            config: ubsan
           - arch: arm
             compiler: clang
-            sanitizer: undefined
+            config: ubsan
           - arch: aarch64
             compiler: clang
-            sanitizer: undefined
+            config: ubsan
 
           # Memory sanitizer is partially unavailable
           - arch: i386
-            sanitizer: memory
+            config: msan
           - arch: riscv64
-            sanitizer: memory
+            config: msan
           - arch: arm
-            sanitizer: memory
+            config: msan
           - arch: aarch64
-            sanitizer: memory
+            config: msan
 
           # Address sanitizer is partially unavailable
           - arch: riscv64
-            sanitizer: address
+            config: asan
           - arch: arm
             compiler: clang
-            sanitizer: address
+            config: asan
           - arch: aarch64
             compiler: clang
-            sanitizer: address
+            config: asan
 
           # Disable Thread sanitizer that runs for over 2h on aarch64
           - arch: aarch64
-            sanitizer: thread
+            config: tsan
 
     steps:
 
@@ -210,23 +216,23 @@ jobs:
         [ 'x${{ matrix.compiler }}' = 'xclang' ] && export CC="clang --target=${{ matrix.ccarch }}-${{ matrix.sys }}"
         [ 'x${{ matrix.compiler }}' = 'xclang' ] && export CXX="clang++ --target=${{ matrix.ccarch }}-${{ matrix.sys }}"
         [ 'x${{ matrix.cross }}' = 'xyes' ] && export LD="${{ matrix.ccarch }}-${{ matrix.sys }}-ld"
-        export CFLAGS="-g -Og -fno-omit-frame-pointer ${{ matrix.compiler_flags }} ${{ matrix.sanitizer_cflags }} ${{ matrix.archcflags }}"
-        export CXXFLAGS="-g -Og -fno-omit-frame-pointer ${{ matrix.compiler_flags }} ${{ matrix.sanitizer_cflags }} ${{ matrix.archcflags }}"
-        cmake -Bbuild ${{ matrix.config }} -DCMAKE_SYSTEM_PROCESSOR=${{ matrix.arch }} -DUSE_ASYNC:BOOL=OFF
+        export CFLAGS="-g -Og -fno-omit-frame-pointer ${{ matrix.compiler_flags }} ${{ matrix.config_cflags }} ${{ matrix.archcflags }}"
+        export CXXFLAGS="-g -Og -fno-omit-frame-pointer ${{ matrix.compiler_flags }} ${{ matrix.config_cflags }} ${{ matrix.archcflags }}"
+        cmake -Bbuild ${{ matrix.settings }} -DCMAKE_SYSTEM_PROCESSOR=${{ matrix.arch }} -DUSE_ASYNC:BOOL=OFF
 
     - name: config-failed-upload
       if: ${{ failure() }}
       uses: actions/upload-artifact@v3
       with:
-        name: cmake-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.compiler }}-${{ matrix.sanitizer }}-builddir
+        name: cmake-${{ matrix.os }}-${{ matrix.arch }}-${{ matrix.compiler }}-${{ matrix.config }}-builddir
         path: build
 
     # Build and test
     - name: make-binary
       run: cmake --build build --target espeak-ng
     - name: make-data
-      run: ${{ matrix.sanitize_env }} ${{ matrix.runenv }} cmake --build build --target data
+      run: ${{ matrix.config_env }} ${{ matrix.runenv }} cmake --build build --target data
     - name: test
       run: |
-        ${{ matrix.sanitize_env }} ${{ matrix.runenv }} cmake --build build --target tests
-        ${{ matrix.sanitize_env }} ${{ matrix.runenv }} ctest --test-dir build -Ttest -j1 --output-on-failure
+        ${{ matrix.config_env }} ${{ matrix.runenv }} cmake --build build --target tests
+        ${{ matrix.config_env }} ${{ matrix.runenv }} ctest --test-dir build -Ttest -j1 --output-on-failure

.github/workflows/windows.yml

@@ -10,12 +10,24 @@ on:
 jobs:
   build:
     runs-on: windows-latest
-    name: build
+    name: "build: ${{ matrix.arch }} ${{ matrix.config }} ${{ matrix.link }}"
+    strategy:
+      fail-fast: false
+      matrix:
+        arch: [Win32, x64]
+        config: [Debug, Release]
+        link: [static, dll]
+
+        include:
+        - link: static
+          shlib: "OFF"
+        - link: dll
+          shlib: "ON"
     steps:
       - uses: actions/checkout@v3
       - name: configure
-        run: cmake -Bbuild -DUSE_ASYNC:BOOL=OFF
+        run: cmake -Bbuild -DUSE_ASYNC:BOOL=OFF -DBUILD_SHARED_LIBS:BOOL=${{ matrix.shlib }} -A ${{ matrix.arch }}
       - name: make
-        run: cmake --build build
+        run: cmake --build build --config ${{ matrix.config }}
       - name: make check
-        run: ctest --test-dir build -Ttest -C Debug -j1 --output-on-failure
+        run: ctest --test-dir build -Ttest -C ${{ matrix.config }} -j1 --output-on-failure

tests/api.c

@@ -17,8 +17,8 @@
  */
 
 #include "config.h"
+#include "test_assert.h"
 
-#include <assert.h>
 #include <stdlib.h>
 #include <string.h>
 
@@ -39,14 +39,14 @@ test_espeak_terminate_without_initialize()
 {
 	printf("testing espeak_Terminate without espeak_Initialize\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -54,19 +54,19 @@ test_espeak_initialize()
 {
 	printf("testing espeak_Initialize\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_PLAYBACK, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 // endregion
@@ -77,32 +77,32 @@ test_espeak_synth()
 {
 	printf("testing espeak_Synth\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -110,33 +110,33 @@ test_espeak_synth_no_voices(const char *path)
 {
 	printf("testing espeak_Synth in path with no voices\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, path, espeakINITIALIZE_DONT_EXIT) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, path, espeakINITIALIZE_DONT_EXIT) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
 	int res = espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL);
 #if USE_ASYNC
-	assert(res == EE_OK);
+	TEST_ASSERT(res == EE_OK);
 #else
-	assert(res == EE_NOT_FOUND);
+	TEST_ASSERT(res == EE_NOT_FOUND);
 #endif
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 // endregion
@@ -147,32 +147,32 @@ test_espeak_ng_synthesize()
 {
 	printf("testing espeak_ng_Synthesize\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_ng_Synthesize(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == ENS_OK);
+	TEST_ASSERT(espeak_ng_Synthesize(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == ENS_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -180,33 +180,33 @@ test_espeak_ng_synthesize_no_voices(const char *path)
 {
 	printf("testing espeak_ng_Synthesize in path with no voices\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, path, espeakINITIALIZE_DONT_EXIT) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, path, espeakINITIALIZE_DONT_EXIT) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
 	int res = espeak_ng_Synthesize(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL);
 #if USE_ASYNC
-	assert(res == EE_OK);
+	TEST_ASSERT(res == EE_OK);
 #else
-	assert(res == ENS_VOICE_NOT_FOUND);
+	TEST_ASSERT(res == ENS_VOICE_NOT_FOUND);
 #endif
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_ng_Synchronize() == ENS_OK);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_ng_Synchronize() == ENS_OK);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 // endregion
@@ -217,36 +217,36 @@ test_espeak_set_voice_by_name_null_voice()
 {
 	printf("testing espeak_SetVoiceByName(NULL)\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_SetVoiceByName("") == EE_NOT_FOUND);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByName("") == EE_NOT_FOUND);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -254,36 +254,36 @@ test_espeak_set_voice_by_name_blank_voice()
 {
 	printf("testing espeak_SetVoiceByName(\"\")\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_SetVoiceByName("") == EE_NOT_FOUND);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByName("") == EE_NOT_FOUND);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -291,37 +291,37 @@ test_espeak_set_voice_by_name_valid_voice()
 {
 	printf("testing espeak_SetVoiceByName(\"de\")\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_SetVoiceByName("de") == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "de") == 0);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByName("de") == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "de") == 0);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "de") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "de") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "de") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "de") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -329,36 +329,36 @@ test_espeak_set_voice_by_name_invalid_voice()
 {
 	printf("testing espeak_SetVoiceByName(\"zzz\")\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_SetVoiceByName("zzz") == EE_NOT_FOUND);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByName("zzz") == EE_NOT_FOUND);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -366,37 +366,37 @@ test_espeak_set_voice_by_name_language_variant_intonation_parameter()
 {
 	printf("testing espeak_SetVoiceByName(\"!v/Annie\") (language variant; intonation)\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_SetVoiceByName("!v/Annie") == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByName("!v/Annie") == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 // endregion
@@ -407,40 +407,40 @@ test_espeak_set_voice_by_properties_empty()
 {
 	printf("testing espeak_SetVoiceByProperties: (none)\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	espeak_VOICE properties;
 	memset(&properties, 0, sizeof(properties));
 
-	assert(espeak_SetVoiceByProperties(&properties) == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByProperties(&properties) == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -448,41 +448,41 @@ test_espeak_set_voice_by_properties_blank_language()
 {
 	printf("testing espeak_SetVoiceByProperties: languages=\"\"\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	espeak_VOICE properties;
 	memset(&properties, 0, sizeof(properties));
 	properties.languages = "";
 
-	assert(espeak_SetVoiceByProperties(&properties) == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByProperties(&properties) == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -490,41 +490,41 @@ test_espeak_set_voice_by_properties_with_valid_language()
 {
 	printf("testing espeak_SetVoiceByProperties: languages=\"mk\" (valid)\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	espeak_VOICE properties;
 	memset(&properties, 0, sizeof(properties));
 	properties.languages = "mk";
 
-	assert(espeak_SetVoiceByProperties(&properties) == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "mk") == 0);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByProperties(&properties) == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "mk") == 0);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "mk") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "mk") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "mk") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "mk") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static void
@@ -532,40 +532,40 @@ test_espeak_set_voice_by_properties_with_invalid_language()
 {
 	printf("testing espeak_SetVoiceByProperties: languages=\"zzz\" (invalid)\n");
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
-	assert(event_list != NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_RETRIEVAL, 0, NULL, 0) == 22050);
+	TEST_ASSERT(event_list != NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	espeak_VOICE properties;
 	memset(&properties, 0, sizeof(properties));
 	properties.languages = "zzz";
 
-	assert(espeak_SetVoiceByProperties(&properties) == EE_NOT_FOUND);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_SetVoiceByProperties(&properties) == EE_NOT_FOUND);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	const char *test = "One two three.";
-	assert(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
+	TEST_ASSERT(espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL) == EE_OK);
 #if !USE_ASYNC
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 #endif
 
-	assert(espeak_Synchronize() == EE_OK);
-	assert(translator != NULL);
-	assert(strcmp(translator->dictionary_name, "en") == 0);
-	assert(p_decoder != NULL);
+	TEST_ASSERT(espeak_Synchronize() == EE_OK);
+	TEST_ASSERT(translator != NULL);
+	TEST_ASSERT(strcmp(translator->dictionary_name, "en") == 0);
+	TEST_ASSERT(p_decoder != NULL);
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 static int
@@ -589,37 +589,37 @@ static void
 test_espeak_ng_phoneme_events(int enabled, int ipa) {
 	printf("testing espeak_ng_SetPhonemeEvents(enabled=%d, ipa=%d)\n", enabled, ipa);
 
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 
 	espeak_ng_InitializePath(NULL);
 	espeak_ng_ERROR_CONTEXT context = NULL;
-	assert(espeak_ng_Initialize(&context) == ENS_OK);
-	assert(espeak_ng_InitializeOutput(0, 0, NULL) == ENS_OK);
+	TEST_ASSERT(espeak_ng_Initialize(&context) == ENS_OK);
+	TEST_ASSERT(espeak_ng_InitializeOutput(0, 0, NULL) == ENS_OK);
 	espeak_SetSynthCallback(_test_espeak_ng_phoneme_events_cb);
-	assert(espeak_ng_SetPhonemeEvents(enabled, ipa) == ENS_OK);
+	TEST_ASSERT(espeak_ng_SetPhonemeEvents(enabled, ipa) == ENS_OK);
 
 	char phoneme_events[256];
 	memset(phoneme_events, 0, sizeof(phoneme_events));
 	const char *test = "test";
 
-	assert(espeak_ng_Synthesize(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, phoneme_events) == ENS_OK);
-	assert(espeak_ng_Synchronize() == ENS_OK);
+	TEST_ASSERT(espeak_ng_Synthesize(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, phoneme_events) == ENS_OK);
+	TEST_ASSERT(espeak_ng_Synchronize() == ENS_OK);
 	if (enabled) {
 		if (ipa) {
-			assert(strncmp(phoneme_events, "t ɛ s t  ", sizeof(phoneme_events)) == 0);
+			TEST_ASSERT(strncmp(phoneme_events, "t ɛ s t  ", sizeof(phoneme_events)) == 0);
 		} else {
-			assert(strncmp(phoneme_events, "t E s t _: _", sizeof(phoneme_events)) == 0);
+			TEST_ASSERT(strncmp(phoneme_events, "t E s t _: _", sizeof(phoneme_events)) == 0);
 		}
 	} else {
-		assert(phoneme_events[0] == 0);
+		TEST_ASSERT(phoneme_events[0] == 0);
 	}
 
-	assert(espeak_Terminate() == EE_OK);
-	assert(event_list == NULL);
-	assert(translator == NULL);
-	assert(p_decoder == NULL);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(event_list == NULL);
+	TEST_ASSERT(translator == NULL);
+	TEST_ASSERT(p_decoder == NULL);
 }
 
 // endregion
@@ -630,8 +630,11 @@ main(int argc, char **argv)
 	(void)argc; // unused parameter
 
 	char *progdir = strdup(argv[0]);
-	char *dir = strrchr(progdir, PATHSEP);
-	if (dir != NULL) *dir = 0;
+
+	// Path separator on windows may be both '/' and '\'
+	char *dir;
+	if ((dir = strrchr(progdir, PATHSEP)) != NULL) *dir = 0;
+	else if ((dir = strrchr(progdir, '/')) != NULL) *dir = 0;
 
 	test_espeak_terminate_without_initialize();
 	test_espeak_initialize();

tests/fuzzrunner.c

@@ -16,6 +16,7 @@
  *             <http://www.gnu.org/licenses/>.
  */
 
+#undef NDEBUG
 #include "config.h"
 #include "common.h"
 

tests/ieee80.c

@@ -20,7 +20,7 @@
  */
 
 #include "config.h"
-#include <assert.h>
+#include "test_assert.h"
 #include <math.h>
 #include <stdlib.h>
 #include "ieee80.h"
@@ -45,19 +45,19 @@ main(int argc, char **argv)
 		{ 0x7f,0xff,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }  /* nan */
 	};
 
-	assert(ieee_extended_to_double(in[0]) == 0.);
-	assert(ieee_extended_to_double(in[1]) == 1.);
-	assert(ieee_extended_to_double(in[2]) == -1.);
-	assert(ieee_extended_to_double(in[3]) == 2.);
-	assert(ieee_extended_to_double(in[4]) == 0.5);
-	assert(ieee_extended_to_double(in[5]) == 0.005859375);
-	assert(ieee_extended_to_double(in[6]) == 40926266145.);
+	TEST_ASSERT(ieee_extended_to_double(in[0]) == 0.);
+	TEST_ASSERT(ieee_extended_to_double(in[1]) == 1.);
+	TEST_ASSERT(ieee_extended_to_double(in[2]) == -1.);
+	TEST_ASSERT(ieee_extended_to_double(in[3]) == 2.);
+	TEST_ASSERT(ieee_extended_to_double(in[4]) == 0.5);
+	TEST_ASSERT(ieee_extended_to_double(in[5]) == 0.005859375);
+	TEST_ASSERT(ieee_extended_to_double(in[6]) == 40926266145.);
 #ifdef INFINITY
-	assert(ieee_extended_to_double(in[7]) == INFINITY);
-	assert(ieee_extended_to_double(in[8]) == -INFINITY);
+	TEST_ASSERT(ieee_extended_to_double(in[7]) == INFINITY);
+	TEST_ASSERT(ieee_extended_to_double(in[8]) == -INFINITY);
 #endif
 #ifdef NAN
-	assert(isnan(ieee_extended_to_double(in[9])));
+	TEST_ASSERT(isnan(ieee_extended_to_double(in[9])));
 #endif
 
 	return EXIT_SUCCESS;

tests/readclause.c

@@ -17,8 +17,8 @@
  */
 
 #include "config.h"
+#include "test_assert.h"
 
-#include <assert.h>
 #include <errno.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -63,18 +63,18 @@ test_latin()
 {
 	printf("testing Latin (Latn)\n");
 
-	assert(clause_type_from_codepoint('?') == CLAUSE_QUESTION);
-	assert(clause_type_from_codepoint('!') == CLAUSE_EXCLAMATION);
-	assert(clause_type_from_codepoint(',') == CLAUSE_COMMA);
-	assert(clause_type_from_codepoint(':') == CLAUSE_COLON);
-	assert(clause_type_from_codepoint(';') == CLAUSE_SEMICOLON);
+	TEST_ASSERT(clause_type_from_codepoint('?') == CLAUSE_QUESTION);
+	TEST_ASSERT(clause_type_from_codepoint('!') == CLAUSE_EXCLAMATION);
+	TEST_ASSERT(clause_type_from_codepoint(',') == CLAUSE_COMMA);
+	TEST_ASSERT(clause_type_from_codepoint(':') == CLAUSE_COLON);
+	TEST_ASSERT(clause_type_from_codepoint(';') == CLAUSE_SEMICOLON);
 
-	assert(clause_type_from_codepoint(0x00A1) == (CLAUSE_SEMICOLON | CLAUSE_OPTIONAL_SPACE_AFTER));
-	assert(clause_type_from_codepoint(0x00Bf) == (CLAUSE_SEMICOLON | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x00A1) == (CLAUSE_SEMICOLON | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x00Bf) == (CLAUSE_SEMICOLON | CLAUSE_OPTIONAL_SPACE_AFTER));
 
-	assert(clause_type_from_codepoint(0x2013) == CLAUSE_SEMICOLON);
-	assert(clause_type_from_codepoint(0x2014) == CLAUSE_SEMICOLON);
-	assert(clause_type_from_codepoint(0x2026) == (CLAUSE_SEMICOLON | CLAUSE_SPEAK_PUNCTUATION_NAME | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x2013) == CLAUSE_SEMICOLON);
+	TEST_ASSERT(clause_type_from_codepoint(0x2014) == CLAUSE_SEMICOLON);
+	TEST_ASSERT(clause_type_from_codepoint(0x2026) == (CLAUSE_SEMICOLON | CLAUSE_SPEAK_PUNCTUATION_NAME | CLAUSE_OPTIONAL_SPACE_AFTER));
 }
 
 static void
@@ -82,8 +82,8 @@ test_latin_sentence()
 {
 	printf("testing Latin (Latn) ... sentence\n");
 
-	assert(clause_type_from_codepoint('a') == CLAUSE_NONE);
-	assert(clause_type_from_codepoint('.') == CLAUSE_PERIOD);
+	TEST_ASSERT(clause_type_from_codepoint('a') == CLAUSE_NONE);
+	TEST_ASSERT(clause_type_from_codepoint('.') == CLAUSE_PERIOD);
 
 	short retix[] = {
 		0, 2, 3, 4, 5, 6, // Jane
@@ -93,20 +93,20 @@ test_latin_sentence()
 		0, 23, 24, 25, // the
 		0, 27, 28, 29, 30 }; // race
 
-	assert(set_text("Janet finished #1 in the race.", "en") == ENS_OK);
+	TEST_ASSERT(set_text("Janet finished #1 in the race.", "en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == (CLAUSE_PERIOD | CLAUSE_DOT_AFTER_LAST_WORD));
-	assert(!strcmp(source, "Janet finished #1 in the race "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == (CLAUSE_PERIOD | CLAUSE_DOT_AFTER_LAST_WORD));
+	TEST_ASSERT(!strcmp(source, "Janet finished #1 in the race "));
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source, " "));
-	assert(charix_top == 0);
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source, " "));
+	TEST_ASSERT(charix_top == 0);
 }
 
 static void
@@ -114,8 +114,8 @@ test_greek()
 {
 	printf("testing Greek (Grek)\n");
 
-	assert(clause_type_from_codepoint(0x037E) == CLAUSE_QUESTION);
-	assert(clause_type_from_codepoint(0x0387) == CLAUSE_SEMICOLON);
+	TEST_ASSERT(clause_type_from_codepoint(0x037E) == CLAUSE_QUESTION);
+	TEST_ASSERT(clause_type_from_codepoint(0x0387) == CLAUSE_SEMICOLON);
 }
 
 static void
@@ -123,11 +123,11 @@ test_armenian()
 {
 	printf("testing Armenian (Armn)\n");
 
-	assert(clause_type_from_codepoint(0x055B) == (CLAUSE_EXCLAMATION | CLAUSE_PUNCTUATION_IN_WORD));
-	assert(clause_type_from_codepoint(0x055C) == (CLAUSE_EXCLAMATION | CLAUSE_PUNCTUATION_IN_WORD));
-	assert(clause_type_from_codepoint(0x055D) == CLAUSE_COMMA);
-	assert(clause_type_from_codepoint(0x055E) == (CLAUSE_QUESTION | CLAUSE_PUNCTUATION_IN_WORD));
-	assert(clause_type_from_codepoint(0x0589) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x055B) == (CLAUSE_EXCLAMATION | CLAUSE_PUNCTUATION_IN_WORD));
+	TEST_ASSERT(clause_type_from_codepoint(0x055C) == (CLAUSE_EXCLAMATION | CLAUSE_PUNCTUATION_IN_WORD));
+	TEST_ASSERT(clause_type_from_codepoint(0x055D) == CLAUSE_COMMA);
+	TEST_ASSERT(clause_type_from_codepoint(0x055E) == (CLAUSE_QUESTION | CLAUSE_PUNCTUATION_IN_WORD));
+	TEST_ASSERT(clause_type_from_codepoint(0x0589) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
 }
 
 static void
@@ -135,10 +135,10 @@ test_arabic()
 {
 	printf("testing Arabic (Arab)\n");
 
-	assert(clause_type_from_codepoint(0x060C) == CLAUSE_COMMA);
-	assert(clause_type_from_codepoint(0x061B) == CLAUSE_SEMICOLON);
-	assert(clause_type_from_codepoint(0x061F) == CLAUSE_QUESTION);
-	assert(clause_type_from_codepoint(0x06D4) == CLAUSE_PERIOD);
+	TEST_ASSERT(clause_type_from_codepoint(0x060C) == CLAUSE_COMMA);
+	TEST_ASSERT(clause_type_from_codepoint(0x061B) == CLAUSE_SEMICOLON);
+	TEST_ASSERT(clause_type_from_codepoint(0x061F) == CLAUSE_QUESTION);
+	TEST_ASSERT(clause_type_from_codepoint(0x06D4) == CLAUSE_PERIOD);
 }
 
 static void
@@ -146,7 +146,7 @@ test_devanagari()
 {
 	printf("testing Devanagari (Deva)\n");
 
-	assert(clause_type_from_codepoint(0x0964) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x0964) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
 }
 
 static void
@@ -154,8 +154,8 @@ test_tibetan()
 {
 	printf("testing Tibetan (Tibt)\n");
 
-	assert(clause_type_from_codepoint(0x0F0D) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
-	assert(clause_type_from_codepoint(0x0F0E) == CLAUSE_PARAGRAPH);
+	TEST_ASSERT(clause_type_from_codepoint(0x0F0D) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x0F0E) == CLAUSE_PARAGRAPH);
 }
 
 static void
@@ -163,7 +163,7 @@ test_sinhala()
 {
 	printf("testing Sinhala (Sinh)\n");
 
-	assert(clause_type_from_codepoint(0x0DF4) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x0DF4) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
 }
 
 static void
@@ -171,7 +171,7 @@ test_georgian()
 {
 	printf("testing Georgian (Geor)\n");
 
-	assert(clause_type_from_codepoint(0x10FB) == CLAUSE_PARAGRAPH);
+	TEST_ASSERT(clause_type_from_codepoint(0x10FB) == CLAUSE_PARAGRAPH);
 }
 
 static void
@@ -179,13 +179,13 @@ test_ethiopic()
 {
 	printf("testing Ethiopic (Ethi)\n");
 
-	assert(clause_type_from_codepoint(0x1362) == CLAUSE_PERIOD);
-	assert(clause_type_from_codepoint(0x1363) == CLAUSE_COMMA);
-	assert(clause_type_from_codepoint(0x1364) == CLAUSE_SEMICOLON);
-	assert(clause_type_from_codepoint(0x1365) == CLAUSE_COLON);
-	assert(clause_type_from_codepoint(0x1366) == CLAUSE_COLON);
-	assert(clause_type_from_codepoint(0x1367) == CLAUSE_QUESTION);
-	assert(clause_type_from_codepoint(0x1368) == CLAUSE_PARAGRAPH);
+	TEST_ASSERT(clause_type_from_codepoint(0x1362) == CLAUSE_PERIOD);
+	TEST_ASSERT(clause_type_from_codepoint(0x1363) == CLAUSE_COMMA);
+	TEST_ASSERT(clause_type_from_codepoint(0x1364) == CLAUSE_SEMICOLON);
+	TEST_ASSERT(clause_type_from_codepoint(0x1365) == CLAUSE_COLON);
+	TEST_ASSERT(clause_type_from_codepoint(0x1366) == CLAUSE_COLON);
+	TEST_ASSERT(clause_type_from_codepoint(0x1367) == CLAUSE_QUESTION);
+	TEST_ASSERT(clause_type_from_codepoint(0x1368) == CLAUSE_PARAGRAPH);
 }
 
 static void
@@ -193,8 +193,8 @@ test_ideographic()
 {
 	printf("testing Ideographic (Hani)\n");
 
-	assert(clause_type_from_codepoint(0x3001) == (CLAUSE_COMMA | CLAUSE_OPTIONAL_SPACE_AFTER));
-	assert(clause_type_from_codepoint(0x3002) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x3001) == (CLAUSE_COMMA | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0x3002) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
 }
 
 static void
@@ -202,12 +202,12 @@ test_fullwidth()
 {
 	printf("testing Full Width\n");
 
-	assert(clause_type_from_codepoint(0xFF01) == (CLAUSE_EXCLAMATION | CLAUSE_OPTIONAL_SPACE_AFTER));
-	assert(clause_type_from_codepoint(0xFF0C) == (CLAUSE_COMMA | CLAUSE_OPTIONAL_SPACE_AFTER));
-	assert(clause_type_from_codepoint(0xFF0E) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
-	assert(clause_type_from_codepoint(0xFF1A) == (CLAUSE_COLON | CLAUSE_OPTIONAL_SPACE_AFTER));
-	assert(clause_type_from_codepoint(0xFF1B) == (CLAUSE_SEMICOLON | CLAUSE_OPTIONAL_SPACE_AFTER));
-	assert(clause_type_from_codepoint(0xFF1F) == (CLAUSE_QUESTION | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0xFF01) == (CLAUSE_EXCLAMATION | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0xFF0C) == (CLAUSE_COMMA | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0xFF0E) == (CLAUSE_PERIOD | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0xFF1A) == (CLAUSE_COLON | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0xFF1B) == (CLAUSE_SEMICOLON | CLAUSE_OPTIONAL_SPACE_AFTER));
+	TEST_ASSERT(clause_type_from_codepoint(0xFF1F) == (CLAUSE_QUESTION | CLAUSE_OPTIONAL_SPACE_AFTER));
 }
 
 static void
@@ -223,7 +223,7 @@ test_uts51_emoji_character()
 		5, -1, -1, -1,
 		6 };
 
-	assert(set_text(
+	TEST_ASSERT(set_text(
 		"\xE2\x86\x94"      // [2194]  left right arrow
 		"\xE2\x86\x95"      // [2195]  up down arrow
 		"\xE2\x9B\x94"      // [26D5]  no entry
@@ -232,18 +232,18 @@ test_uts51_emoji_character()
 		"en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source,
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source,
 		"\xE2\x86\x94"     // [2194]  left right arrow
 		"\xE2\x86\x95"     // [2195]  up down arrow
 		"\xE2\x9B\x94"     // [26D5]  no entry
 		"\xF0\x9F\x90\x8B" // [1F40B] whale
 		"\xF0\x9F\x90\xAC" // [1F42C] dolphin
 		" "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 }
 
 static void
@@ -258,7 +258,7 @@ test_uts51_text_presentation_sequence()
 		7, -1, -1, -1, 8, -1, -1,
 		9 };
 
-	assert(set_text(
+	TEST_ASSERT(set_text(
 		"#\xEF\xB8\x8E"                 // [0023 FE0E]  number sign (text style)
 		"4\xEF\xB8\x8E"                 // [0034 FE0E]  digit four (text style)
 		"\xE2\x80\xBC\xEF\xB8\x8E"      // [203C FE0E]  double exclamation mark (text style)
@@ -266,17 +266,17 @@ test_uts51_text_presentation_sequence()
 		"en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source,
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source,
 		"#\xEF\xB8\x8E"                // [0023 FE0E]  number sign (text style)
 		"4\xEF\xB8\x8E"                // [0034 FE0E]  digit four (text style)
 		"\xE2\x80\xBC\xEF\xB8\x8E"     // [203C FE0E]  double exclamation mark (text style)
 		"\xF0\x9F\x97\x92\xEF\xB8\x8E" // [1F5D2 FE0E] spiral note pad (text style)
 		" "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 }
 
 static void
@@ -291,7 +291,7 @@ test_uts51_emoji_presentation_sequence()
 		7, -1, -1, -1, 8, -1, -1,
 		9 };
 
-	assert(set_text(
+	TEST_ASSERT(set_text(
 		"#\xEF\xB8\x8F"                 // [0023 FE0F]  number sign (emoji style)
 		"4\xEF\xB8\x8F"                 // [0034 FE0F]  digit four (emoji style)
 		"\xE2\x80\xBC\xEF\xB8\x8F"      // [203C FE0F]  double exclamation mark (emoji style)
@@ -299,17 +299,17 @@ test_uts51_emoji_presentation_sequence()
 		"en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source,
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source,
 		"#\xEF\xB8\x8F"                // [0023 FE0F]  number sign (emoji style)
 		"4\xEF\xB8\x8F"                // [0034 FE0F]  digit four (emoji style)
 		"\xE2\x80\xBC\xEF\xB8\x8F"     // [203C FE0F]  double exclamation mark (emoji style)
 		"\xF0\x9F\x97\x92\xEF\xB8\x8F" // [1F5D2 FE0F] spiral note pad (emoji style)
 		" "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 }
 
 static void
@@ -323,23 +323,23 @@ test_uts51_emoji_modifier_sequence()
 		5, -1, -1, -1, 6, -1, -1, -1,
 		7 };
 
-	assert(set_text(
+	TEST_ASSERT(set_text(
 		"\xE2\x98\x9D\xF0\x9F\x8F\xBB"      // [261D 1F3FB]  index pointing up; light skin tone
 		"\xF0\x9F\x91\xB0\xF0\x9F\x8F\xBD"  // [1F5D2 1F3FD] bride with veil; medium skin tone
 		"\xF0\x9F\x92\xAA\xF0\x9F\x8F\xBF", // [1F4AA 1F3FF] flexed biceps; dark skin tone
 		"en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source,
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source,
 		"\xE2\x98\x9D\xF0\x9F\x8F\xBB"     // [261D 1F3FB]  index pointing up; light skin tone
 		"\xF0\x9F\x91\xB0\xF0\x9F\x8F\xBD" // [1F5D2 1F3FD] bride with veil; medium skin tone
 		"\xF0\x9F\x92\xAA\xF0\x9F\x8F\xBF" // [1F4AA 1F3FF] flexed biceps; dark skin tone
 		" "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 }
 
 static void
@@ -354,7 +354,7 @@ test_uts51_emoji_flag_sequence()
 		7, -1, -1, -1, 8, -1, -1, -1,
 		9 };
 
-	assert(set_text(
+	TEST_ASSERT(set_text(
 		"\xF0\x9F\x87\xA6\xF0\x9F\x87\xB7"  // [1F1E6 1F1F7] AR (argentina)
 		"\xF0\x9F\x87\xA7\xF0\x9F\x87\xAC"  // [1F1E7 1F1EC] BG (bulgaria)
 		"\xF0\x9F\x87\xAC\xF0\x9F\x87\xA8"  // [1F1EC 1F1E8] GC -- unknown country flag
@@ -362,17 +362,17 @@ test_uts51_emoji_flag_sequence()
 		"en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source,
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source,
 		"\xF0\x9F\x87\xA6\xF0\x9F\x87\xB7" // [1F1E6 1F1F7] AR (argentina)
 		"\xF0\x9F\x87\xA7\xF0\x9F\x87\xAC" // [1F1E7 1F1EC] BG (bulgaria)
 		"\xF0\x9F\x87\xAC\xF0\x9F\x87\xA8" // [1F1EC 1F1E8] GC -- unknown country flag
 		"\xF0\x9F\x87\xAC\xF0\x9F\x87\xB1" // [1F1EC 1F1F1] GL (greenland)
 		" "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 }
 
 static void
@@ -392,7 +392,7 @@ test_uts51_emoji_tag_sequence_emoji_character()
 		20, -1, -1, -1, // tag term
 		21 };
 
-	assert(set_text(
+	TEST_ASSERT(set_text(
 		// tag_base = emoji_character (RGI sequence)
 		"\xF0\x9F\x8F\xB4"  // [1F3F4] flag
 		"\xF3\xA0\x81\xA7"  // [E0067] tag : g
@@ -419,8 +419,8 @@ test_uts51_emoji_tag_sequence_emoji_character()
 		"en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source,
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source,
 		// tag_base = emoji_character (RGI sequence)
 		"\xF0\x9F\x8F\xB4" // [1F3F4] flag
 		"\xF3\xA0\x81\xA7" // [E0067] tag : g
@@ -445,10 +445,10 @@ test_uts51_emoji_tag_sequence_emoji_character()
 		"\xF3\xA0\x81\xA1" // [E006E] tag : a
 		"\xF3\xA0\x81\xBF" // [E007F] tag : (cancel)
 		" "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 }
 
 static void
@@ -462,23 +462,23 @@ test_uts51_emoji_combining_sequence()
 		6, -1, -1, 7, -1, -1, 8, -1, -1, // emoji presentation sequence
 		9 };
 
-	assert(set_text(
+	TEST_ASSERT(set_text(
 		"\xE2\x86\x95\xE2\x83\x9E"              // [2195 20DE]      up down arrow; Me (enclosing square)
 		"\xE2\x86\x95\xEF\xB8\x8E\xE2\x83\x9E"  // [2195 FE0E 20DE] up down arrow; Me (enclosing square)
 		"\xE2\x86\x95\xEF\xB8\x8F\xE2\x83\x9E", // [2195 FE0F 20DE] up down arrow; Me (enclosing square)
 		"en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source,
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source,
 		"\xE2\x86\x95\xE2\x83\x9E"             // [2195 20DE]      up down arrow; Me (enclosing square)
 		"\xE2\x86\x95\xEF\xB8\x8E\xE2\x83\x9E" // [2195 FE0E 20DE] up down arrow; Me (enclosing square)
 		"\xE2\x86\x95\xEF\xB8\x8F\xE2\x83\x9E" // [2195 FE0F 20DE] up down arrow; Me (enclosing square)
 		" "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 }
 
 static void
@@ -492,23 +492,23 @@ test_uts51_emoji_keycap_sequence()
 		7, 8, -1, -1, 9, -1, -1,
 		10 };
 
-	assert(set_text(
+	TEST_ASSERT(set_text(
 		"5\xEF\xB8\x8E\xE2\x83\xA3"  // [0035 FE0E 20E3] keycap 5
 		"#\xEF\xB8\x8E\xE2\x83\xA3"  // [0023 FE0E 20E3] keycap #
 		"*\xEF\xB8\x8E\xE2\x83\xA3", // [002A FE0E 20E3] keycap *
 		"en") == ENS_OK);
 
 	charix_top = 0;
-	assert(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
-	assert(!strcmp(source,
+	TEST_ASSERT(ReadClause(translator, source, charix, &charix_top, N_TR_SOURCE, &tone2, voice_change_name) == CLAUSE_EOF);
+	TEST_ASSERT(!strcmp(source,
 		"5\xEF\xB8\x8E\xE2\x83\xA3" // [0035 FE0E 20E3] keycap 5
 		"#\xEF\xB8\x8E\xE2\x83\xA3" // [0023 FE0E 20E3] keycap #
 		"*\xEF\xB8\x8E\xE2\x83\xA3" // [002A FE0E 20E3] keycap *
 		" "));
-	assert(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
-	assert(!memcmp(charix, retix, sizeof(retix)));
-	assert(tone2 == 0);
-	assert(voice_change_name[0] == 0);
+	TEST_ASSERT(charix_top == (sizeof(retix)/sizeof(retix[0])) - 1);
+	TEST_ASSERT(!memcmp(charix, retix, sizeof(retix)));
+	TEST_ASSERT(tone2 == 0);
+	TEST_ASSERT(voice_change_name[0] == 0);
 }
 
 int
@@ -517,7 +517,7 @@ main(int argc, char **argv)
 	(void)argc; // unused parameter
 	(void)argv; // unused parameter
 
-	assert(espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS, 0, NULL, espeakINITIALIZE_DONT_EXIT) == 22050);
+	TEST_ASSERT(espeak_Initialize(AUDIO_OUTPUT_SYNCHRONOUS, 0, NULL, espeakINITIALIZE_DONT_EXIT) == 22050);
 
 	test_latin();
 	test_latin_sentence();
@@ -542,7 +542,7 @@ main(int argc, char **argv)
 	test_uts51_emoji_combining_sequence();
 	test_uts51_emoji_keycap_sequence();
 
-	assert(espeak_Terminate() == EE_OK);
+	TEST_ASSERT(espeak_Terminate() == EE_OK);
 
 	return EXIT_SUCCESS;
 }

tests/test_assert.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stdio.h>
+#include <stdio.h>
+
+#define TEST_ASSERT(x) { \
+  if (!((x))) { \
+    fflush(stdout); \
+    fprintf(stderr, "FAILED: [%s:%d] %s\n", __FILE__, __LINE__, #x); \
+    fflush(stderr); \
+    exit(1); \
+  } \
+}