/* See LICENSE file for copyright and license details. */
#include "common.h"
#ifndef TEST

unsigned
liblog_logmask__(enum liblog_level least_verbose, enum liblog_level most_verbose)
{
	unsigned min, max;

	least_verbose = MAX(least_verbose, 0);
	least_verbose = MIN(least_verbose, LIBLOG_DEBUG);
	most_verbose = MAX(most_verbose, 0);
	most_verbose = MIN(most_verbose, LIBLOG_DEBUG);

	min = (unsigned)least_verbose / (unsigned)NEXT_LOGLEVEL(0);
	max = (unsigned)most_verbose  / (unsigned)NEXT_LOGLEVEL(0);

	if (min > max)
		return 0;

	min = 1U << min;
	max = 2U << max;
	return (max - 1U) ^ (min - 1U);
}

#else

static void
check_singletons(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_EMERGENCY), 0x0001);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_ALERT), 0x0002);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_CRITICAL), 0x0004);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_ERROR), 0x0008);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_WARNING), 0x0010);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_NOTICE), 0x0020);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_INFO), 0x0040);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_TRACE), 0x0080);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_DEBUG), 0x0100);
}

static void
check_custom(void)
{
	unsigned logmask = liblog_logmask__(LIBLOG_NOTICE + 1, LIBLOG_NOTICE + 1);
	ASSERT_IS_TRUE(logmask == 0x0020 || logmask == 0x0040);
}

static void
check_from_emergency(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_ALERT), 0x0003U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_CRITICAL), 0x0007U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_ERROR), 0x000FU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_WARNING), 0x001FU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_NOTICE), 0x003FU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_INFO), 0x007FU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_TRACE), 0x00FFU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_EMERGENCY, LIBLOG_DEBUG), 0x01FFU);
}

static void
check_from_alert(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_EMERGENCY), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_CRITICAL), 0x0006U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_ERROR), 0x000EU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_WARNING), 0x001EU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_NOTICE), 0x003EU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_INFO), 0x007EU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_TRACE), 0x00FEU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ALERT, LIBLOG_DEBUG), 0x01FEU);
}

static void
check_from_critical(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_EMERGENCY), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_ALERT), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_ERROR), 0x000CU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_WARNING), 0x001CU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_NOTICE), 0x003CU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_INFO), 0x007CU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_TRACE), 0x00FCU);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_CRITICAL, LIBLOG_DEBUG), 0x01FCU);
}

static void
check_from_error(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_EMERGENCY), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_ALERT), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_CRITICAL), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_WARNING), 0x0018U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_NOTICE), 0x0038U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_INFO), 0x0078U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_TRACE), 0x00F8U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_ERROR, LIBLOG_DEBUG), 0x01F8U);
}

static void
check_from_warning(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_EMERGENCY), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_ALERT), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_CRITICAL), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_ERROR), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_NOTICE), 0x0030U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_INFO), 0x0070U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_TRACE), 0x00F0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_WARNING, LIBLOG_DEBUG), 0x01F0U);
}

static void
check_from_notice(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_EMERGENCY), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_ALERT), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_CRITICAL), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_ERROR), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_WARNING), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_INFO), 0x0060U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_TRACE), 0x00E0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_NOTICE, LIBLOG_DEBUG), 0x01E0U);
}

static void
check_from_info(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_EMERGENCY), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_ALERT), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_CRITICAL), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_ERROR), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_WARNING), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_NOTICE), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_TRACE), 0x00C0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_INFO, LIBLOG_DEBUG), 0x01C0U);
}

static void
check_from_trace(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_EMERGENCY), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_ALERT), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_CRITICAL), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_ERROR), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_WARNING), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_NOTICE), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_INFO), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_TRACE, LIBLOG_DEBUG), 0x0180U);
}

static void
check_from_debug(void)
{
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_EMERGENCY), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_ALERT), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_CRITICAL), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_ERROR), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_WARNING), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_NOTICE), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_INFO), 0U);
	ASSERT_EQ_UINT(liblog_logmask__(LIBLOG_DEBUG, LIBLOG_TRACE), 0U);
}

static void
check_negative(void)
{
	if ((enum liblog_level)-1 < 0)
		ASSERT_EQ_UINT(liblog_logmask__((enum liblog_level)-10, (enum liblog_level)-10), 1U);
}

static void
check_hyperverbose(void)
{
	ASSERT_EQ_UINT(liblog_logmask__((enum liblog_level)0x7FFF, (enum liblog_level)0x7FFF), 0x0100U);
}

int
main(void)
{
	check_singletons();
	check_custom();
	check_from_emergency();
	check_from_alert();
	check_from_critical();
	check_from_error();
	check_from_warning();
	check_from_notice();
	check_from_info();
	check_from_trace();
	check_from_debug();
	check_negative();
	check_hyperverbose();
	return 0;
}

#endif