/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "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:       

*

*/

// INCLUDE FILES

#include <e32svr.h>

#include <StifParser.h>

#include <Stiftestinterface.h>

#include<iostream>

#include<fstream>

#include<string>

#include<ostream>

#include <sstream>

#include<strstream>

#include<deque>

#include<iterator>

#include<vector>

#include <ios>

#include <iostream>

#include <fstream>

#include <stl\char_traits.h>

 #include<e32std.h>

#include<exception>

#include "tiostreams.h"

using namespace std;

 #define STDCPP_OOM FALSE// TRUE for OOM testing

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// Ctiostreams::Delete

// Delete here all resources allocated and opened from test methods. 

// Called from destructor. 

// -----------------------------------------------------------------------------

//

void Ctiostreams::Delete() 

    {

    }

// -----------------------------------------------------------------------------

// Ctiostreams::RunMethodL

// Run specified method. Contains also table of test mothods and their names.

// -----------------------------------------------------------------------------

//

TInt Ctiostreams::RunMethodL( 

    CStifItemParser& aItem ) 

    {

    static TStifFunctionInfo const KFunctions[] =

        {  

        // Copy this line for every implemented function.

        // First string is the function name used in TestScripter script file.

        // Second is the actual implementation member function. 

              // Second is the actual implementation member function. 

 ENTRY( "iofstreamL", Ctiostreams::iofstreamL ),

 ENTRY( "stringbufL", Ctiostreams::stringbufL ),

 ENTRY( "stringstreamL", Ctiostreams::stringstreamL ),

 ENTRY( "streambufL", Ctiostreams:: streambufL ),

 ENTRY( "ostreamL", Ctiostreams:: ostreamL ),

 ENTRY( "istreamL", Ctiostreams:: istreamL ),

 ENTRY( "istringstreamL", Ctiostreams:: istringstreamL ),

 ENTRY( "ostringstreamL", Ctiostreams:: ostringstreamL ),

 ENTRY( "ostreamiterators", Ctiostreams::ostreamiterators ),

 ENTRY( "fstreamL", Ctiostreams::fstreamL),

 ENTRY( "istrstreamL", Ctiostreams::istrstreamL),

 ENTRY( "strstreamL", Ctiostreams::strstreamL),

 ENTRY( "ostrstreamL", Ctiostreams::ostrstreamL),

 ENTRY( "istreamiterators", Ctiostreams::istreamiterators ),

 ENTRY( "istreambufiterators", Ctiostreams::istreambufiterators ),

 ENTRY( "strstreambufL", Ctiostreams::strstreambufL ),

 ENTRY( "freezeL", Ctiostreams::freezeL ),

 ENTRY( "fposL", Ctiostreams::fposL ),

  ENTRY( "filebufL", Ctiostreams::filebufL ),

          ENTRY( "basicstring", Ctiostreams::basicstring ),

        ENTRY( "basicfilebufL", Ctiostreams::basicfilebufL ),

        ENTRY( "basicistreamL", Ctiostreams::basicistreamL ),

        ENTRY( "wfstreamL", Ctiostreams::wfstreamL ),

        ENTRY( "wifstreamL", Ctiostreams::wifstreamL ),

        ENTRY( "wistreamL", Ctiostreams::wistreamL ),

		ENTRY( "wofstreamL", Ctiostreams::wofstreamL ),

 		ENTRY( "wistringstreamL", Ctiostreams::wistringstreamL ),

 		ENTRY( "wostringstreamL", Ctiostreams::wostringstreamL ),

 		ENTRY( "wstreambufL", Ctiostreams::wstreambufL ),

 		ENTRY( "wostreamL", Ctiostreams::wostreamL ),

 		ENTRY( "wstringbufL", Ctiostreams::wstringbufL ),

        };

    const TInt count = sizeof( KFunctions ) / 

                        sizeof( TStifFunctionInfo );

    return RunInternalL( KFunctions, count, aItem );

    }

// -----------------------------------------------------------------------------

// Ctiostreams:: ofstream,ifstream

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt Ctiostreams::iofstreamL( CStifItemParser& aItem )

    {

//__UHEAP_MARK;

int failures=0 ;

try

{

cout<<"";	

#if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 

    ofstream myfile;

    filebuf *fbuf;

    char * buffer;

  long size;

    //ifstream 

  myfile.open ("c:\\TestFramework\\docs\\example.txt");

  if(!myfile.is_open())

  failures++;

  myfile << "Writing this to a file.";

  myfile<<"\0";

   myfile.close();

  if(myfile.is_open())

  failures++;

 // string line;

   ifstream myfile1; 

 myfile1.open("c:\\TestFramework\\docs\\example.txt" );

fbuf=myfile1.rdbuf();

 // get file size using buffer's members

  size=fbuf->pubseekoff (0,ios::end,ios::in);

  fbuf->pubseekpos (0,ios::in);

  // allocate memory to contain file data

  buffer=new char[size];

  // get file data  

  fbuf->sgetn (buffer,size);

#if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  #endif 

  if(buffer != "Writing this to a file.");

  else

  failures++;

  if(size!= 23)

  failures++;

if(!myfile1.is_open())

failures++;

myfile1.close();

if(myfile1.is_open())

failures++;

   delete buffer;

ios_base::Init();  // 0 -   218 FUNCTION Init()  iostream.cpp

filebuf*  _Stl_create_filebuf(FILE* f, ios_base::openmode mode );  // 0 -   225 FUNCTION _Stl_create_filebuf() iostream.cpp

ios_base::sync_with_stdio();//0 -   445 FUNCTION ios_base::sync_with_stdio()

/* 

 if(failures)

  return KErrGeneral;

 return KErrNone;

*/

  //#if STDCPP_OOM

//failures++;

// #endif

    }

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

	if( failures == 0 )

		return KErrNone;

  else  

		return KErrGeneral;

    }

// -----------------------------------------------------------------------------

// Ctiostreams:: stringbuf

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

 TInt Ctiostreams::stringbufL(CStifItemParser& aItem )

 {

 	int failures = 0;

 	try

 	{

 cout<<"";		

 #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 	

stringbuf sb;

  string mystr;

  sb.sputn("Sample string",13);

  mystr=sb.str();

   if(sb.in_avail()!=13)

  failures++;

    char ch = sb.sgetc();

   if(ch!= 'S')

   failures++;

   if(mystr.compare("Sample string") != 0)

   failures++;

  #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  #endif 

  /* if(failures)

  return KErrGeneral;

  else

  return KErrNone;

 */

   //#if STDCPP_OOM

//failures++;

// #endif

 }

 catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

	if( failures == 0 )

		return KErrNone;

  else  

		return KErrGeneral;

    }

// -----------------------------------------------------------------------------

// Ctiostreams:: stringstream

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

 TInt Ctiostreams::stringstreamL(CStifItemParser& aItem )

 {

 	int val;

  string  teststr;

  int failures = 0;

  try

  {

  cout<<"";	

  #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 

   stringstream ss (stringstream::in | stringstream::out);

   stringstream teststring;

   teststring<<"stringstream testcase";

   teststr = teststring.str();

   if(!teststr.compare("stringstream testcase"))

   ;

   else

   failures++;

 ss << "120 42 377 6 5 2000";

#if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  #endif 

 for (int n=0; n<6; n++)

  {

    ss >> val;

    switch(n)

    {

    	case 0://precision 

    	if(val!=120)

    	failures++;

    	break;

    	case 1:

    	if(val!=42)

    	failures++;

    	break;

    	case 2:

    	if(val!=377)

    	failures++;

    	break;

    	case 3:

    	if(val!=6)

    	failures++;

    	break;

    	case 4:

    	if(val!=5)

    	failures++;

    	break;

    	case 5:

    	if(val!=2000)

    	failures++;

    	break;

    default:

    break;

    }

  }

 /* if(failures)

   return KErrGeneral;

  return KErrNone;

 */

  //#if STDCPP_OOM

//failures++;

// #endif

 }

catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

	if( failures == 0 )

		return KErrNone;

  else  

		return KErrGeneral;

    }

// -----------------------------------------------------------------------------

// Ctiostreams:: streambuf

// Example test method function.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

 TInt Ctiostreams::streambufL(CStifItemParser& aItem )

 {

//    locale   loc ("en_GB.UTF-8");

 int failures = 0;

 try

 {

 char a[4]=

 {

 	0

 };

 char sentence[]= "Sample sentence";

 cout<<"";

 #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::EDeterministic,1);

  #endif 

 streambuf * pbuf;

 ofstream ostr ("c:\\TestFramework\\docs\\streambuf.txt");

 if(!cout.rdbuf( )->getloc( ).name( ).c_str( ))    //failing

// failures++;

 ;

 char ch[14];

 //rdbuf()s

 pbuf = ostr.rdbuf();

//sputn()

 pbuf->sputn (sentence,sizeof(sentence)-1);

 ostr.open("c:\\TestFramework\\docs\\streambuf.txt");

 if(!ostr.is_open())

 failures++;

 long size1 = pbuf->pubseekoff(0,ios_base::end);

 if(size1!=15)

 failures++;

  pbuf->sputc('a');

 long size2 = pbuf->pubseekoff(0,ios_base::end);

 if(size2!=16)

 failures++;

 ifstream istr("c:\\TestFramework\\docs\\streambuf.txt");

 pbuf = istr.rdbuf();

streamsize i = istr.rdbuf()->sgetn(&a[0], 3);   

    // Display the size and contents of the buffer passed to sgetn.

   if(i!=3)

   failures++;

 int k = pbuf->snextc();

 //sgetc()

 while (pbuf->sgetc()!=EOF)

  {

    // static int i;

    int  i=0;

      //sbumpc()

     ch[i] = pbuf->sbumpc();

     i++;

  }

  if(ch[0]!='a' )

  failures++;

  istr.close();

  #if  STDCPP_OOM

User::__DbgSetAllocFail(FALSE,RHeap::ENone,1);

  #endif 

  /*

  if(failures)

  return KErrGeneral;

  else

  return KErrNone;

   */

  //#if STDCPP_OOM

//failures++;

// #endif

 }

 catch(bad_alloc&)

   {

   	//do nothing