mahta.fetrat
/
HomoFast-eSpeak-Persian
Watch 1
Star 0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Browse Source

CI: variants (#1586)

master
Alexander Epaneshnikov 2 years ago
parent
892651bb77 ed05e0ac97
commit
b5205df2fc
No account linked to committer's email address
9 changed files with 1127 additions and 1006 deletions
Unified View Show Diff Stats
  1. 86
    0
      .github/workflows/autoconf.yml
  2. 59
    53
      .github/workflows/ci.yml
  3. 16
    4
      .github/workflows/windows.yml
  4. 316
    313
      tests/api.c
  5. 513
    513
      tests/encoding.c
  6. 1
    0
      tests/fuzzrunner.c
  7. 11
    11
      tests/ieee80.c
  8. 112
    112
      tests/readclause.c
  9. 13
    0
      tests/test_assert.h

+ 86
- 0
.github/workflows/autoconf.yml View File

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

+ 59
- 53
.github/workflows/ci.yml View File

build: build:
runs-on: ${{ matrix.os }}-${{ matrix.osver }} 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: strategy:
fail-fast: false fail-fast: false
matrix: matrix:
os: [ubuntu, macos] os: [ubuntu, macos]
arch: [amd64, i386, aarch64, arm, riscv64] 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] compiler: [gcc, clang]


include: include:
runenv: 'LD_LIBRARY_PATH=/usr/riscv64-linux-gnu/lib:$LD_LIBRARY_PATH' runenv: 'LD_LIBRARY_PATH=/usr/riscv64-linux-gnu/lib:$LD_LIBRARY_PATH'
cross: yes 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++" 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: exclude:
- os: macos - os: macos
arch: riscv64 arch: riscv64


- os: macos - os: macos
sanitizer: valgrind # Not supported on macOS
config: valgrind # Not supported on macOS


- compiler: gcc - compiler: gcc
sanitizer: memory # Not supported by GCC
config: msan # Not supported by GCC


- os: macos - os: macos
compiler: clang compiler: clang
sanitizer: leak # Not supported by Apple Clang
config: lsan # Not supported by Apple Clang
- os: macos - os: macos
compiler: clang compiler: clang
sanitizer: memory # Not supported by Apple Clang
config: msan # Not supported by Apple Clang
- os: macos - os: macos
compiler: gcc compiler: gcc
sanitizer: thread # Failing on CI, should be supported?
config: tsan # Failing on CI, should be supported?


# Valgrind is unavailable for cross-builds # Valgrind is unavailable for cross-builds
- arch: aarch64 - arch: aarch64
sanitizer: valgrind
config: valgrind
- arch: arm - arch: arm
sanitizer: valgrind
config: valgrind
- arch: riscv64 - arch: riscv64
sanitizer: valgrind
config: valgrind


# Leak sanitizer is unavailable for cross-builds # Leak sanitizer is unavailable for cross-builds
- arch: i386 - arch: i386
sanitizer: leak
config: lsan
- arch: aarch64 - arch: aarch64
sanitizer: leak
config: lsan
- arch: arm - arch: arm
sanitizer: leak
config: lsan
- arch: riscv64 - arch: riscv64
sanitizer: leak
config: lsan
# Thread sanitizer is partially unavailable # Thread sanitizer is partially unavailable
- arch: i386 - arch: i386
sanitizer: thread
config: tsan
- arch: arm - arch: arm
sanitizer: thread
config: tsan
- arch: riscv64 - arch: riscv64
sanitizer: thread
config: tsan
- arch: aarch64 - arch: aarch64
compiler: clang compiler: clang
sanitizer: thread
config: tsan


# Undefined sanitizer is partially unavailable # Undefined sanitizer is partially unavailable
- arch: riscv64 - arch: riscv64
sanitizer: undefined
config: ubsan
- arch: arm - arch: arm
compiler: clang compiler: clang
sanitizer: undefined
config: ubsan
- arch: aarch64 - arch: aarch64
compiler: clang compiler: clang
sanitizer: undefined
config: ubsan


# Memory sanitizer is partially unavailable # Memory sanitizer is partially unavailable
- arch: i386 - arch: i386
sanitizer: memory
config: msan
- arch: riscv64 - arch: riscv64
sanitizer: memory
config: msan
- arch: arm - arch: arm
sanitizer: memory
config: msan
- arch: aarch64 - arch: aarch64
sanitizer: memory
config: msan


# Address sanitizer is partially unavailable # Address sanitizer is partially unavailable
- arch: riscv64 - arch: riscv64
sanitizer: address
config: asan
- arch: arm - arch: arm
compiler: clang compiler: clang
sanitizer: address
config: asan
- arch: aarch64 - arch: aarch64
compiler: clang compiler: clang
sanitizer: address
config: asan


# Disable Thread sanitizer that runs for over 2h on aarch64 # Disable Thread sanitizer that runs for over 2h on aarch64
- arch: aarch64 - arch: aarch64
sanitizer: thread
config: tsan


steps: steps:


[ 'x${{ matrix.compiler }}' = 'xclang' ] && export CC="clang --target=${{ matrix.ccarch }}-${{ matrix.sys }}" [ '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.compiler }}' = 'xclang' ] && export CXX="clang++ --target=${{ matrix.ccarch }}-${{ matrix.sys }}"
[ 'x${{ matrix.cross }}' = 'xyes' ] && export LD="${{ matrix.ccarch }}-${{ matrix.sys }}-ld" [ '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 - name: config-failed-upload
if: ${{ failure() }} if: ${{ failure() }}
uses: actions/upload-artifact@v3 uses: actions/upload-artifact@v3
with: 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 path: build


# Build and test # Build and test
- name: make-binary - name: make-binary
run: cmake --build build --target espeak-ng run: cmake --build build --target espeak-ng
- name: make-data - 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 - name: test
run: | 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

+ 16
- 4
.github/workflows/windows.yml View File

jobs: jobs:
build: build:
runs-on: windows-latest 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: steps:
- uses: actions/checkout@v3 - uses: actions/checkout@v3
- name: configure - 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 - name: make
run: cmake --build build
run: cmake --build build --config ${{ matrix.config }}
- name: make check - 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

+ 316
- 313
tests/api.c View File

*/ */


#include "config.h" #include "config.h"
#include "test_assert.h"


#include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>


{ {
printf("testing espeak_Terminate without espeak_Initialize\n"); 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 static void
{ {
printf("testing espeak_Initialize\n"); 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 // endregion
{ {
printf("testing espeak_Synth\n"); 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."; 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 #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 #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 static void
{ {
printf("testing espeak_Synth in path with no voices\n"); 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."; const char *test = "One two three.";
int res = espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL); int res = espeak_Synth(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL);
#if USE_ASYNC #if USE_ASYNC
assert(res == EE_OK);
TEST_ASSERT(res == EE_OK);
#else #else
assert(res == EE_NOT_FOUND);
TEST_ASSERT(res == EE_NOT_FOUND);
#endif #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 // endregion
{ {
printf("testing espeak_ng_Synthesize\n"); 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."; 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 #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 #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 static void
{ {
printf("testing espeak_ng_Synthesize in path with no voices\n"); 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."; const char *test = "One two three.";
int res = espeak_ng_Synthesize(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL); int res = espeak_ng_Synthesize(test, strlen(test)+1, 0, POS_CHARACTER, 0, espeakCHARS_AUTO, NULL, NULL);
#if USE_ASYNC #if USE_ASYNC
assert(res == EE_OK);
TEST_ASSERT(res == EE_OK);
#else #else
assert(res == ENS_VOICE_NOT_FOUND);
TEST_ASSERT(res == ENS_VOICE_NOT_FOUND);
#endif #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 // endregion
{ {
printf("testing espeak_SetVoiceByName(NULL)\n"); 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."; 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 #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 #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 static void
{ {
printf("testing espeak_SetVoiceByName(\"\")\n"); 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."; 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 #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 #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 static void
{ {
printf("testing espeak_SetVoiceByName(\"de\")\n"); 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."; 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 #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 #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 static void
{ {
printf("testing espeak_SetVoiceByName(\"zzz\")\n"); 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."; 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 #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 #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 static void
{ {
printf("testing espeak_SetVoiceByName(\"!v/Annie\") (language variant; intonation)\n"); 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."; 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 #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 #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 // endregion
{ {
printf("testing espeak_SetVoiceByProperties: (none)\n"); 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; espeak_VOICE properties;
memset(&properties, 0, sizeof(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."; 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 #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 #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 static void
{ {
printf("testing espeak_SetVoiceByProperties: languages=\"\"\n"); 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; espeak_VOICE properties;
memset(&properties, 0, sizeof(properties)); memset(&properties, 0, sizeof(properties));
properties.languages = ""; 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."; 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 #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 #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 static void
{ {
printf("testing espeak_SetVoiceByProperties: languages=\"mk\" (valid)\n"); 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; espeak_VOICE properties;
memset(&properties, 0, sizeof(properties)); memset(&properties, 0, sizeof(properties));
properties.languages = "mk"; 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."; 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 #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 #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 static void
{ {
printf("testing espeak_SetVoiceByProperties: languages=\"zzz\" (invalid)\n"); 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; espeak_VOICE properties;
memset(&properties, 0, sizeof(properties)); memset(&properties, 0, sizeof(properties));
properties.languages = "zzz"; 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."; 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 #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 #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 static int
test_espeak_ng_phoneme_events(int enabled, int ipa) { test_espeak_ng_phoneme_events(int enabled, int ipa) {
printf("testing espeak_ng_SetPhonemeEvents(enabled=%d, ipa=%d)\n", enabled, 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_InitializePath(NULL);
espeak_ng_ERROR_CONTEXT context = 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); 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]; char phoneme_events[256];
memset(phoneme_events, 0, sizeof(phoneme_events)); memset(phoneme_events, 0, sizeof(phoneme_events));
const char *test = "test"; 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 (enabled) {
if (ipa) { 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 { } 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 { } 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 // endregion
(void)argc; // unused parameter (void)argc; // unused parameter


char *progdir = strdup(argv[0]); 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_terminate_without_initialize();
test_espeak_initialize(); test_espeak_initialize();

+ 513
- 513
tests/encoding.c
File diff suppressed because it is too large
View File


+ 1
- 0
tests/fuzzrunner.c View File

* <http://www.gnu.org/licenses/>. * <http://www.gnu.org/licenses/>.
*/ */


#undef NDEBUG
#include "config.h" #include "config.h"
#include "common.h" #include "common.h"



+ 11
- 11
tests/ieee80.c View File

*/ */


#include "config.h" #include "config.h"
#include <assert.h>
#include "test_assert.h"
#include <math.h> #include <math.h>
#include <stdlib.h> #include <stdlib.h>
#include "ieee80.h" #include "ieee80.h"
{ 0x7f,0xff,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x00 } /* nan */ { 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 #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 #endif
#ifdef NAN #ifdef NAN
assert(isnan(ieee_extended_to_double(in[9])));
TEST_ASSERT(isnan(ieee_extended_to_double(in[9])));
#endif #endif


return EXIT_SUCCESS; return EXIT_SUCCESS;

+ 112
- 112
tests/readclause.c View File

*/ */


#include "config.h" #include "config.h"
#include "test_assert.h"


#include <assert.h>
#include <errno.h> #include <errno.h>
#include <stdint.h> #include <stdint.h>
#include <stdlib.h> #include <stdlib.h>
{ {
printf("testing Latin (Latn)\n"); 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 static void
{ {
printf("testing Latin (Latn) ... sentence\n"); 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[] = { short retix[] = {
0, 2, 3, 4, 5, 6, // Jane 0, 2, 3, 4, 5, 6, // Jane
0, 23, 24, 25, // the 0, 23, 24, 25, // the
0, 27, 28, 29, 30 }; // race 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; 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; 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 static void
{ {
printf("testing Greek (Grek)\n"); 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 static void
{ {
printf("testing Armenian (Armn)\n"); 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 static void
{ {
printf("testing Arabic (Arab)\n"); 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 static void
{ {
printf("testing Devanagari (Deva)\n"); 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 static void
{ {
printf("testing Tibetan (Tibt)\n"); 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 static void
{ {
printf("testing Sinhala (Sinh)\n"); 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 static void
{ {
printf("testing Georgian (Geor)\n"); printf("testing Georgian (Geor)\n");


assert(clause_type_from_codepoint(0x10FB) == CLAUSE_PARAGRAPH);
TEST_ASSERT(clause_type_from_codepoint(0x10FB) == CLAUSE_PARAGRAPH);
} }


static void static void
{ {
printf("testing Ethiopic (Ethi)\n"); 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 static void
{ {
printf("testing Ideographic (Hani)\n"); 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 static void
{ {
printf("testing Full Width\n"); 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 static void
5, -1, -1, -1, 5, -1, -1, -1,
6 }; 6 };


assert(set_text(
TEST_ASSERT(set_text(
"\xE2\x86\x94" // [2194] left right arrow "\xE2\x86\x94" // [2194] left right arrow
"\xE2\x86\x95" // [2195] up down arrow "\xE2\x86\x95" // [2195] up down arrow
"\xE2\x9B\x94" // [26D5] no entry "\xE2\x9B\x94" // [26D5] no entry
"en") == ENS_OK); "en") == ENS_OK);


charix_top = 0; 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\x94" // [2194] left right arrow
"\xE2\x86\x95" // [2195] up down arrow "\xE2\x86\x95" // [2195] up down arrow
"\xE2\x9B\x94" // [26D5] no entry "\xE2\x9B\x94" // [26D5] no entry
"\xF0\x9F\x90\x8B" // [1F40B] whale "\xF0\x9F\x90\x8B" // [1F40B] whale
"\xF0\x9F\x90\xAC" // [1F42C] dolphin "\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 static void
7, -1, -1, -1, 8, -1, -1, 7, -1, -1, -1, 8, -1, -1,
9 }; 9 };


assert(set_text(
TEST_ASSERT(set_text(
"#\xEF\xB8\x8E" // [0023 FE0E] number sign (text style) "#\xEF\xB8\x8E" // [0023 FE0E] number sign (text style)
"4\xEF\xB8\x8E" // [0034 FE0E] digit four (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) "\xE2\x80\xBC\xEF\xB8\x8E" // [203C FE0E] double exclamation mark (text style)
"en") == ENS_OK); "en") == ENS_OK);


charix_top = 0; 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) "#\xEF\xB8\x8E" // [0023 FE0E] number sign (text style)
"4\xEF\xB8\x8E" // [0034 FE0E] digit four (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) "\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) "\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 static void
7, -1, -1, -1, 8, -1, -1, 7, -1, -1, -1, 8, -1, -1,
9 }; 9 };


assert(set_text(
TEST_ASSERT(set_text(
"#\xEF\xB8\x8F" // [0023 FE0F] number sign (emoji style) "#\xEF\xB8\x8F" // [0023 FE0F] number sign (emoji style)
"4\xEF\xB8\x8F" // [0034 FE0F] digit four (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) "\xE2\x80\xBC\xEF\xB8\x8F" // [203C FE0F] double exclamation mark (emoji style)
"en") == ENS_OK); "en") == ENS_OK);


charix_top = 0; 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) "#\xEF\xB8\x8F" // [0023 FE0F] number sign (emoji style)
"4\xEF\xB8\x8F" // [0034 FE0F] digit four (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) "\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) "\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 static void
5, -1, -1, -1, 6, -1, -1, -1, 5, -1, -1, -1, 6, -1, -1, -1,
7 }; 7 };


assert(set_text(
TEST_ASSERT(set_text(
"\xE2\x98\x9D\xF0\x9F\x8F\xBB" // [261D 1F3FB] index pointing up; light skin tone "\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\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 "\xF0\x9F\x92\xAA\xF0\x9F\x8F\xBF", // [1F4AA 1F3FF] flexed biceps; dark skin tone
"en") == ENS_OK); "en") == ENS_OK);


charix_top = 0; 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 "\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\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 "\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 static void
7, -1, -1, -1, 8, -1, -1, -1, 7, -1, -1, -1, 8, -1, -1, -1,
9 }; 9 };


assert(set_text(
TEST_ASSERT(set_text(
"\xF0\x9F\x87\xA6\xF0\x9F\x87\xB7" // [1F1E6 1F1F7] AR (argentina) "\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\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\xA8" // [1F1EC 1F1E8] GC -- unknown country flag
"en") == ENS_OK); "en") == ENS_OK);


charix_top = 0; 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\xA6\xF0\x9F\x87\xB7" // [1F1E6 1F1F7] AR (argentina)
"\xF0\x9F\x87\xA7\xF0\x9F\x87\xAC" // [1F1E7 1F1EC] BG (bulgaria) "\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\xA8" // [1F1EC 1F1E8] GC -- unknown country flag
"\xF0\x9F\x87\xAC\xF0\x9F\x87\xB1" // [1F1EC 1F1F1] GL (greenland) "\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 static void
20, -1, -1, -1, // tag term 20, -1, -1, -1, // tag term
21 }; 21 };


assert(set_text(
TEST_ASSERT(set_text(
// tag_base = emoji_character (RGI sequence) // tag_base = emoji_character (RGI sequence)
"\xF0\x9F\x8F\xB4" // [1F3F4] flag "\xF0\x9F\x8F\xB4" // [1F3F4] flag
"\xF3\xA0\x81\xA7" // [E0067] tag : g "\xF3\xA0\x81\xA7" // [E0067] tag : g
"en") == ENS_OK); "en") == ENS_OK);


charix_top = 0; 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) // tag_base = emoji_character (RGI sequence)
"\xF0\x9F\x8F\xB4" // [1F3F4] flag "\xF0\x9F\x8F\xB4" // [1F3F4] flag
"\xF3\xA0\x81\xA7" // [E0067] tag : g "\xF3\xA0\x81\xA7" // [E0067] tag : g
"\xF3\xA0\x81\xA1" // [E006E] tag : a "\xF3\xA0\x81\xA1" // [E006E] tag : a
"\xF3\xA0\x81\xBF" // [E007F] tag : (cancel) "\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 static void
6, -1, -1, 7, -1, -1, 8, -1, -1, // emoji presentation sequence 6, -1, -1, 7, -1, -1, 8, -1, -1, // emoji presentation sequence
9 }; 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\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\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) "\xE2\x86\x95\xEF\xB8\x8F\xE2\x83\x9E", // [2195 FE0F 20DE] up down arrow; Me (enclosing square)
"en") == ENS_OK); "en") == ENS_OK);


charix_top = 0; 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\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\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) "\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 static void
7, 8, -1, -1, 9, -1, -1, 7, 8, -1, -1, 9, -1, -1,
10 }; 10 };


assert(set_text(
TEST_ASSERT(set_text(
"5\xEF\xB8\x8E\xE2\x83\xA3" // [0035 FE0E 20E3] keycap 5 "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" // [0023 FE0E 20E3] keycap #
"*\xEF\xB8\x8E\xE2\x83\xA3", // [002A FE0E 20E3] keycap * "*\xEF\xB8\x8E\xE2\x83\xA3", // [002A FE0E 20E3] keycap *
"en") == ENS_OK); "en") == ENS_OK);


charix_top = 0; 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 "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" // [0023 FE0E 20E3] keycap #
"*\xEF\xB8\x8E\xE2\x83\xA3" // [002A 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 int
(void)argc; // unused parameter (void)argc; // unused parameter
(void)argv; // 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();
test_latin_sentence(); test_latin_sentence();
test_uts51_emoji_combining_sequence(); test_uts51_emoji_combining_sequence();
test_uts51_emoji_keycap_sequence(); test_uts51_emoji_keycap_sequence();


assert(espeak_Terminate() == EE_OK);
TEST_ASSERT(espeak_Terminate() == EE_OK);


return EXIT_SUCCESS; return EXIT_SUCCESS;
} }

+ 13
- 0
tests/test_assert.h View File

#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); \
} \
}

Write Preview
Loading…
Cancel
Save