#include <cassert>
#include <type_traits>

#include "freertos/heap_stats.hpp"

namespace
{

HeapStats_t raw {
    1200U,
    800U,
    400U,
    2U,
    600U,
    7U,
    4U
};

} // namespace

extern "C" void vPortGetHeapStats( HeapStats_t * stats )
{
    *stats = raw;
}

static_assert( std::is_trivially_copyable< freertos::HeapStats >::value );
static_assert( std::is_trivially_copyable< freertos::HeapWatermark >::value );

int main()
{
    const freertos::HeapStats sample = freertos::HeapStats::read();
    assert( sample.available_bytes == 1200U );
    assert( sample.largest_free_block == 800U );
    assert( sample.smallest_free_block == 400U );
    assert( sample.free_blocks == 2U );
    assert( sample.minimum_ever_free_bytes == 600U );
    assert( sample.successful_allocations == 7U );
    assert( sample.successful_frees == 4U );
    assert( sample.has_multiple_free_blocks() );
    assert( sample.total_exceeds_largest() );

    const freertos::HeapStats baseline {
        1600U, 1600U, 1600U, 1U, 1500U, 1U, 1U };
    const freertos::HeapWatermark watermark { baseline };
    assert( watermark.baseline_bytes() == 1600U );
    assert( watermark.current_bytes_used( sample ) == 400U );
    assert( watermark.peak_bytes_used( sample ) == 1000U );
    assert( !watermark.recovered( sample ) );

    const freertos::HeapStats recovered {
        1600U, 1600U, 1600U, 1U, 600U, 8U, 8U };
    assert( watermark.recovered( recovered ) );
    assert( watermark.current_bytes_used( recovered ) == 0U );
    assert( watermark.peak_bytes_used( recovered ) == 1000U );
    return 0;
}