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

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // TE_ETELCOREDTSD.CPP

    15 // 

    16 //

    17 

    18 #include "TE_EtelBase.h"

    19 #include "TE_Etelcoredstd.h"

    20 

    21 CTestOpenPhoneFc::CTestOpenPhoneFc()

    22 /** Each test step initialises it's own name

    23 */

    24 	{

    25 	SetTestStepName(_L("TestOpenPhoneFc"));

    26 	}

    27 

    28 enum TVerdict CTestOpenPhoneFc::doTestStepL()

    29 	{

    30 	INFO_PRINTF1(_L("Test Open Phone Fc"));

    31     RTelServer server;

    32 	TInt ret = server.Connect();

    33 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

    34     TESTCHECK(ret, KErrNone);

    35    	ret=server.LoadPhoneModule(DSTD_MODULE_NAME);

    36     TESTCHECK(ret, KErrNone);

    37 

    38 	RPhone phoneFc;

    39     ret = phoneFc.Open(server,DSTDFC_PHONE_NAME);

    40     TESTCHECK(ret, KErrNone);

    41 	phoneFc.Close();

    42 

    43 	ret=server.UnloadPhoneModule(DSTD_MODULE_NAME);

    44 	TESTCHECK(ret, KErrNone);

    45     ServerClose(server);

    46 

    47 	return TestStepResult();

    48 	}

    49 

    50 CTestOpenAllSubSessInFc::CTestOpenAllSubSessInFc()

    51 /** Each test step initialises it's own name

    52 */

    53 	{

    54 	SetTestStepName(_L("TestOpenSubSessInFc"));

    55 	}

    56 

    57 enum TVerdict CTestOpenAllSubSessInFc::doTestStepL()

    58 	{

    59 	INFO_PRINTF1(_L("Test Open All Sub Sessions In Fc"));

    60     RTelServer server;

    61 	TInt ret = server.Connect();

    62 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

    63     TESTCHECK(ret, KErrNone);

    64    	ret=server.LoadPhoneModule(DSTD_MODULE_NAME);

    65     TESTCHECK(ret, KErrNone);

    66 

    67 	RPhone phoneFc;

    68     ret = phoneFc.Open(server,DSTDFC_PHONE_NAME);

    69     TESTCHECK(ret, KErrNone);

    70 	RLine lineFc;

    71     ret = lineFc.Open(phoneFc,DSTDFC_LINE_NAME);

    72 	TESTCHECK(ret, KErrNone);

    73 	RCall callFc;

    74 	ret = callFc.OpenNewCall(lineFc);

    75     TESTCHECK(ret, KErrNone);

    76 	RFax faxFc;

    77     ret = faxFc.Open(callFc);

    78     TESTCHECK(ret, KErrNone);

    79 

    80 	faxFc.Close();

    81 	callFc.Close();

    82 	lineFc.Close();

    83 	phoneFc.Close();

    84 

    85 	ret=server.UnloadPhoneModule(DSTD_MODULE_NAME);

    86 	TESTCHECK(ret, KErrNone);

    87     ServerClose(server);

    88 

    89 	return TestStepResult();

    90 	}

    91 

    92 CTestOpenAllSubSess::CTestOpenAllSubSess()

    93 /** Each test step initialises it's own name

    94 */

    95 	{

    96 	SetTestStepName(_L("TestOpenAllSubSess"));

    97 	}

    98 

    99 enum TVerdict CTestOpenAllSubSess::doTestStepL()

   100 	{

   101 	INFO_PRINTF1(_L("Test Open All Sub Sessions"));

   102     RTelServer server;

   103 	TInt ret = server.Connect();

   104 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

   105     TESTCHECK(ret, KErrNone);

   106    	ret=server.LoadPhoneModule(DSTD_MODULE_NAME);

   107     TESTCHECK(ret, KErrNone);

   108 

   109 	RPhone phone;

   110     ret = phone.Open(server,DSTD_PHONE_NAME);

   111     TESTCHECK(ret, KErrNone);

   112 	RLine line;

   113     ret = line.Open(phone,DSTD_LINE_NAME);

   114 	TESTCHECK(ret, KErrNone);

   115 	RCall call;

   116 	ret = call.OpenNewCall(line);

   117     TESTCHECK(ret, KErrNone);

   118 	RFax fax;

   119     ret = fax.Open(call);

   120     TESTCHECK(ret, KErrNone);

   121 

   122 	RPhone phoneFc;

   123     ret = phoneFc.Open(server,DSTDFC_PHONE_NAME);

   124     TESTCHECK(ret, KErrNone);

   125 	RLine lineFc;

   126     ret = lineFc.Open(phoneFc,DSTDFC_LINE_NAME);

   127 	TESTCHECK(ret, KErrNone);

   128 	RCall callFc;

   129 	ret = callFc.OpenNewCall(lineFc);

   130     TESTCHECK(ret, KErrNone);

   131 	RFax faxFc;

   132     ret = faxFc.Open(callFc);

   133     TESTCHECK(ret, KErrNone);

   134 

   135 	RPhone phonePm;

   136     ret = phonePm.Open(server,DSTDPM_PHONE_NAME);

   137     TESTCHECK(ret, KErrNone);

   138 	RLine linePm;

   139     ret = linePm.Open(phonePm,DSTDPM_LINE_NAME);

   140 	TESTCHECK(ret, KErrNone);

   141 	RCall callPm;

   142 	ret = callPm.OpenNewCall(linePm);

   143     TESTCHECK(ret, KErrNone);

   144 	RFax faxPm;

   145     ret = faxPm.Open(callPm);

   146     TESTCHECK(ret, KErrNone);

   147 

   148 	fax.Close();

   149 	call.Close();

   150 	line.Close();

   151 	phone.Close();

   152 

   153 	faxFc.Close();

   154 	callFc.Close();

   155 	lineFc.Close();

   156 	phoneFc.Close();

   157 

   158 	faxPm.Close();

   159 	callPm.Close();

   160 	linePm.Close();

   161 	phonePm.Close();

   162 

   163 	ret=server.UnloadPhoneModule(DSTD_MODULE_NAME);

   164 	TESTCHECK(ret, KErrNone);

   165     ServerClose(server);

   166 

   167 	return TestStepResult();

   168 	}

   169 

   170 CTestServerOpenClose::CTestServerOpenClose()

   171 /** Each test step initialises it's own name

   172 */

   173 	{

   174 	SetTestStepName(_L("TestServerOpenClose"));

   175 	}

   176 

   177 enum TVerdict CTestServerOpenClose::doTestStepL()

   178 //

   179 // Test Server ability to load and unload phone module

   180 //

   181     {

   182 	INFO_PRINTF1(_L("Test server Open Close"));

   183 

   184     RTelServer server;

   185 	TInt ret = server.Connect();

   186 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

   187     TESTCHECK(ret, KErrNone);

   188    	ret=server.LoadPhoneModule(DSTD_MODULE_NAME);

   189     TESTCHECK(ret, KErrNone);

   190   	ret=server.UnloadPhoneModule(DSTD_MODULE_NAME);

   191 	TESTCHECK(ret, KErrNone);

   192 	// second name has ".tsy" appended

   193    	ret=server.LoadPhoneModule(DSTD_MODULE_NAME2);

   194     TESTCHECK(ret, KErrNone);

   195   	ret=server.UnloadPhoneModule(DSTD_MODULE_NAME2);

   196 	TESTCHECK(ret, KErrNone);

   197     ServerClose(server);

   198 

   199 	return TestStepResult();

   200     }

   201 

   202 CTestUnload::CTestUnload()

   203 /* Each test step initialises it's own name */

   204 	{

   205 	SetTestStepName(_L("TestUnload"));

   206 	}

   207 

   208 enum TVerdict CTestUnload::doTestStepL()

   209 	{

   210 	INFO_PRINTF1(_L("Test Unload"));

   211 

   212     RTelServer server;

   213 	TInt ret = server.Connect();

   214 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

   215     TESTCHECK(ret, KErrNone);

   216    	ret=server.LoadPhoneModule(DSTD_MODULE_NAME);

   217     TESTCHECK(ret, KErrNone);

   218 

   219 	RPhone phone;

   220     ret = phone.Open(server,DSTD_PHONE_NAME);

   221     TESTCHECK(ret, KErrNone);

   222 

   223 	RLine line;

   224     ret = line.Open(phone,DSTD_LINE_NAME);

   225 	TESTCHECK(ret, KErrNone);

   226 

   227 	RCall call;

   228     ret = call.OpenNewCall(line);

   229 	TESTCHECK(ret, KErrNone);

   230 

   231 	RFax fax;

   232 	ret=fax.Open(call);

   233 	TESTCHECK(ret, KErrNone);

   234 

   235 	fax.Close();

   236 	call.Close();

   237 	line.Close();

   238 	phone.Close();

   239 

   240   	ret=server.UnloadPhoneModule(DSTD_MODULE_NAME);

   241 	TESTCHECK(ret, KErrNone);

   242     ServerClose(server);

   243 

   244 	return TestStepResult();

   245 	}

   246 

   247 CTestOpenMoreSubSess::CTestOpenMoreSubSess()

   248 /** Each test step initialises it's own name

   249 */

   250 	{

   251 	SetTestStepName(_L("TestOpenMoreSubSess"));

   252 	}

   253 

   254 enum TVerdict CTestOpenMoreSubSess::doTestStepL()

   255 	{

   256 	INFO_PRINTF1(_L("Test Opens More Sub Session"));

   257 

   258     RTelServer server;

   259 	TInt ret = server.Connect();

   260 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

   261     TESTCHECK(ret, KErrNone);

   262    	ret=server.LoadPhoneModule(DSTD_MODULE_NAME);

   263     TESTCHECK(ret, KErrNone);

   264 

   265 	RPhone phone1;

   266     ret = phone1.Open(server,DSTD_PHONE_NAME);

   267     TESTCHECK(ret, KErrNone);

   268 

   269 	// open existing phone

   270 	RPhone phone2;

   271     ret = phone2.Open(server,DSTD_PHONE_NAME);

   272     TESTCHECK(ret, KErrNone);

   273 	phone2.Close();

   274 

   275 	RLine line1;

   276     ret = line1.Open(phone1,DSTD_LINE_NAME);

   277 	TESTCHECK(ret, KErrNone);

   278 

   279 	// Open existing line

   280 	RLine line2;

   281     ret = line2.Open(phone1,DSTD_LINE_NAME);

   282 	TESTCHECK(ret, KErrNone);

   283 	line2.Close();

   284 

   285 	RCall call1;

   286 	TName name;

   287     ret = call1.OpenNewCall(line1,name);

   288 	TESTCHECK(ret, KErrNone);

   289 	RLine::TCallInfo callinfo;

   290 	line1.GetCallInfo(0,callinfo);

   291 

   292 	// open call by handle

   293 	RCall call2;

   294     ret = call2.OpenExistingCall(line1,name);

   295 	TESTCHECK(ret, KErrNone);

   296 	call2.Close();

   297 

   298 	TName badName;

   299 	RCall call3;

   300 	INFO_PRINTF1(_L("Check zero length callnames"));

   301 	ret = call3.OpenExistingCall(line1,badName);

   302     TESTCHECK(ret, KErrBadName);

   303     call3.Close();

   304 

   305 	call1.Close();

   306 	line1.Close();

   307 	phone1.Close();

   308 	phone2.Close();

   309 	line2.Close();

   310 

   311   	ret=server.UnloadPhoneModule(DSTD_MODULE_NAME);

   312 	TESTCHECK(ret, KErrNone);

   313     ServerClose(server);

   314 

   315 	return TestStepResult();

   316     }

   317 

   318 CTestNotify::CTestNotify()

   319 /** Each test step initialises it's own name

   320 */

   321 	{

   322 	SetTestStepName(_L("TestNotify"));

   323 	}

   324 

   325 enum TVerdict CTestNotify::doTestStepL()

   326 	{

   327 	INFO_PRINTF1(_L("Notify a request!"));

   328     RTelServer server;

   329 	TInt ret = server.Connect();

   330 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

   331     TESTCHECK(ret, KErrNone);

   332    	ret=server.LoadPhoneModule(DSTD_MODULE_NAME);

   333     TESTCHECK(ret, KErrNone);

   334 

   335 	RPhone phone;

   336 	ret = phone.Open(server,DSTD_PHONE_NAME);

   337     TESTCHECK(ret, KErrNone);

   338 

   339 	TRequestStatus phoneStatus;

   340 	RPhone::TModemDetection detection;

   341 

   342 	phone.NotifyModemDetected(phoneStatus,detection);

   343 	User::WaitForRequest(phoneStatus);

   344 

   345 	phone.Close();

   346   	ret=server.UnloadPhoneModule(DSTD_MODULE_NAME);

   347 	TESTCHECK(ret, KErrNone);

   348     ServerClose(server);

   349 

   350 	return TestStepResult();

   351 	}

   352 

   353 CTestNotify2Client::CTestNotify2Client()

   354 /** Each test step initialises it's own name

   355 */

   356 	{

   357 	SetTestStepName(_L("TestNotify2Client"));

   358 	}

   359 

   360 enum TVerdict CTestNotify2Client::doTestStepL()

   361 	{

   362 	INFO_PRINTF1(_L("Notify 2 clients for the same request!"));

   363     RTelServer server1;

   364 	TInt ret = server1.Connect();

   365 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

   366     TESTCHECK(ret, KErrNone);

   367    	ret=server1.LoadPhoneModule(DSTD_MODULE_NAME);

   368     TESTCHECK(ret, KErrNone);

   369 

   370     RTelServer server2;

   371     ret = server2.Connect();

   372 	INFO_PRINTF2(_L("RTelServer::Connect returned %d."),ret);

   373     TESTCHECK(ret, KErrNone);

   374    	ret=server2.LoadPhoneModule(DSTD_MODULE_NAME);

   375     TESTCHECK(ret, KErrNone);

   376 

   377 	RPhone phone1,phone2;

   378 	ret = phone1.Open(server1,DSTD_PHONE_NAME);

   379     TESTCHECK(ret, KErrNone);

   380 	ret = phone2.Open(server2,DSTD_PHONE_NAME);

   381     TESTCHECK(ret, KErrNone);

   382 

   383 	TRequestStatus phone1Status;

   384 	TRequestStatus phone2Status;

   385 	RPhone::TModemDetection detection1;

   386 	RPhone::TModemDetection detection2;

   387 

   388 	phone1.NotifyModemDetected(phone1Status,detection1);

   389 	phone2.NotifyModemDetected(phone2Status,detection2);

   390 	User::WaitForRequest(phone1Status);

   391 	User::WaitForRequest(phone2Status);

   392 

   393 	phone1.Close();

   394 	phone2.Close();

   395 

   396 	ret=server1.UnloadPhoneModule(DSTD_MODULE_NAME);

   397 	TESTCHECK(ret, KErrNone);

   398     server1.Close();

   399 

   400   	ret=server2.UnloadPhoneModule(DSTD_MODULE_NAME);

   401 	TESTCHECK(ret, KErrNone);

   402     ServerClose(server2);

   403 

   404 	return TestStepResult();

   405 	}