diff --git a/CMakeLists.txt b/CMakeLists.txt
index 8318039cc..8a83d9162 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,19 +1,23 @@
 # Copyright (c) 2017 The Bitcoin developers
 
 cmake_minimum_required(VERSION 3.1)
 project(BitcoinABC)
 
 # Add path for custom modules
 set(CMAKE_MODULE_PATH
 	${CMAKE_MODULE_PATH}
 	${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules
 )
 
 # If ccache is available, then use it.
 find_program(CCACHE_FOUND ccache)
 if(CCACHE_FOUND)
     set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE ccache)
     set_property(GLOBAL PROPERTY RULE_LAUNCH_LINK ccache)
 endif(CCACHE_FOUND)
 
+# Add the magic taret check and check-all
+add_custom_target(check-all)
+add_custom_target(check)
+
 add_subdirectory(src)
diff --git a/cmake/modules/TestSuite.cmake b/cmake/modules/TestSuite.cmake
new file mode 100644
index 000000000..91b422705
--- /dev/null
+++ b/cmake/modules/TestSuite.cmake
@@ -0,0 +1,18 @@
+# Allow to easily build test suites
+
+macro(create_test_suite NAME)
+	enable_testing()
+	set(TARGET "check-${NAME}")
+	add_custom_target(${TARGET} COMMAND ${CMAKE_CTEST_COMMAND})
+
+	# If the magic target check-all exists, attach to it.
+	if(TARGET check-all)
+		add_dependencies(check-all ${TARGET})
+	endif()
+endmacro(create_test_suite)
+
+function(add_test_to_suite SUITE NAME)
+	add_executable(${NAME} EXCLUDE_FROM_ALL ${ARGN})
+	add_test(${NAME} ${NAME} COMMAND ${NAME})
+	add_dependencies("check-${SUITE}" ${NAME})
+endfunction(add_test_to_suite)
diff --git a/src/leveldb/CMakeLists.txt b/src/leveldb/CMakeLists.txt
index 76c4c3294..a2c5d187f 100644
--- a/src/leveldb/CMakeLists.txt
+++ b/src/leveldb/CMakeLists.txt
@@ -1,222 +1,223 @@
 # Copyright 2017 The LEVELDB Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file. See the AUTHORS file for names of contributors.
 
 cmake_minimum_required(VERSION 3.1)
 project(Leveldb VERSION 0.1.0 LANGUAGES C CXX)
 
 # This project can take advantage of C++11.
 set(CMAKE_CXX_STANDARD 11)
 
 # Remove some warnings for leveldb as they can get noisy.
 add_compiler_flag(-Wno-sign-compare -Wno-implicit-fallthrough)
 add_c_compiler_flag(-Wno-strict-prototypes)
 remove_compiler_flags(-Wstrict-prototypes)
 
 include(TestBigEndian)
 test_big_endian(LEVELDB_IS_BIG_ENDIAN)
 
 include(CheckIncludeFile)
 check_include_file("unistd.h" HAVE_UNISTD_H)
 
 include(CheckIncludeFileCXX)
 check_include_file_cxx("atomic" LEVELDB_ATOMIC_PRESENT)
 
 include(CheckLibraryExists)
 check_library_exists(crc32c crc32c_value "" HAVE_CRC32C)
 check_library_exists(snappy snappy_compress "" HAVE_SNAPPY)
 
 include(CheckSymbolExists)
 check_symbol_exists(fdatasync "unistd.h" HAVE_FDATASYNC)
 
 configure_file(
   port/port_config.h.cmake.in
   include/port/port_config.h
 )
 
 include_directories(.)
 
 add_library(leveldb
 	db/builder.cc
 	db/c.cc
 	db/dbformat.cc
 	db/db_impl.cc
 	db/db_iter.cc
 	db/dumpfile.cc
 	db/filename.cc
 	db/log_reader.cc
 	db/log_writer.cc
 	db/memtable.cc
 	db/repair.cc
 	db/table_cache.cc
 	db/version_edit.cc
 	db/version_set.cc
 	db/write_batch.cc
 	table/block_builder.cc
 	table/block.cc
 	table/filter_block.cc
 	table/format.cc
 	table/iterator.cc
 	table/merger.cc
 	table/table_builder.cc
 	table/table.cc
 	table/two_level_iterator.cc
 	util/arena.cc
 	util/bloom.cc
 	util/cache.cc
 	util/coding.cc
 	util/comparator.cc
 	util/crc32c.cc
 	util/env.cc
 	util/env_posix.cc
 	util/filter_policy.cc
 	util/hash.cc
 	util/histogram.cc
 	util/logging.cc
 	util/options.cc
 	util/status.cc
 
 	# Always include that guy even when not using SSE or posix.
 	# TODO: proper support of SSE.
 	port/port_posix_sse.cc
 )
 
 target_include_directories(leveldb
 	PUBLIC
 		include
 		"${PROJECT_BINARY_DIR}/include"
 )
 
 # Select the proper port: posix or Windows.
 if(${CMAKE_SYSTEM_NAME} MATCHES "Windows")
 	set(LEVELDB_PLATFORM WINDOWS)
 	set(LEVELDB_OS WINDOWS)
 	target_sources(leveldb
 		PRIVATE
 			util/env_win.cc
 			port/port_win.cc
 	)
 	target_compile_definitions(leveldb
 		PRIVATE
 			WINVER=0x0500
 			__USE_MINGW_ANSI_STDIO=1
 	)
 
 	find_package(SHLWAPI REQUIRED)
 	target_link_libraries(leveldb ${SHLWAPI_LIBRARY})
 	target_include_directories(leveldb PUBLIC ${SHLWAPI_INCLUDE_DIR})
 else()
 	set(LEVELDB_PLATFORM POSIX)
 	target_sources(leveldb
 		PRIVATE
 			port/port_posix.cc
 	)
 
 	set(THREADS_PREFER_PTHREAD_FLAG ON)
 	find_package(Threads REQUIRED)
 	target_link_libraries(leveldb Threads::Threads)
 
 	# TODO: If the plateform supports SSE4.2 activate
 	# LEVELDB_PLATFORM_POSIX_SSE and the proper compiler flags.
 
 	if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
 		set(LEVELDB_OS LINUX)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
 		set(LEVELDB_OS MACOSX)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "(Solaris|SunOS)")
 		set(LEVELDB_OS SOLARIS)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD")
 		set(LEVELDB_OS FREEBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "NetBSD")
 		set(LEVELDB_OS NETBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD")
 		set(LEVELDB_OS OPENBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "DragonFly")
 		set(LEVELDB_OS DRAGONFLYBSD)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "Android")
 		set(LEVELDB_OS ANDROID)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "HPUX")
 		# No idea what's the proper system name is here.
 		set(LEVELDB_OS HPUX)
 	elseif(${CMAKE_SYSTEM_NAME} MATCHES "iOS")
 		# No idea what's the proper system name is here.
 		set(LEVELDB_OS IOS)
 	else()
 		set(LEVELDB_OS LINUX)
 	endif()
 endif()
 
 target_compile_definitions(leveldb
 	PUBLIC
 		OS_${LEVELDB_OS}
 		LEVELDB_PLATFORM_${LEVELDB_PLATFORM}
 )
 
 # Right now this is not used but the latest version of leveldb uses this
 # so we might as well be ready for it.
 if (HAVE_CRC32C)
   target_link_libraries(leveldb crc32c)
 endif (HAVE_CRC32C)
 if (HAVE_SNAPPY)
   target_link_libraries(leveldb snappy)
 endif (HAVE_SNAPPY)
 
 # The libmemenv library.
 add_library(memenv helpers/memenv/memenv.cc)
 target_include_directories(memenv PUBLIC include)
 target_compile_definitions(memenv
 	PUBLIC
 		OS_${LEVELDB_OS}
 		LEVELDB_PLATFORM_${LEVELDB_PLATFORM}
 )
 
 option(LEVELDB_BUILD_TESTS "Build LevelDB's unit tests" ON)
 if(LEVELDB_BUILD_TESTS)
-	enable_testing()
+	include(TestSuite)
+	create_test_suite(leveldb)
 
 	add_library(leveldb_test_base
+		EXCLUDE_FROM_ALL
 		util/testharness.cc
 		util/testutil.cc
 	)
 
 	target_link_libraries(leveldb_test_base leveldb)
 
 	function(create_leveldb_test NAME FILES)
-		add_executable(${NAME} ${FILES})
+		add_test_to_suite(leveldb ${NAME} EXCLUDE_FROM_ALL ${FILES})
 		target_link_libraries(${NAME} leveldb_test_base)
-		add_test(NAME ${NAME} COMMAND ${NAME})
 	endfunction()
 
 	create_leveldb_test(autocompact_test db/autocompact_test.cc)
 	create_leveldb_test(corruption_test db/corruption_test.cc)
 	create_leveldb_test(db_test db/db_test.cc)
 	create_leveldb_test(dbformat_test db/dbformat_test.cc)
 	create_leveldb_test(fault_injection_test db/fault_injection_test.cc)
 	create_leveldb_test(filename_test db/filename_test.cc)
 	create_leveldb_test(log_test db/log_test.cc)
 	create_leveldb_test(recovery_test db/recovery_test.cc)
 	create_leveldb_test(skiplist_test db/skiplist_test.cc)
 	create_leveldb_test(version_edit_test db/version_edit_test.cc)
 	create_leveldb_test(version_set_test db/version_set_test.cc)
 	create_leveldb_test(write_batch_test db/write_batch_test.cc)
 	create_leveldb_test(issue178_test issues/issue178_test.cc)
 	create_leveldb_test(issue200_test issues/issue200_test.cc)
 	create_leveldb_test(filter_block_test table/filter_block_test.cc)
 	create_leveldb_test(table_test table/table_test.cc)
 	create_leveldb_test(arena_test util/arena_test.cc)
 	create_leveldb_test(bloom_test util/bloom_test.cc)
 	create_leveldb_test(cache_test util/cache_test.cc)
 	create_leveldb_test(coding_test util/coding_test.cc)
 	create_leveldb_test(crc32c_test util/crc32c_test.cc)
 	create_leveldb_test(env_test util/env_test.cc)
 	create_leveldb_test(hash_test util/hash_test.cc)
 
 	create_leveldb_test(memenv_test helpers/memenv/memenv_test.cc)
 	target_link_libraries(memenv_test memenv)
 
 	# These tests only work on posix
 	if(${LEVELDB_PLATFORM} MATCHES "POSIX")
 		create_leveldb_test(c_test db/c_test.c)
 		create_leveldb_test(env_posix_test util/env_posix_test.cc)
 	endif()
 endif(LEVELDB_BUILD_TESTS)
diff --git a/src/secp256k1/CMakeLists.txt b/src/secp256k1/CMakeLists.txt
index c01ee3fbf..e6e42a813 100644
--- a/src/secp256k1/CMakeLists.txt
+++ b/src/secp256k1/CMakeLists.txt
@@ -1,110 +1,110 @@
 # Copyright (c) 2017 The Bitcoin developers
 
 cmake_minimum_required(VERSION 3.1)
 project(secp256k1)
 
 # libsecp256k1 use a different set of flags.
 add_compiler_flag(
 	-pedantic
 	-Wshadow
 	-Wno-unused-function
 	-Wno-nonnull
 	-Wno-nonnull-compare
 )
 
 # TODO: change this to include when possible
 include_directories(
 	.
 	src
 	# For the config
 	${CMAKE_CURRENT_BINARY_DIR}/src
 )
 
 # The library
 add_library(secp256k1 src/secp256k1.c)
 target_include_directories(secp256k1 PUBLIC include)
 
 # We need to link in GMP
 find_package(GMP)
 if(GMP_FOUND)
 	target_include_directories(secp256k1 PUBLIC ${GMP_INCLUDE_DIR})
 	target_link_libraries(secp256k1 ${GMP_LIBRARIES})
 	set(USE_NUM_GMP 1)
 	set(USE_FIELD_INV_NUM 1)
 	set(USE_SCALAR_INV_NUM 1)
 else()
 	set(USE_NUM_NONE 1)
 	set(USE_FIELD_INV_BUILTIN 1)
 	set(USE_SCALAR_INV_BUILTIN 1)
 endif()
 
 # We make sure __int128 is defined
 include(CheckTypeSize)
 check_type_size(__int128 SIZEOF___INT128)
 if(SIZEOF___INT128 EQUAL 16)
 	set(HAVE___INT128 1)
 else()
 	# If we do not support __int128, we should be falling back
 	# on 32bits implementations for field and scalar.
 endif()
 
 # Detect if we are on a 32 or 64 bits plateform and chose
 # scalar and filed implementation accordingly
 if(CMAKE_SIZEOF_VOID_P EQUAL 8)
 	# 64 bits implementationr require either __int128 or asm support.
 	# TODO: support asm.
 	if(NOT SIZEOF___INT128 EQUAL 16)
 		message(SEND_ERROR "Compiler does not support __int128")
 	endif()
 
 	set(USE_SCALAR_4X64 1)
 	set(USE_FIELD_5X52 1)
 else()
 	set(USE_SCALAR_8X32 1)
 	set(USE_FIELD_10X26 1)
 endif()
 
 # Recovery module
 option(SECP256K1_ENABLE_MODULE_RECOVERY "Build libsecp256k1's recovery module" ON)
 if(SECP256K1_ENABLE_MODULE_RECOVERY)
 	set(ENABLE_MODULE_RECOVERY 1)
 
 	#TODO: recovery benchmark
 endif()
 
 # ECDH module
 option(SECP256K1_ENABLE_MODULE_ECDH "Build libsecp256k1's ECDH module" OFF)
 if(SECP256K1_ENABLE_MODULE_ECDH)
 	set(ENABLE_MODULE_ECDH 1)
 
 	#TODO: ECDH benchmark
 endif()
 
 # Generate the config
 configure_file(src/libsecp256k1-config.h.cmake.in src/libsecp256k1-config.h ESCAPE_QUOTES)
 target_compile_definitions(secp256k1 PRIVATE HAVE_CONFIG_H)
 
 # Tests
 option(SECP256K1_BUILD_TEST "Build secp256k1's unit tests" ON)
 if(SECP256K1_BUILD_TEST)
-	enable_testing()
+	include(TestSuite)
+	create_test_suite(secp256k1)
 
 	function(create_secp256k1_test NAME FILES)
-		add_executable(${NAME} ${FILES})
+		add_test_to_suite(secp256k1 ${NAME} EXCLUDE_FROM_ALL ${FILES})
 		target_link_libraries(${NAME} secp256k1)
-		add_test(NAME ${NAME} COMMAND ${NAME})
 		target_compile_definitions(${NAME} PRIVATE HAVE_CONFIG_H)
 	endfunction()
 
 	create_secp256k1_test(secp256k1_tests src/tests.c)
 	target_compile_definitions(secp256k1_tests PRIVATE VERIFY)
 
 	create_secp256k1_test(exhaustive_tests src/tests_exhaustive.c)
 	# This should not be enabled at the same time as coverage is.
 	# TODO: support coverage.
 	target_compile_definitions(exhaustive_tests PRIVATE VERIFY)
 endif(SECP256K1_BUILD_TEST)
 
 # TODO: emult static precomputation
 # TODO: ecdh module
 # TODO: RECOVERY module
diff --git a/src/test/CMakeLists.txt b/src/test/CMakeLists.txt
index f679680f6..2b3781739 100644
--- a/src/test/CMakeLists.txt
+++ b/src/test/CMakeLists.txt
@@ -1,149 +1,153 @@
 # Copyright (c) 2018 The Bitcoin developers
 
 project(bitcoin-test)
 
 # Process json files.
 find_program(HEXDUMP "hexdump")
 find_program(SED "sed")
 function(gen_json_header NAME)
 	set(HEADERS "")
 	foreach(f ${ARGN})
 		set(hex "${CMAKE_CURRENT_BINARY_DIR}/${f}.hex")
 		set(h "${CMAKE_CURRENT_BINARY_DIR}/${f}.h")
 		add_custom_command(OUTPUT ${hex}
 			COMMAND ${HEXDUMP}
 			ARGS
 				-v
 				-e "8/1 \"0x%02x, \""
 				-e "\"\\n\""
 				"${CMAKE_CURRENT_SOURCE_DIR}/${f}" > ${hex}
 			MAIN_DEPENDENCY ${f}
 			VERBATIM
 		)
 		# Get the proper name for the test variable.
 		get_filename_component(TEST_NAME ${f} NAME_WE)
 		add_custom_command(OUTPUT ${h}
 			COMMAND ${SED}
 			ARGS
 				-e "s/0x  ,//g"
 				-e "1 s/^/namespace json_tests{\\nstatic unsigned const char ${TEST_NAME}[] = {\\n/"
 				-e "\${s:\$:\\n\\};\\n\\}; // namespace json_tests:}"
 				< ${hex} > ${h}
 			MAIN_DEPENDENCY ${hex}
 			VERBATIM
 		)
 		list(APPEND HEADERS ${h})
 	endforeach(f)
 	set(${NAME} "${HEADERS}" PARENT_SCOPE)
 endfunction()
 
 gen_json_header(JSON_HEADERS
 	data/script_tests.json
 	data/base58_keys_valid.json
 	data/base58_encode_decode.json
 	data/base58_keys_invalid.json
 	data/tx_invalid.json
 	data/tx_valid.json
 	data/sighash.json
 )
 
-add_executable(test_bitcoin
+include(TestSuite)
+create_test_suite(bitcoin)
+add_dependencies(check check-bitcoin)
+
+add_test_to_suite(bitcoin test_bitcoin
 	arith_uint256_tests.cpp
 	addrman_tests.cpp
 	amount_tests.cpp
 	allocator_tests.cpp
 	base32_tests.cpp
 	base58_tests.cpp
 	base64_tests.cpp
 	bip32_tests.cpp
 	blockcheck_tests.cpp
 	blockencodings_tests.cpp
 	bloom_tests.cpp
 	bswap_tests.cpp
 	cashaddr_tests.cpp
 	cashaddrenc_tests.cpp
 	coins_tests.cpp
 	compress_tests.cpp
 	config_tests.cpp
 	crypto_tests.cpp
 	cuckoocache_tests.cpp
 	dbwrapper_tests.cpp
 	DoS_tests.cpp
 	dstencode_tests.cpp
 	excessiveblock_tests.cpp
 	getarg_tests.cpp
 	hash_tests.cpp
 	inv_tests.cpp
 	jsonutil.cpp
 	key_tests.cpp
 	limitedmap_tests.cpp
 	main_tests.cpp
 	mempool_tests.cpp
 	merkle_tests.cpp
 	miner_tests.cpp
 	monolith_opcodes.cpp
 	multisig_tests.cpp
 	net_tests.cpp
 	netbase_tests.cpp
 	pmt_tests.cpp
 	policyestimator_tests.cpp
 	pow_tests.cpp
 	prevector_tests.cpp
 	raii_event_tests.cpp
 	random_tests.cpp
 	reverselock_tests.cpp
 	rpc_tests.cpp
 	sanity_tests.cpp
 	scheduler_tests.cpp
 	script_antireplay_tests.cpp
 	script_P2SH_tests.cpp
 	script_tests.cpp
 	script_sighashtype_tests.cpp
 	scriptflags.cpp
 	scriptnum_tests.cpp
 	serialize_tests.cpp
 	sighash_tests.cpp
 	sigopcount_tests.cpp
 	sigutil.cpp
 	skiplist_tests.cpp
 	streams_tests.cpp
 	test_bitcoin.cpp
 	test_bitcoin_main.cpp
 	testutil.cpp
 	timedata_tests.cpp
 	transaction_tests.cpp
 	txvalidationcache_tests.cpp
 	versionbits_tests.cpp
 	uint256_tests.cpp
 	undo_tests.cpp
 	univalue_tests.cpp
 	util_tests.cpp
 	validation_tests.cpp
 
 	# Tests generated from JSON
 	${JSON_HEADERS}
 )
 
 target_include_directories(test_bitcoin
 	PUBLIC
 		# To access the generated json headers.
 		${CMAKE_CURRENT_BINARY_DIR}
 )
 
 find_package(Boost 1.58 REQUIRED unit_test_framework)
 
 target_link_libraries(test_bitcoin Boost::unit_test_framework rpcclient server)
 
 # FIXME: We need to detect if that flag is required. For now assume it is.
 target_compile_definitions(test_bitcoin PRIVATE BOOST_TEST_DYN_LINK)
 
 if(BUILD_BITCOIN_WALLET)
 	target_sources(test_bitcoin
 		PRIVATE
 			../wallet/test/wallet_test_fixture.cpp
 			../wallet/test/accounting_tests.cpp
 			../wallet/test/wallet_tests.cpp
 			../wallet/test/walletdb_tests.cpp
 			../wallet/test/crypto_tests.cpp
 	)
 endif()
diff --git a/src/univalue/CMakeLists.txt b/src/univalue/CMakeLists.txt
index 001dd933c..8a048cb90 100644
--- a/src/univalue/CMakeLists.txt
+++ b/src/univalue/CMakeLists.txt
@@ -1,60 +1,59 @@
 # Copyright (c) 2017 The Bitcoin developers
 
 cmake_minimum_required(VERSION 3.1)
 project(univalue)
 
 option(UNIVALUE_BUILD_TESTS "Build univalue's unit tests" ON)
 
 # TODO: Version info
 add_library(univalue
 	lib/univalue.cpp
 	lib/univalue_get.cpp
 	lib/univalue_read.cpp
 	lib/univalue_write.cpp
 )
 
 target_include_directories(univalue
 	PUBLIC
 		include
 	PRIVATE
 		lib
 )
 
 if(UNIVALUE_BUILD_TESTS)
-	enable_testing()
+	include(TestSuite)
+	create_test_suite(univalue)
 
-	add_executable(unitester_test test/unitester.cpp)
-	add_test(NAME unitester_test COMMAND unitester_tests)
-	target_link_libraries(unitester_test univalue)
+	function(create_univalue_test NAME FILES)
+		add_test_to_suite(univalue ${NAME} ${FILES})
+		target_link_libraries(${NAME} univalue)
+	endfunction()
 
+	create_univalue_test(unitester_test test/unitester.cpp)
 	target_compile_definitions(unitester_test
 		PUBLIC JSON_TEST_SRC="${PROJECT_SOURCE_DIR}/test"
 	)
 
-	add_executable(json_test test/test_json.cpp)
-	add_test(NAME json_test COMMAND json_test)
-	target_link_libraries(json_test univalue)
-
-	add_executable(no_nul_test test/no_nul.cpp)
-	add_test(NAME no_nul_test COMMAND no_nul_test)
-	target_link_libraries(no_nul_test univalue)
+	create_univalue_test(no_nul_test test/no_nul.cpp)
+	create_univalue_test(object_test test/object.cpp)
 
-	add_executable(object_test test/object.cpp)
-	add_test(NAME object_test COMMAND object_test)
-	target_link_libraries(object_test univalue)
+	# test_json is not meant to run in an automated test suite.
+	add_executable(json_test EXCLUDE_FROM_ALL test/test_json.cpp)
+	target_link_libraries(json_test univalue)
+	add_dependencies(check-univalue json_test)
 endif(UNIVALUE_BUILD_TESTS)
 
 # Generate lib/univalue_escapes.h
 add_executable(univalue_gen gen/gen.cpp)
 target_include_directories(univalue_gen PUBLIC include)
 
 file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/lib)
 add_custom_command(
 	OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/lib/univalue_escapes.h
 	COMMAND univalue_gen > ${CMAKE_CURRENT_BINARY_DIR}/lib/univalue_escapes.h
 	DEPENDS univalue_gen ${CMAKE_CURRENT_SOURCE_DIR}/lib/univalue_escapes.h
 )
 add_custom_target(generate_univalue_escapes_h
 	DEPENDS
 		${CMAKE_CURRENT_BINARY_DIR}/lib/univalue_escapes.h
 )