void DemoSimApplication::toneMenu( const QSimTerminalResponse& resp )
{
QSimCommand cmd;
if ( resp.result() == QSimTerminalResponse::Success ) {
// Item selected.
cmd.setType( QSimCommand::PlayTone );
cmd.setDestinationDevice( QSimCommand::Earpiece );
cmd.setTone( (QSimCommand::Tone)( resp.menuItem() ) );
if ( cmd.tone() == QSimCommand::ToneDial )
cmd.setDuration( 5000 );
else if ( cmd.tone() == QSimCommand::ToneGeneralBeep ||
cmd.tone() == QSimCommand::TonePositiveBeep ||
cmd.tone() == QSimCommand::ToneNegativeBeep )
cmd.setDuration( 1000 );
else
cmd.setDuration( 3000 );
command( cmd, this, SLOT(sendToneMenu()) );
} else if ( resp.result() == QSimTerminalResponse::BackwardMove ) {
// Request to move backward.
mainMenu();
} else {
// Unknown response - just go back to the main menu.
mainMenu();
}
}
void DemoSimApplication::sendIconSEMenu()
{
QSimCommand cmd;
QSimMenuItem item;
QList<QSimMenuItem> items;
cmd.setType( QSimCommand::SelectItem );
cmd.setTitle( "Icons SE" );
item.setIdentifier( 1 );
item.setLabel( "Basic Icon" );
item.setIconId( 1 );
item.setIconSelfExplanatory( true );
items += item;
item.setIdentifier( 2 );
item.setLabel( "Color Icon" );
item.setIconId( 2 );
item.setIconSelfExplanatory( true );
items += item;
item.setIdentifier( 3 );
item.setLabel( "Bad Icon" );
item.setIconId( 70 );
item.setIconSelfExplanatory( true );
items += item;
cmd.setMenuItems( items );
command( cmd, this, SLOT(iconSEMenu(QSimTerminalResponse)) );
}
void DemoSimApplication::sendBrowserMenu()
{
QSimCommand cmd;
QSimMenuItem item;
QList<QSimMenuItem> items;
cmd.setType( QSimCommand::SelectItem );
cmd.setTitle( "Web Browser" );
item.setIdentifier( 1 );
item.setLabel( "Qt Extended" );
items += item;
item.setIdentifier( 2 );
item.setLabel( "Google (normal)" );
items += item;
item.setIdentifier( 3 );
item.setLabel( "Google (if browser not in use)" );
items += item;
item.setIdentifier( 4 );
item.setLabel( "Google (clear history)" );
items += item;
item.setIdentifier( 5 );
item.setLabel( "Default Home Page" );
items += item;
cmd.setMenuItems( items );
command( cmd, this, SLOT(browserMenu(QSimTerminalResponse)) );
}
void DemoSimApplication::sendSportsMenu()
{
QSimCommand cmd;
QSimMenuItem item;
QList<QSimMenuItem> items;
cmd.setType( QSimCommand::SelectItem );
cmd.setTitle( "Sports" );
item.setIdentifier( SportsMenu_Chess );
item.setLabel( "Chess" );
items += item;
item.setIdentifier( SportsMenu_Painting );
item.setLabel( "Finger Painting" );
items += item;
item.setIdentifier( SportsMenu_Snakes );
item.setLabel( "Snakes and Ladders" );
items += item;
item.setIdentifier( SportsMenu_Main );
item.setLabel( "Return to main menu" );
items += item;
cmd.setMenuItems( items );
command( cmd, this, SLOT(sportsMenu(QSimTerminalResponse)) );
}
void DemoSimApplication::sticksGameShow()
{
QSimCommand cmd;
if ( sticksLeft == 1 ) {
cmd.setType( QSimCommand::GetInkey );
cmd.setText( "There is only 1 stick left. You lose. Play again?" );
cmd.setWantYesNo( true );
command( cmd, this, SLOT(sticksGamePlayAgain(QSimTerminalResponse)) );
} else {
cmd.setType( QSimCommand::GetInkey );
cmd.setText( "There are 21 sticks left. How many do you take (1, 2, or 3)?" );
cmd.setWantDigits( true );
if ( sticksLeft == 21 )
cmd.setHasHelp( true );
command( cmd, this, SLOT(sticksGameLoop(QSimTerminalResponse)) );
}
}
void DemoSimApplication::sportsMenu( const QSimTerminalResponse& resp )
{
QSimCommand cmd;
if ( resp.result() == QSimTerminalResponse::Success ) {
// Item selected.
switch ( resp.menuItem() ) {
case SportsMenu_Chess:
{
cmd.setType( QSimCommand::DisplayText );
cmd.setDestinationDevice( QSimCommand::Display );
cmd.setText( "Kasparov 3, Deep Blue 4" );
command( cmd, this, SLOT(sendSportsMenu()) );
}
break;
case SportsMenu_Painting:
{
cmd.setType( QSimCommand::DisplayText );
cmd.setDestinationDevice( QSimCommand::Display );
cmd.setText( "Little Johnny 4, Little Sally 6" );
command( cmd, this, SLOT(sendSportsMenu()) );
}
break;
case SportsMenu_Snakes:
{
cmd.setType( QSimCommand::DisplayText );
cmd.setDestinationDevice( QSimCommand::Display );
cmd.setText( "Little Johnny 0, Little Sally 2" );
cmd.setClearAfterDelay( true );
command( cmd, this, SLOT(sendSportsMenu()) );
}
break;
default: mainMenu(); break;
}
} else if ( resp.result() == QSimTerminalResponse::BackwardMove ) {
// Request to move backward.
mainMenu();
} else {
// Unknown response - just go back to the main menu.
mainMenu();
}
}
void tst_QSimToolkit::testDeliverSendDTMF()
{
QFETCH( QByteArray, data );
QFETCH( QByteArray, resp );
QFETCH( int, resptype );
QFETCH( QString, text );
QFETCH( QString, number );
QFETCH( int, iconId );
QFETCH( bool, iconSelfExplanatory );
QFETCH( QByteArray, textAttribute );
QFETCH( QString, html );
QFETCH( int, options );
Q_UNUSED(resptype);
Q_UNUSED(html);
// Output a dummy line to give some indication of which test we are currently running.
qDebug() << "";
// Clear the client/server state.
server->clear();
deliveredCommand = QSimCommand();
// Compose and send the command.
QSimCommand cmd;
cmd.setType( QSimCommand::SendDTMF );
cmd.setDestinationDevice( QSimCommand::Network );
cmd.setText( text );
cmd.setNumber( number );
cmd.setIconId( (uint)iconId );
cmd.setIconSelfExplanatory( iconSelfExplanatory );
cmd.setTextAttribute( textAttribute );
server->emitCommand( cmd );
// Wait for the command to arrive in the client.
QVERIFY( QFutureSignal::wait( this, SIGNAL(commandSeen()), 100 ) );
// Verify that the command was delivered exactly as we asked.
QVERIFY( deliveredCommand.type() == cmd.type() );
QVERIFY( deliveredCommand.text() == cmd.text() );
QVERIFY( deliveredCommand.number() == cmd.number() );
QVERIFY( deliveredCommand.iconId() == cmd.iconId() );
QVERIFY( deliveredCommand.iconSelfExplanatory() == cmd.iconSelfExplanatory() );
QVERIFY( deliveredCommand.textAttribute() == cmd.textAttribute() );
QCOMPARE( deliveredCommand.toPdu( (QSimCommand::ToPduOptions)options ), data );
// The terminal response should have been sent immediately to ack reception of the command.
// We cannot check the return data explicitly because that will be handled in the modem
// and will typically be invisible to Qtopia. We therefore compare against what the
// response would be without the return data.
QCOMPARE( server->responseCount(), 1 );
QCOMPARE( server->envelopeCount(), 0 );
QSimTerminalResponse resp2;
resp2.setCommand( deliveredCommand );
resp2.setResult( QSimTerminalResponse::Success );
QCOMPARE( server->lastResponse(), resp2.toPdu() );
}
void DemoSimApplication::sendToneMenu()
{
QSimCommand cmd;
QSimMenuItem item;
QList<QSimMenuItem> items;
cmd.setType( QSimCommand::SelectItem );
cmd.setTitle( "Tones" );
item.setIdentifier( (uint)QSimCommand::ToneDial );
item.setLabel( "Dial" );
items += item;
item.setIdentifier( (uint)QSimCommand::ToneBusy );
item.setLabel( "Busy" );
items += item;
item.setIdentifier( (uint)QSimCommand::ToneCongestion );
item.setLabel( "Congestion" );
items += item;
item.setIdentifier( (uint)QSimCommand::ToneRadioAck );
item.setLabel( "Radio Ack" );
items += item;
item.setIdentifier( (uint)QSimCommand::ToneDropped );
item.setLabel( "Dropped" );
items += item;
item.setIdentifier( (uint)QSimCommand::ToneError );
item.setLabel( "Error" );
items += item;
item.setIdentifier( (uint)QSimCommand::ToneCallWaiting );
item.setLabel( "Call Waiting" );
items += item;
item.setIdentifier( (uint)QSimCommand::ToneGeneralBeep );
item.setLabel( "General Beep" );
items += item;
item.setIdentifier( (uint)QSimCommand::TonePositiveBeep );
item.setLabel( "Positive Beep" );
items += item;
item.setIdentifier( (uint)QSimCommand::ToneNegativeBeep );
item.setLabel( "Negative Beep" );
items += item;
cmd.setMenuItems( items );
command( cmd, this, SLOT(toneMenu(QSimTerminalResponse)) );
}
void DemoSimApplication::getInputLoop( const QSimTerminalResponse& resp )
{
QSimCommand cmd;
if ( resp.result() == QSimTerminalResponse::HelpInformationRequested ) {
// Display help for the game.
cmd.setType( QSimCommand::DisplayText );
cmd.setDestinationDevice( QSimCommand::Display );
cmd.setText("Enter code of the company." );
command( cmd, this, SLOT(mainMenu()) );
} else {
mainMenu();
}
}
void tst_QSimToolkit::testDeliverRefresh()
{
QFETCH( QByteArray, data );
QFETCH( QByteArray, resp );
QFETCH( int, resptype );
QFETCH( int, refreshtype );
QFETCH( int, numfiles );
QFETCH( QString, fileids );
QFETCH( int, options );
// Output a dummy line to give some indication of which test we are currently running.
qDebug() << "";
// Clear the client/server state.
server->clear();
deliveredCommand = QSimCommand();
// Compose and send the command.
QSimCommand cmd;
cmd.setType( QSimCommand::Refresh );
cmd.setRefreshType( (QSimCommand::RefreshType)refreshtype );
if ( numfiles > 0 ) {
QByteArray extData;
extData += (char)numfiles;
extData += QAtUtils::fromHex( fileids );
cmd.addExtensionField( 0x92, extData );
}
server->emitCommand( cmd );
// Wait for the command to arrive in the client.
QVERIFY( QFutureSignal::wait( this, SIGNAL(commandSeen()), 100 ) );
// Verify that the command was delivered exactly as we asked.
QVERIFY( deliveredCommand.type() == cmd.type() );
QVERIFY( deliveredCommand.refreshType() == cmd.refreshType() );
QVERIFY( deliveredCommand.extensionData() == cmd.extensionData() );
QCOMPARE( deliveredCommand.toPdu( (QSimCommand::ToPduOptions)options ), data );
// The response should have been sent immediately.
QCOMPARE( server->responseCount(), 1 );
QCOMPARE( server->envelopeCount(), 0 );
if ( resptype != 0x0003 ) {
QCOMPARE( server->lastResponse(), resp );
} else {
// We cannot test the "additional EF's read" case because the qtopiaphone
// library will always respond with "command performed successfully".
QByteArray resp2 = resp;
resp2[resp2.size() - 1] = 0x00;
QCOMPARE( server->lastResponse(), resp2 );
}
}
void DemoSimApplication::sticksGameLoop( const QSimTerminalResponse& resp )
{
QSimCommand cmd;
if ( resp.result() == QSimTerminalResponse::Success ) {
// User has selected the number of sticks they want.
int taken = 0;
if ( resp.text() == "1" ) {
taken = 1;
} else if ( resp.text() == "2" ) {
taken = 2;
} else if ( resp.text() == "3" ) {
taken = 3;
} else {
cmd.setType( QSimCommand::GetInkey );
cmd.setText( "Must be 1, 2, or 3. There are " + QString::number( sticksLeft ) +
" sticks left. How many sticks do you take?" );
cmd.setWantDigits( true );
command( cmd, this, SLOT(sticksGameLoop(QSimTerminalResponse)) );
return;
}
cmd.setType( QSimCommand::DisplayText );
cmd.setDestinationDevice( QSimCommand::Display );
cmd.setText( "I take " + QString::number( 4 - taken ) + " sticks." );
cmd.setClearAfterDelay( true );
sticksLeft -= 4;
command( cmd, this, SLOT(sticksGameShow()) );
} else if ( resp.result() == QSimTerminalResponse::HelpInformationRequested ) {
// Display help for the game.
cmd.setType( QSimCommand::DisplayText );
cmd.setDestinationDevice( QSimCommand::Display );
cmd.setText( "Starting with 21 sticks, players pick up 1, 2, or 3 sticks at a time. "
"The loser is the player who has to pick up the last stick." );
command( cmd, this, SLOT(startSticksGame()) );
} else {
// Probably aborted.
mainMenu();
}
}
void DemoSimApplication::mainMenu()
{
QSimCommand cmd;
QSimMenuItem item;
QList<QSimMenuItem> items;
cmd.setType( QSimCommand::SetupMenu );
item.setIdentifier( MainMenu_News );
item.setLabel( "News" );
items += item;
item.setIdentifier( MainMenu_Sports );
item.setLabel( "Sports" );
items += item;
item.setIdentifier( MainMenu_Time );
item.setLabel( "Time" );
items += item;
item.setIdentifier( MainMenu_SticksGame );
item.setLabel( "Sticks Game" );
items += item;
item.setIdentifier( MainMenu_Tones );
item.setLabel( "Tones" );
items += item;
item.setIdentifier( MainMenu_Icons );
item.setLabel( "Icons (not self-explanatory)" );
items += item;
item.setIdentifier( MainMenu_IconsSE );
item.setLabel( "Icons (self-explanatory)" );
items += item;
item.setIdentifier( MainMenu_Finance );
item.setLabel( "Finance" );
items += item;
item.setIdentifier( MainMenu_Browser );
item.setLabel( "Web Browser" );
items += item;
cmd.setMenuItems( items );
command( cmd, 0, 0 );
}
void DemoSimApplication::sendDisplayText()
{
// Display a text string and then go back to the main menu once the
// text is accepted by the user.
QSimCommand cmd;
cmd.setType( QSimCommand::DisplayText );
cmd.setDestinationDevice( QSimCommand::Display );
cmd.setClearAfterDelay(false);
cmd.setImmediateResponse(true);
cmd.setHighPriority(false);
immediateResponse = true;
cmd.setText( "Police today arrested a man on suspicion "
"of making phone calls while intoxicated. Witnesses claimed "
"that they heard the man exclaim \"I washent dwinkn!\" as "
"officers escorted him away." );
command( cmd, this, SLOT(displayTextResponse(QSimTerminalResponse)) );
}
void tst_QSimToolkit::testDeliverPowerOffCard()
{
QFETCH( QByteArray, data );
QFETCH( QByteArray, resp );
QFETCH( int, resptype );
QFETCH( int, device );
QFETCH( int, options );
// Output a dummy line to give some indication of which test we are currently running.
qDebug() << "";
// Clear the client/server state.
server->clear();
deliveredCommand = QSimCommand();
// Compose and send the command.
QSimCommand cmd;
cmd.setType( QSimCommand::PowerOffCard );
cmd.setDestinationDevice( (QSimCommand::Device)( device + 0x10 ) );
server->emitCommand( cmd );
// Wait for the command to arrive in the client.
QVERIFY( QFutureSignal::wait( this, SIGNAL(commandSeen()), 100 ) );
// Verify that the command was delivered exactly as we asked.
QVERIFY( deliveredCommand.type() == cmd.type() );
QCOMPARE( deliveredCommand.toPdu( (QSimCommand::ToPduOptions)options ), data );
// The response should have been sent immediately.
QCOMPARE( server->responseCount(), 1 );
QCOMPARE( server->envelopeCount(), 0 );
if ( resptype == 0x0000 ) {
QCOMPARE( server->lastResponse(), resp );
} else {
// We cannot test the "no card inserted" case because the qtopiaphone
// library will always respond with "command performed successfully".
static unsigned char const ok_resp[] =
{0x81, 0x03, 0x01, 0x32, 0x00, 0x82, 0x02, 0x82, 0x81, 0x83, 0x01, 0x00};
QByteArray resp2 = QByteArray( (char *)ok_resp, sizeof( ok_resp ) );
QCOMPARE( server->lastResponse(), resp2 );
}
}
void tst_QSimToolkit::testDeliverPowerOnCard()
{
QFETCH( QByteArray, data );
QFETCH( QByteArray, resp );
QFETCH( QByteArray, atr );
QFETCH( int, resptype );
QFETCH( int, device );
QFETCH( int, options );
Q_UNUSED(resp);
Q_UNUSED(resptype);
Q_UNUSED(atr);
// Output a dummy line to give some indication of which test we are currently running.
qDebug() << "";
// Clear the client/server state.
server->clear();
deliveredCommand = QSimCommand();
// Compose and send the command.
QSimCommand cmd;
cmd.setType( QSimCommand::PowerOnCard );
cmd.setDestinationDevice( (QSimCommand::Device)( device + 0x10 ) );
server->emitCommand( cmd );
// Wait for the command to arrive in the client.
QVERIFY( QFutureSignal::wait( this, SIGNAL(commandSeen()), 100 ) );
// Verify that the command was delivered exactly as we asked.
QVERIFY( deliveredCommand.type() == cmd.type() );
QCOMPARE( deliveredCommand.toPdu( (QSimCommand::ToPduOptions)options ), data );
// The response should have been sent immediately, and should always be success.
// We cannot test the answer to reset behaviour with this interface.
QCOMPARE( server->responseCount(), 1 );
QCOMPARE( server->envelopeCount(), 0 );
static unsigned char const ok_resp[] =
{0x81, 0x03, 0x01, 0x31, 0x00, 0x82, 0x02, 0x82, 0x81, 0x83, 0x01, 0x00};
QByteArray resp2 = QByteArray( (char *)ok_resp, sizeof( ok_resp ) );
QCOMPARE( server->lastResponse(), resp2 );
}
void tst_QSimToolkit::testDeliverProvideLocalInformation()
{
QFETCH( QByteArray, data );
QFETCH( QByteArray, resp );
QFETCH( QByteArray, info );
QFETCH( int, resptype );
QFETCH( int, localtype );
QFETCH( int, options );
// Output a dummy line to give some indication of which test we are currently running.
qDebug() << "";
// Clear the client/server state.
server->clear();
deliveredCommand = QSimCommand();
// Compose and send the command.
QSimCommand cmd;
cmd.setType( QSimCommand::ProvideLocalInformation );
cmd.setQualifier( localtype );
server->emitCommand( cmd );
// Wait for the command to arrive in the client.
QVERIFY( QFutureSignal::wait( this, SIGNAL(commandSeen()), 100 ) );
// Verify that the command was delivered exactly as we asked.
QVERIFY( deliveredCommand.type() == cmd.type() );
QVERIFY( deliveredCommand.qualifier() == cmd.qualifier() );
QCOMPARE( deliveredCommand.toPdu( (QSimCommand::ToPduOptions)options ), data );
// The response should have been sent immediately.
QCOMPARE( server->responseCount(), 1 );
QCOMPARE( server->envelopeCount(), 0 );
QSimTerminalResponse resp2 = QSimTerminalResponse::fromPdu( server->lastResponse() );
QVERIFY( resp2.result() == (QSimTerminalResponse::Result)resptype );
QVERIFY( resp2.cause() == QSimTerminalResponse::NoSpecificCause );
}
void DemoSimApplication::browserMenu( const QSimTerminalResponse& resp )
{
QSimCommand cmd;
if ( resp.result() == QSimTerminalResponse::Success ) {
// Item selected.
switch ( resp.menuItem() ) {
case 1:
{
cmd.setType( QSimCommand::LaunchBrowser );
cmd.setText( "Qt Extended" );
cmd.setBrowserLaunchMode( QSimCommand::UseExisting );
cmd.setUrl( "http://www.qtextended.org/" );
command( cmd, this, SLOT(sendBrowserMenu()) );
}
break;
case 2:
{
cmd.setType( QSimCommand::LaunchBrowser );
cmd.setText( "Google" );
cmd.setBrowserLaunchMode( QSimCommand::UseExisting );
cmd.setUrl( "http://www.google.com/" );
command( cmd, this, SLOT(sendBrowserMenu()) );
}
break;
case 3:
{
cmd.setType( QSimCommand::LaunchBrowser );
cmd.setText( "Google" );
cmd.setBrowserLaunchMode( QSimCommand::IfNotAlreadyLaunched );
cmd.setUrl( "http://www.google.com/" );
command( cmd, this, SLOT(sendBrowserMenu()) );
}
break;
case 4:
{
cmd.setType( QSimCommand::LaunchBrowser );
cmd.setText( "Google" );
cmd.setBrowserLaunchMode( QSimCommand::CloseExistingAndLaunch );
cmd.setUrl( "http://www.google.com/" );
command( cmd, this, SLOT(sendBrowserMenu()) );
}
break;
case 5:
{
cmd.setType( QSimCommand::LaunchBrowser );
cmd.setText( "Default Home Page" );
cmd.setBrowserLaunchMode( QSimCommand::UseExisting );
cmd.setUrl( "" );
command( cmd, this, SLOT(sendBrowserMenu()) );
}
break;
default: mainMenu(); break;
}
} else if ( resp.result() == QSimTerminalResponse::BackwardMove ) {
// Request to move backward.
mainMenu();
} else {
// Unknown response - just go back to the main menu.
mainMenu();
}
}
void tst_QSimToolkit::testDeliverSendSMS()
{
QFETCH( QByteArray, data );
QFETCH( QByteArray, resp );
QFETCH( QByteArray, tpdu );
QFETCH( int, resptype );
QFETCH( QString, text );
QFETCH( QString, number );
QFETCH( bool, smsPacking );
QFETCH( int, iconId );
QFETCH( bool, iconSelfExplanatory );
QFETCH( QByteArray, textAttribute );
QFETCH( QString, html );
QFETCH( int, options );
Q_UNUSED(html);
// Output a dummy line to give some indication of which test we are currently running.
qDebug() << "";
// Clear the client/server state.
server->clear();
deliveredCommand = QSimCommand();
// Compose and send the command.
QSimCommand cmd;
cmd.setType( QSimCommand::SendSMS );
cmd.setDestinationDevice( QSimCommand::Network );
cmd.setText( text );
if ( text.isEmpty() && ( options & QSimCommand::EncodeEmptyStrings ) != 0 )
cmd.setSuppressUserFeedback( true );
cmd.setNumber( number );
cmd.setSmsPacking( smsPacking );
cmd.setIconId( (uint)iconId );
cmd.setIconSelfExplanatory( iconSelfExplanatory );
cmd.setTextAttribute( textAttribute );
QByteArray newtpdu = tpdu;
if ( smsPacking ) {
// To prevent truncation of the 1.4.1 test data during 7-bit to 8-bit conversion,
// we extract the TPDU from "data" rather than use "tpdu".
newtpdu = QSimCommand::fromPdu( data ).extensionField(0x8B);
}
newtpdu[1] = (char)0;
cmd.addExtensionField( 0x8B, newtpdu );
server->emitCommand( cmd );
// Wait for the command to arrive in the client.
QVERIFY( QFutureSignal::wait( this, SIGNAL(commandSeen()), 100 ) );
// Verify that the command was delivered exactly as we asked.
QVERIFY( deliveredCommand.type() == cmd.type() );
QVERIFY( deliveredCommand.text() == cmd.text() );
QVERIFY( deliveredCommand.suppressUserFeedback() == cmd.suppressUserFeedback() );
QVERIFY( deliveredCommand.number() == cmd.number() );
QVERIFY( deliveredCommand.smsPacking() == cmd.smsPacking() );
QVERIFY( deliveredCommand.iconId() == cmd.iconId() );
QVERIFY( deliveredCommand.iconSelfExplanatory() == cmd.iconSelfExplanatory() );
QVERIFY( deliveredCommand.extensionData() == cmd.extensionData() );
QVERIFY( deliveredCommand.textAttribute() == cmd.textAttribute() );
QCOMPARE( deliveredCommand.toPdu( (QSimCommand::ToPduOptions)options ), data );
// The terminal response should have been sent immediately to ack reception of the command.
QCOMPARE( server->responseCount(), 1 );
QCOMPARE( server->envelopeCount(), 0 );
if ( resptype != 0x0004 ) {
QCOMPARE( server->lastResponse(), resp );
} else {
// We cannot test the "icon not displayed" case because the qtopiaphone
// library will always respond with "command performed successfully".
// Presumably the Qtopia user interface can always display icons.
QByteArray resp2 = resp;
resp2[resp2.size() - 1] = 0x00;
QCOMPARE( server->lastResponse(), resp2 );
}
}
void tst_QSimToolkit::testUISendSMS()
{
QFETCH( QByteArray, data );
QFETCH( QByteArray, resp );
QFETCH( QByteArray, tpdu );
QFETCH( int, resptype );
QFETCH( QString, text );
QFETCH( QString, number );
QFETCH( bool, smsPacking );
QFETCH( int, iconId );
QFETCH( bool, iconSelfExplanatory );
QFETCH( QByteArray, textAttribute );
QFETCH( QString, html );
QFETCH( int, options );
Q_UNUSED(html);
Q_UNUSED(options);
// Skip tests that we cannot test using the "simapp" UI.
if ( resptype == 0x0004 ) { // Icon not displayed
QSKIP( "", SkipSingle );
}
// Output a dummy line to give some indication of which test we are currently running.
qDebug() << "";
// Create the command to be tested.
QSimCommand cmd;
cmd.setType( QSimCommand::SendSMS );
cmd.setDestinationDevice( QSimCommand::Network );
cmd.setText( text );
if ( text.isEmpty() && ( options & QSimCommand::EncodeEmptyStrings ) != 0 )
cmd.setSuppressUserFeedback( true );
cmd.setNumber( number );
cmd.setSmsPacking( smsPacking );
cmd.setIconId( (uint)iconId );
cmd.setIconSelfExplanatory( iconSelfExplanatory );
cmd.setTextAttribute( textAttribute );
QByteArray newtpdu = tpdu;
if ( smsPacking ) {
// To prevent truncation of the 1.4.1 test data during 7-bit to 8-bit conversion,
// we extract the TPDU from "data" rather than use "tpdu".
newtpdu = QSimCommand::fromPdu( data ).extensionField(0x8B);
}
newtpdu[1] = (char)0;
cmd.addExtensionField( 0x8B, newtpdu );
// Set up the server with the command, ready to be selected
// from the "Run Test" menu item on the test menu.
server->startUsingTestMenu( cmd );
QVERIFY( waitForView( SimMenu::staticMetaObject ) );
// Clear the server state just before we request the actual command under test.
server->clear();
// Select the first menu item.
select();
// Wait for the text to display. If user feedback is suppressed, then
// the command is supposed to be performed silently.
if ( cmd.suppressUserFeedback() )
QVERIFY( !waitForView( SimText::staticMetaObject ) );
else
QVERIFY( waitForView( SimText::staticMetaObject ) );
// Check that the response is what we expected. The response is
// sent automatically by the back-end and is always "success".
QCOMPARE( server->responseCount(), 1 );
QCOMPARE( server->envelopeCount(), 0 );
QCOMPARE( server->lastResponse(), resp );
}
void DemoSimApplication::mainMenuSelection( int id )
{
QSimCommand cmd;
switch ( id ) {
case MainMenu_News:
{
QTimer::singleShot( 0, this, SLOT(sendDisplayText()) );
}
break;
case MainMenu_Sports:
{
sendSportsMenu();
}
break;
case MainMenu_Time:
{
cmd.setType( QSimCommand::SetupCall );
cmd.setNumber( "1194" );
cmd.setText( "Dialing the Time Guy ..." );
command( cmd, this, SLOT(mainMenu()) );
}
break;
case MainMenu_SticksGame:
{
startSticksGame();
}
break;
case MainMenu_Tones:
{
sendToneMenu();
}
break;
case MainMenu_Icons:
{
sendIconMenu();
}
break;
case MainMenu_IconsSE:
{
sendIconSEMenu();
}
break;
case MainMenu_Finance:
{
cmd.setType( QSimCommand::GetInput );
cmd.setText( "Enter code" );
cmd.setWantDigits( true );
cmd.setMinimumLength( 3 );
cmd.setHasHelp( true );
command( cmd, this, SLOT(getInputLoop(QSimTerminalResponse)) );
}
break;
case MainMenu_Browser:
{
sendBrowserMenu();
}
break;
default:
{
// Don't know what this item is, so just re-display the main menu.
mainMenu();
}
break;
}
}
