// Copyright (c) 1998-2009 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\locale\t_currencyformat.cpp

// Overview:

// Test the currency formatting capabilities of the locale class.

// API Information:

// TLocale.

// Details:

// - Set the currency symbol position before the currency amount.

// - Set no space between the currency symbol and the currency amount.

// - Set 2 decimal places to currency values. 

// - Set negative currency value to be enclosed in brackets without a minus sign.

// - Allow triads in currency values.

// - Set comma as separator to separate groups of three digits to the left of the decimal

// separator.

// - Set dot as separator to separate a whole number from its fractional part.

// - Set currency symbol to pound.

// - Test some simple English Locale currency formats and check it is as expected.

// - Render a currency value as text, based on the locale's currency and numeric format 

// settings and check the Overflow handling capability is as expected.

// - Change a variety of locale settings and verify currency formatting is as expected.

// - Change a variety of locale settings display the results.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h> 

#include <e32std.h>

#include <e32std_private.h>

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

_LIT(KNewLine, "\n");

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

LOCAL_D TLocale locale; 

class TTestOverflowHandler : public TDesOverflow

	{

	void Overflow(TDes& aDes);

	};

void TTestOverflowHandler::Overflow(TDes& aDes)

	{

	test.Printf(_L(" %S is too large... Overflow Handled!!"), &aDes);

	test.Printf(KNewLine);

	}

void SetEnglishCurrency()

	{

	locale.SetCurrencySymbolPosition(ELocaleBefore);

	locale.SetCurrencySpaceBetween(EFalse);

	locale.SetCurrencyDecimalPlaces(2);

	locale.SetCurrencyNegativeInBrackets(ETrue);

	locale.SetCurrencyTriadsAllowed(ETrue);

	locale.SetThousandsSeparator(',');

	locale.SetDecimalSeparator('.');

	User::SetCurrencySymbol(_L("\xA3"));

	}

void TestSimpleEnglishCurrencyFormat()

	{

	TBuf<32> fcurrency; 

	// Set a few of the locale variables and then test that formatting the amount

	// returns what we expected..... 

	test.Start(_L("Testing simple English Locale currency formats"));

	locale.FormatCurrency(fcurrency, 4000);

	test(fcurrency==_L("\xA3\x34\x30.00"));

	locale.FormatCurrency(fcurrency, -567654);

	test(fcurrency==_L("(\xA3\x35,676.54)"));

	locale.FormatCurrency(fcurrency,2);

	test(fcurrency==_L("\xA3\x30.02"));

	locale.FormatCurrency(fcurrency,12500000);

	test(fcurrency==_L("\xA3\x31\x32\x35,000.00"));

	locale.FormatCurrency(fcurrency, 00001);

	test(fcurrency==_L("\xA3\x30.01"));

	test.Printf(_L("SimplEnglishCurrencyPass"));

	}

void TestOverflowCapacity()

	{

	// try to test each stage that overflow at occur

	TBuf<10> smallcurrency;

	TTestOverflowHandler handler; 

	test.Next(_L("Testing the Overflow handling capability"));

	// test the overflow handling capability

	locale.SetCurrencyDecimalPlaces(11);

	locale.FormatCurrency(smallcurrency,handler,1);

	test(smallcurrency!=_L("0.00000000001"));

	locale.SetCurrencyDecimalPlaces(2);

	locale.FormatCurrency(smallcurrency,handler, -1234567890);

	test(smallcurrency!=_L("(\xA3\x31\x32\x33\x34\x35\x36\x37\x38.90)"));

	locale.FormatCurrency(smallcurrency, handler, 95000000);

	test(smallcurrency!=_L("\xA3\x39\x35\x30,000.00"));

	locale.SetCurrencySpaceBetween(ETrue);

	locale.FormatCurrency(smallcurrency, handler, 2000000);

	test(smallcurrency!=_L("\xA3 20,000.00"));

	locale.FormatCurrency(smallcurrency, handler, -240000);

	test(smallcurrency!=_L("(\xA3 2,400.00)"));

	User::SetCurrencySymbol(_L("Fake\xA3"));

	locale.FormatCurrency(smallcurrency, handler, 240);

	test(smallcurrency==_L("Fake\xA3 2.40"));

	locale.SetCurrencySpaceBetween(EFalse);

	locale.FormatCurrency(smallcurrency, handler, -240);

	test(smallcurrency!=_L("(Fake\xA3\x32.40)"));

	test.Printf(_L("Overflow Pass"));

	}

void TestChangeInformation()

	{

	TBuf<32> fcurrency; 

	// Make changes to the locale currency informationa and check formatting

	test.Next(_L("Changing locale information and testing currency Formatting "));

	// Change the format, add space in between

	locale.SetCurrencySpaceBetween(ETrue);

	locale.FormatCurrency(fcurrency,450);

	test(fcurrency==_L("\xA3 4.50"));

	// change the position of the CurrencySymbol 

	locale.SetCurrencySymbolPosition(ELocaleAfter);

	locale.FormatCurrency(fcurrency, 300000);

	test(fcurrency==_L("3,000.00 \xA3"));

	// test the negative format implementation

	locale.FormatCurrency(fcurrency , -3000);

	test(fcurrency!=_L("-30.00 \xA3"));

	test(fcurrency==_L("(30.00 \xA3)"));

	// call the deprecated function to check for compatability

	locale.SetCurrencyNegativeInBrackets(ETrue);

	locale.SetNegativeLoseSpace(ETrue);

	locale.SetNegativeCurrencySymbolOpposite(ETrue);

	locale.FormatCurrency(fcurrency,-2500);

	locale.SetNegativeCurrencySymbolOpposite(EFalse);

	locale.SetNegativeLoseSpace(EFalse);

	test(fcurrency==_L("(\xA3\x32\x35.00)"));

	locale.SetCurrencySymbolPosition(ELocaleBefore);

	locale.FormatCurrency(fcurrency, 300000);

	test(fcurrency==_L("\xA3 3,000.00"));

	// test the negative format implementation

	locale.FormatCurrency(fcurrency , -3000);

	test(fcurrency!=_L("-30.00 \xA3"));

	test(fcurrency==_L("(\xA3 30.00)"));

	// call the deprecated function to check for compatability

	locale.SetCurrencyNegativeInBrackets(ETrue);

	locale.SetNegativeLoseSpace(ETrue);

	locale.SetNegativeCurrencySymbolOpposite(ETrue);

	locale.FormatCurrency(fcurrency,-2500);

	locale.SetNegativeCurrencySymbolOpposite(EFalse);

	test(fcurrency==_L("(25.00\xA3)"));

	// test the New NegativeCurrencyFormat

	locale.SetNegativeCurrencyFormat(TLocale::EInterveningMinusSign);

	locale.FormatCurrency(fcurrency,-32500);

	test(fcurrency==_L("\xA3-325.00"));

	// test the decimal places implementation

	locale.SetCurrencyDecimalPlaces(6);

	locale.FormatCurrency(fcurrency,-32500);

	locale.SetNegativeLoseSpace(EFalse);

	test(fcurrency==_L("\xA3-0.032500"));

	// testing Thousandseparators and triads

	locale.SetCurrencyDecimalPlaces(2);

	locale.SetThousandsSeparator(' ');

	locale.SetCurrencySymbolPosition(ELocaleAfter);

	locale.FormatCurrency(fcurrency, 300000000);

	test(fcurrency==_L("3 000 000.00 \xA3"));

	locale.SetCurrencyTriadsAllowed(EFalse);

	locale.FormatCurrency(fcurrency, 300000000);

	test(fcurrency==_L("3000000.00 \xA3"));

	// test the other NegativeCurrencyFormat Options

	locale.SetNegativeCurrencyFormat(TLocale::ETrailingMinusSign);

	locale.FormatCurrency(fcurrency, -24000000);

	test(fcurrency==_L("240000.00 \xA3-"));

	locale.SetNegativeCurrencyFormat(TLocale::EInterveningMinusSign);

	locale.FormatCurrency(fcurrency, -40000000);

	test(fcurrency== _L("400000.00- \xA3"));

	// change the currency symbol 

	User::SetCurrencySymbol(_L("NZ$"));

	locale.FormatCurrency(fcurrency,250000);

	test(fcurrency!=_L("2,500.00 \xA3"));

	test(fcurrency==_L("2500.00 NZ$"));

	// move the currency symbol forward

	locale.SetCurrencySymbolPosition(ELocaleBefore);

	locale.FormatCurrency(fcurrency,300);

	test(fcurrency==_L("NZ$ 3.00"));

	locale.SetCurrencySpaceBetween(EFalse);

	locale.FormatCurrency(fcurrency, 43020);

	test(fcurrency==_L("NZ$430.20"));

	locale.SetCurrencyTriadsAllowed(ETrue);

	locale.SetThousandsSeparator(',');

	locale.SetCurrencySpaceBetween(ETrue);

	locale.FormatCurrency(fcurrency,-2450000);

	test(fcurrency==_L("NZ$ -24,500.00"));

	locale.SetNegativeCurrencySymbolOpposite(EFalse);

	}

void TestDisplyCurrencyFormats() 

	{

	// Display Differenct locale currency as a test 

	test.Next(_L("Samples of a few Currency formats that can be displayed"));

	TBuf<32> fcurrency; 

	locale.FormatCurrency (fcurrency, 2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	locale.SetCurrencySpaceBetween(EFalse);

	User::SetCurrencySymbol(_L("\xA3"));

	locale.SetCurrencySymbolPosition(ELocaleAfter);

	locale.FormatCurrency (fcurrency, 2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	locale.SetCurrencySymbolPosition(ELocaleBefore);

	User::SetCurrencySymbol(_L("$"));

	locale.SetNegativeCurrencyFormat(TLocale::EInBrackets);

	locale.FormatCurrency (fcurrency, -2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	locale.SetNegativeCurrencyFormat(TLocale::ELeadingMinusSign);

	locale.FormatCurrency (fcurrency, -2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	locale.SetNegativeCurrencySymbolOpposite(ETrue);

	locale.SetNegativeLoseSpace(ETrue);

	locale.FormatCurrency (fcurrency, -2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	locale.SetNegativeCurrencySymbolOpposite(EFalse);

	locale.SetNegativeCurrencyFormat(TLocale::EInterveningMinusSign);

	locale.FormatCurrency (fcurrency, -2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	//******************

	locale.SetCurrencySymbolPosition(ELocaleAfter);

	User::SetCurrencySymbol(_L("$"));

	locale.SetNegativeCurrencyFormat(TLocale::EInBrackets);

	locale.SetNegativeLoseSpace(ETrue);

	locale.FormatCurrency (fcurrency, -2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	locale.SetNegativeCurrencyFormat(TLocale::ELeadingMinusSign);

	locale.FormatCurrency (fcurrency, -2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	locale.SetNegativeCurrencySymbolOpposite(ETrue);

	locale.SetNegativeLoseSpace(ETrue);

	locale.FormatCurrency (fcurrency, -2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	locale.SetNegativeCurrencySymbolOpposite(EFalse);

	locale.SetNegativeCurrencyFormat(TLocale::EInterveningMinusSign);

	locale.FormatCurrency (fcurrency, -2500000);

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	//******************

	TInt64 x=25000000;

	x*=10000;

	locale.FormatCurrency (fcurrency,x );

	test.Printf(fcurrency);

	test.Printf(KNewLine);

	}

GLDEF_C TInt E32Main(void)

	{

	// Call all the tests from here 

	test.Title();

	SetEnglishCurrency(); 

	TestSimpleEnglishCurrencyFormat();

	TestOverflowCapacity();

	SetEnglishCurrency(); 

	TestChangeInformation();

	TestDisplyCurrencyFormats();

	test.End();

	return KErrNone; 

	}