/*

* 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 <new>

 #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( "seekpL", Ctiostreams::seekpL ),

        };

    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

    }

   catch(...)

   {

   	failures++;

   }

	if( failures == 0 )

		return KErrNone;

  else  

		return KErrGeneral;

    }

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

// Ctiostreams:: ostream

// Example test method function.

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

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

//

 TInt Ctiostreams::ostreamL(CStifItemParser& aItem )

 {

 int failures = 0;

 try

 {

 filebuf fb;

char input[17] = "ostream testcase";

streamsize size = 5;

  fb.open ("c:\\TestFramework\\docs\\ostream.txt",ios::out);

  cout<<"";

  #if  STDCPP_OOM

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

  #endif 

  ostream os(&fb);

  os.write(input,size);

  streamoff i = os.tellp();

  if(i!= 5)

  failures++;

  os.put('K');

  streamoff j = os.tellp();

  if(j!=6)

  failures++;

  os.seekp(2);

    os<<"i";

  streamoff k = os.tellp();

  if(k!=3)

  failures++;

 os.flush();

   #if  STDCPP_OOM

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

  #endif 

  /*

  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:: istream

// Example test method function.

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

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

//

  TInt Ctiostreams::istreamL(CStifItemParser& aItem )

  {

int failures =0;

try

{

int length;

//char * buffer;

char getl[8] ;

 filebuf fb;

 fb.open ("c:\\TestFramework\\docs\\istream.txt",ios::in);

 cout<<"";

 #if  STDCPP_OOM

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

  #endif 

 istream is(&fb);

 //needs to rewrite

  // get length of file:

  is.seekg (0, ios::end);

  length = is.tellg();

  is.seekg (0, ios::beg);

if(length != 7)

failures++;

 char ch = is.get();

 if(is.gcount() != 1)

 failures++;

 if( ch != 'S')

 failures++;

 char pk1 = is.peek();

 if(pk1!= 'h')

 failures++;

 is.unget();

 char pk2 = is.peek();

 if(pk2!= 'S')

 failures++;

 is.get();

 is.putback('K');

 is.getline(getl,8,'\0');

 if(getl == "Khaheen")

 failures++;

 if(is.gcount() != 7)

 failures++;

  fb.close();

  /*if(failures)

  return KErrGeneral;

  return KErrNone;

 */

   #if  STDCPP_OOM

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

  #endif 

   //#if STDCPP_OOM

//failures++;

// #endif

  }

  catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

	if( failures == 0 )

		return KErrNone;

  else  

		return KErrGeneral;

    }

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

// Ctiostreams:: istringstream

// Example test method function.

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

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

//  

   TInt Ctiostreams::istringstreamL(CStifItemParser& aItem )

   {

   	int n,val;

 	int failures =0;

 	try

 	{

 	string strvalues = "125 320 512 750 333";

 	cout<<"";	

 	#if  STDCPP_OOM

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

  #endif 

  	istringstream iss (strvalues,istringstream::in);

if(iss.str()  != "125 320 512 750 333")

failures++;

#if  STDCPP_OOM

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

  #endif 

  for (n=0; n<5; n++)

  {

    iss >> val;

     switch(n)

    {

    	case 0:

    	if(val!=125)

    	failures++;

    	break;

    	case 1:

    	if(val!=320)

    	failures++;

    	break;

    	case 2:

    	if(val!=512)

    	failures++;

    	break;

    	case 3:

    	if(val!=750)

    	failures++;

    	break;

    	case 4:

    	if(val!=333)

    	failures++;

    	break;

    default:

    break;

    }

  }

   //#if STDCPP_OOM

//failures++;

// #endif

/* if(failures)

 return KErrGeneral;

 else

 return KErrNone;*/

   }

   catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

	if( failures == 0 )

		return KErrNone;

  else  

		return KErrGeneral;

    }

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

// Ctiostreams:: ostringstream,

// Example test method function.

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

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

//

   TInt Ctiostreams::ostringstreamL(CStifItemParser& aItem )

   {

 	int failures =0 ;

 	try

 	{

 	basic_string<char> i( "test" );

 	cout<<"";

 	#if  STDCPP_OOM

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

  #endif 

   ostringstream ss;

   ss.rdbuf( )->str( i );

   if(ss.str( ).compare("test") != 0)

   failures++; 

   ss << "z";

   if(ss.str( ) .compare("zest")!=0)

   failures++;

   ss.rdbuf( )->str( "be" );

   if(ss.str( ).compare("be")!=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;

    }

    TInt Ctiostreams::ostreamiterators(CStifItemParser& aItem )

    {

  //needs to rewrite

  //____________________

   int arr[4] = { 3,4,7,8 };

//   int total=0;

   deque<int> d(arr+0, arr+4);

   //

   // stream the whole vector and a sum to cout

   //

   copy(d.begin(),(d.end()-1),ostream_iterator<int,char>(cout,""));

  if( *(d.end()-1) == 8)

  return KErrNone;

  return KErrGeneral;

 }

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

// Ctiostreams:: fstream

// Example test method function.

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

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

//

    TInt Ctiostreams::fstreamL(CStifItemParser& aItem ) 

    {

   //  __UHEAP_MARK;

int failures =0;

try

{

cout<<"";	

#if  STDCPP_OOM

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

  #endif 

fstream filestr ("c:\\TestFramework\\docs\\fstream.txt", fstream::in | fstream::out);

if(!filestr.is_open())

failures++;

filestr.close();

if(filestr.is_open())

failures++;

 // __UHEAP_MARKEND;

  /*if(failures)

return KErrNone;

return KErrGeneral;

    */  

 #if  STDCPP_OOM

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

  #endif    

   //#if STDCPP_OOM

//failures++;

// #endif

    }

   catch(bad_alloc&)

   {

   	//do nothing

    }

   catch(...)

   {

   	failures++;

   }

	if( failures == 0 )

		return KErrNone;

  else  

		return KErrGeneral;

    } 

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

// Ctiostreams:: istrstream

// Example test method function.

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

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

//   

    TInt Ctiostreams::istrstreamL(CStifItemParser& aItem ) 

    {

  //  __UHEAP_MARK;	

  int failures=0;

  try

  {

    char* p = "This is first string";

    char* q = "This is second string";

    char* r = "";

    const char* s ="const char";

    streamsize  n =10;

    cout<<"";

    #if  STDCPP_OOM

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

  #endif 

    istrstream first(p);

    istrstream second(q);