/*
 * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef TEST_CONTEXT_H
#define TEST_CONTEXT_H


#include <stdarg.h>
#include <stdio.h>

#include <KernelExport.h>

#include "TestOutput.h"


class Test;
class TestContext;
class TestError;


struct TestOptions {
                        bool                            panicOnFailure;
                        bool                            quitAfterFailure;

        public:
                                                                TestOptions();
};


struct GlobalTestContext {
                                                                GlobalTestContext(TestOutput& output,
                                                                        TestOptions& options);
                                                                ~GlobalTestContext();

        static  GlobalTestContext*      Current();

                        TestOutput&                     Output() const  { return fOutput; }
                        TestOptions&            Options() const { return fOptions; }

                        TestContext*            CurrentContext() const
                                                                        { return fCurrentContext; }
                        void                            SetCurrentContext(TestContext* context);

                        int32                           TotalTests() const      { return fTotalTests; }
                        int32                           FailedTests() const     { return fFailedTests; }

                        void                            TestDone(bool success);

                        thread_id                       SpawnThread(thread_func function,
                                                                        const char* name, int32 priority,
                                                                        void* arg);

private:
                        struct ThreadEntry {
                                ThreadEntry*            globalNext;
                                ThreadEntry*            contextNext;
                                GlobalTestContext*      context;
                                thread_id                       thread;

                                ThreadEntry(GlobalTestContext* context)
                                        :
                                        globalNext(NULL),
                                        contextNext(NULL),
                                        context(context),
                                        thread(find_thread(NULL))
                                {
                                }
                        };

                        struct ThreadCookie;

private:
        static  void                            _SetCurrent(ThreadEntry* entry);
        static  void                            _UnsetCurrent(ThreadEntry* entry);
        static  status_t                        _ThreadEntry(void* data);

private:
        static  ThreadEntry*            sGlobalThreads;
                        ThreadEntry*            fThreads;
                        ThreadEntry                     fThreadEntry;
                        TestOutput&                     fOutput;
                        TestOptions&            fOptions;
                        TestContext*            fCurrentContext;
                        int32                           fTotalTests;
                        int32                           fFailedTests;
};


class TestContext {
public:
                                                                TestContext(GlobalTestContext* globalContext);
                                                                TestContext(TestContext& parent, Test* test);
                                                                ~TestContext();

        static  TestContext*            Current();

                        GlobalTestContext*      GlobalContext() const { return fGlobalContext; }
                        TestContext*            Parent() const  { return fParent; }
                        int32                           Level() const   { return fLevel; }
                        TestOutput&                     Output() const
                                                                        { return fGlobalContext->Output(); }
                        TestOptions&            Options() const
                                                                        { return fGlobalContext->Options(); }

        inline  int                                     PrintArgs(const char* format, va_list args);
        inline  int                                     Print(const char* format,...);

                        void                            ErrorArgs(const char* format, va_list args);
        inline  void                            Error(const char* format,...);

        inline  void                            AssertFailed(const char* file, int line,
                                                                        const char* function,
                                                                        const char* condition);
        inline  void                            AssertFailed(const char* file, int line,
                                                                        const char* function,
                                                                        const char* condition,
                                                                        const char* format,...);

                        void                            TestDone(bool success);

private:
                        GlobalTestContext*      fGlobalContext;
                        TestContext*            fParent;
                        Test*                           fTest;
                        TestError*                      fErrors;
                        int32                           fLevel;
};


/*static*/ inline TestContext*
TestContext::Current()
{
        return GlobalTestContext::Current()->CurrentContext();
}


int
TestContext::PrintArgs(const char* format, va_list args)
{
        return Output().PrintArgs(format, args);
}


int
TestContext::Print(const char* format,...)
{
        va_list args;
        va_start(args, format);
        int result = Output().PrintArgs(format, args);
        va_end(args);

        return result;
}


void
TestContext::Error(const char* format,...)
{
        va_list args;
        va_start(args, format);
        ErrorArgs(format, args);
        va_end(args);
}


void
TestContext::AssertFailed(const char* file, int line, const char* function,
        const char* condition)
{
        Error("ASSERT FAILED at %s:%d %s: %s\n", file, line, function, condition);
}


void
TestContext::AssertFailed(const char* file, int line, const char* function,
        const char* condition, const char* format,...)
{
        char buffer[256];

        va_list args;
        va_start(args, format);
        vsnprintf(buffer, sizeof(buffer), format, args);
        va_end(args);

        Error("ASSERT FAILED at %s:%d %s: %s; %s\n", file, line, function,
                condition, buffer);
}


#endif  // TEST_CONTEXT_H