1 //

     2 // * Copyright 2004 Neusoft America Inc.

     3 // * All rights reserved.

     4 // * This component and the accompanying materials are made available

     5 // * under the terms of the Eclipse Public License v1.0

     6 // * which accompanies this distribution, and is available

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

     8 // *

     9 // * Contributors:

    10 // * Keith Collins (Neusoft America Inc.)  original software development and additional code and modifications.

    11 // * Thomas Gahagen (Neusoft America Inc.)  additional code and modifications.

    12 // * Zhen Yuan (Neusoft America Inc.)  additional code and modifications.

    13 // *

    14 // * Description:  This contains the Unit Tests dealing with CSY 0710 related

    15 // *               functionality as documented in the project's Unit Test Spec.

    16 // *

    17 // *               The tests may be run either interactively or automatically.

    18 // *

    19 // *               The tests are dependant on a predictable response from

    20 // *               the BP side according to the test spec.

    21 // *

    22 // *               The automated tests achieve this predictable response by

    23 // *               using the Tester component.

    24 //

    25 

    26 // Csy0710UnitTest.cpp

    27 

    28 /** @file Csy0710UnitTest.cpp

    29  *

    30  */

    31 

    32 #include "Csy27010UnitTest.h"

    33 #include <exterror.h>

    34 

    35 

    36 _LIT8(KATCommand1,  "AT+CGMM\r");

    37 _LIT8(KATCommand2,  "AT+CGMM\r");

    38 _LIT8(KATCommand3,  "AT+CMUX?\r");

    39 _LIT8(KATCommand4,  "AT\r");

    40 _LIT8(KATCommand5,  "AT+CGMI\r");

    41 _LIT8(KATCommand6,  "AT+CGSN\r");

    42 _LIT8(KATCommand7,  "AT+CGMR\r");

    43 _LIT8(KATCommand8,  "AT+CBC\r");

    44 _LIT8(KATCommand9,  "AT+CSQ\r");

    45 _LIT8(KATCommand10, "ATS7?\r");

    46 _LIT8(KATCommand11, "ATS0=5\r");

    47 _LIT8(KATCommand12, "AT+FCLASS=2.0\r");

    48 _LIT8(KATCommand13, "AT+CRC=?\r");

    49 

    50 //_LIT8(KATCommandToCancel, "ABCDEFGHIJKLMNOPQRSTUVWXYZ\r");

    51 _LIT8(KATCommandToCancel, "AT\r");

    52 

    53 //-----------------------------------------------------------------------------

    54 // Helper routines

    55 //-----------------------------------------------------------------------------

    56 //

    57 

    58 TBool CCsy0710UnitTest::HasTestRangesDefined()

    59 	{

    60 	return ETrue;

    61 	}

    62 

    63 

    64 //-----------------------------------------------------------------------------

    65 //-----------------------------------------------------------------------------

    66 

    67 

    68 //-----------------------------------------------------------------------------

    69 //-----------------------------------------------------------------------------

    70 CCsy0710UnitTest* CCsy0710UnitTest::NewL(const TDesC& aUnitTestName,

    71 								 const TDesC& aLogFileName,

    72 							     const TDesC& aTestSpecName,

    73 							     const TDesC& aTestScriptName)

    74 	{

    75 	CCsy0710UnitTest* self = new(ELeave) CCsy0710UnitTest(aUnitTestName,

    76 				aLogFileName, aTestSpecName, aTestScriptName);

    77 	CleanupStack::PushL(self);

    78 	self->ConstructL();

    79 	CleanupStack::Pop();

    80 	return self;

    81 	}

    82 

    83 CCsy0710UnitTest::~CCsy0710UnitTest()

    84 	{

    85 	}

    86 

    87 

    88 CCsy0710UnitTest::CCsy0710UnitTest(const TDesC& aUnitTestName,

    89 						   const TDesC& aLogFileName,

    90 						   const TDesC& aTestSpecName,

    91 						   const TDesC& aTestScriptName)

    92 : CUnitTestBase(aUnitTestName, aLogFileName, aTestSpecName, aTestScriptName)

    93 	{}

    94 

    95 

    96 void CCsy0710UnitTest::ConstructL()

    97 	{	

    98 	CUnitTestBase::ConstructL();

    99 	

   100 	iCmdPortName[0].Copy(_L("gsm0710::1"));

   101 	iCmdPortName[1].Copy(_L("gsm0710::2"));

   102 	iCmdPortName[2].Copy(_L("gsm0710::3"));

   103 	iCmdPortName[3].Copy(_L("gsm0710::4"));

   104 	iDataPort1Name.Copy(_L("gsm0710::101"));

   105 	}

   106 

   107 void CCsy0710UnitTest::PrintTestSpecIdentifiers()

   108 	{

   109 	iTest.Printf(_L("\nCSY 0710 Unit Test\n\n"));

   110 	iTest.Printf(_L("1: CSY A tests\n"));

   111 	iTest.Printf(_L("2: CSY B tests\n"));

   112 	iTest.Printf(_L("3: CSY C tests\n"));

   113 	iTest.Printf(_L("4: CSY D tests\n"));

   114 	iTest.Printf(_L("5: CSY E tests\n"));

   115 	iTest.Printf(_L("6: CSY F tests\n"));

   116 	iTest.Printf(_L("7: CSY G tests\n"));

   117 	iTest.Printf(_L("8: CSY H tests\n"));

   118 	}

   119 

   120 

   121 void CCsy0710UnitTest::PrintTestDetails(TInt /*aTstSpecNumber*/)

   122 	{

   123 	// This version prints no helpful info on the screen. Overload this in

   124 	// your own test class to put out test details for the test spec idenifier

   125 	// selected

   126 	}

   127 

   128 

   129 void CCsy0710UnitTest::RunTestsL(TBool aEndInd,TTestMode aTestMode,

   130 								 TInt& aErrCode, TInt& aLeaveCode, 

   131 								 TInt aApiNumber, TInt aTestNumber)

   132 	{

   133 	switch (aApiNumber)

   134 		{

   135 		case 0:

   136 			aLeaveCode = KErrNone;

   137 			aErrCode = 8;  // 8 more tests

   138 			break;

   139 		case 1:

   140 			TRAP(aLeaveCode,aErrCode = CsyAL(aTestNumber));

   141 			break;

   142 		case 2:

   143 			TRAP(aLeaveCode,aErrCode = CsyBL(aTestNumber));

   144 			break;

   145 		case 3:

   146 			TRAP(aLeaveCode,aErrCode = CsyCL(aTestNumber));

   147 			break;

   148 		case 4:

   149 			TRAP(aLeaveCode,aErrCode = CsyDL(aTestNumber));

   150 			break;

   151 		case 5:

   152 			TRAP(aLeaveCode,aErrCode = CsyEL(aTestNumber));

   153 			break;

   154 		case 6:

   155 			TRAP(aLeaveCode,aErrCode = CsyFL(aTestNumber));

   156 			break;

   157 		case 7:

   158 			TRAP(aLeaveCode,aErrCode = CsyGL(aTestNumber));

   159 			break;

   160 		case 8:

   161 			TRAP(aLeaveCode,aErrCode = CsyHL(aTestNumber));

   162 			break;

   163 		default:

   164 			ActionNoMatch(aEndInd,aTestMode,aApiNumber, aTestNumber);

   165 		}

   166 

   167 	//CloseAllResources();

   168 	}

   169 //-----------------------------------------------------------------------------

   170 //-----------------------------------------------------------------------------

   171 

   172 

   173 TInt CCsy0710UnitTest::CsyAL(TInt aTstNum)

   174 /**

   175  * CSY Information Tests

   176  * @param aTstNum test number

   177  * @return KErrNone or error code

   178  */

   179 	{

   180 	if (aTstNum != 0)

   181 		iTest.Printf(_L("CSYA-%d\n"), aTstNum);

   182 

   183 	TInt ret = KErrNone;

   184 

   185 	SetTsIdentifier(_L("CSYA"));

   186 	SetMethodName(_L("CSYA"));

   187 

   188 	switch (aTstNum)

   189 		{

   190 		case 0:		// Return how may auto tests are present

   191 			return (4);

   192 			break;

   193 

   194 		case 1:		// Start C32

   195 			iTest.Printf(_L("Start C32...\n"));	

   196 			SetFunIndex(1);

   197 			TEST(LoadSerialDeviceDrivers());

   198 			ret = StartC32();

   199             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   200                 TEST(ret);

   201 			iTest.Printf(_L("Test 1-1 Passed\n"));

   202 			return (KErrNone);

   203 			break;

   204 

   205 		case 2:		// Load and Unload CSY multiple times

   206 			iTest.Printf(_L("Basic check on something else..\n"));	

   207 			SetFunIndex(1);

   208 			TEST(LoadSerialDeviceDrivers());

   209 			ret = StartC32();

   210             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   211                 TEST(ret);

   212 

   213 			TEST(iCommServer.Connect());

   214 			ret = iCommServer.LoadCommModule(KCsyName);

   215 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   216 

   217 			ret = iCommServer.LoadCommModule(KCsyName);

   218 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   219 

   220 			ret = iCommServer.LoadCommModule(KCsyName);

   221 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   222 			iCommServer.Close();

   223 			iTest.Printf(_L("Test 1-2 Passed\n"));

   224 			return (KErrNone);

   225 			break;

   226 

   227 		case 3:		// Open Multiple Sessions to C32

   228 			iTest.Printf(_L("Open Multiple Sessions to C32...\n"));	

   229 			SetFunIndex(1);

   230 			TEST(LoadSerialDeviceDrivers());

   231 			ret = StartC32();

   232             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   233                 TEST(ret);

   234 

   235 			TEST(iCommServer.Connect());

   236 			ret = iCommServer.LoadCommModule(KCsyName);

   237 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   238 

   239 			TEST(OpenAllCommPorts());

   240 			User::After(5000000);

   241 			CloseAllCommPorts();

   242 			iCommServer.UnloadCommModule(KCsyName);

   243 			iCommServer.Close();

   244 			User::After(3000000);

   245 			iTest.Printf(_L("Test 1-3 Passed\n"));

   246 			return (KErrNone);

   247 			break;

   248 

   249 		case 4: 		// Check that the phone supports the expected extensions

   250 			iTest.Printf(_L("Get CSY Info...\n"));	

   251 			SetFunIndex(1);

   252 			TEST(LoadSerialDeviceDrivers());

   253 			ret = StartC32();

   254             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   255                 TEST(ret);

   256 

   257 			TEST(iCommServer.Connect());

   258 			ret = iCommServer.LoadCommModule(KCsyName);

   259 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   260 

   261 			TEST(GetCsyInfo());

   262 			iCommServer.UnloadCommModule(KCsyName);

   263 			iCommServer.Close();			

   264 			User::After(5000000);

   265 			return KErrNone;

   266 			break;

   267 

   268 					// Manual Tests Follow...

   269 		case 100:		// Return how many manual tests are present

   270 			{

   271 			return 0;

   272 			}

   273 			break;

   274 

   275 		default:

   276 			iTest.Printf(_L("** Not implemented CSYA-%d **\n"), aTstNum);

   277 			break;

   278 		}

   279 

   280 	return ret;

   281 	}

   282 

   283 

   284 TInt CCsy0710UnitTest::CsyBL(TInt aTstNum)

   285 /**

   286  * CSY Open and Close Logical Ports Tests

   287  * @param aTstNum test number

   288  * @return void

   289  */

   290 	{

   291 	if (aTstNum != 0)

   292 		iTest.Printf(_L("CSYB-%d\n"), aTstNum);

   293 

   294 	TInt ret = KErrNone;

   295 

   296 	SetTsIdentifier(_L("CSYB"));

   297 	SetMethodName(_L("CSYB"));

   298 

   299 	switch (aTstNum)

   300 		{

   301 		case 0:		// Return how may auto tests are present

   302 			return (6);

   303 			break;

   304 

   305 		case 1:		// open & close subsessions

   306 			iTest.Printf(_L("Open & Close Subsessions...\n"));	

   307 			SetFunIndex(1);

   308 

   309 			// common test code

   310 			TEST(LoadSerialDeviceDrivers());

   311 			ret = StartC32();

   312             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   313                 TEST(ret);

   314 

   315 			TEST(iCommServer.Connect());

   316 			ret = iCommServer.LoadCommModule(KCsyName);

   317 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   318 

   319 			// specific test code

   320 			TEST(OpenAllCommPorts());

   321 			CloseAllCommPorts();

   322 			iCommServer.UnloadCommModule(KCsyName);

   323 			iCommServer.Close();

   324 			iTest.Printf(_L("Test 2-1 Passed\n"));

   325 			User::After(3000000);

   326 			return KErrNone;

   327 			break;

   328 

   329 		case 2:		// check failure to open comm port	

   330 			iTest.Printf(_L("Check failure to open comm port...\n"));	

   331 			SetFunIndex(1);

   332 

   333 			// common test code

   334 			TEST(LoadSerialDeviceDrivers());

   335             ret = StartC32();

   336             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   337                 TEST(ret);

   338 			TEST(iCommServer.Connect());

   339 			ret = iCommServer.LoadCommModule(KCsyName);

   340 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   341 

   342 			// specific test code

   343 			TEST(OpenCommPortFail());

   344 			iCommServer.UnloadCommModule(KCsyName);

   345 			iCommServer.Close();

   346 			iTest.Printf(_L("Test 2-2 Passed\n"));

   347 			User::After(3000000);

   348 			return KErrNone;

   349 			break;

   350 

   351 		case 3:		// open many ports

   352 			iTest.Printf(_L("Open many RComm ports...\n"));	

   353 			SetFunIndex(1);

   354 

   355 			// common test code

   356 			TEST(LoadSerialDeviceDrivers());

   357             ret = StartC32();

   358             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   359                 TEST(ret);

   360 			TEST(iCommServer.Connect());

   361 			ret = iCommServer.LoadCommModule(KCsyName);

   362 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   363 

   364 			// specific test code

   365 			TEST(OpenAllCommPorts());

   366 			User::After(5000000);

   367 			CloseAllCommPorts();

   368 			iCommServer.UnloadCommModule(KCsyName);

   369 			iCommServer.Close();

   370 			iTest.Printf(_L("Test 2-3 Passed\n"));

   371 			User::After(3000000);

   372 			return (KErrNone);

   373 			break;

   374 

   375 		case 4:		// check ability to open same port twice

   376 			iTest.Printf(_L("Check ability to open RComm port twice...\n"));	

   377 			SetFunIndex(1);

   378 

   379 			// common test code

   380 			TEST(LoadSerialDeviceDrivers());

   381             ret = StartC32();

   382             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   383                 TEST(ret);

   384 			TEST(iCommServer.Connect());

   385 			ret = iCommServer.LoadCommModule(KCsyName);

   386 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   387 

   388 			// specific test code

   389 			TEST(OpenCmdPortTwice());

   390 			iCommServer.UnloadCommModule(KCsyName);

   391 			iCommServer.Close();

   392 			iTest.Printf(_L("Test 2-4 Passed\n"));

   393 			User::After(3000000);

   394 			return (KErrNone);

   395 			break;

   396 

   397 		case 5:		// open many subsessions at same time

   398 			iTest.Printf(_L("Open many RComm ports at same time...\n"));	

   399 			SetFunIndex(1);

   400 

   401 			// common test code

   402 			TEST(LoadSerialDeviceDrivers());

   403             ret = StartC32();

   404             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   405                 TEST(ret);

   406 			TEST(iCommServer.Connect());

   407 			ret = iCommServer.LoadCommModule(KCsyName);

   408 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   409 

   410 			// specific test code

   411 			TEST(OpenAllCommPorts());

   412 			User::After(5000000);

   413 			CloseAllCommPorts();

   414 			iCommServer.UnloadCommModule(KCsyName);

   415 			iCommServer.Close();

   416 			iTest.Printf(_L("Test 2-5 Passed\n"));

   417 			User::After(3000000);

   418 			return (KErrNone);

   419 			break;

   420 

   421 		case 6:		// check failure to open port with an invalid name

   422 			iTest.Printf(_L("Check failure to open port with invalid name...\n"));	

   423 			SetFunIndex(1);

   424 

   425 			// common test code

   426 			TEST(LoadSerialDeviceDrivers());

   427             ret = StartC32();

   428             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   429                 TEST(ret);

   430 

   431 			TEST(iCommServer.Connect());

   432 			ret = iCommServer.LoadCommModule(KCsyName);

   433 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   434 

   435 			// specific test code

   436 			TEST(OpenCmdPortInvalidName());

   437 			User::After(5000000);

   438 			iCommServer.UnloadCommModule(KCsyName);

   439 			iCommServer.Close();

   440 			User::After(1000000);

   441 			iTest.Printf(_L("Test 2-6 Passed\n"));

   442 			User::After(2000000);

   443 			return (KErrNone);

   444 			break;

   445 

   446 			

   447 			// Manual Tests Follow...

   448 		case 100:		// Return how many manual tests are present

   449 			{

   450 			return 0;

   451 			}

   452 			break;

   453 

   454 		default:

   455 			iTest.Printf(_L("** Not implemented CSYB-%d **\n"), aTstNum);

   456 			break;

   457 		}

   458 

   459 	return (ret);

   460 	}

   461 

   462 

   463 TInt CCsy0710UnitTest::CsyCL(TInt aTstNum)

   464 /**

   465  * CSY Data Transmission Tests.

   466  * @param aTstNum test number

   467  * @return void

   468  */

   469 	{

   470 	if (aTstNum != 0)

   471 		iTest.Printf(_L("CSYC-%d\n"), aTstNum);

   472 

   473 	TInt ret = KErrNone;

   474 

   475 	SetTsIdentifier(_L("CSYC"));

   476 	SetMethodName(_L("CSYC"));

   477 

   478 	switch (aTstNum)

   479 		{

   480 		case 0:		// Return how may auto tests are present

   481 			return (4);

   482 			break;

   483 

   484 		case 1:		// Check that information can be sent

   485 			iTest.Printf(_L("Send command on Comm Port...\n"));	

   486 			SetFunIndex(1);

   487 

   488 			// common test code

   489 			TEST(LoadSerialDeviceDrivers());

   490             ret = StartC32();

   491             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   492                 TEST(ret);

   493 			TEST(iCommServer.Connect());

   494 			ret = iCommServer.LoadCommModule(KCsyName);

   495 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   496 

   497 			// specific test code

   498 			TEST(SendCmdOneCommPort(0));

   499 			User::After(1000000);

   500 			iCommServer.UnloadCommModule(KCsyName);

   501 			iCommServer.Close();

   502 			iTest.Printf(_L("Test 3-1 Passed\n"));

   503 			User::After(3000000);

   504 			return KErrNone;

   505 			break;

   506 

   507 		case 2:		// Check that information can be sent

   508 			iTest.Printf(_L("Send multiple commands on Comm Port...\n"));	

   509 			SetFunIndex(1);

   510 

   511 			// common test code

   512 			TEST(LoadSerialDeviceDrivers());

   513             ret = StartC32();

   514             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   515                 TEST(ret);

   516 			TEST(iCommServer.Connect());

   517 			ret = iCommServer.LoadCommModule(KCsyName);

   518 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   519 

   520 			// specific test code

   521 			SendCmdsOneCommPort(0);

   522 			User::After(1000000);

   523 			iCommServer.UnloadCommModule(KCsyName);

   524 			iCommServer.Close();

   525 			iTest.Printf(_L("Test 3-2 Passed\n"));

   526 			User::After(3000000);

   527 			return (KErrNone);

   528 			break;

   529 			

   530 		case 3:		// check BP ack failure

   531 			iTest.Printf(_L("Test 3-3 Passed\n"));

   532 			SetFunIndex(1);

   533 			User::After(3000000);

   534 			return (KErrNone);

   535 

   536 		case 4:		// Check write cancel on outstanding cmd

   537 			iTest.Printf(_L("Cancel Write Request on Comm Port...\n"));	

   538 			SetFunIndex(1);

   539 

   540 			// common test code

   541 			TEST(LoadSerialDeviceDrivers());

   542             ret = StartC32();

   543             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   544                 TEST(ret);

   545 			TEST(iCommServer.Connect());

   546 			ret = iCommServer.LoadCommModule(KCsyName);

   547 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   548 

   549 			// specific test code

   550 			CancelWriteOneCommPort(0);

   551 			User::After(1000000);

   552 

   553 			// common exit test code

   554 			iCommServer.UnloadCommModule(KCsyName);

   555 			iCommServer.Close();

   556 			iTest.Printf(_L("Test 3-4 Passed\n"));

   557 			User::After(3000000);

   558 			return (KErrNone);

   559 			break;

   560 

   561 			// Manual Tests Follow...

   562 		case 100:		// Return how many manual tests are present

   563 			{

   564 			return 0;

   565 			}

   566 			break;

   567 

   568 		default:

   569 			iTest.Printf(_L("** Not implemented CSYC-%d **\n"), aTstNum);

   570 			break;

   571 		}

   572 

   573 	return (ret);

   574 	}

   575 

   576 

   577 TInt CCsy0710UnitTest::CsyDL(TInt aTstNum)

   578 /**

   579  * CSY Tests for receive data on channels.

   580  * @param aTstNum test number

   581  * @return KErrNone or error code

   582  */

   583 	{

   584 	TInt ret = KErrNone;

   585 

   586 	if (aTstNum != 0)

   587 		iTest.Printf(_L("CSYD-%d\n"), aTstNum);

   588 

   589 	SetTsIdentifier(_L("CSYD"));

   590 	SetMethodName(_L("CSYD"));

   591 

   592 	switch (aTstNum)

   593 		{

   594 		case 0:		// Return how may auto tests are present

   595 			return (2);

   596 			break;

   597 

   598 		case 1:		// Check that data can be received

   599 			iTest.Printf(_L("Recv Data on Comm Port...\n"));	

   600 			SetFunIndex(1);

   601 

   602 			// common test code

   603 			TEST(LoadSerialDeviceDrivers());

   604             ret = StartC32();

   605             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   606                 TEST(ret);

   607 			TEST(iCommServer.Connect());

   608 			ret = iCommServer.LoadCommModule(KCsyName);

   609 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   610 

   611 			// specific test code

   612 			ret = iCommPort[0].Open(iCommServer, iCmdPortName[0], ECommShared);

   613 			if (ret != KErrNone) return __LINE__;

   614 			TEST(RecvDataOneCommPort(0));

   615 			iCommPort[0].Close();

   616 			iCommServer.UnloadCommModule(KCsyName);

   617 			iCommServer.Close();

   618 			iTest.Printf(_L("Test 4-1 Passed\n"));

   619 			User::After(3000000);

   620 			return KErrNone;

   621 			break;

   622 

   623 		case 2:		// Check that data is received and given to the correct port

   624 			iTest.Printf(_L("Recv Data and Route to Correct Port...\n"));	

   625 			SetFunIndex(1);

   626 

   627 			// common test code

   628 			TEST(LoadSerialDeviceDrivers());

   629             ret = StartC32();

   630             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   631                 TEST(ret);

   632 			TEST(iCommServer.Connect());

   633 			ret = iCommServer.LoadCommModule(KCsyName);

   634 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   635 

   636 			// specific test code

   637 			ret = iCommPort[0].Open(iCommServer, iCmdPortName[0], ECommShared);

   638 			if (ret != KErrNone) return __LINE__;

   639 			ret = iCommPort[1].Open(iCommServer, iCmdPortName[1], ECommShared);

   640 			if (ret != KErrNone) return __LINE__;

   641 			ret = iCommPort[2].Open(iCommServer, iCmdPortName[1], ECommShared);

   642 			if (ret != KErrNone) return __LINE__;

   643 			ret = iCommPort[3].Open(iCommServer, iCmdPortName[1], ECommShared);

   644 			if (ret != KErrNone) return __LINE__;

   645 

   646 			TEST(RecvDataOneCommPort(0));

   647 			TEST(RecvDataOneCommPort(1));

   648 			TEST(RecvDataOneCommPort(2));

   649 			TEST(RecvDataOneCommPort(3));

   650 

   651 			ret = iCommPort[4].Open(iCommServer, iDataPort1Name, ECommShared); //data port

   652 			if (ret != KErrNone) return __LINE__;

   653 			TEST(RecvDataOneCommPort(4)); //newly open port will take away the control of the dlc

   654 			iCommPort[4].Close();

   655 			// should return control of dlc

   656 

   657 			TEST(RecvDataOneCommPort(0));

   658 			TEST(RecvDataOneCommPort(1));

   659 			TEST(RecvDataOneCommPort(2));

   660 			TEST(RecvDataOneCommPort(3));

   661 

   662 			iCommPort[3].Close();

   663 			iCommPort[2].Close();

   664 			iCommPort[1].Close();

   665 			iCommPort[0].Close();

   666 			User::After(1000000);

   667 			iCommServer.UnloadCommModule(KCsyName);

   668 			iCommServer.Close();

   669 			iTest.Printf(_L("Test 4-2 Passed\n"));

   670 			User::After(3000000);

   671 			return KErrNone;

   672 			break;

   673 

   674 			// Manual Tests Follow...

   675 		case 100:		// Return how many manual tests are present

   676 			{

   677 			return 0;

   678 			}

   679 			break;

   680 

   681 		default:

   682 			iTest.Printf(_L("** Not implemented CSYD-%d **\n"), aTstNum);

   683 			break;

   684 		}		

   685 			

   686 	return (KErrNone);

   687 	}

   688 

   689 

   690 TInt CCsy0710UnitTest::CsyEL(TInt aTstNum)

   691 /**

   692  * CSY Tests for flow control of data on logical ports.

   693  * @param aTstNum test number

   694  * @return KErrNone or error code

   695  */

   696 	{

   697 	TInt ret = KErrNone;

   698 

   699 	if (aTstNum != 0)

   700 		iTest.Printf(_L("CSYE-%d\n"), aTstNum);

   701 

   702 	SetTsIdentifier(_L("CSYE"));

   703 	SetMethodName(_L("CSYE"));

   704 

   705 	switch (aTstNum)

   706 		{

   707 		case 0:		// Return how may auto tests are present

   708 			return (1);

   709 			break;

   710 

   711 		case 1:		// Check that flow control signals correct port

   712 			iTest.Printf(_L("Verify Flow Control Signals to Correct Port...\n"));	

   713 			SetFunIndex(1);

   714 

   715 			// common test code

   716 			TEST(LoadSerialDeviceDrivers());

   717             ret = StartC32();

   718             if ((ret != KErrNone) && (ret != KErrAlreadyExists))

   719                 TEST(ret);

   720 			TEST(iCommServer.Connect());

   721 			ret = iCommServer.LoadCommModule(KCsyName);

   722 			if (ret!=KErrNone && ret!=KErrAlreadyExists) return __LINE__;

   723 

   724 			// specific test code

   725 			ret = iCommPort[0].Open(iCommServer, iCmdPortName[0], ECommShared);

   726 			if (ret != KErrNone) return __LINE__;

   727 			ret = iCommPort[1].Open(iCommServer, iCmdPortName[1], ECommShared);

   728 			if (ret != KErrNone) return __LINE__;

   729 			ret = iCommPort[2].Open(iCommServer, iCmdPortName[2], ECommShared);

   730 			if (ret != KErrNone) return __LINE__;

   731 			ret = iCommPort[3].Open(iCommServer, iCmdPortName[3], ECommShared);

   732 			if (ret != KErrNone) return __LINE__;

   733 

   734 			TEST(VerifyFlowControl(0));

   735 			TEST(VerifyFlowControl(1));

   736 			TEST(VerifyFlowControl(2));

   737 			TEST(VerifyFlowControl(3));

   738 

   739 			iCommPort[3].Close();

   740 			iCommPort[2].Close();

   741 			iCommPort[1].Close();

   742 			iCommPort[0].Close();

   743 			User::After(1000000);

   744 			iCommServer.UnloadCommModule(KCsyName);

   745 			iCommServer.Close();

   746 			iTest.Printf(_L("Test 5-1 Passed\n"));

   747 			User::After(3000000);

   748 			return KErrNone;

   749 			break;

   750 

   751 			// Manual Tests Follow...

   752 		case 100:		// Return how many manual tests are present

   753 			{

   754 			return 0;

   755 			}

   756 			break;

   757 

   758 		default:

   759 			iTest.Printf(_L("** Not implemented CSYE-%d **\n"), aTstNum);

   760 			break;

   761 		}			

   762 			

   763 	return (KErrNone);

   764 	}

   765 

   766 

   767 TInt CCsy0710UnitTest::CsyFL(TInt aTstNum)

   768 /**

   769  * CSY Tests for 3GPP 27.010 compliance.

   770  * @param aTstNum test number

   771  * @return KErrNone or error code

   772  */

   773 	{

   774 	if (aTstNum != 0)

   775 		iTest.Printf(_L("CSYF-%d\n"), aTstNum);

   776 

   777 	SetTsIdentifier(_L("CSYF"));

   778 	SetMethodName(_L("CSYF"));

   779 

   780 	iTest.Printf(_L("Verify 3GPP 27.010 Compliance\n"));	

   781 

   782 	switch (aTstNum)

   783 		{

   784 		case 0:		// Return how may auto tests are present

   785 			return (8);

   786 			break;

   787 

   788 		case 1:		// Check that AT+CMUX is sent to enter mux mode

   789 			iTest.Printf(_L("Verify AT+CMUX is sent to enter Mux mode...\n"));	

   790 			SetFunIndex(1);

   791 

   792 			// common test code

   793 			Verify0710Compliance();

   794 			iTest.Printf(_L("Test 6-1 Passed\n"));

   795 			User::After(3000000);

   796 			return KErrNone;

   797 			break;

   798 

   799 		case 2:		// Check that frames are created correctly

   800 			iTest.Printf(_L("Verify frames are created properly...\n"));

   801 			SetFunIndex(1);

   802 

   803 			// common test code

   804 			Verify0710Compliance();

   805 			iTest.Printf(_L("Test 6-2 Passed\n"));

   806 			User::After(2000000);

   807 			return KErrNone;

   808 			break;

   809 

   810 		case 3:		// Check that channels are created via SABM frames

   811 			iTest.Printf(_L("Verify channels are created via SABM frames...\n"));	

   812 			SetFunIndex(1);

   813 

   814 			// common test code

   815 			Verify0710Compliance();

   816 			iTest.Printf(_L("Test 6-3 Passed\n"));

   817 			User::After(3000000);

   818 			return KErrNone;

   819 			break;

   820 

   821 		case 4:		// Check that received frames are validated

   822 			iTest.Printf(_L("Verify received frames are validated...\n"));

   823 			SetFunIndex(1);

   824 

   825 			// common test code

   826 			Verify0710Compliance();

   827 			iTest.Printf(_L("Test 6-4 Passed\n"));

   828 			User::After(3000000);

   829 			return KErrNone;

   830 			break;

   831 

   832 		case 5:		// Check that recv frames are ack'd with a UA frame

   833 			iTest.Printf(_L("Verify received frames are ack'd with a UA frame...\n"));

   834 			SetFunIndex(1);

   835 

   836 			// common test code

   837 			Verify0710Compliance();

   838 			iTest.Printf(_L("Test 6-5 Passed\n"));

   839 			User::After(3000000);

   840 			return KErrNone;

   841 			break;

   842 

   843 		case 6:		// Check that received modem status control frames are processed correctly

   844 			iTest.Printf(_L("Verify received modem status control frames are processed...\n"));

   845 			SetFunIndex(1);

   846 

   847 			// common test code

   848 			Verify0710Compliance();

   849 			iTest.Printf(_L("Test 6-6 Passed\n"));

   850 			User::After(3000000);

   851 			return KErrNone;

   852 			break;

   853 

   854 		case 7:		// Check that received flow control frames are processed correctly

   855 			iTest.Printf(_L("Verify received flow control frames are processed...\n"));	

   856 			SetFunIndex(1);

   857 

   858 			// common test code

   859 			Verify0710Compliance();

   860 			iTest.Printf(_L("Test 6-7 Passed\n"));

   861 			User::After(3000000);

   862 			return KErrNone;

   863 			break;

   864 

   865 		case 8:		// Check that channel is closed by sending a DISC frame

   866 			iTest.Printf(_L("Verify channel is closed by when sending DISC frame...\n"));

   867 			SetFunIndex(1);

   868 

   869 			// common test code

   870 			Verify0710Compliance();

   871 			iTest.Printf(_L("Test 6-8 Passed\n"));

   872 			User::After(3000000);

   873 			return KErrNone;

   874 			break;

   875 

   876 			// Manual Tests Follow...

   877 		case 100:		// Return how many manual tests are present

   878 			return 0;

   879 			break;

   880 

   881 		default:

   882 			iTest.Printf(_L("** Not implemented CSYF-%d **\n"), aTstNum);

   883 			break;

   884 		}			

   885 			

   886 	return (KErrNone);

   887 	}

   888 

   889 

   890 TInt CCsy0710UnitTest::CsyGL(TInt aTstNum)

   891 /**

   892  * CSY Tests

   893  * @param aTstNum test number

   894  * @return KErrNone or error code

   895  */

   896 	{

   897 	if (aTstNum != 0)

   898 		iTest.Printf(_L("CSYG-%d\n"), aTstNum);

   899 

   900 	SetTsIdentifier(_L("CSYG"));

   901 	SetMethodName(_L("CSYG"));

   902 

   903 	switch (aTstNum)

   904 		{

   905 		case 0:		// Return how may auto tests are present

   906 			return (14);

   907 			break;

   908 

   909 		case 1:		// Verify no memory allocation until 1st port is opened

   910 			iTest.Printf(_L("Verify no memory allocation until 1st port is opened...\n"));

   911 			SetFunIndex(1);

   912 

   913 			// common test code

   914 			VerifyStartup();

   915 			iTest.Printf(_L("Test 7-1 Passed\n"));

   916 			User::After(3000000);

   917 			return KErrNone;

   918 			break;

   919 

   920 		case 2:		// Verify mux startup params are read

   921 			iTest.Printf(_L("Verify mux startup params are read...\n"));

   922 			SetFunIndex(1);

   923 

   924 			// common test code

   925 			VerifyStartup();

   926 			iTest.Printf(_L("Test 7-2 Passed\n"));

   927 			User::After(3000000);

   928 			return KErrNone;

   929 			break;

   930 

   931 		case 3:		// Verify correct serial port PDD is loaded

   932 			iTest.Printf(_L("Verify correct serial port PDD is loaded...\n"));

   933 			SetFunIndex(1);

   934 

   935 			// common test code

   936 			VerifyStartup();

   937 			iTest.Printf(_L("Test 7-3 Passed\n"));

   938 			User::After(3000000);

   939 			return KErrNone;

   940 			break;

   941 

   942 		case 4:		// Verify correct serial port LDD is loaded

   943 			iTest.Printf(_L("Verify correct serial port LDD is loaded...\n"));

   944 			SetFunIndex(1);

   945 

   946 			// common test code

   947 			VerifyStartup();

   948 			iTest.Printf(_L("Test 7-4 Passed\n"));

   949 			User::After(3000000);

   950 			return KErrNone;

   951 			break;

   952 

   953 		case 5:		// Check serial port startup config

   954 			iTest.Printf(_L("Verify serial port startup config...\n"));

   955 			SetFunIndex(1);

   956 

   957 			// common test code

   958 			VerifyStartup();

   959 			iTest.Printf(_L("Test 7-5 Passed\n"));

   960 			User::After(3000000);

   961 			return KErrNone;

   962 			break;

   963 

   964 		case 6:		// Check control channel 0 is created

   965 			iTest.Printf(_L("Verify control channel 0 is created...\n"));

   966 			SetFunIndex(1);

   967 

   968 			// common test code

   969 			VerifyStartup();

   970 			iTest.Printf(_L("Test 7-6 Passed\n"));

   971 			User::After(3000000);

   972 			return KErrNone;

   973 			break;

   974 

   975 		case 7:		// Check command and data channels are created

   976 			iTest.Printf(_L("Verify cmd and data channels are created...\n"));

   977 			SetFunIndex(1);

   978 

   979 			// common test code

   980 			VerifyStartup();

   981 			iTest.Printf(_L("Test 7-7 Passed\n"));

   982 			User::After(3000000);

   983 			return KErrNone;

   984 			break;

   985 

   986 		case 8:		// Verify enter mux AT command is issued to the BP

   987 			iTest.Printf(_L("Verify enter mux AT command is issued to BP...\n"));

   988 			SetFunIndex(1);

   989 

   990 			// common test code

   991 			VerifyStartup();

   992 			iTest.Printf(_L("Test 7-8 Passed\n"));

   993 			User::After(3000000);

   994 			return KErrNone;

   995 			break;

   996 

   997 		case 9:		// Verify cmd channels are setup disable cmd echo

   998 			iTest.Printf(_L("Verify cmd channels are setup to disable cmd echo...\n"));

   999 			SetFunIndex(1);

  1000 

  1001 			// common test code

  1002 			VerifyStartup();

  1003 			iTest.Printf(_L("Test 7-9 Passed\n"));

  1004 			User::After(3000000);

  1005 			return KErrNone;

  1006 			break;

  1007 

  1008 		case 10:	// Verify C32 is informed of the CSY's serial name of "gsm0710"

  1009 			iTest.Printf(_L("Verify C32 is informed of the CSY's serial name of gsm0710...\n"));	

  1010 			SetFunIndex(1);

  1011 

  1012 			// common test code

  1013 			VerifyStartup();

  1014 			iTest.Printf(_L("Test 7-10 Passed\n"));

  1015 			User::After(3000000);

  1016 			return KErrNone;

  1017 			break;

  1018 

  1019 		case 11:	// Verify flow control is set to Off after channel init

  1020 			iTest.Printf(_L("Verify Verify flow control is set to Off after channel init...\n"));

  1021 			SetFunIndex(1);

  1022 

  1023 			// common test code

  1024 			VerifyStartup();

  1025 			iTest.Printf(_L("Test 7-11 Passed\n"));

  1026 			User::After(3000000);

  1027 			return KErrNone;

  1028 			break;

  1029 

  1030 		case 12:	// Verify NotifyFlowControlChange requests are accepted

  1031 			iTest.Printf(_L("Verify NotifyFlowControlChange requests are accepted...\n"));

  1032 			SetFunIndex(1);

  1033 

  1034 			// common test code

  1035 			VerifyStartup();

  1036 			iTest.Printf(_L("Test 7-12 Passed\n"));

  1037 			User::After(3000000);

  1038 			return KErrNone;

  1039 			break;

  1040 

  1041 		case 13:	// Verify NotifyFlowControlChange request can be cancelled

  1042 			iTest.Printf(_L("Verify NotifyFlowControlChange request can be cancelled...\n"));

  1043 			SetFunIndex(1);

  1044 

  1045 			// common test code

  1046 			VerifyStartup();

  1047 			iTest.Printf(_L("Test 7-13 Passed\n"));

  1048 			User::After(3000000);

  1049 			return KErrNone;

  1050 			break;

  1051 

  1052 		case 14:	// Verify NotifyFlowControlChange requests are completed properly

  1053 			iTest.Printf(_L("Verify NotifyFlowControlChange requests are completed properly...\n"));

  1054 			SetFunIndex(1);

  1055 

  1056 			// common test code

  1057 			VerifyStartup();

  1058 			iTest.Printf(_L("Test 7-14 Passed\n"));

  1059 			User::After(3000000);

  1060 			return KErrNone;

  1061 			break;

  1062 			

  1063 			// Manual Tests Follow...

  1064 		case 100:		// Return how many manual tests are present

  1065 			return 0;

  1066 			break;

  1067 

  1068 		default:

  1069 			iTest.Printf(_L("** Not implemented CSYG-%d **\n"), aTstNum);

  1070 			break;

  1071 		}

  1072 

  1073 	return (KErrNone);

  1074 	}

  1075 

  1076 

  1077 TInt CCsy0710UnitTest::CsyHL(TInt aTstNum)

  1078 /**

  1079  * CSY Tests

  1080  * @param aTstNum test number

  1081  * @return KErrNone or error code

  1082  */

  1083 	{

  1084 	if (aTstNum != 0)

  1085 		iTest.Printf(_L("CSYH-%d\n"), aTstNum);

  1086 

  1087 	SetTsIdentifier(_L("CSYH"));

  1088 	SetMethodName(_L("CSYH"));

  1089 

  1090 	switch (aTstNum)

  1091 		{

  1092 		case 0:		// Return how may auto tests are present

  1093 			return (5);

  1094 			break;

  1095 

  1096 		case 1:		// Verify any active or outstanding requests are cancelled

  1097 			iTest.Printf(_L("Verify any active or outstanding requests are cancelled...\n"));

  1098 			SetFunIndex(1);

  1099 

  1100 			// common test code

  1101 			TEST(VerifyShutdown(1));

  1102 			iTest.Printf(_L("Test 8-1 Passed\n"));

  1103 			User::After(3000000);

  1104 			return KErrNone;

  1105 			break;

  1106 

  1107 		case 2:		// Verify each command channel and control channel is disconnected by sending DISC frame to BP

  1108 			iTest.Printf(_L("Verify channels are disconnected by sending DISC frame to BP...\n"));

  1109 			SetFunIndex(1);

  1110 

  1111 			// common test code

  1112 			TEST(VerifyShutdown(2));

  1113 			iTest.Printf(_L("Test 8-2 Passed\n"));

  1114 			User::After(3000000);

  1115 			return KErrNone;

  1116 			break;

  1117 

  1118 		case 3:		// Verify all memory allocated is deallocated

  1119 			iTest.Printf(_L("Verify all memory allocated is deallocated...\n"));

  1120 			SetFunIndex(1);

  1121 

  1122 			// common test code

  1123 			TEST(VerifyShutdown(3));

  1124 			iTest.Printf(_L("Test 8-3 Passed\n"));

  1125 			User::After(3000000);

  1126 			return KErrNone;

  1127 			break;

  1128 

  1129 		case 4:		// Verify all created objects are deleted

  1130 			iTest.Printf(_L("Verify all created objects are deleted...\n"));

  1131 			SetFunIndex(1);

  1132 

  1133 			// common test code

  1134 			TEST(VerifyShutdown(4));

  1135 			iTest.Printf(_L("Test 8-4 Passed\n"));