C++ CConsoleBase::Printf方法代码示例

/**
 *
 * Write to the log.
 *
 * @param	"const TDesC& aMsg"
 *			The message string to write
 *
 * @param	"TInt aLogMode"
 *			The log mode (as bitmask of TTestFrameworkLogMode)
 *
 * @xxxx
 *
 */
void CTestFrameworkServer::WriteLog(const TDesC& aMsg, TInt aLogMode)
{
    if(aLogMode & ELogToConsole)
    {
        if(iConsole)
        {
            CConsoleBase* theConsole = iConsole->Console();
            theConsole->Printf(aMsg);
            theConsole->Printf(_L("\n")); // add newline
        }
    }

    if(aLogMode & ELogToFile)
    {
        if(iFileLogger)
        {
            iFileLogger->WriteLog(aMsg);
        }
    }

    if(aLogMode & ELogToPort)
    {
        RDebug::Print(aMsg);
    }
}

void CDeleteCommand::ExecuteL(CConsoleBase& aConsole)
	{
	// Connect to the SIF server
	RSoftwareInstall sif;
	TInt err = sif.Connect();
	if (err != KErrNone)
		{
		aConsole.Printf(KTxtSifConnectionFailure);
		User::Leave(err);
		}
	CleanupClosePushL(sif);

	// Delete the component
	TRequestStatus status;
	sif.Uninstall(iComponentId, status);
	aConsole.Printf(KTxtDeleting);
	User::WaitForRequest(status);
	if (status.Int() != KErrNone)
		{
		User::Leave(status.Int());
		}

	// Disconnect from the SIF server
	CleanupStack::PopAndDestroy(&sif);
	}

static void MainL(void)
/**
Takes a User Prompt Service policy resource file and dumps it as human readable text to the 
console. The user may also specify the name of an output file on the command line. If so, text
is also written to this file.
*/
	{
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
		
	CConsoleBase* console = Console::NewL(KAppName, TSize(KDefaultConsWidth, KDefaultConsHeight));
	CleanupStack::PushL(console);
	
	CCommandLineArguments* args = CCommandLineArguments::NewLC();
	
	if (args->Count() > 1)
		{		
		CPolicyReader* reader = CPolicyReader::NewLC(fs, args->Arg(1));		
		CPrinter* printer(0);
		if (args->Count() > 2)
			{
			RFile outFile;
			User::LeaveIfError(outFile.Replace(fs, args->Arg(2), EFileShareExclusive | EFileWrite));
			CleanupClosePushL(outFile);
			printer = CPrinter::NewLC(console, outFile);		
			
			CleanupStack::Pop(printer); 
			CleanupStack::PopAndDestroy(&outFile);
			CleanupStack::PushL(printer);
			}
		else
			{
			printer = CPrinter::NewLC(console);	
			}
		__UHEAP_MARK;
		PrintPoliciesL(printer, reader);
		__UHEAP_MARKEND;
		
		if (args->Count() < 3)
			{
			// If no output file is specified then pause after finishing
			// because the console will vanish when it is closed.
			console->Printf(_L("Press any key to continue\r\n"));
			console->Getch();
			}		
		CleanupStack::PopAndDestroy(2, reader); // printer, reader		
		}
	else 
		{
		console->Printf(_L("Usage: dumppolicy.exe policy.rsc <output.txt>\r\n"));
		console->Printf(_L("Press any key to continue\r\n"));
		console->Getch();
		}
	
	CleanupStack::PopAndDestroy(3, &fs); // args, console, fs
	}

LOCAL_C void mainL()
	{
	CCommandLineArguments* cmdLine = CCommandLineArguments::NewLC();
	CConsoleBase* console = Console::NewL(_L("Siftestintegrationlockfile"),TSize(KConsFullScreen,KConsFullScreen));
	CleanupStack::PushL(console);
	TInt argTotal(cmdLine->Count());
	if (argTotal < 2  || argTotal > 3)
		{
		console->Printf(_L("Incorrect arguments specified: expected 1, received %d"), argTotal - 1);
		User::Leave(KErrArgument);
		}
		
	TPtrC filename(cmdLine->Arg(1));
	_LIT(KDoLockFileParam, " lockfile");
	if (argTotal == 2)
		{
		RBuf params;
		params.CreateL(filename.Length() + KDoLockFileParam().Length());
		params.CleanupClosePushL();
		params.Append(cmdLine->Arg(1));
		params.Append(KDoLockFileParam());
		// Since this executable is used by TEF, we wish to lock the file after the launched process has exited, so we spawn this process again with a different set of parameters
		RProcess newInstance;
		User::LeaveIfError(newInstance.Create(_L("Siftestintegrationlockfile"), params));
		CleanupClosePushL(newInstance);
		newInstance.Resume();
		TRequestStatus status;		
		newInstance.Rendezvous(status);
		User::WaitForRequest(status);
		User::LeaveIfError(status.Int());
		CleanupStack::PopAndDestroy(2, &params); // newInstance
		}
	else
		{
		// This is the execution for locking the file, invoked using the branch above
		console->Printf(_L("Locking file %S for read"), &filename);	
		RFs fs;
		User::LeaveIfError(fs.Connect());
		CleanupClosePushL(fs);
	
		RFile file;
		User::LeaveIfError(file.Open(fs, filename, EFileShareReadersOnly|EFileRead));
		CleanupClosePushL(file);
		// Signal the invoker only here, so that the file will definitely get locked before TEF proceeds to the next step
		RProcess::Rendezvous(KErrNone);		
		
		User::After(10*1000*1000); // Wait for 10 seconds
	
		CleanupStack::PopAndDestroy(2 , &fs); // file
		}
	CleanupStack::PopAndDestroy(2, cmdLine); // console,
    }

void CCTSYIntegrationTestSuiteStepBase::ConsolePrintL(const TDesC& aText )
	{
	CConsoleBase* con = NULL;
	TRAPD(err, con = Console::NewL(_L("Interactive Print"), TSize(KConsFullScreen, KConsFullScreen)));
	TEST(err == KErrNone);

	CleanupStack::PushL(con);
	con->Printf(_L("%S"), &aText);
	CleanupStack::PopAndDestroy(); // con
	
	}

void TestUiTimer::RunL()
	{
	// display the current progress
	if(iEmailOperation!=NULL)
		{
		TImSmtpProgress temp;	
		TPckgC<TImSmtpProgress> paramPack(temp);
		paramPack.Set(iEmailOperation->ProgressL());
		TImSmtpProgress progress=paramPack();	

		iConsole->SetPos(0, 12);
		TBuf<80> progressBuf = Progress(progress.iSendFileProgress.iSessionState);
		iConsole->Printf(TRefByValue<const TDesC>_L("   Operation Progress      : %S           "), &progressBuf);
		iConsole->SetPos(0, 13);
		iConsole->Printf(TRefByValue<const TDesC>_L("   Progress:  %d/%d %d/%d                \n"),
					progress.MsgNo() + 1,
					progress.SendTotal(),
					progress.iSendFileProgress.iBytesSent,
					progress.iSendFileProgress.iBytesSent + progress.iSendFileProgress.iBytesToSend);
		iConsole->SetPos(0, 15);
		iConsole->Printf(TRefByValue<const TDesC>_L("   Error: %d                             \n"), progress.Error());
		}
	IssueRequest();
	};

/**
 @fn void StartConsoleL()
 Start the console and create the ini file, then call the read method
 to manually test the contents.
 */
LOCAL_C void StartConsoleL()
    {
    // set INI file drive
    IniFileName[0] = 'A' + static_cast<TInt>(RFs::GetSystemDrive());
    
	// Create the console and put it on the cleanup stack
	CConsoleBase* console = 
		Console::NewL(KConsoleName, TSize(KConsFullScreen, KConsFullScreen));
	CleanupStack::PushL(console);

	// Call the main function and trap the result
	TRAPD(error, WriteIniFileL()); // create the ini file
	if(!error)
		{
		TRAPD(error2, ReadIniFileL()); // perform test
		error = error2;
		}
	if (error)
		console->Printf(KFailedMessage, error);
	else
		console->Printf(KOkMessage);

	CleanupStack::PopAndDestroy(console);	// close console
    }

// -----------------------------------------------------------------------------
// CHtiFramework::StartL
// The method that gets the show going.
// -----------------------------------------------------------------------------
TInt CHtiFramework::StartL()
    {
    HTI_LOG_FUNC_IN( "CHtiFramework::StartL" );

    CConsoleBase* console = iDispatcher->GetConsole();
    if ( console )
        {
        console->Printf( _L( "HTI up and running.\n" ) );
        }

    // start scheduler
    CActiveScheduler::Start();

    HTI_LOG_FUNC_OUT( "CHtiFramework::StartL" );
    return KErrNone;

    }

void CPrinter::PrintL(TRefByValue<const TDesC16> aFormat, ...)
	{
	VA_LIST list;
	VA_START(list, aFormat);
		
	iBuffer.Zero();
	iBuffer.AppendFormatList(aFormat, list);
		
	iCon->Printf(iBuffer);	
	if (iLogToFile)
		{
		HBufC8* utf8 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(iBuffer);
		CleanupStack::PushL(utf8);
		User::LeaveIfError(iFile.Write(*utf8));
		CleanupStack::PopAndDestroy(utf8);
		}	
	
	VA_END(list);
	}

TInt CCTSYIntegrationTestSuiteStepBase::DoPauseL(const TDesC& aText, TTimeDuration aTimeout /* = ETimeMedium */)
/**
 Performs a pause, usually to allow user to intervene in Manual tests
 
 @param		aText - text for prompt
 @param		aTimeout - 
 @return	KErrNone if user pressed a key
 */
	{
	TInt ret = KErrNone;
		
	CConsoleBase* con = NULL;
	TRAPD(err, con = Console::NewL(_L("Interactive Test"), TSize(KConsFullScreen, KConsFullScreen)));

	INFO_PRINTF2(_L("Console status = %d"), err);
	TEST(err == KErrNone);
	CleanupStack::PushL(con);
	
	TConsoleReadRequestStatus readRequest(*con);
	//add to cleanup stack
	CleanupStack::PushL(readRequest);
	con->Printf(_L("%S (timeout %d secs) ..."), &aText, aTimeout / KOneSecond);
	con->Read(readRequest);
	
	ret = WaitForRequestWithTimeOut(readRequest, aTimeout);	
		
	if (ret == KErrTimedOut)
		{
		WARN_PRINTF1(_L("[doPause] No keypress detected, timeout! Manual action may not have occurred."));
		}

	if (readRequest.Int() == KRequestPending)	
		{
		readRequest.Cancel();
		}
	
	CleanupStack::PopAndDestroy(); // readRequest
	CleanupStack::PopAndDestroy(); // con
	
	return ret;
	}

LOCAL_C void ActiveTestL()
    {
	CConsoleBase* console = Console::NewL(_L("ACTIVETEST"), TSize(KConsFullScreen, KConsFullScreen));
	CleanupStack::PushL(console);

	CActiveScheduler* scheduler = new(ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install(scheduler);

	CActiveConsole* activeConsole = CActiveConsole::NewLC(*console);
	activeConsole->RequestCharacter();
	CActiveScheduler::Start();
	// NB CActiveScheduler::Start only returns when someone somewhere has 
	// called CActiveScheduler::Stop.

	CleanupStack::PopAndDestroy(2); // activeConsole, scheduler

	console->Printf(_L("\nPress any key"));
	console->Getch(); // get and ignore character
	CleanupStack::PopAndDestroy(); // console
	}

LOCAL_C void mainL()
	{

	TInt timerDuration(KDefaultTimeout);

	// There's only something useful to do if the timeDuration is
	// a positive value.
	if(timerDuration > 0)
		{
		CConsoleBase* console; // write all your messages to this

		console=Console::NewL(KTxtExampleCode,TSize(KConsFullScreen,KConsFullScreen));
		
		console->Printf(KFormatRunning, timerDuration);

		while(1)
		{
		//console->Printf(KTxtExampleCode);
		User::After(1000000); //After 1 sec
		}

		}
    }

/**
 *
 * Open a log.
 *
 * @param	"const TDesC& aLogName"
 *			The log name
 *
 * @param	"TInt aLogMode"
 *			The log mode (as bitmask of TTestFrameworkLogMode)
 *
 * @xxxx
 *
 */
void CTestFrameworkServer::OpenLogL(const TDesC& aLogName, TInt aLogMode)
{
    // NB we need to check if a console is already open - if so, we do NOT
    // create another one. Ditto with file / port.

    if(aLogMode & ELogToConsole)
    {
        if(!iConsole)
        {
            iConsole = CServerConsole::NewL(aLogName);

            CConsoleBase* theConsole = iConsole->Console();
            theConsole->Printf(_L("%S : Server log starting\n"), &aLogName);

            iLogMode |= ELogToConsole;

            if (aLogMode & ELogConsoleFull)
                iLogMode |= ELogConsoleFull;
        }
    }

    // NB relative paths will not work with TParse (there is no file server open).
    // Exception is a bare filename (with no path) : this will be found in root of C:

    // NOTE! We have no mechanism to notify this error. The console will display
    // and then exit. The log file cannot be opened.

    // TO BE ENHANCED - if console is made active, then we can pause

    if(aLogMode & ELogToFile)
    {
        if(!iFileLogger)
        {
            TRAPD(err, iFileLogger = CFileLogger::NewL());
            if(err != KErrNone)
            {
                // if we can't create a logger, we panic
                User::Panic(_L("TestFrameworkServer"), 1);
            }

            _LIT(KLogPath, "C:\\Logs\\TestResults");
            _LIT(KDefault, "C:\\.htm");

            TParse parseLogName;
            parseLogName.Set(aLogName, NULL, NULL);

            TFileName logFilePath;
            logFilePath = KLogPath;

            if(parseLogName.PathPresent())
                logFilePath.Append(parseLogName.Path());
            else
                logFilePath.Append(_L("\\"));


            // overwrite extension if supplied with .htm
            TParse logFileFullName;
            TInt returnCode = logFileFullName.Set(KDefault, &logFilePath, &aLogName);
            if (returnCode == KErrNone)
            {
                TInt ret = iFileLogger->Connect();
                if (ret == KErrNone)
                {
                    iFileLogger->CreateLog(logFilePath, logFileFullName.NameAndExt());
                    iLogMode |= ELogToFile;
                }
            }
        }
    }

    if(aLogMode & ELogToPort)
    {
        // RDebug::Print will deal with the serial port, we don't do anything special here
        iLogMode |= ELogToPort;
    }
}

void CBtraceReader::DecodeFrame(const TBtraceHeader& aHeader, const TDesC8& aFrame, TUint32)
{
    if (aHeader.iCategory == BTrace::EKernPrintf)
    {
        TUint32 threadId = *(TUint32*)aFrame.Ptr();
        TBuf<256> text;
        text.Copy(aFrame.Mid(4));
        if (iDebugConsole)
        {
            iDebugConsole->Printf(_L("Kern::Printf (0x%08x) \'%S\'\r\n"), &threadId, &text);
        }
    }
    else if (aHeader.iCategory == RMemSampler::EBtraceCategory)
    {
        switch (aHeader.iSubCategory)
        {
        case RMemSampler::ENewChunk:
        {
            TUint32 address = *(TUint32*)aFrame.Ptr();
            TInt maxSize = *((TUint32*)aFrame.Ptr() + 1);
            TFullName fullName;
            fullName.Copy(aFrame.Mid(8));
            if (iDebugConsole)
            {
                iDebugConsole->Printf(_L("New chunk - %S\r\n\taddress: 0x%08x max size: %d\r\n"), &fullName, address, maxSize);
            }
            if (iMemoryView)
            {
                iMemoryView->HandleNewChunk(fullName, address, maxSize);
            }
            break;
        }
        case RMemSampler::EChangedChunk:
        {
            TUint32 address = *(TUint32*)aFrame.Ptr();
            TUint32 size = *((TUint32*)aFrame.Ptr() + 1);
            TUint32 highWaterMark = *((TUint32*)aFrame.Ptr() + 2);
            if (iDebugConsole)
            {
                iDebugConsole->Printf(_L("Changed chunk - address: 0x%08x size: %d hwm: %d\r\n"), address, size, highWaterMark);
            }
            if (iMemoryView)
            {
                iMemoryView->HandleChangedChunk(address, size, highWaterMark);
            }
            break;
        }
        case RMemSampler::EDeletedChunk:
        {
            TUint32 address = *(TUint32*)aFrame.Ptr();
            if (iDebugConsole)
            {
                iDebugConsole->Printf(_L("Deleted chunk - address: 0x%08x\r\n"), address);
            }
            if (iMemoryView)
            {
                iMemoryView->HandleDeletedChunk(address);
            }
            break;
        }
        }
    }
}

void MainL()
	{
	
	/* Create the named - pipe */
    int ret_val = mkfifo(HALF_DUPLEX, S_IWUSR | S_IRUSR | S_IRGRP | S_IROTH);
    
    if ((ret_val == -1) && (errno != EEXIST)) {
        perror("Error creating the named pipe");
        return ; 
        //exit (1);
    }
    
    int pipe = open(HALF_DUPLEX, O_RDONLY | O_NONBLOCK);
    
	_LIT(KTitle,"TestExecute Standalone Logger Test Code");
	CConsoleBase* console = Console::NewL(KTitle,TSize(KConsFullScreen,KConsFullScreen));
	CleanupStack::PushL(console);

	_LIT(KMessage1,"Connect() To Logger and Close() immediately\r\n");
	console->Printf(KMessage1);
	RTestExecutePIPSLogServ logger;
	User::LeaveIfError(logger.Connect());
	logger.Close();

	_LIT(KMessage2,"Immediate re-Connect() To Logger and Close() immediately\r\n");
	console->Printf(KMessage2);
	User::LeaveIfError(logger.Connect());
	logger.Close();

	_LIT(KMessage3,"Immediate re-Connect() To Logger CreateLog() and Close() immediately\r\n");
	console->Printf(KMessage3);
	User::LeaveIfError(logger.Connect());
	User::LeaveIfError(logger.CreateLog(KLogFile1));
	logger.Close();

	// OS needs time to shutdown the server
	// No delay means we get server terminated from the OS
	User::After(1000000);

	_LIT(KMessage4,"Connect() To Logger CreateLog() %S Call API's\r\n");
	TBuf<80> logFile(KLogFile1);
	console->Printf(KMessage4,&logFile);
	User::LeaveIfError(logger.Connect());
	User::LeaveIfError(logger.CreateLog(KLogFile1));
	TBuf<20> buf16(K16BitString);
	TBuf8<20> buf8(K8BitString);
	logger.Write(K16BitText);
	logger.Write(K8BitText);
	logger.WriteFormat(K16BitFormatText,16,&buf16);
	logger.WriteFormat(K8BitFormatText,8,&buf8);
	logger.LogExtra(((TText8*)__FILE__), __LINE__,ESevrInfo,K16BitFormatText,1,&buf16);

	_LIT(KMessage5,"ALL API's Called - Call Close(),\r\n");
	console->Printf(KMessage5);
	//console->Getch();
	logger.Close();
	
	//try an empty pipe 
	_LIT(KLogFileEmpty,"");
	_LIT(KMessageEmp,"Connect() To Logger CreateLog() %S Call API's\r\n");
	TBuf<80> logFiley(KLogFileEmpty);
	console->Printf(KMessageEmp,&logFiley);
	User::LeaveIfError(logger.Connect());
	User::LeaveIfError(logger.CreateLog(KLogFileEmpty));
	logger.Write(K16BitText);
	logger.Write(K8BitText);
	logger.WriteFormat(K16BitFormatText,16,&buf16);
	logger.WriteFormat(K8BitFormatText,8,&buf8);
	logger.LogExtra(((TText8*)__FILE__), __LINE__,ESevrInfo,K16BitFormatText,1,&buf16);
	console->Printf(KMessage5);
	console->Getch();
	logger.Close();

	CleanupStack::PopAndDestroy(console);

	}