// Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\system\t_console.cpp

// Overview:

// Test methods of CConsoleBase, CProxyConsole and CColorConsole class.

// API Information:

// CConsoleBase.

// Details:

// - Create an object of CTestConsole class which is derived from CColorConsole. 

// - Call methods of CColorConsole class with this test object.

// - Create a full screen console object of CConsoleBase.

// - Call methods of CConsoleBase class with this console object.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32event.h>

#include <e32svr.h>

LOCAL_D RTest test(_L("T_CONSOLE"));

// Literals

_LIT(KTxtTitle,"Console App");

_LIT(KTxtNewTitle,"New Console Title");

_LIT(KTxtWrite,"Write some text ");

_LIT(KTxtPressAnyKey,"Press any key or wait 2 seconds");

// This is test class for testing methods of CColorConsoleBase

class CTestConsole : public CColorConsoleBase

    {

    public:

    TInt Extension_(TUint aExtensionId, TAny*& a0, TAny* a1)

        {

        return CColorConsoleBase::Extension_(aExtensionId, a0, a1);

        }

    };

// Creates an object of CTestConsole.

// Calls methods of CColorConsoleBase 

LOCAL_C void InitTestConsoleL()

    {

    // create a full screen test console object

    CTestConsole* testConsole;

    testConsole = (CTestConsole*)Console::NewL(KTxtTitle, TSize(KConsFullScreen,KConsFullScreen));

    CleanupStack::PushL(testConsole);

    // Defines the bold text attribute.

    testConsole->SetTextAttribute(ETextAttributeBold);

    testConsole->Write(KTxtWrite);

    // Defines the inverse text attribute.

    testConsole->SetTextAttribute(ETextAttributeInverse);

    testConsole->Write(KTxtWrite);

    // Defines the highlight text attribute.

    testConsole->SetTextAttribute(ETextAttributeHighlight);

    testConsole->Write(KTxtWrite);

    // Defines the normal text attribute.

    testConsole->SetTextAttribute(ETextAttributeNormal);

    testConsole->Write(KTxtWrite);

    TInt a1 = 0;

    TAny* any = 0;

    testConsole->Extension_((TUint)a1,any,any);

    // cleanup and return

    CleanupStack::PopAndDestroy(); // close console

    }

LOCAL_C void SimulateKeyPress(TStdScanCode aScanCode)

    {

    TRawEvent eventDown;

    eventDown.Set(TRawEvent::EKeyDown, aScanCode);

    UserSvr::AddEvent(eventDown);

    TRawEvent eventUp;

    eventUp.Set(TRawEvent::EKeyUp, aScanCode);

    UserSvr::AddEvent(eventUp);    

    }

LOCAL_C void ReadConsole(CConsoleBase* aConsole)

    {

    aConsole->Printf(KTxtPressAnyKey);

    TRequestStatus keyStatus;

    // Gets a keystroke from the console window, asynchronously

    aConsole->Read(keyStatus);

    RTimer timer;

    test_KErrNone(timer.CreateLocal());

    TRequestStatus timerStatus;

    timer.After(timerStatus,2*1000000);

    User::WaitForRequest(timerStatus,keyStatus);

    if(keyStatus!=KRequestPending)

        {

        TKeyCode keyCode = aConsole->KeyCode();

        aConsole->Printf(_L("Keycode %d\n"),keyCode);

        }

    timer.Cancel();

    // Cancels any outstanding request 

    aConsole->ReadCancel();

    User::WaitForAnyRequest();

    }

LOCAL_C void InitConsoleL()

    {

    // create a full screen console object

    CConsoleBase* console;

    console = Console::NewL(KTxtTitle, TSize(KConsFullScreen,KConsFullScreen));

    CleanupStack::PushL(console);

    //Gets the size of the console

    TSize screenSize = console->ScreenSize();

    test.Printf(_L("Screen size %d %d\r\n"),screenSize.iWidth,screenSize.iHeight);

    // Gets the cursor's x-position

    TInt x = console->WhereX();

    // Gets the cursor's y-position

    TInt y = console->WhereY();

    test_Equal(x, 0);

    test_Equal(y, 0);

    test.Printf(_L("**1** Cursor positions x: %d  y: %d\r\n"),x, y);

    // Sets the cursor's x-position

    for(TInt i=0; i<4; i++)

        {

        console->SetPos(screenSize.iWidth + i);

        x = console->WhereX();

        test_Equal(x, screenSize.iWidth -3);

		}

    test.Printf(_L("**2** Cursor positions x: %d  y: %d\r\n"),x, y);

    // Clears the console and set cursor to position 0,0

    console->ClearScreen();

    test_Equal(console->WhereX(), 0);

	test_Equal(console->WhereY(), 0);

    // Sets the cursor's x-position and y-position

    for(TInt j=0; j<4; j++)

        {

        console->SetPos(screenSize.iWidth - j, screenSize.iHeight - j);

        x = console->WhereX();

        y = console->WhereY();

        test_Equal(x, screenSize.iWidth -3);

		test_Equal(y, screenSize.iHeight -3);

		}

    test.Printf(_L("**3** Cursor positions x: %d  y: %d\r\n"),x, y);

    console->SetPos(0,0);

    x = console->WhereX();

    y = console->WhereY();

    test_Equal(x, 0);

    test_Equal(y, 0);

	test.Printf(_L("**4** Cursor positions x: %d  y: %d\r\n"),x, y);

    console->SetPos(screenSize.iWidth/2,screenSize.iHeight/2);

    x = console->WhereX();

    y = console->WhereY();

    test.Printf(_L("**5** Cursor positions x: %d  y: %d\r\n"),x, y);

    // Sets the percentage height of the cursor

    console->SetCursorHeight(50);

    // Gets the current cursor position relative to the console window

    TPoint cursorPos = console->CursorPos();

    test.Printf(_L("CursorPos iX: %d  iY: %d\r\n"),cursorPos.iX, cursorPos.iY);

    // Puts the cursor at the specified position relative

    // to the current cursor position

    TPoint relPos;

    relPos.iX = screenSize.iWidth/4;

    relPos.iY = screenSize.iHeight/4;

    console->SetCursorPosRel(relPos);

    cursorPos = console->CursorPos();

    test.Printf(_L("CursorPosRel iX: %d  iY: %d\r\n"),cursorPos.iX, cursorPos.iY);

    // Puts the cursor at the absolute position in the window

    cursorPos.iX = screenSize.iWidth/6;

    cursorPos.iY = screenSize.iHeight/6;

    console->SetCursorPosAbs(cursorPos);

    cursorPos = console->CursorPos();

    test.Printf(_L("CursorPosAbs iX: %d  iY: %d\r\n"),cursorPos.iX, cursorPos.iY);

    // Sets a new console title

    console->SetTitle(KTxtNewTitle);

    // Writes the content of the specified descriptor to the console window

    console->Write(KTxtWrite);

    cursorPos.iX = cursorPos.iX + 6;

    console->SetCursorPosAbs(cursorPos);

    // Clears the console from the current cursor position to the end of the line

    console->ClearToEndOfLine();

    // Clears the console and set cursor to position 0,0

    console->ClearScreen();

    TUint keyModifiers = console->KeyModifiers();

	test.Printf(_L("keyModifiers %d"),keyModifiers);

    TKeyCode keyCode = console->KeyCode();

    ReadConsole(console);

    SimulateKeyPress(EStdKeyEnter);

    keyCode = console->Getch();

    // cleanup and return

    CleanupStack::PopAndDestroy(); // close console

    }

TInt E32Main()

//

// 

//

    {

    test.Title();

    __UHEAP_MARK;

    test.Start(_L("Testing Console"));

    // Get cleanup stack

    CTrapCleanup* cleanup = CTrapCleanup::New();

    TInt result = KErrNoMemory;

    if (cleanup)

	    {

        TRAP(result, InitTestConsoleL());

	    TRAP(result, InitConsoleL());

	    // Destroy the cleanup stack

	    delete cleanup;

	    }

	__UHEAP_MARKEND;

	test.End();

	return(result);

	}