// Copyright (c) 2007-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:

// The TEFUnit test suite for FixedDialling in the Common TSY.

// 

//

/**

 @file 

*/

#include "cctsyfixeddiallingfu.h"

#include <etel.h>

#include <etelmm.h>

#include <et_clsvr.h>

#include <ctsy/mmtsy_names.h>

#include <ctsy/serviceapi/mmtsy_ipcdefs.h>

#include "tmockltsydata.h"

#include <ctsy/serviceapi/gsmerror.h>

CTestSuite* CCTsyFixedDiallingFU::CreateSuiteL(const TDesC& aName)

	{

	SUB_SUITE;

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0001bL);

    ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0001cL);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0002L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0004L);	

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0006L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0006bL);

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0007L);  still not supported

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0008L);  still not supported

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck0009L);  still not supported

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck00010L); still not supported

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck00011L);

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck00012L); still not supported

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck00013L); still not supported

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck00014L); still not supported

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestDialNoFdnCheck00015L); still not supported

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestGetFdnStatus0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestGetFdnStatus0002L);

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestGetFdnStatus0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestGetFdnStatus0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestGetFdnStatus0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestSetFdnSetting0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestSetFdnSetting0002L);

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestSetFdnSetting0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestSetFdnSetting0004L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestSetFdnSetting0005L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestNotifyFdnStatusChange0001L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestNotifyFdnStatusChange0002L);

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestNotifyFdnStatusChange0003L);

	ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestNotifyFdnStatusChange0004L);

	//ADD_TEST_STEP_ISO_CPP(CCTsyFixedDiallingFU, TestNotifyFdnStatusChange0005L);

	END_SUITE;

	}

//

// Actual test cases

//

/**

@SYMTestCaseID BA-CTSY-FXD-CDNFC-0001

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialNoFdnCheck for voice calls

@SYMTestPriority High

@SYMTestActions Invokes RMobileCall::DialNoFdnCheck for voice calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyFixedDiallingFU::TestDialNoFdnCheck0001L()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 expectData;

	CleanupClosePushL(expectData);

	RBuf8 completeData;

	CleanupClosePushL(completeData);

    TInt errorCode = KErrNone;    

    //-- For Voice1 -------------------------

    TBuf<256> lineName(KMmTsyVoice1LineName);    

    // Open new line

    RLine line;

    errorCode = line.Open(iPhone, lineName);

    ASSERT_EQUALS(KErrNone, errorCode);

    CleanupClosePushL(line);      

    // open call

    _LIT(KDoubleColon, "::");    

    TBuf<256> name;

    name = KMmTsyPhoneName;

    name.Append(KDoubleColon);

    name.Append(lineName);

    name.Append(KDoubleColon);

    RMobileCall call;

    errorCode = call.OpenNewCall(line, name);

    ASSERT_EQUALS(KErrNone, errorCode);

    CleanupClosePushL(call);   

    TRequestStatus requestStatus;    

    _LIT(KSomeNumber, "123456789");    

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

	// TEST A: failure to dispatch request to LTSY

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

	// data for ExpextL

	RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;    

    TInt expecteCallId = 0;

    RMobileCall::TMobileCallParamsV1 callParams; 

    RMobileCall::TMobileCallParamsV1Pckg    pckgCallParams(callParams);

    RMobileCall::TMobileCallInfoV8 callInfo;   

	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;    

	callInfo.iService	= mobileService;

	callInfo.iStatus	= RMobileCall::EStatusUnknown;

	callInfo.iCallId	= -1;

	callInfo.iExitCode	=0; 

	callInfo.iEmergency	=0;

	callInfo.iForwarded	=0;	

	callInfo.iPrivacy				= RMobilePhone::EPrivacyUnspecified;

	callInfo.iAlternatingCall		= RMobilePhone::EAlternatingModeUnspecified;	

	//callInfo.iDuration.iIntervel	= 0;			// this is protected value

	callInfo.iDialledParty.iTelNumber.Copy( KSomeNumber );

	callInfo.iDialledParty.iNumberPlan = 

        RMobilePhone::EUnknownNumberingPlan;

    callInfo.iDialledParty.iTypeOfNumber = 

        RMobilePhone::EUnknownNumber;	

    TMockLtsyCallData2< RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV8 >

    											 mockCallData(expecteCallId, mobileService, callParams, callInfo);

    mockCallData.SerialiseL(expectData);

    iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData, KErrNotSupported);

    call.DialNoFdnCheck(requestStatus, pckgCallParams, KSomeNumber);

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());      

    CleanupStack::PopAndDestroy();// call  

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

	// Test B: Test passing wrong descriptor size to parameter in

	// RMobileCall::DialNoFdnCheck

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

 	TInt callId = 1;

 	// create new incoming call

 	TName incomingCallName;

 	RMobileCall::TMobileCallStatus mobileCallStatus = RMobileCall::EStatusIdle; 

	errorCode = CreateIncomingCallL(line, callId, lineName, incomingCallName, 

                             mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);	 	

    // --------  make for this call callId > 0 --------------------------------------

	line.NotifyIncomingCall(requestStatus, incomingCallName);

    callInfo.iService = mobileService;

    TMockLtsyCallData1<RMobileCall::TMobileCallInfoV1> idleCallData3(callId, mobileService, callInfo);

    idleCallData3.SerialiseL(completeData);

	TRequestStatus mockLtsyStatus;

    iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.CompleteL(EEtelLineNotifyIncomingCall, KErrNone, completeData);

    User::WaitForRequest(mockLtsyStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNone, requestStatus.Int());

    errorCode = call.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

	CleanupClosePushL(call);

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

 	// data for ExpectL 		

 	callInfo.iRemoteParty.iDirection = RMobileCall::EMobileTerminated; 	

 	TMockLtsyCallData2< RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1 >

    											 mockCallData2(callId, mobileService, callParams, callInfo);

    expectData.Close();

    mockCallData2.SerialiseL(expectData);

 	// data for CompleteL 	

 	TMockLtsyCallData0 mockDataComplete(callId, mobileService);

 	completeData.Close();

 	mockDataComplete.SerialiseL(completeData);

 	iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData);   	

  	iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrGeneral, completeData);   	

    call.DialNoFdnCheck(requestStatus, pckgCallParams, KSomeNumber);   

    User::WaitForRequest(requestStatus);          

    ASSERT_EQUALS(KErrGeneral, requestStatus.Int());    

    AssertMockLtsyStatusL();  

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

	// TEST C: Successful completion request of

	// RMobileCall::DialNoFdnCheck when result is not cached.

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

	iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData);   	

  	iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData);   	

    call.DialNoFdnCheck(requestStatus, pckgCallParams, KSomeNumber);   

    User::WaitForRequest(requestStatus);          

    ASSERT_EQUALS(KErrNone, requestStatus.Int());

    AssertMockLtsyStatusL();   

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

	// TEST E: Unsolicited completion of RMobileCall::DialNoFdnCheck

	// from LTSY.

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

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData);

	User::WaitForRequest(mockLtsyStatus);

	AssertMockLtsyStatusL();	

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

	// TEST 1  for coverage increasing

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

 	// change status of call

 	mobileCallStatus = RMobileCall::EStatusRinging;

    TMockLtsyCallData1<RMobileCall::TMobileCallStatus> mockCallData4(callId, mobileService, mobileCallStatus);

    completeData.Close();

    mockCallData4.SerialiseL(completeData);

    iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.CompleteL(EMobileCallNotifyMobileCallStatusChange, KErrNone, completeData);

    User::WaitForRequest(mockLtsyStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

   	call.DialNoFdnCheck(requestStatus, pckgCallParams, KSomeNumber);   

    User::WaitForRequest(requestStatus);          

    ASSERT_EQUALS(KErrNotReady, requestStatus.Int());

    AssertMockLtsyStatusL();   

    // data for ExpectL

    TInt hangUpCause( KErrGsmReleaseByUser );

    TBool autoStChangeDisable = EFalse; 

    TMockLtsyCallData2< TInt, TBool >

    							mockCallDataClose(callId, mobileService, hangUpCause, autoStChangeDisable);

    expectData.Close();

    mockCallDataClose.SerialiseL(expectData);

    iMockLTSY.ExpectL(EEtelCallHangUp, expectData); // this expect is necessary for call closing when EStatusRinging  

   	CleanupStack::PopAndDestroy(); // call

    AssertMockLtsyStatusL(); 

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

	// TEST 2  for coverage increasing

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

    // create new call    

    callId = 2;

    mobileCallStatus = RMobileCall::EStatusIdle;

    errorCode = CreateIncomingCallL(line, callId, lineName, incomingCallName, 

                             mobileService, mobileCallStatus);	

	ASSERT_EQUALS(KErrNone, errorCode);	 	

    errorCode = call.OpenExistingCall(line, incomingCallName);

    ASSERT_EQUALS(KErrNone, errorCode);

	CleanupClosePushL(call);

	// set RFStatus to Inactive state

	TRfStateInfo rfInfo (ERfsStateInfoInactive);

	TMockLtsyData1<TRfStateInfo> mockCallData5(rfInfo);

    completeData.Close();

    mockCallData5.SerialiseL(completeData);

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, completeData);

    User::WaitForRequest(mockLtsyStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

  	call.DialNoFdnCheck(requestStatus, pckgCallParams, KSomeNumber);       

    User::WaitForRequest(requestStatus); 

    TInt expectedErrorCode = ( KErrGeneral & 0x0000FFFF ) |( KErrGsmOfflineOpNotAllowed << 16 );

	expectedErrorCode = (expectedErrorCode>>16) | 0xFFFF0000;

    ASSERT_EQUALS(expectedErrorCode, requestStatus.Int());

    AssertMockLtsyStatusL();   

 	// close call, cause theres no way to use it again

   	CleanupStack::PopAndDestroy(&call);

   	AssertMockLtsyStatusL();

	// create new incoming call

	errorCode = call.OpenNewCall(line, name);

    ASSERT_EQUALS(KErrNone, errorCode);

    CleanupClosePushL(call); 

    // set RFStatus to Normal state

	rfInfo = ERfsStateInfoNormal;

	TMockLtsyData1<TRfStateInfo> mockCallData6(rfInfo);

    completeData.Close();

    mockCallData6.SerialiseL(completeData);

	iMockLTSY.NotifyTerminated(mockLtsyStatus);

    iMockLTSY.CompleteL(EMmTsyBootGetRFStatusIPC, KErrNone, completeData);

    User::WaitForRequest(mockLtsyStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNone, mockLtsyStatus.Int());

    // data for ExpectL

    callInfo.iRemoteParty.iDirection = RMobileCall::EDirectionUnknown; 	

    TMockLtsyCallData2< RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1 >    

    											 mockCallData7(expecteCallId, mobileService, callParams, callInfo);

	expectData.Close();    											 

    mockCallData7.SerialiseL(expectData);

	// Test A: ... 

	iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData, KErrNotSupported);    

    call.DialNoFdnCheck(requestStatus, pckgCallParams, KSomeNumber);

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int()); 

	// ...and now repeat this test A

    // This repetition is here to test that SetDialFlag(EFalse) is called when

    // the EMobileCallDialNoFdnCheck request completes with an error

    iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData, KErrNotSupported);

    call.DialNoFdnCheck(requestStatus, pckgCallParams, KSomeNumber);

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());

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

	// TEST to show defect 120102

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

  	iMockLTSY.ExpectL(EMobileCallDialNoFdnCheck, expectData);   	

 	CallGetMobileCallInfoL(callId, mobileService, KSomeNumber); 

 	completeData.Close();

 	TMockLtsyCallData0 mockDataComplete2(callId, mobileService);

 	mockDataComplete2.SerialiseL(completeData);

  	iMockLTSY.CompleteL(EMobileCallDialNoFdnCheck, KErrNone, completeData);   	

    call.DialNoFdnCheck(requestStatus, pckgCallParams, KSomeNumber);   

    User::WaitForRequest(requestStatus);      

    ASSERT_EQUALS(KErrNone, requestStatus.Int());      

    AssertMockLtsyStatusL();

	CleanupStack::PopAndDestroy(5, this); // ... this

	}

/**

@SYMTestCaseID BA-CTSY-FXD-CDNFC-0001b

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialNoFdnCheck for voice calls

@SYMTestPriority High

@SYMTestActions Invokes RMobileCall::DialNoFdnCheck for voice calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyFixedDiallingFU::TestDialNoFdnCheck0001bL()

	{

	OpenEtelServerL(EUseExtendedError);

	CleanupStack::PushL(TCleanupItem(Cleanup,this));

	OpenPhoneL();

	RBuf8 expectData;

	CleanupClosePushL(expectData);

    TInt errorCode = KErrNone;    

    //-- For Voice1 -------------------------    

    TBuf<256> lineName(KMmTsyVoice1LineName);

    // Open new line

    RLine line;

    errorCode = line.Open(iPhone, lineName);

    ASSERT_EQUALS(KErrNone, errorCode);

    CleanupClosePushL(line);  

    // open call

    _LIT(KDoubleColon, "::");

    TBuf<256> name;

    name = KMmTsyPhoneName;

    name.Append(KDoubleColon);

    name.Append(lineName);

    name.Append(KDoubleColon);

    RMobileCall call;

    errorCode = call.OpenNewCall(line, name);

    ASSERT_EQUALS(KErrNone, errorCode);

    CleanupClosePushL(call);    

    TRequestStatus requestStatus;

    _LIT(KSomeNumber, "123456789");

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

	// TEST A: failure to dispatch request to LTSY

	// for API version without params

	// i.e. for void RMobileCall::DialNoFdnCheck(TRequestStatus& aReqStatus,const TDesC& aTelNumber)

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

	// data for ExpextL

	RMobilePhone::TMobileService mobileService = RMobilePhone::EVoiceService;    

    TInt expecteCallId = 0;

    RMobileCall::TMobileCallParamsV1 callParams; 

    RMobileCall::TMobileCallParamsV1Pckg    pckgCallParams(callParams);

    RMobileCall::TMobileCallInfoV1 callInfo;   

	callInfo.iValid = RMobileCall::KCallDialledParty | RMobileCall::KCallAlternating;    

	callInfo.iService	= mobileService;

	callInfo.iStatus	= RMobileCall::EStatusUnknown;

	callInfo.iCallId	= -1;

	callInfo.iExitCode	=0; 

	callInfo.iEmergency	=0;

	callInfo.iForwarded	=0;	

	callInfo.iPrivacy				= RMobilePhone::EPrivacyUnspecified;

	callInfo.iAlternatingCall		= RMobilePhone::EAlternatingModeUnspecified;	

	//callInfo.iDuration.iIntervel	= 0;			// this is protected value

	callInfo.iTch = RMobileCall::ETchUnknown;				

	callInfo.iRemoteParty.iCallingName = KNullDesC;

	callInfo.iRemoteParty.iRemoteIdStatus = RMobileCall::ERemoteIdentityUnknown;

	callInfo.iRemoteParty.iRemoteNumber.iTelNumber = KNullDesC;

	callInfo.iRemoteParty.iRemoteNumber.iNumberPlan = RMobilePhone::EUnknownNumberingPlan;

	callInfo.iRemoteParty.iRemoteNumber.iTypeOfNumber = RMobilePhone::EUnknownNumber;

	callInfo.iDialledParty.iTelNumber.Copy( KSomeNumber );

	callInfo.iDialledParty.iNumberPlan = 

        RMobilePhone::EUnknownNumberingPlan;

    callInfo.iDialledParty.iTypeOfNumber = 

        RMobilePhone::EUnknownNumber;	

    TMockLtsyCallData2< RMobileCall::TMobileCallParamsV1, RMobileCall::TMobileCallInfoV1 >

    											 mockCallData(expecteCallId, mobileService, callParams, callInfo);

    mockCallData.SerialiseL(expectData);

    ERR_PRINTF2(_L("<font color=Orange>$CTSYKnownFailure: defect id = %d</font>"), 120101);

    iMockLTSY.ExpectL(EEtelCallDial, expectData, KErrNone);    

    // Cause to fail to show defect 120101

    ASSERT_TRUE(EFalse);

    call.DialNoFdnCheck(requestStatus, KSomeNumber);    

    User::WaitForRequest(requestStatus);

    AssertMockLtsyStatusL();

    ASSERT_EQUALS(KErrNotSupported, requestStatus.Int());    

    CleanupStack::PopAndDestroy(4, this); // call,line, expectData, this    

	}

/**

@SYMTestCaseID BA-CTSY-FXD-CDNFC-0001c

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileCall::DialNoFdnCheck for voice calls with minimal parameters (RCall::TCallParams)

@SYMTestPriority High

@SYMTestActions Invokes RMobileCall::DialNoFdnCheck for voice calls

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

void CCTsyFixedDiallingFU::TestDialNoFdnCheck0001cL()

    {

    OpenEtelServerL(EUseExtendedError);

    CleanupStack::PushL(TCleanupItem(Cleanup,this));

    OpenPhoneL();

    RBuf8 expectData;

    CleanupClosePushL(expectData);

    RBuf8 completeData;

    CleanupClosePushL(completeData);

    TInt errorCode = KErrNone;    

    //-- For Voice1 -------------------------

    TBuf<256> lineName(KMmTsyVoice1LineName);    

    // Open new line

    RLine line;

    errorCode = line.Open(iPhone, lineName);

    ASSERT_EQUALS(KErrNone, errorCode);

    CleanupClosePushL(line);      

    // open call