/*---------------------------------------------------------------------------*
  Project:  Horizon
  File:     test_Test.cpp

  Copyright (C)2009 Nintendo Co., Ltd.  All rights reserved.

  These coded instructions, statements, and computer programs contain
  proprietary information of Nintendo of America Inc. and/or Nintendo
  Company Ltd., and are protected by Federal copyright law.  They may
  not be disclosed to third parties or copied or duplicated in any form,
  in whole or in part, without the prior written consent of Nintendo.

  $Rev: 12449 $
 *---------------------------------------------------------------------------*/

#include <nn.h>
//#include <nn/Result.h>
//#include <nn/os.h>
//#include <nn/Handle.h>
//#include <nn/os/os_Thread.h>
#include <nn/os/os_Initialize.h>
#include <nn/test/test_Test.h>
using namespace nn::dbg;
using namespace nn::os;

using nn::Handle;
using nn::test::String;
using nn::test::TextOutput;
using nn::test::XmlOutput;
using nn::test::AssertInfo;


// テストスイートの定義
//
// Suite を継承したクラスがテストスイートになる
// このクラスの中にテストメソッドを作り、コンストラクタ内で登録する
class Test : public nn::test::Suite
{
public:
    Test()
    {
        // テストスイート名
        SUITE_NAME("Test");

        // テストケースの登録
        TEST_ADD(Test::Test1)
        TEST_ADD(Test::Test2)
        TEST_ADD(Test::Test3)
        TEST_ADD(Test::Test4)
    }
    virtual ~Test() {}

private:
    // 以下、テストメソッド
    void	Test1()
    {
    }
    void	Test2()
    {
        NN_TEST_ASSERT(1 == 0);
        NN_TEST_ASSERT(2 & 0);
    }
    void    Test3()
    {
        NN_TEST_ASSERT(1 > 2);
    }

    void    Test4()
    {
        NN_TEST_ASSERT_EQUAL(1, 2);
    }
};


class SuccessTest : public nn::test::Suite
{
public:
    SuccessTest()
    {
        // テストスイート名
        SUITE_NAME("SuccessTest");

        // テストケースの登録
        TEST_ADD(SuccessTest::Test1)
        TEST_ADD(SuccessTest::Test2)
        TEST_ADD(SuccessTest::Test3)
        TEST_ADD(SuccessTest::Test4)
    }
    virtual ~SuccessTest() {}

private:
    // 以下、テストメソッド
    void    Test1()
    {
    }
    void    Test2()
    {
        NN_TEST_ASSERT(1 == 1);
        NN_TEST_ASSERT(2 & 2);
    }
    void    Test3()
    {
        NN_TEST_ASSERT(1 > 0);
    }

    void    Test4()
    {
        NN_TEST_ASSERT_EQUAL(1, 1);
    }
};



class SubTest1 : public nn::test::Suite
{
public:
    SubTest1()
    {
        SUITE_NAME("SubTest1");
        TEST_ADD(SubTest1::Test1)
        TEST_ADD(SubTest1::Test2)
        TEST_ADD(SubTest1::Test3)
    }
private:
    void Test1()
    {
        NN_TLOG_("SubTest1::Test1 in");
        NN_TEST_BEGIN_EXPECT_FAILURE_ANY
        {
            NN_TASSERT_(0);
        }
        NN_TEST_END_EXPECT_FAILURE

        NN_TLOG_("SubTest1::Test1 out");

    }
    void Test2()
    {
        NN_TLOG_("SubTest1::Test2 in");
        NN_TEST_ASSERTMSG(10 == 9, "Assert!, %d\n", 1 + 2);
        NN_TEST_ASSERT(1 == 2);
        NN_TLOG_("SubTest1::Test2 out");
    }
    void Test3()
    {
        NN_TLOG_("SubTest1::Test3 in");
        NN_TEST_ASSERT(10 == 9);
        NN_TLOG_("SubTest1::Test3 out");
    }
};



class SubTest2 : public nn::test::Suite
{
public:
    SubTest2()
    {
        SUITE_NAME("SubTest2");
        TEST_ADD_WITH_INFO(SubTest2::Test1, "SubTest2::Test1", "2_1 info")
        TEST_ADD_WITH_INFO(SubTest2::Test2, "SubTest2::Test2", "2_2 info")
    }
private:
    void Test1()
    {
        NN_TLOG_("Do SubTest2::Test1.Success");
    }
    void Test2()
    {
        NN_TLOG_("Do SubTest2::Test2.Failure");
        NN_TEST_ASSERT(1 == 2);
    }
};



class SubTest3 : public nn::test::Suite
{
public:
    SubTest3()
    {
        SUITE_NAME("SubTest3");
        TEST_ADD_WITH_NAME(SubTest3::Test1, "Test3_1GO")
    }
private:
    void Test1()
    {
        NN_TLOG_("Do SubTest3::Test1.Failure");
        NN_TEST_ASSERT(1 == 2);
    }
};



class InitializeFinalizeSuiteTest : public nn::test::Suite
{
public:
    InitializeFinalizeSuiteTest()
    {
        SUITE_NAME("InitializeFinalizeSuiteTest");
        TEST_ADD(InitializeFinalizeSuiteTest::Test)

        isInitialized = false;
        isFinalized = false;
        isTested = false;
    }

    bool isInitialized;
    bool isFinalized;
    bool isTested;

protected:
    virtual bool InitializeSuite() { isInitialized = true; } // スートに属するテスト開始前に一度だけ呼ばれる
    virtual void FinalizeSuite() {isFinalized = true;}                 // スートに属するテストの終了時に呼ばれる


private:
    void Test()
    {
        NN_TLOG_("Do InitializeFinalizeSuiteTest::Test");
        isTested = true;
    }
};

#define TOTAL_TEST_NUM 11


/**
 * Run関数のテスト
 */
void testRun(nn::test::Output& out)
{
    // Runの実行。テストがすべて成功するケース
    {
        SuccessTest test;
        NN_TASSERT_(true == test.Run(out, false));
    }

    // Runの実行。失敗ケースあり。第二引数がtrue の場合、アサートに引っかかってもそのテストケースを抜けない
    {
        Test test;              // テストスイートの作成

        // テストケースの子として実行させるテストスイートがあれば
        // AddSubSuite メソッドで子を登録できる
        SubTest1 subTest1;
        test.AddSubSuite(&subTest1);

        // テストを実行
        NN_TASSERT_(false == test.Run(out, true));
    }

    // Runの実行。失敗ケースあり。第二引数がfalse の場合、アサートに引っかかるとそのテストケースを抜ける
    {
        Test test;              // テストスイートの作成

        // テストケースの子として実行させるテストスイートがあれば
        // AddSubSuite メソッドで子を登録できる
        SubTest1 subTest1;
        test.AddSubSuite(&subTest1);

        // テストを実行
        NN_TASSERT_(false == test.Run(out, false));
    }

    // Runの実行。サブSuiteのInitialize()とFinalizeSuite()が実行されることの確認テスト
    {
        SuccessTest test;              // テストスイートの作成
        InitializeFinalizeSuiteTest initializeFinalizeSuiteTest;
        test.AddSubSuite(&initializeFinalizeSuiteTest);

        NN_TASSERT_(initializeFinalizeSuiteTest.isInitialized == false);
        NN_TASSERT_(initializeFinalizeSuiteTest.isFinalized == false);
        NN_TASSERT_(initializeFinalizeSuiteTest.isTested == false);
        NN_TASSERT_(true == test.Run(out, true));
        NN_TASSERT_(initializeFinalizeSuiteTest.isInitialized == true);
        NN_TASSERT_(initializeFinalizeSuiteTest.isFinalized == true);
        NN_TASSERT_(initializeFinalizeSuiteTest.isTested == true);
    }
}


/**
 * Get系関数のテスト(Suite内のテストの情報を取得する機能に関するテスト)
 */
void testGetFunc()
{
    Test test;
    SubTest1 subTest1;
    test.AddSubSuite(&subTest1);
    SubTest2 subTest2;
    test.AddSubSuite(&subTest2);
    SubTest3 subTest3;
    test.AddSubSuite(&subTest3);

    /*---------------------------------------------------------------------------*
        GetTestName()
     *---------------------------------------------------------------------------*/
    NN_TASSERT_(test.GetTestName() == "Test");
    NN_TASSERT_(subTest1.GetTestName() == "SubTest1");
    NN_TASSERT_(subTest2.GetTestName() == "SubTest2");
    NN_TASSERT_(subTest3.GetTestName() == "SubTest3");
    
    /*---------------------------------------------------------------------------*
        GetTestNum()
     *---------------------------------------------------------------------------*/
    NN_TASSERT_(test.GetTestNum() == 4);
    NN_TASSERT_(subTest1.GetTestNum() == 3);
    NN_TASSERT_(subTest2.GetTestNum() == 2);
    NN_TASSERT_(subTest3.GetTestNum() == 1);
    
    /*---------------------------------------------------------------------------*
        GetTotalTestNum()
     *---------------------------------------------------------------------------*/
    NN_TASSERT_(test.GetTotalTestNum() == 10);
    NN_TASSERT_(subTest1.GetTotalTestNum() == 3);
    NN_TASSERT_(subTest2.GetTotalTestNum() == 2);
    NN_TASSERT_(subTest3.GetTotalTestNum() == 1);
    
    /*---------------------------------------------------------------------------*
        GetTestFuncInfos()
     *---------------------------------------------------------------------------*/
    String suiteName;
    String funcName;
    
    NN_TASSERT_(false == test.GetTestFuncInfos(0, suiteName, funcName));
    
    NN_TASSERT_(true == test.GetTestFuncInfos(1, suiteName, funcName));
    NN_TASSERT_(suiteName == "Test");
    NN_TASSERT_(funcName == "Test::Test1");
    
    NN_TASSERT_(true == test.GetTestFuncInfos(4, suiteName, funcName));
    NN_TASSERT_(suiteName == "Test");
    NN_TASSERT_(funcName == "Test::Test4");

    NN_TASSERT_(true == test.GetTestFuncInfos(5, suiteName, funcName));
    NN_TASSERT_(suiteName == "SubTest1");
    NN_TASSERT_(funcName == "SubTest1::Test1");
    
    NN_TASSERT_(true == test.GetTestFuncInfos(7, suiteName, funcName));
    NN_TASSERT_(suiteName == "SubTest1");
    NN_TASSERT_(funcName == "SubTest1::Test3");
    
    NN_TASSERT_(true == test.GetTestFuncInfos(8, suiteName, funcName));
    NN_TASSERT_(suiteName == "SubTest2");
    NN_TASSERT_(funcName == "SubTest2::Test1");
    
    NN_TASSERT_(true == test.GetTestFuncInfos(9, suiteName, funcName));
    NN_TASSERT_(suiteName == "SubTest2");
    NN_TASSERT_(funcName == "SubTest2::Test2");

    NN_TASSERT_(true == test.GetTestFuncInfos(10, suiteName, funcName));
    NN_TASSERT_(suiteName == "SubTest3");
    NN_TASSERT_(funcName == "Test3_1GO");
    
    NN_TASSERT_(false == test.GetTestFuncInfos(11, suiteName, funcName));

    //テストの付帯情報が取得できることの確認
    String funcInfo;
    NN_TASSERT_(true == test.GetTestFuncInfos(7, suiteName, funcName, funcInfo));
    NN_TASSERT_(funcInfo == "");

    
    NN_TASSERT_(true == test.GetTestFuncInfos(8, suiteName, funcName, funcInfo));
    NN_TASSERT_(funcInfo == "2_1 info");

    NN_TASSERT_(true == test.GetTestFuncInfos(9, suiteName, funcName, funcInfo));
    NN_TASSERT_(funcInfo == "2_2 info");

}


/**
 * RunSpecificTestFunc()のテスト(Suite内の特定テストのみ実施する機能に関するテスト)
 */
void testRunSpecificTestFunc(nn::test::Output& output)
{
    Test test;
    SubTest1 subTest1;
    test.AddSubSuite(&subTest1);
    SubTest2 subTest2;
    test.AddSubSuite(&subTest2);
    SubTest3 subTest3;
    test.AddSubSuite(&subTest3);
    InitializeFinalizeSuiteTest initializeFinalizeSuiteTest;
    test.AddSubSuite(&initializeFinalizeSuiteTest);

    test.Initialize();
    /*「テスト名を指定して実行」のテスト*/
    NN_TASSERT_(true == test.RunSpecificTestFunc("Test::Test1", output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("Test::Test2", output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("Test::Test3", output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("Test::Test4", output));
    ////テスト名を指定しての実行では、サブSuiteのテストは実行できない//
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest1::Test1", output));
    NN_TASSERT_(test.GetTotalTestNum() == TOTAL_TEST_NUM);
    
    /*「テストIDを指定して実行」のテスト*/
    NN_TASSERT_(true == test.RunSpecificTestFunc(1, output));
    NN_TASSERT_(false == test.RunSpecificTestFunc(2, output));
    NN_TASSERT_(false == test.RunSpecificTestFunc(3, output));
    NN_TASSERT_(false == test.RunSpecificTestFunc(4, output));
    ////「テストIDを指定して実行」では、サブSuiteのテストも実行できる//
    NN_TASSERT_(true == test.RunSpecificTestFunc(5, output));
    NN_TASSERT_(test.GetTotalTestNum() == TOTAL_TEST_NUM);
    
    /*「テストSuiteとテスト名を指定して実行」のテスト*/
    NN_TASSERT_(true == test.RunSpecificTestFunc("SubTest1", "SubTest1::Test1", output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest1", "SubTest1::Test2", output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest1", "SubTest1::Test3", output));
    NN_TASSERT_(true == test.RunSpecificTestFunc("SubTest2", "SubTest2::Test1", output));
    NN_TASSERT_(true == test.RunSpecificTestFunc(8, output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest2", "SubTest2::Test2", output));

    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest3", "SubTest3::Test1", output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest3", "Test3_1GO", output));
    NN_TASSERT_(test.GetTotalTestNum() == TOTAL_TEST_NUM);

    ////「テストSuiteとテスト名を指定して実行」では、Suiteとテスト名が合致していない場合、実行は失敗する//
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest3", "SubTest1::Test1", output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest3", "SubTest2::Test1", output));
    NN_TASSERT_(test.GetTotalTestNum() == TOTAL_TEST_NUM);


    /*RunSpecificTestFunc()の引数contAfterFailをfalseにした際のテスト*/
    NN_TASSERT_(true == test.RunSpecificTestFunc(1, output, false));
    NN_TASSERT_(false == test.RunSpecificTestFunc(2, output, false));
    NN_TASSERT_(false == test.RunSpecificTestFunc(3, output, false));
    NN_TASSERT_(false == test.RunSpecificTestFunc(4, output, false));
    NN_TASSERT_(true == test.RunSpecificTestFunc(5, output, false));
    NN_TASSERT_(true == test.RunSpecificTestFunc("SubTest1", "SubTest1::Test1", output, false));
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest1", "SubTest1::Test2", output, false));
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest1", "SubTest1::Test3", output, false));
    NN_TASSERT_(true == test.RunSpecificTestFunc("SubTest2", "SubTest2::Test1", output, false));
    NN_TASSERT_(true == test.RunSpecificTestFunc(8, output));
    NN_TASSERT_(false == test.RunSpecificTestFunc("SubTest2", "SubTest2::Test2", output, false));
    NN_TASSERT_(test.GetTotalTestNum() == TOTAL_TEST_NUM);

    /*RunSpecificTestFunc()において、サブSuiteのInitialize()とFinalizeSuite()が実行されることの確認テスト*/
    NN_TASSERT_(initializeFinalizeSuiteTest.isInitialized == false);
    NN_TASSERT_(initializeFinalizeSuiteTest.isFinalized == false);
    NN_TASSERT_(initializeFinalizeSuiteTest.isTested == false);
    NN_TASSERT_(true == test.RunSpecificTestFunc("InitializeFinalizeSuiteTest", "InitializeFinalizeSuiteTest::Test", output));
    NN_TASSERT_(initializeFinalizeSuiteTest.isInitialized == true);
    NN_TASSERT_(initializeFinalizeSuiteTest.isFinalized == true);
    NN_TASSERT_(initializeFinalizeSuiteTest.isTested == true);

    test.Finalize();
}


// nninitStartup と、nnMain については、
// 全テストコード置き換え時に、テストライブラリに組み込み
// ビルドシステムで CUnit 使わないようにして切り替える予定
//
// 置き換え段階では、各テストプロセス毎に定義してください。

// スタートアップ内で test::Startup を呼ぶ必要がある
void    nninitStartUp()
{
    nn::os::Initialize();
    nn::test::InitializeAllocator();
}

void nnMain( void )
{
    //__breakpoint(0);
    // 出力の設定
#ifdef NN_TEST_DEBUG
    TextOutput out;          // デバッグ時はテキスト出力
#else
    XmlOutput out;           // 非デバッグ時（自動テスト時は）XML 出力
#endif
    /**
     *Test.Runのテスト
     */
    testRun(out);


    /**
     *Get系関数のテスト(Suite内のテストの情報を取得する機能に関するテスト)
     */
    testGetFunc();
     
     /**
     *RunSpecificTestFunc()のテスト(Suite内の特定テストのみ実施する機能に関するテスト)
     */
     testRunSpecificTestFunc(out);

    NN_TLOG_("---test_Test.cpp nnMain() finished.(into infinite roop)");
    while(1)
    {
        // Sleep しつづける。
        nn::os::Thread::Sleep(nn::fnd::TimeSpan::FromSeconds(1));
    }
}