# makefile of pianobar

# Version is defined in src/config.h only (do not pass -DVERSION from here).

PKG_CONFIG?=pkg-config
PREFIX:=/usr/local
BINDIR:=${PREFIX}/bin
LIBDIR:=${PREFIX}/lib
INCDIR:=${PREFIX}/include
MANDIR:=${PREFIX}/share/man
LOCALEDIR:=${PREFIX}/share/pianobar/locale
DYNLINK:=0
CFLAGS?=-O2 -DNDEBUG

# Runtime debug categories (debug=N in config, PIANOBAR_DEBUG env) unless MINIMAL=1.
# Mask 0 means no DEBUG_* output. Keeps -DNDEBUG for asserts in release builds.
ifndef MINIMAL
override CFLAGS+=-DHAVE_DEBUGLOG
endif

# Feature test macros for POSIX/BSD/GNU functions (flock, usleep, clock_gettime, etc.)
# Use 'override' so these are always included even when CFLAGS is set on command line
override CFLAGS+=-D_GNU_SOURCE -D_POSIX_C_SOURCE=200809L -D_DEFAULT_SOURCE -D_DARWIN_C_SOURCE

ifeq (${CC},cc)
	OS := $(shell uname)
	ifeq (${OS},Darwin)
		CC:=gcc
	else ifeq (${OS},FreeBSD)
		CC:=cc
	else ifeq (${OS},OpenBSD)
		CC:=cc
	else
		CC:=cc
	endif
endif

# Default ISO C17 unless the caller already set a dialect in CFLAGS (e.g. -std=gnu11).
ifeq ($(findstring -std=,$(CFLAGS)),)
override CFLAGS+=-std=c17
endif

PIANOBAR_DIR:=src
# Third-party miniaudio wrapper: omit from cppcheck (vendored, multi-config noise)
PIANOBAR_LINT_C:=$(filter-out ${PIANOBAR_DIR}/miniaudio_impl.c,$(wildcard ${PIANOBAR_DIR}/*.c))
LOCALE_YAML:=$(wildcard locale/*.yaml)
LOCALE_GEN_MARKER:=${PIANOBAR_DIR}/l10n_defaults_gen.c
# Updated when codegen runs; avoids re-running Python on every `make locale-codegen` (e.g. after
# root `make`, webui `npm run prebuild` only prints GEN if YAML/script changed).
LOCALE_CODEGEN_STAMP:=.locale-codegen.stamp
PIANOBAR_SRC:=\
		${PIANOBAR_DIR}/main.c \
		${PIANOBAR_DIR}/interrupt.c \
		${PIANOBAR_DIR}/playback_lifecycle.c \
		${PIANOBAR_DIR}/log.c \
		${PIANOBAR_DIR}/miniaudio_impl.c \
		${PIANOBAR_DIR}/parse_utils.c \
		${PIANOBAR_DIR}/player.c \
		${PIANOBAR_DIR}/bar_state.c \
		${PIANOBAR_DIR}/playback_manager.c \
		${PIANOBAR_DIR}/settings.c \
		${PIANOBAR_DIR}/l10n.c \
		${PIANOBAR_DIR}/l10n_defaults_gen.c \
		${PIANOBAR_DIR}/station_display.c \
		${PIANOBAR_DIR}/station_sort.c \
		${PIANOBAR_DIR}/terminal.c \
		${PIANOBAR_DIR}/ui_act.c \
		${PIANOBAR_DIR}/ui.c \
		${PIANOBAR_DIR}/ui_readline.c \
		${PIANOBAR_DIR}/ui_dispatch.c \
		${PIANOBAR_DIR}/websocket_bridge.c \
		${PIANOBAR_DIR}/system_volume.c

# WebSocket support (enabled by default, use NOWEBSOCKET=1 to disable)
WEBSOCKET_DIR:=src/websocket
ifneq ($(NOWEBSOCKET),1)
	PIANOBAR_SRC+=\
		${WEBSOCKET_DIR}/core/websocket.c \
		${WEBSOCKET_DIR}/core/websocket_lws_log.c \
		${WEBSOCKET_DIR}/core/queue.c \
		${WEBSOCKET_DIR}/http/http_server.c \
		${WEBSOCKET_DIR}/protocol/socketio.c \
		${WEBSOCKET_DIR}/protocol/error_messages.c \
		${WEBSOCKET_DIR}/daemon/daemon.c
endif

PIANOBAR_OBJ:=${PIANOBAR_SRC:.c=.o}

LIBPIANO_DIR:=src/libpiano
LIBPIANO_SRC:=\
		${LIBPIANO_DIR}/crypt.c \
		${LIBPIANO_DIR}/piano.c \
		${LIBPIANO_DIR}/request.c \
		${LIBPIANO_DIR}/response.c \
		${LIBPIANO_DIR}/list.c
LIBPIANO_OBJ:=${LIBPIANO_SRC:.c=.o}
LIBPIANO_RELOBJ:=${LIBPIANO_SRC:.c=.lo}
LIBPIANO_INCLUDE:=${LIBPIANO_DIR}

LIBAV_CFLAGS:=$(shell $(PKG_CONFIG) --cflags libavcodec libavformat libavutil libavfilter)
LIBAV_LDFLAGS:=$(shell $(PKG_CONFIG) --libs libavcodec libavformat libavutil libavfilter)

LIBCURL_CFLAGS:=$(shell $(PKG_CONFIG) --cflags libcurl)
LIBCURL_LDFLAGS:=$(shell $(PKG_CONFIG) --libs libcurl)

LIBGCRYPT_CFLAGS:=$(shell $(PKG_CONFIG) --cflags libgcrypt)
LIBGCRYPT_LDFLAGS:=$(shell $(PKG_CONFIG) --libs libgcrypt)

LIBJSONC_CFLAGS:=$(shell $(PKG_CONFIG) --cflags json-c 2>/dev/null || $(PKG_CONFIG) --cflags json)
LIBJSONC_LDFLAGS:=$(shell $(PKG_CONFIG) --libs json-c 2>/dev/null || $(PKG_CONFIG) --libs json)

# miniaudio is header-only, no linking required

# System volume control - platform-specific
OS := $(shell uname)
ifeq (${OS},Darwin)
	# macOS - CoreAudio is always available (requires macOS 12.0+)
	SYSVOLUME_LDFLAGS:=-framework CoreAudio -framework AudioToolbox
	CFLAGS+=-mmacosx-version-min=12.0 -DMAC_OS_X_VERSION_MAX_ALLOWED=260000 -DMAC_OS_VERSION_12_0=120000
	# macOS does not need BLAS/LAPACK
	BLAS_LAPACK_LDFLAGS:=
else ifeq (${OS},Linux)
	# Linux - try PulseAudio library, always link ALSA for fallback
	HAVE_PULSEAUDIO:=$(shell $(PKG_CONFIG) --exists libpulse && echo yes)
	ifeq (${HAVE_PULSEAUDIO},yes)
		SYSVOLUME_CFLAGS:=$(shell $(PKG_CONFIG) --cflags libpulse) -DHAVE_PULSEAUDIO
		SYSVOLUME_LDFLAGS:=$(shell $(PKG_CONFIG) --libs libpulse)
	endif
	# Always link ALSA on Linux (for native API fallback)
	SYSVOLUME_LDFLAGS+=$(shell $(PKG_CONFIG) --libs alsa)
	# BLAS/LAPACK required by libsphinxbase (transitive dep of FFmpeg/PulseAudio)
	BLAS_LAPACK_LDFLAGS:=-lblas -llapack
endif

# WebSocket library flags (unless disabled)
ifneq ($(NOWEBSOCKET),1)
	LIBWEBSOCKETS_CFLAGS:=$(shell $(PKG_CONFIG) --cflags libwebsockets openssl)
	LIBWEBSOCKETS_LDFLAGS:=$(shell $(PKG_CONFIG) --libs libwebsockets openssl)
endif

# Check unit-test framework (always, so NOWEBSOCKET=1 tests can run)
CHECK_CFLAGS:=$(shell $(PKG_CONFIG) --cflags check 2>/dev/null)
CHECK_LDFLAGS:=$(shell $(PKG_CONFIG) --libs check 2>/dev/null)

# First real rule was locale-codegen; without this, bare `make` only runs codegen and
# never builds pianobar. Default goal must be the binary (locale-codegen is a dep of pianobar).
.DEFAULT_GOAL := pianobar

$(LOCALE_CODEGEN_STAMP): $(LOCALE_YAML) scripts/locale_codegen.py
	@echo "  GEN   locale catalogs"
	@python3 scripts/locale_codegen.py --repo-root .
	@touch $(LOCALE_CODEGEN_STAMP)

.PHONY: locale-codegen
locale-codegen: $(LOCALE_CODEGEN_STAMP)

.PHONY: locale-check-sync
locale-check-sync:
	python3 scripts/check_locale_sync.py

# combine all flags
ALL_CFLAGS:=${CFLAGS} -I ${LIBPIANO_INCLUDE} \
			${LIBAV_CFLAGS} ${LIBCURL_CFLAGS} \
			${LIBGCRYPT_CFLAGS} ${LIBJSONC_CFLAGS} \
			${SYSVOLUME_CFLAGS}
ALL_LDFLAGS:=${LDFLAGS} -lpthread -lm \
		${LIBAV_LDFLAGS} ${LIBCURL_LDFLAGS} \
		${LIBGCRYPT_LDFLAGS} ${LIBJSONC_LDFLAGS} \
		${SYSVOLUME_LDFLAGS} ${BLAS_LAPACK_LDFLAGS}

# Add WebSocket flags (unless disabled)
ifneq ($(NOWEBSOCKET),1)
	ALL_CFLAGS+=-DWEBSOCKET_ENABLED ${LIBWEBSOCKETS_CFLAGS}
	ALL_LDFLAGS+=${LIBWEBSOCKETS_LDFLAGS}
endif

# Be verbose if V=1 (gnu autotools’ --disable-silent-rules)
SILENTCMD:=@
SILENTECHO:=@echo
ifeq (${V},1)
	SILENTCMD:=
	SILENTECHO:=@true
endif

# build pianobar
ifeq (${DYNLINK},1)
pianobar: locale-codegen ${PIANOBAR_OBJ} libpiano.so.0
	${SILENTECHO} "  LINK  $@"
	${SILENTCMD}${CC} -o $@ ${PIANOBAR_OBJ} -L. -lpiano ${ALL_LDFLAGS}
else
pianobar: locale-codegen ${PIANOBAR_OBJ} ${LIBPIANO_OBJ}
	${SILENTECHO} "  LINK  $@"
	${SILENTCMD}${CC} -o $@ ${PIANOBAR_OBJ} ${LIBPIANO_OBJ} ${ALL_LDFLAGS}
endif

# build shared and static libpiano
libpiano.so.0: ${LIBPIANO_RELOBJ} ${LIBPIANO_OBJ}
	${SILENTECHO} "  LINK  $@"
	${SILENTCMD}${CC} -shared -Wl,-soname,libpiano.so.0 -o libpiano.so.0.0.0 \
			${LIBPIANO_RELOBJ} ${ALL_LDFLAGS}
	${SILENTCMD}ln -fs libpiano.so.0.0.0 libpiano.so.0
	${SILENTCMD}ln -fs libpiano.so.0 libpiano.so
	${SILENTECHO} "    AR  libpiano.a"
	${SILENTCMD}${AR} rcs libpiano.a ${LIBPIANO_OBJ}


-include $(PIANOBAR_SRC:.c=.d)
-include $(LIBPIANO_SRC:.c=.d)

# Test-specific compilation rules (must come before general %.o: %.c rule)
test/%.o: test/%.c
	${SILENTECHO} "    CC  $< (test)"
	${SILENTCMD}${CC} -c -o $@ ${ALL_CFLAGS} ${CHECK_CFLAGS} -MMD -MF $(@:.o=.d) -MP $<

test/unit/%.o: test/unit/%.c
	${SILENTECHO} "    CC  $< (test)"
	${SILENTCMD}${CC} -c -o $@ ${ALL_CFLAGS} ${CHECK_CFLAGS} -MMD -MF $(@:.o=.d) -MP $<

test/integration/%.o: test/integration/%.c
	${SILENTECHO} "    CC  $< (test)"
	${SILENTCMD}${CC} -c -o $@ ${ALL_CFLAGS} ${CHECK_CFLAGS} -MMD -MF $(@:.o=.d) -MP $<

# Special rule for miniaudio_impl.c - suppress deprecation warnings from third-party library
src/miniaudio_impl.o: src/miniaudio_impl.c
	${SILENTECHO} "    CC  $<"
	${SILENTCMD}${CC} -c -o $@ ${ALL_CFLAGS} -Wno-deprecated-declarations -MMD -MF $*.d -MP $<

# Ensure generated strings are up to date before compiling (safe with parallel -j).
${PIANOBAR_DIR}/l10n_defaults_gen.o: $(LOCALE_CODEGEN_STAMP)

# build standard object files
%.o: %.c
	${SILENTECHO} "    CC  $<"
	${SILENTCMD}${CC} -c -o $@ ${ALL_CFLAGS} -MMD -MF $*.d -MP $<

# create position independent code (for shared libraries)
%.lo: %.c
	${SILENTECHO} "    CC  $< (PIC)"
	${SILENTCMD}${CC} -c -fPIC -o $@ ${ALL_CFLAGS} -MMD -MF $*.d -MP $<

clean:
	${SILENTECHO} " CLEAN"
	${SILENTCMD}${RM} ${PIANOBAR_OBJ} ${LIBPIANO_OBJ} \
			${LIBPIANO_RELOBJ} pianobar libpiano.so* \
			libpiano.a $(PIANOBAR_SRC:.c=.d) $(LIBPIANO_SRC:.c=.d) \
			$(LOCALE_CODEGEN_STAMP) \
			$(BASE_TEST_SRC:.c=.o) $(WS_TEST_SRC:.c=.o) \
			$(BASE_TEST_SRC:.c=.d) $(WS_TEST_SRC:.c=.d) \
			${TEST_BIN}

distclean: clean
	${SILENTECHO} " DISTCLEAN"
	${SILENTCMD}find . -name '*.gcda' -delete
	${SILENTCMD}find . -name '*.gcno' -delete
	${SILENTCMD}find . -name '*.gcov' -delete

all: pianobar
	@echo "Build complete. Running tests..."
	@${MAKE} test

.PHONY: minimal
minimal:
	@$(MAKE) MINIMAL=1 pianobar

ifeq (${DYNLINK},1)
install: pianobar install-libpiano
else
install: pianobar
endif
	install -d ${DESTDIR}${BINDIR}/
	install -m755 pianobar ${DESTDIR}${BINDIR}/
	install -d ${DESTDIR}${MANDIR}/man1/
	install -m644 contrib/pianobar.1 ${DESTDIR}${MANDIR}/man1/
	install -d ${DESTDIR}${LOCALEDIR}/
	@for f in locale/*; do \
		case $$f in *.yaml) ;; *) test -f "$$f" && install -m644 "$$f" "${DESTDIR}${LOCALEDIR}/" ;; esac; \
	done

install-libpiano:
	install -d ${DESTDIR}${LIBDIR}/
	install -m644 libpiano.so.0.0.0 ${DESTDIR}${LIBDIR}/
	ln -fs libpiano.so.0.0.0 ${DESTDIR}${LIBDIR}/libpiano.so.0
	ln -fs libpiano.so.0 ${DESTDIR}${LIBDIR}/libpiano.so
	install -m644 libpiano.a ${DESTDIR}${LIBDIR}/
	install -d ${DESTDIR}${INCDIR}/
	install -m644 src/libpiano/piano.h ${DESTDIR}${INCDIR}/

uninstall:
	$(RM) ${DESTDIR}/${BINDIR}/pianobar \
	${DESTDIR}/${MANDIR}/man1/pianobar.1 \
	${DESTDIR}/${LIBDIR}/libpiano.so.0.0.0 \
	${DESTDIR}/${LIBDIR}/libpiano.so.0 \
	${DESTDIR}/${LIBDIR}/libpiano.so \
	${DESTDIR}/${LIBDIR}/libpiano.a \
	${DESTDIR}/${INCDIR}/piano.h

# Test suite: split into base (no WebSocket deps) and WS-only parts
TEST_DIR:=test
TEST_BIN:=pianobar_test

# Tests that build and run in both full and NOWEBSOCKET=1 configurations
BASE_TEST_SRC:=\
		${TEST_DIR}/test_main.c \
		${TEST_DIR}/unit/test_l10n.c \
		${TEST_DIR}/unit/test_settings.c \
		${TEST_DIR}/unit/test_player.c \
		${TEST_DIR}/unit/test_bar_state.c \
		${TEST_DIR}/unit/test_log.c \
		${TEST_DIR}/unit/test_playback_manager.c \
		${TEST_DIR}/unit/test_playback_lifecycle.c \
		${TEST_DIR}/unit/test_system_volume.c \
		${TEST_DIR}/unit/test_ui_readline.c \
		${TEST_DIR}/unit/test_ui.c \
		${TEST_DIR}/unit/test_station_sort.c \
		${TEST_DIR}/unit/test_interrupt.c \
		${TEST_DIR}/unit/test_libpiano_response.c

# Tests that require WebSocket objects
WS_TEST_SRC:=\
		${TEST_DIR}/unit/test_websocket.c \
		${TEST_DIR}/unit/test_http_server.c \
		${TEST_DIR}/unit/test_daemon.c \
		${TEST_DIR}/unit/test_socketio.c \
		${TEST_DIR}/unit/test_error_messages.c \
		${TEST_DIR}/unit/test_ui_act_reconnect.c \
		${TEST_DIR}/unit/test_ui_act_station.c \
		${TEST_DIR}/integration/fixture_http.c \
		${TEST_DIR}/integration/test_playback_integration.c

ifeq ($(NOWEBSOCKET),1)
TEST_SRC:=${BASE_TEST_SRC}
else
TEST_SRC:=${BASE_TEST_SRC} ${WS_TEST_SRC}
endif

TEST_OBJ:=${TEST_SRC:.c=.o}
-include $(TEST_OBJ:.o=.d)

# Objects common to both test variants (no WebSocket objects)
BASE_TEST_LINK_OBJ:=src/interrupt.o src/playback_lifecycle.o src/log.o src/miniaudio_impl.o src/parse_utils.o src/bar_state.o src/playback_manager.o src/websocket_bridge.o src/ui.o src/ui_act.o src/ui_dispatch.o src/ui_readline.o src/terminal.o src/player.o src/settings.o src/station_display.o src/station_sort.o src/system_volume.o src/l10n.o src/l10n_defaults_gen.o ${LIBPIANO_OBJ}

ifeq ($(NOWEBSOCKET),1)
# NOWEBSOCKET=1: link only base objects (no websocket/socketio/daemon/queue/http)
${TEST_BIN}: locale-codegen ${TEST_OBJ} ${BASE_TEST_LINK_OBJ}
	${SILENTECHO} "  LINK  $@"
	${SILENTCMD}${CC} -o $@ ${TEST_OBJ} ${BASE_TEST_LINK_OBJ} ${ALL_LDFLAGS} ${CHECK_LDFLAGS}
else
# Full WebSocket build: link all objects including WebSocket modules
${TEST_BIN}: locale-codegen ${TEST_OBJ} ${BASE_TEST_LINK_OBJ} ${WEBSOCKET_DIR}/core/websocket.o ${WEBSOCKET_DIR}/core/websocket_lws_log.o ${WEBSOCKET_DIR}/core/queue.o ${WEBSOCKET_DIR}/http/http_server.o ${WEBSOCKET_DIR}/protocol/socketio.o ${WEBSOCKET_DIR}/protocol/error_messages.o ${WEBSOCKET_DIR}/daemon/daemon.o
	${SILENTECHO} "  LINK  $@"
	${SILENTCMD}${CC} -o $@ ${TEST_OBJ} ${BASE_TEST_LINK_OBJ} ${WEBSOCKET_DIR}/core/websocket.o ${WEBSOCKET_DIR}/core/websocket_lws_log.o ${WEBSOCKET_DIR}/core/queue.o ${WEBSOCKET_DIR}/http/http_server.o ${WEBSOCKET_DIR}/protocol/socketio.o ${WEBSOCKET_DIR}/protocol/error_messages.o ${WEBSOCKET_DIR}/daemon/daemon.o ${ALL_LDFLAGS} ${CHECK_LDFLAGS}
endif

# Run tests
test: ${TEST_BIN}
	${SILENTECHO} "   TEST  Running test suite..."
	${SILENTCMD}./${TEST_BIN}

# Integration tests (local HTTP audio fixture + mocked Pandora playlist)
test-integration: ${TEST_BIN}
	${SILENTECHO} "   TEST  Running integration tests..."
	${SILENTCMD}PIANOBAR_INTEGRATION=1 PIANOBAR_TEST_NO_DEVICE=1 ./${TEST_BIN}

# Reproduce GitHub Actions c-tests in Docker (headless Ubuntu, no sound card)
test-ci-local:
	${SILENTECHO} "   TEST  Running CI-local Docker repro..."
	${SILENTCMD}chmod +x scripts/test-ci-local.sh && ./scripts/test-ci-local.sh

# Run static analysis (requires cppcheck)
# Suppressions: .cppcheck-suppress (miniaudio.h and project-specific false positives)
# PIANOBAR_LINT_C omits miniaudio_impl.c (vendored wrapper, noisy configs)
# Different cppcheck versions recognize different entries in the shared suppression list.
lint:
	${SILENTECHO} "   LINT  Running static analysis..."
	${SILENTCMD}cppcheck --enable=all --suppress=unmatchedSuppression --max-configs=3 --suppress=missingIncludeSystem --suppress=unusedFunction \
		--suppress=toomanyconfigs --suppress=normalCheckLevelMaxBranches --suppress=checkersReport \
		--inline-suppr --error-exitcode=1 --suppressions-list=.cppcheck-suppress \
		-I ${LIBPIANO_INCLUDE} ${PIANOBAR_LINT_C} ${LIBPIANO_DIR}/*.c

# Run linter on test files
lint-test:
	${SILENTECHO} "   LINT  Running static analysis on tests..."
	${SILENTCMD}cppcheck --enable=all --suppress=missingIncludeSystem \
		--inline-suppr --error-exitcode=1 \
		-I ${LIBPIANO_INCLUDE} -I ${PIANOBAR_DIR} ${TEST_DIR}/**/*.c ${TEST_DIR}/*.c

# Comprehensive test suite: unit tests + linting
test-all: test lint
	${SILENTECHO} "   TEST  All tests passed!"

# Build and run tests with coverage instrumentation
test-coverage: clean
	${SILENTECHO} "   TEST  Building with coverage instrumentation..."
	${SILENTCMD}${MAKE} ${TEST_BIN} CFLAGS="${CFLAGS} --coverage -g -O0" LDFLAGS="${LDFLAGS} --coverage"
	${SILENTECHO} "   TEST  Running test suite (CI parity: integration + headless audio)..."
	${SILENTCMD}PIANOBAR_INTEGRATION=1 PIANOBAR_TEST_NO_DEVICE=1 ./${TEST_BIN}
	${SILENTECHO} "   COV   Generating coverage report..."
	${SILENTCMD}lcov --capture --directory . --output-file coverage.info \
		--rc lcov_branch_coverage=1 --ignore-errors inconsistent,unused
	${SILENTCMD}lcov --remove coverage.info '/usr/*' '*/test/*' --output-file coverage.info \
		--rc lcov_branch_coverage=1 --ignore-errors inconsistent,unused
	${SILENTCMD}lcov --remove coverage.info '*l10n_defaults_gen.c' --output-file coverage.info \
		--rc lcov_branch_coverage=1 --ignore-errors inconsistent,unused
	${SILENTECHO} "   COV   Coverage report: coverage.info"

# Clean coverage files
coverage-clean:
	${SILENTECHO} " CLEAN  coverage"
	${SILENTCMD}find . -name '*.gcno' -delete
	${SILENTCMD}find . -name '*.gcda' -delete
	${SILENTCMD}${RM} coverage.info

# Clean test files
test-clean:
	${SILENTECHO} " CLEAN  tests"
	${SILENTCMD}${RM} ${TEST_OBJ} ${TEST_BIN}

# Run tests with memory leak detection using AddressSanitizer
# Full clean required so all code linked into the test binary is built with ASan (cf. test-coverage).
test-asan: clean clean-test-asan
	${SILENTECHO} "   TEST  Building with AddressSanitizer..."
	${SILENTCMD}${MAKE} ${TEST_BIN} CFLAGS="${CFLAGS} -fsanitize=address -fno-omit-frame-pointer -g" LDFLAGS="${LDFLAGS} -fsanitize=address"
	${SILENTECHO} "   TEST  Running test suite with memory leak detection..."
	${SILENTCMD}./${TEST_BIN}

clean-test-asan:
	${SILENTCMD}${RM} ${TEST_OBJ} ${TEST_BIN}

# Run tests with valgrind (Linux only, optional)
test-valgrind: ${TEST_BIN}
	${SILENTECHO} "   TEST  Running test suite with valgrind..."
	${SILENTCMD}valgrind --leak-check=full --show-leak-kinds=all --track-origins=yes --error-exitcode=1 ./${TEST_BIN}

.PHONY: install install-libpiano uninstall test test-integration test-ci-local test-all test-coverage coverage-clean lint lint-test test-clean test-asan clean-test-asan test-valgrind minimal all locale-codegen
