void TestDatatype::TestTaskTime()
{
TaskTime data1;
QVERIFY(data1.isNull());
TaskTime data2(-10, 10);
QVERIFY(data2.isNull());
TaskTime data3(10, -10);
QVERIFY(data3.isNull());
TaskTime data4(10, 22);
QVERIFY(!data4.isNull());
QVERIFY(data4.start() == 10);
QVERIFY(data4.end() == 22);
QVERIFY(data4.total() == 12);
TaskTime data5(22, 10);
QVERIFY(!data5.isNull());
QVERIFY(data5.start() == 10);
QVERIFY(data5.end() == 22);
QVERIFY(data5.total() == 12);
TaskTime data6(10, 22);
QVERIFY(!(data3 == data4));
QVERIFY(data1 == data2);
QVERIFY(data5 == data6);
QVERIFY(data3 != data4);
QVERIFY(!(data1 != data2));
QVERIFY(!(data5 != data6));
}
int main(){
Sales_data data1;
Sales_data data2("cpp primer5th");
Sales_data data3("cpp primer5th", 5, 80);
Sales_data data4(cin);
cout << data4.isbn();
getchar();
getchar();
getchar();
}
int __cdecl wmain()
{
// Ignoring the return value because we want to continue running even in the
// unlikely event that HeapSetInformation fails.
HeapSetInformation(NULL, HeapEnableTerminationOnCorruption, NULL, 0);
if (SUCCEEDED(CoInitialize(NULL)))
{
PlotData data1(200);
for(size_t i = 0; i < 200; ++i)
{
data1[i * 2] = i / 200.0f;
data1[i * 2 + 1] = pow(i, 1.6f) / 8.0f;
}
PlotData data2(200);
for(size_t i = 0; i < 200; ++i)
{
data2[i * 2] = i / 200.0f;
data2[i * 2 + 1] = i;
//data2[100 + i * 2] = 1;
//data2[101 + i * 2] = 1;
}
PlotData data3(200);
for(size_t i = 0; i < 200; ++i)
{
data3[i * 2] = i / 200.0f;
data3[i * 2 + 1] = i * 2;
}
PlotData data4(200);
for(size_t i = 0; i < 200; ++i)
{
data4[i * 2 ] = i / 200.0f;
data4[i * 2 + 1] = 0.125f * pow(i, 1.3f);
}
PlotData *data[] = { &data1, &data2, &data3, &data4, 0 };
HRESULT hr = SaveToImageFile(data, 800, 600, 1.0f, 600.0f, 50.0f, 40.0f, 0.1f, 100.0f);
if (FAILED(hr))
{
wprintf(L"Unexpected error: 0x%x", hr);
}
CoUninitialize();
}
return 0;
}
int
U_EXPORT main (int argc, char* argv[])
{
U_ULIB_INIT(argv);
U_TRACE(5,"main(%d)",argc)
UTimeDate data1(31,12,99), data2("31/12/99");
U_ASSERT( UTimeDate("14/09/1752").getJulian() == 2361222 )
U_ASSERT( UTimeDate("31/12/1900").getJulian() == 2415385 )
U_ASSERT( UTimeDate("01/01/1970").getJulian() == 2440588 )
U_ASSERT( data1 == data2 )
U_ASSERT( data1.getDayOfWeek() == 5 ) // Venerdi
U_ASSERT( data2.getDayOfYear() == 365 )
U_ASSERT( UTimeDate("1/3/00").getDayOfWeek() == 3 ) // Mercoledi
U_ASSERT( UTimeDate(31,12,00).getDayOfYear() == 366 )
UTimeDate data3(60,2000);
UTimeDate data4("29/02/00");
U_ASSERT( data3 == data4 )
U_ASSERT( data3.getDayOfYear() == 60 )
UTimeDate data5(60,1901);
UTimeDate data6("1/3/1901");
U_ASSERT( data5 == data6 )
U_ASSERT( UTimeDate(17, 5, 2002).isValid() == true ) // TRUE May 17th 2002 is valid
U_ASSERT( UTimeDate(30, 2, 2002).isValid() == false ) // FALSE Feb 30th does not exist
U_ASSERT( UTimeDate(29, 2, 2004).isValid() == true ) // TRUE 2004 is a leap year
UTimeDate data7(29, 2, 2004);
UString x = data7.strftime("%Y-%m-%d");
U_ASSERT( x == U_STRING_FROM_CONSTANT("2004-02-29") )
U_ASSERT( UTimeDate("14/09/1752").getJulian() == 2361222 )
cout << "Date: " << data6.strftime("%d/%m/%y") << '\n';
while (cin >> data6) cout << data6 << '\n';
U_ASSERT( UTimeDate::getSecondFromTime("19030314104248Z", true, "%4u%2u%2u%2u%2u%2uZ") < u_now->tv_sec )
}
void ComponentEventTest::testConvertValue()
{
std::map<std::string, std::string> attributes;
attributes["id"] = "1";
attributes["name"] = "DataItemTest1";
attributes["type"] = "ACCELERATION";
attributes["category"] = "SAMPLE";
std::string time("NOW"), value("2.0");
attributes["nativeUnits"] = "REVOLUTION/MINUTE";
DataItem data1 (attributes);
ComponentEvent event1(data1, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f, event1.getFValue());
CPPUNIT_ASSERT(event1.getSValue().empty());
attributes["nativeUnits"] = "REVOLUTION/SECOND";
DataItem data2 (attributes);
ComponentEvent event2 (data2, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 60.0f, event2.getFValue());
CPPUNIT_ASSERT(event2.getSValue().empty());
attributes["nativeUnits"] = "GRAM/INCH";
DataItem data3 (attributes);
ComponentEvent event3 (data3, 123, time, value);
CPPUNIT_ASSERT_EQUAL((2.0f / 1000.0f) / 25.4f, event3.getFValue());
CPPUNIT_ASSERT(event3.getSValue().empty());
attributes["nativeUnits"] = "MILLIMETER/MINUTE^3";
DataItem data4 (attributes);
ComponentEvent event4 (data4, 123, time, value);
CPPUNIT_ASSERT_EQUAL((2.0f) / (60.0f * 60.0f * 60.0f), event4.getFValue());
CPPUNIT_ASSERT(event4.getSValue().empty());
attributes["nativeUnits"] = "MILLIMETER/MINUTE^3";
attributes["nativeScale"] = "0.5";
DataItem data5 (attributes);
ComponentEvent event5 (data5, 123, time, value);
CPPUNIT_ASSERT_EQUAL((2.0f) / (60.0f * 60.0f * 60.0f * 0.5f),
event5.getFValue());
CPPUNIT_ASSERT(event5.getSValue().empty());
}
void test1 ( void ) {
WCIsvDList<int_ddata> list;
int_ddata data1(1);
int_ddata data2(2);
int_ddata data3(3);
int_ddata data4(4);
int_ddata data5(5);
list.exceptions( WCExcept::check_all );
list.append( &data2 );
list.append( &data3 );
list.append( &data4 );
list.insert( &data1 );
list.append( &data5 );
cout << "<intrusive double list for int_ddata>\n";
list.forAll( data_isv_prt, "" );
data_isv_prt( list.find( 3 ), "<the fourth element>" );
data_isv_prt( list.get( 2 ), "<the third element>" );
data_isv_prt( list.get(), "<the first element>" );
list.clear();
cout.flush();
}
void ComponentEventTest::testConvertSimpleUnits()
{
std::map<std::string, std::string> attributes;
attributes["id"] = "1";
attributes["name"] = "DataItemTest1";
attributes["type"] = "ACCELERATION";
attributes["category"] = "SAMPLE";
std::string time("NOW"), value("2.0");
attributes["nativeUnits"] = "INCH";
DataItem data1 (attributes);
ComponentEvent event1 (data1, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 25.4f, event1.getFValue());
CPPUNIT_ASSERT(event1.getSValue().empty());
attributes["nativeUnits"] = "FOOT";
DataItem data2 (attributes);
ComponentEvent event2 (data2, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 304.8f, event2.getFValue());
CPPUNIT_ASSERT(event2.getSValue().empty());
attributes["nativeUnits"] = "CENTIMETER";
DataItem data3 (attributes);
ComponentEvent event3 (data3, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 10.0f, event3.getFValue());
CPPUNIT_ASSERT(event3.getSValue().empty());
attributes["nativeUnits"] = "DECIMETER";
DataItem data4 (attributes);
ComponentEvent event4 (data4, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 100.0f, event4.getFValue());
CPPUNIT_ASSERT(event4.getSValue().empty());
attributes["nativeUnits"] = "METER";
DataItem data5 (attributes);
ComponentEvent event5 (data5, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 1000.0f, event5.getFValue());
CPPUNIT_ASSERT(event5.getSValue().empty());
attributes["nativeUnits"] = "FAHRENHEIT";
DataItem data6 (attributes);
ComponentEvent event6 (data6, 123, "NOW", "2.0");
CPPUNIT_ASSERT_EQUAL((2.0f - 32.0f) * (5.0f / 9.0f), event6.getFValue());
CPPUNIT_ASSERT(event6.getSValue().empty());
attributes["nativeUnits"] = "POUND";
DataItem data7 (attributes);
ComponentEvent event7 (data7, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 0.45359237f, event7.getFValue());
CPPUNIT_ASSERT(event7.getSValue().empty());
attributes["nativeUnits"] = "GRAM";
DataItem data8 (attributes);
ComponentEvent event8 (data8, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f / 1000.0f, event8.getFValue());
CPPUNIT_ASSERT(event8.getSValue().empty());
attributes["nativeUnits"] = "RADIAN";
DataItem data9 (attributes);
ComponentEvent event9 (data9, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 57.2957795f, event9.getFValue());
CPPUNIT_ASSERT(event9.getSValue().empty());
attributes["nativeUnits"] = "MINUTE";
DataItem data10 (attributes);
ComponentEvent event10 (data10, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 60.0f, event10.getFValue());
CPPUNIT_ASSERT(event10.getSValue().empty());
attributes["nativeUnits"] = "HOUR";
DataItem data11 (attributes);
ComponentEvent event11 (data11, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f * 3600.0f, event11.getFValue());
CPPUNIT_ASSERT(event11.getSValue().empty());
attributes["nativeUnits"] = "MILLIMETER";
DataItem data12 (attributes);
ComponentEvent event12 (data12, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f, event12.getFValue());
CPPUNIT_ASSERT(event12.getSValue().empty());
attributes["nativeUnits"] = "PERCENT";
DataItem data13 (attributes);
ComponentEvent event13 (data13, 123, time, value);
CPPUNIT_ASSERT_EQUAL(2.0f, event13.getFValue());
CPPUNIT_ASSERT(event13.getSValue().empty());
}
void OnActive(Character* character, InteractiveElementType /*type*/)
{
// Seuelement une instance du script ou bien ? Du coup va poser des problèmes
// si plusieurs joueurs en même temps ? Du coup gérer la création de nouvelles instances de scripts ?
m_char = character;
// Envoie comme quoi l'élémentId n'est plus "usable" (différence avec le paquet de spawn 200)
WorldPacket data(SMSG_INTERACTIVE_ELEMENT_UPDATE);
data << quint64(20114); // Instance ElementId
data.StartBlock<quint16>();
{
data << quint8(1); // BlockCount
data << quint8(2); // blockId
data << quint32(6); // offset
data << quint8(2); // BlockId
data << quint16(1); // ?
data << quint8(1); // isVisible
data << quint8(0); // isUsable
data << quint8(0); // ?
data << quint8(0); // ?
data << quint8(0); // ?
data << quint32(0); // ?
}
data.EndBlock<quint16>();
character->GetSession()->SendPacket(data);
// Spawn Wapin
WorldPacket data2(SMSG_UPDATE_OBJECT);
data2 << quint8(0);
data2 << quint8(1);
data2 << quint8(1);
data2 << qint64(-1706442045669898);
data2.StartBlock<quint16>();
{
data2 << quint8(7);
// GUID
data2 << qint64(-1706442045669898);
// IDENTITY
data2 << quint8(1);
data2 << qint64(-1);
// NAME
data2 << quint16(0);
// BREED
data2 << quint16(2644);
// POSITION
data2 << qint32(0); // X
data2 << qint32(-17); // Y
data2 << qint16(0); // Z
data2 << quint16(-1); // InstanceId
data2 << quint8(3); // Direction
// APPEARANCE
data2 << quint8(1); // Show
// PUBLIC_CHARACTERISTICS
data2 << quint16(1); // Level
data2 << quint16(0); // States size
// FIGHT_PROPERTIES
data2 << quint8(0); // hasProperties
// FIGHT
data2 << qint32(-1); // currentFightId
data2 << quint8(0); // isKo
data2 << quint8(0); // isDead
data2 << quint8(0); // isSummoned
data2 << quint8(0); // isFleeing
data2 << qint8(-1); // obstacleId
data2 << quint8(0); // hasSummon
// EQUIPMENT_APPEARANCE
data2 << quint8(0); // size
// RUNNING_EFFECTS
data2 << quint8(1); // hasInFightData
data2 << quint16(1); // data size
data2 << quint8(13); // data
data2 << quint8(1); // hasOutFightData
data2 << quint16(0); // size
// CURRENT_MOVEMENT_PATH
data2 << quint8(0); // hasCurrentPath
// WORLD_PROPERTIES
data2 << quint8(0); // hasProperties
// GROUP
data2 << quint64(79645873605204); // PartyId
data2 << quint16(1); // Members size
data2 << qint16(-1); // breedId
data2 << qint16(-1); // Level
// TEMPLATE
data2 << quint16(0); // sightRadius
data2 << quint16(0); // aggroRadius
// COLLECT
data2 << quint16(0);
// OCCUPATION
data2 << quint8(0);
// XP
data2 << quint64(0);
// XP_CHARACTERISTICS
data2 << quint16(0);
data2 << quint16(0);
//data2 << quint16(0);
//data2 << quint32(0);
// Pourquoi sniff size 110 et la on est déjà à 117 ??
}
data2.EndBlock<quint16>();
character->GetSession()->SendPacket(data2);
// Activation du script (mouvement de la fenêtre entre autre)
// Root aussi le joueur ?
WorldPacket data3(SMSG_SCENARIO_SCRIPT);
data3 << quint8(0); // Event
data3 << quint32(12603); // Function
data3 << quint32(1611); // ScenarioId
data3 << quint8(1); // Long size?
data3 << qint64(-1706442045669898); // Param
character->GetSession()->SendPacket(data3);
// Spawn Kano
WorldPacket data4(SMSG_UPDATE_OBJECT);
data4 << quint8(0);
data4 << quint8(1);
data4 << quint8(1);
data4 << qint64(-1706442045669878);
data4.StartBlock<quint16>();
{
data4 << quint8(7);
// GUID
data4 << qint64(-1706442045669878);
// IDENTITY
data4 << quint8(1);
data4 << qint64(-1);
// NAME
data4 << quint16(0);
// BREED
data4 << quint16(2694);
// POSITION
data4 << qint32(0); // X
data4 << qint32(-21); // Y
data4 << qint16(3); // Z
data4 << quint16(-1); // InstanceId
data4 << quint8(3); // Direction
// APPEARANCE
data4 << quint8(1); // Show
// PUBLIC_CHARACTERISTICS
data4 << quint16(100); // Level
data4 << quint16(0); // States size
// FIGHT_PROPERTIES
data4 << quint8(0); // hasProperties
// FIGHT
data4 << qint32(-1); // currentFightId
data4 << quint8(0); // isKo
data4 << quint8(0); // isDead
data4 << quint8(0); // isSummoned
data4 << quint8(0); // isFleeing
data4 << qint8(-1); // obstacleId
data4 << quint8(0); // hasSummon
// EQUIPMENT_APPEARANCE
data4 << quint8(0); // size
// RUNNING_EFFECTS should be wrong
data4 << quint8(1); // hasInFightData
data4 << quint16(1); // data size
data4 << quint8(13); // data
data4 << quint8(1); // hasOutFightData
data4 << quint16(0); // size
// CURRENT_MOVEMENT_PATH
data4 << quint8(0); // hasCurrentPath
// WORLD_PROPERTIES
data4 << quint8(0); // hasProperties
// GROUP
data4 << quint64(79645873605204); // PartyId
data4 << quint16(1); // Members size
data4 << qint16(-1); // breedId
data4 << qint16(-1); // Level
// TEMPLATE
data4 << quint16(0); // sightRadius
data4 << quint16(0); // aggroRadius
// COLLECT
data4 << quint16(0);
// OCCUPATION
data4 << quint8(0);
// XP
data4 << quint64(0);
// XP_CHARACTERISTICS
data4 << quint16(0);
data4 << quint16(0);
//data4 << quint16(0);
//data4 << quint32(0);
// Pourquoi sniff size 110 et la on est déjà à 117 ??
}
data4.EndBlock<quint16>();
character->GetSession()->SendPacket(data4);
// Texte : "Hé toi le nouveau" etc.
WorldPacket data5(SMSG_SCENARIO_SCRIPT);
data5 << quint8(0); // Event
data5 << quint32(12687); // Function
data5 << quint32(1611); // ScenarioId
data5 << quint8(1); // Params size?
data5 << qint64(-1706442045669878); // Param
character->GetSession()->SendPacket(data5);
// Flèche sur le wapin
WorldPacket data6(SMSG_SCENARIO_SCRIPT);
data6 << quint8(0); // Event
data6 << quint32(12691); // Function
data6 << quint32(1611); // ScenarioId
data6 << quint8(1); // Long size?
data6 << qint64(-1706442045669898); // Param
character->GetSession()->SendPacket(data6);
m_spawned = true;
}
void CCommandParser::RunL()
{
RDebug::Print(_L("CCommandParser::RunL report: %X"),iState);
switch(iState)
{
case TControllerDataTypes::EWiiMoteReportButton:
{
TUint16 btn(0);
btn = iDataPtr[2];
btn = iDataPtr[2] << 8;
btn |= iDataPtr[3];
HandleButtonReport(btn);
}break;
case TControllerDataTypes::EWiiMoteReportButtonAcc:
{
TUint16 btn(0);
TUint16 accX(0);
TUint16 accY(0);
TUint16 accZ(0);
btn = iDataPtr[2];
btn = btn << 8;
btn |= iDataPtr[3];
HandleButtonReport(btn);
accX = iDataPtr[4];
accY = iDataPtr[5];
accZ = iDataPtr[6];
TUint8 lsb1(0);
TUint8 lsb2(0);
TUint8 lsb3(0);
TUint8 lsb4(0);
lsb1 = iDataPtr[2] & 0x40;
lsb2 = iDataPtr[2] & 0x20;
lsb3 = iDataPtr[3] & 0x40;
lsb4 = iDataPtr[3] & 0x20;
RDebug::Print(_L("XLRLSB: %X , %d - XLRLSB: %X , %d"),lsb1,lsb1,lsb2,lsb2);
RDebug::Print(_L("XLRLSB: %X , %d - XLRLSB: %X , %d"),lsb3,lsb3,lsb4,lsb4);
RDebug::Print(_L("AccX: %X , %d - AccY: %X , %d - AccZ: %X , %d"),accX,accX,accY,accY,accZ,accZ);
HandleAccReport(accX,accY,accZ);
}break;
case TControllerDataTypes::EWiiMoteReportControlStatus:
{
TUint8 data(0);
data = iDataPtr[7];
TRemoteInfo info;
info = iObserver.RemoteInfo();
info.iCommand = (TControllerDataTypes::TWiiMoteCommands)iState;
TReal32 d(data);
TReal32 b(TControllerDataTypes::EWiiMoteControlStatusBattery);
TInt16 bat=0;
TReal calc( (d/b)*100);
Math::Int(bat,calc);
info.iBattery = bat;
iObserver.UpdateRemoteInfo(info);
}break;
case TControllerDataTypes::EWiiMoteReportWrite:
{
TUint8 data1(0);
TUint8 data2(0);
TUint8 data3(0);
TUint8 data4(0);
data1 = iDataPtr[0];
data2 = iDataPtr[1];
data3 = iDataPtr[2];
data4 = iDataPtr[3];
TRemoteInfo info;
info = iObserver.RemoteInfo();
info.iCommand = (TControllerDataTypes::TWiiMoteCommands)data3;
switch(data3)
{
case TControllerDataTypes::EWiiMoteCommandAudioEnable:
case TControllerDataTypes::EWiiMoteCommandAudioMute:
{
if(data1 || data2 || data4)
{
info.iWiiSpeakerEnabled = TControllerDataTypes::EWiiSpeakerError;
}
}break;
}
iObserver.UpdateRemoteInfo(info);
}break;
default:
break;
}
}
BOOST_FIXTURE_TEST_CASE(GeneralSigningInterface, IdentityManagementFixture)
{
Name id("/id");
Name certName = m_keyChain.createIdentity(id);
shared_ptr<v1::IdentityCertificate> idCert = m_keyChain.getCertificate(certName);
Name keyName = idCert->getPublicKeyName();
m_keyChain.setDefaultIdentity(id);
Name id2("/id2");
Name cert2Name = m_keyChain.createIdentity(id2);
shared_ptr<v1::IdentityCertificate> id2Cert = m_keyChain.getCertificate(cert2Name);
// SigningInfo is set to default
Data data1("/data1");
m_keyChain.sign(data1);
BOOST_CHECK(Validator::verifySignature(data1, idCert->getPublicKeyInfo()));
BOOST_CHECK_EQUAL(data1.getSignature().getKeyLocator().getName(), certName.getPrefix(-1));
Interest interest1("/interest1");
m_keyChain.sign(interest1);
BOOST_CHECK(Validator::verifySignature(interest1, idCert->getPublicKeyInfo()));
SignatureInfo sigInfo1(interest1.getName()[-2].blockFromValue());
BOOST_CHECK_EQUAL(sigInfo1.getKeyLocator().getName(), certName.getPrefix(-1));
// SigningInfo is set to Identity
Data data2("/data2");
m_keyChain.sign(data2, SigningInfo(SigningInfo::SIGNER_TYPE_ID, id2));
BOOST_CHECK(Validator::verifySignature(data2, id2Cert->getPublicKeyInfo()));
BOOST_CHECK_EQUAL(data2.getSignature().getKeyLocator().getName(), cert2Name.getPrefix(-1));
Interest interest2("/interest2");
m_keyChain.sign(interest2, SigningInfo(SigningInfo::SIGNER_TYPE_ID, id2));
BOOST_CHECK(Validator::verifySignature(interest2, id2Cert->getPublicKeyInfo()));
SignatureInfo sigInfo2(interest2.getName()[-2].blockFromValue());
BOOST_CHECK_EQUAL(sigInfo2.getKeyLocator().getName(), cert2Name.getPrefix(-1));
// SigningInfo is set to Key
Data data3("/data3");
m_keyChain.sign(data3, SigningInfo(SigningInfo::SIGNER_TYPE_KEY, keyName));
BOOST_CHECK(Validator::verifySignature(data3, idCert->getPublicKeyInfo()));
BOOST_CHECK_EQUAL(data3.getSignature().getKeyLocator().getName(), certName.getPrefix(-1));
Interest interest3("/interest3");
m_keyChain.sign(interest3);
BOOST_CHECK(Validator::verifySignature(interest3, idCert->getPublicKeyInfo()));
SignatureInfo sigInfo3(interest1.getName()[-2].blockFromValue());
BOOST_CHECK_EQUAL(sigInfo3.getKeyLocator().getName(), certName.getPrefix(-1));
// SigningInfo is set to Cert
Data data4("/data4");
m_keyChain.sign(data4, SigningInfo(SigningInfo::SIGNER_TYPE_CERT, certName));
BOOST_CHECK(Validator::verifySignature(data4, idCert->getPublicKeyInfo()));
BOOST_CHECK_EQUAL(data4.getSignature().getKeyLocator().getName(), certName.getPrefix(-1));
Interest interest4("/interest4");
m_keyChain.sign(interest4, SigningInfo(SigningInfo::SIGNER_TYPE_CERT, certName));
BOOST_CHECK(Validator::verifySignature(interest4, idCert->getPublicKeyInfo()));
SignatureInfo sigInfo4(interest4.getName()[-2].blockFromValue());
BOOST_CHECK_EQUAL(sigInfo4.getKeyLocator().getName(), certName.getPrefix(-1));
// SigningInfo is set to DigestSha256
Data data5("/data5");
m_keyChain.sign(data5, SigningInfo(SigningInfo::SIGNER_TYPE_SHA256));
BOOST_CHECK(Validator::verifySignature(data5, DigestSha256(data5.getSignature())));
Interest interest5("/interest4");
m_keyChain.sign(interest5, SigningInfo(SigningInfo::SIGNER_TYPE_SHA256));
BOOST_CHECK(Validator::verifySignature(interest5,
DigestSha256(Signature(interest5.getName()[-2].blockFromValue(),
interest5.getName()[-1].blockFromValue()))));
}
int
U_EXPORT main (int argc, char* argv[])
{
U_ULIB_INIT(argv);
U_TRACE(5,"main(%d)",argc)
UTimeDate data1(31,12,99), data2("31/12/99");
U_ASSERT( UTimeDate("14/09/1752").getJulian() == 2361222 )
U_ASSERT( UTimeDate("31/12/1900").getJulian() == 2415385 )
U_ASSERT( UTimeDate("01/01/1970").getJulian() == 2440588 )
U_ASSERT( data1 == data2 )
U_ASSERT( data1.getDayOfWeek() == 5 ) // Venerdi
U_ASSERT( data2.getDayOfYear() == 365 )
U_ASSERT( UTimeDate("1/3/00").getDayOfWeek() == 3 ) // Mercoledi
U_ASSERT( UTimeDate(31,12,0).getDayOfYear() == 366 )
UTimeDate data3(60,2000);
UTimeDate data4("29/02/00");
U_ASSERT( data3 == data4 )
U_ASSERT( data3.getDayOfYear() == 60 )
UTimeDate data5(60,1901);
UTimeDate data6("1/3/1901");
U_ASSERT( data5 == data6 )
U_ASSERT( UTimeDate(17, 5, 2002).isValid() == true ) // TRUE May 17th 2002 is valid
U_ASSERT( UTimeDate(30, 2, 2002).isValid() == false ) // FALSE Feb 30th does not exist
U_ASSERT( UTimeDate(29, 2, 2004).isValid() == true ) // TRUE 2004 is a leap year
UTimeDate data7(29, 2, 2004);
UString x = data7.strftime("%Y-%m-%d");
U_ASSERT( x == U_STRING_FROM_CONSTANT("2004-02-29") )
U_ASSERT( UTimeDate("14/09/1752").getJulian() == 2361222 )
cout << "Date: " << data6.strftime("%d/%m/%y") << '\n';
while (cin >> data6) cout << data6 << '\n';
U_ASSERT( UTimeDate::getSecondFromTime("19030314104248Z", true, "%4u%2u%2u%2u%2u%2uZ") < u_now->tv_sec )
/*
typedef struct static_date {
struct timeval _timeval; // => u_now
char lock1[1];
char date1[17+1]; // 18/06/12 18:45:56
char lock2[1];
char date2[26+1]; // 04/Jun/2012:18:18:37 +0200
char lock3[1];
char date3[6+29+2+12+2+19+1]; // Date: Wed, 20 Jun 2012 11:43:17 GMT\r\nServer: ULib\r\nConnection: close\r\n
} static_date;
*/
ULog::static_date log_data;
(void) u_strftime2(log_data.date1, 17, "%d/%m/%y %T", u_now->tv_sec + u_now_adjust);
(void) u_strftime2(log_data.date2, 26, "%d/%b/%Y:%T %z", u_now->tv_sec + u_now_adjust);
(void) u_strftime2(log_data.date3, 6+29+2+12+2+17+2, "Date: %a, %d %b %Y %T GMT\r\nServer: ULib\r\nConnection: close\r\n", u_now->tv_sec);
U_INTERNAL_DUMP("date1 = %.17S date2 = %.26S date3+6 = %.29S", log_data.date1, log_data.date2, log_data.date3+6)
/*
for (int i = 0; i < 360; ++i)
{
u_now->tv_sec++;
UTimeDate::updateTime(log_data.date1 + 12);
UTimeDate::updateTime(log_data.date2 + 15);
UTimeDate::updateTime(log_data.date3+6 + 20);
cout.write(log_data.date1, 17);
cout.write(" - ", 3);
cout.write(log_data.date2, 26);
cout.write(" - ", 3);
cout.write(log_data.date3+6, 29);
cout.put('\n');
}
*/
}
void TestLpdu::testBuildLpdu()
{
/* application layer data for r1 */
uint8_t a1[] = { 0xcd, 0xcc, 0x01, 0x3c, 0x02, 0x06, 0x3c, 0x03,
0x06, 0x3c, 0x04, 0x06 };
/* application layer data for r2 */
uint8_t a2[] = { 0xc1, 0xe3, 0x81, 0x96, 0x00, 0x02, 0x01, 0x28,
0x01, 0x00, 0x00, 0x00, 0x01, 0x02, 0x01, 0x28,
0x01, 0x00, 0x01, 0x00, 0x01, 0x02, 0x01, 0x28,
0x01, 0x00, 0x02, 0x00, 0x01, 0x02, 0x01, 0x28,
0x01, 0x00, 0x03, 0x00, 0x01, 0x20, 0x02, 0x28,
0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x20,
0x02, 0x28, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x03, 0x00,
0x00, 0x1e, 0x02, 0x01, 0x00, 0x00, 0x01, 0x00,
0x01, 0x00, 0x00, 0x01, 0x00, 0x00 };
/* these are known good DNP LPDUs */
uint8_t r0[] = { 0x05, 0x64, 0x05, 0xc0, 0x02, 0x00, 0x01, 0x00,
0x9e, 0x59 }; /* header only */
uint8_t r1[] = { 0x05, 0x64, 0x11, 0xc4, 0x15, 0x00, 0x17, 0x00,
0x63, 0x62, 0xcd, 0xcc, 0x01, 0x3c, 0x02, 0x06,
0x3c, 0x03, 0x06, 0x3c, 0x04, 0x06, 0x08, 0x9e };
uint8_t r2[] = { 0x05, 0x64, 0x53, 0x73, 0x00, 0x04, 0x01, 0x00,
0x03, 0xfc, 0xc1, 0xe3, 0x81, 0x96, 0x00, 0x02,
0x01, 0x28, 0x01, 0x00, 0x00, 0x00, 0x01, 0x02,
0x01, 0x28, 0x05, 0x24, 0x01, 0x00, 0x01, 0x00,
0x01, 0x02, 0x01, 0x28, 0x01, 0x00, 0x02, 0x00,
0x01, 0x02, 0x01, 0x28, 0xb4, 0x77, 0x01, 0x00,
0x03, 0x00, 0x01, 0x20, 0x02, 0x28, 0x01, 0x00,
0x00, 0x00, 0x01, 0x00, 0x00, 0x20, 0xa5, 0x25,
0x02, 0x28, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x03, 0x00,
0x2f, 0xac, 0x00, 0x1e, 0x02, 0x01, 0x00, 0x00,
0x01, 0x00, 0x01, 0x00, 0x00, 0x01, 0x00, 0x00,
0x16, 0xed };
uint8_t twoLpdus[] = { 0x05, 0x64, 0x08, 0xc4, 0x02, 0x00, 0x2d, 0x00,
0xa4, 0x1c, 0xc0, 0xcd, 0x00, 0x23, 0x65, 0x05,
0x64, 0x0b, 0xc4, 0x02, 0x00, 0x2d, 0x00, 0xf4,
0x8f, 0xc0, 0xce, 0x01, 0x3c, 0x02, 0x06, 0x09,
0x7f };
/* header only - no application data */
uint8_t r3[] = { 0x05, 0x64, 0x05, 0xc0, 0x01, 0x00, 0x00, 0x04,
0xe9, 0x21 };
/* header only - no application data */
uint8_t r4[] = { 0x05, 0x64, 0x05, 0x00, 0x00, 0x04, 0x01, 0x00,
0x19, 0xa6 };
uint8_t r5[] = { 0x05, 0x64, 0x0a, 0x44, 0x01, 0x00, 0x02, 0x00,
0xfa, 0x4a, 0xc1, 0xe1, 0x81, 0x10, 0x00, 0x6d,
0xd5 };
/* known bad lpdu data */
uint8_t r10[] ={ 108, 68, 3, 0, 17, 8, 127, 38, 193, 201 };
uint8_t r11[] ={ 129, 144, 0, 20, 6, 0, 0, 8, 16, 0 };
uint8_t r12[] ={ 0, 0, 16, 0, 48, 78, 16, 0, 7, 0 };
uint8_t r13[] ={ 0, 0, 7, 0, 7, 0, 17, 0, 30, 4 };
uint8_t r14[] ={ 0, 0, 156, 186, 34, 120, 0, 120, 0, 120 };
uint8_t r15[] ={ 0, 120, 0, 48, 81, 66, 81, 69, 81, 61 };
uint8_t r16[] ={ 76, 53, 81, 4, 0, 5, 0, 4, 0, 4 };
uint8_t r20[] ={ 81, 48, 81, 48, 223, 36, 81, 4, 0, 5 };
enum StatIndex { RX_START_OCTETS = 0,
RX_LPDUS,
LOST_BYTES,
CRC_ERRORS,
NUM_STATS };
Stats::Element statElements[] =
{
{ RX_START_OCTETS, "Rx Start Octets", Stats::NORMAL,0,0},
{ RX_LPDUS, "Rx Lpdus", Stats::NORMAL,0,0},
{ LOST_BYTES, "Lost Bytes", Stats::ABNORMAL,0,0},
{ CRC_ERRORS, "CRC Errors", Stats::ABNORMAL,0,0},
};
Stats stats;
char name[Stats::MAX_USER_NAME_LEN];
int debugLevel = -1;
DummyDb db;
assert(sizeof(statElements)/sizeof(Stats::Element) == NUM_STATS);
snprintf(name, Stats::MAX_USER_NAME_LEN, "DL TEST");
stats = Stats( name, 1, &debugLevel, statElements, NUM_STATS, &db);
Lpdu lpdu = Lpdu( &stats);
unsigned int i;
bool lpduFound;
lpdu.build( 1, 1, 0, 0, 0, 2, 1);
lpduToArrayCmp( lpdu, r0);
lpdu.build( 1, 1, 0, 0, 4, 21, 23, TO_BYTES(a1));
lpduToArrayCmp( lpdu, r1);
lpdu.build( 0, 1, 1, 1, 3, 1024, 1, TO_BYTES(a2));
lpduToArrayCmp( lpdu, r2);
lpdu.reset();
/* test building from incoming bytes */
Bytes data1( r5, r5 + 10);
lpduFound = lpdu.buildFromBytes( data1);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 10);
Bytes data2( &r5[10], &r5[10] + sizeof(r5) - 10);
lpduFound = lpdu.buildFromBytes( data2);
QVERIFY( lpduFound == true);
QVERIFY (lpdu.getStat(Lpdu::RX_START_OCTETS) == 1);
QVERIFY (lpdu.getStat(Lpdu::LOST_BYTES) == 0);
QVERIFY (lpdu.getStat(Lpdu::CRC_ERRORS) == 0);
Bytes data3(TO_BYTES(r3));
lpduFound = lpdu.buildFromBytes( data3);
QVERIFY( lpduFound == true);
Bytes data4(TO_BYTES(r4));
lpduFound = lpdu.buildFromBytes( data4);
QVERIFY( lpduFound == true);
/* create 4x a good lpdu */
Bytes data5(TO_BYTES(r1));
Bytes data6(data5);
data6.insert(data6.end(), data5.begin(), data5.end());
data6.insert(data6.end(), data5.begin(), data5.end());
data6.insert(data6.end(), data5.begin(), data5.end());
/* ensure we receive 4 good ones */
for (i=0; i<4; i++)
{
lpdu.reset();
lpduFound = lpdu.buildFromBytes( data6);
QVERIFY( lpduFound == true);
QVERIFY (data6.size() == (sizeof(r1)*(3-i)));
QVERIFY (lpdu.getStat(Lpdu::RX_START_OCTETS) == (2+i));
QVERIFY (lpdu.getStat(Lpdu::LOST_BYTES) == 0);
QVERIFY (lpdu.getStat(Lpdu::CRC_ERRORS) == 0);
}
/* header only lpdu */
lpdu.reset();
Bytes data7(TO_BYTES(r0));
lpduFound = lpdu.buildFromBytes( data7);
QVERIFY( lpduFound == true);
QVERIFY (lpdu.getStat(Lpdu::RX_START_OCTETS) == 6);
QVERIFY (lpdu.getStat(Lpdu::LOST_BYTES) == 0);
QVERIFY (lpdu.getStat(Lpdu::CRC_ERRORS) == 0);
/* building of two lpdus coming in across two simulated reads */
/* with the break on the last byte of the last CRC */
lpdu.reset();
Bytes data8(TO_BYTES(twoLpdus));
Bytes data9;
data9.push_back(data8.back());
data8.pop_back();
lpduFound = lpdu.buildFromBytes( data8);
QVERIFY( lpduFound == true);
QVERIFY (lpdu.ab.size() == 15); /* manually counted */
QVERIFY (lpdu.getStat(Lpdu::RX_START_OCTETS) == 7);
QVERIFY (lpdu.getStat(Lpdu::LOST_BYTES) == 0);
QVERIFY (lpdu.getStat(Lpdu::CRC_ERRORS) == 0);
QVERIFY( data8.size() == 17);
lpdu.reset();
lpduFound = lpdu.buildFromBytes( data8);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 17);
QVERIFY (lpdu.getStat(Lpdu::RX_START_OCTETS) == 8);
QVERIFY (lpdu.getStat(Lpdu::LOST_BYTES) == 0);
QVERIFY (lpdu.getStat(Lpdu::CRC_ERRORS) == 0);
lpduFound = lpdu.buildFromBytes( data9);
QVERIFY( lpduFound == true);
QVERIFY (lpdu.getStat(Lpdu::RX_START_OCTETS) == 8);
QVERIFY (lpdu.getStat(Lpdu::LOST_BYTES) == 0);
QVERIFY (lpdu.getStat(Lpdu::CRC_ERRORS) == 0);
lpdu.reset();
/* test known bad cases */
Bytes data10(TO_BYTES(r10));
lpduFound = lpdu.buildFromBytes( data10);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 0);
lpdu.reset();
Bytes data11(TO_BYTES(r11));
lpduFound = lpdu.buildFromBytes( data11);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 0);
lpdu.reset();
Bytes data12(TO_BYTES(r12));
lpduFound = lpdu.buildFromBytes( data12);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 0);
lpdu.reset();
Bytes data13(TO_BYTES(r13));
lpduFound = lpdu.buildFromBytes( data13);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 0);
lpdu.reset();
Bytes data14(TO_BYTES(r14));
lpduFound = lpdu.buildFromBytes( data14);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 0);
lpdu.reset();
Bytes data15(TO_BYTES(r15));
lpduFound = lpdu.buildFromBytes( data15);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 0);
lpdu.reset();
Bytes data16(TO_BYTES(r16));
lpduFound = lpdu.buildFromBytes( data16);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 0);
lpdu.reset();
Bytes data20(TO_BYTES(r20));
lpduFound = lpdu.buildFromBytes( data20);
QVERIFY( lpduFound == false);
QVERIFY (lpdu.ab.size() == 0);
}
int main(int argc, char* argv[])
{
try
{
IDL::traits<CORBA::ORB>::ref_type _orb = CORBA::ORB_init (argc, argv);
if (_orb == nullptr)
{
std::cerr << "ERROR: CORBA::ORB_init (argc, argv) returned nil ORB." << std::endl;
return 1;
}
IDL::traits<CORBA::Object>::ref_type obj = _orb->string_to_object ("file://test.ior");
if (obj == nullptr)
{
std::cerr << "ERROR: string_to_object(<ior>) returned nil reference." << std::endl;
return 1;
}
std::cout << "retrieved object reference" << std::endl;
IDL::traits<Test::Foo>::ref_type foo = IDL::traits<Test::Foo>::narrow (obj);
if (!foo)
{
std::cerr << "ERROR: IDL::traits<Test::Foo>::narrow (obj) returned nil object." << std::endl;
return 1;
}
std::cout << "narrowed Foo interface" << std::endl;
Test::Data data;
data._default ();
if (!foo->pass_union(data))
{
std::cerr << "ERROR: Test::Foo call failed." << std::endl;
return 1;
}
std::cout << "successfully called Foo::pass_union ("; dump (data); std::cout << ")" << std::endl;
// Not a copy here but a move!
Test::Data data2 = foo->return_union();
std::cout << "successfully called Foo::return_union() => "; dump (data2); std::cout << std::endl;
Test::Data data3;
if (!foo->get_union(data3))
{
std::cerr << "ERROR: Test::Foo call failed." << std::endl;
return 1;
}
std::cout << "successfully called Foo::get_union ("; dump (data3); std::cout << ")" << std::endl;
// This is a copy (as intended).
Test::Data data4 (data3);
// NOTE: just passed (and returned) by reference!
if (!foo->update_union(data4))
{
std::cerr << "ERROR: Test::Foo call failed." << std::endl;
return 1;
}
std::cout << "successfully called Foo::update_union ("; dump (data3); std::cout << ") => "; dump (data4); std::cout << std::endl;
std::cout << "shutting down...";
foo->shutdown ();
std::cout << std::endl;
}
catch (const std::exception& e)
{
std::cerr << "exception caught: " << e.what() << std::endl;
}
return 0;
}
void CUT_PBASE_T_USBDI_0498::TransferCompleteL(TInt aTransferId,TInt aCompletionCode)
{
OstTraceFunctionEntryExt( CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_ENTRY, this );
Cancel();
TInt err(KErrNone);
TBuf<256> msg;
OstTraceExt3(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL, "Transfer completed (id=%d), aCompletionCode = %d, test step = %d",aTransferId, aCompletionCode, iCaseStep);
switch(iCaseStep)
{
case ETransfer:
if(aCompletionCode != KErrNone)
{
iIfc1OutTransfer[0]->Cancel();
iIfc1OutTransfer[1]->Cancel();
iIfc2OutTransfer[0]->Cancel();
iIfc2OutTransfer[1]->Cancel();
iIfc1InTransfer[0]->Cancel();
iIfc1InTransfer[1]->Cancel();
iIfc2InTransfer[0]->Cancel();
iIfc2InTransfer[1]->Cancel();
err = KErrCorrupt;
msg.Format(_L("<Error %d> The transfer completed with an error."), aCompletionCode);
break; //switch(iCaseStep)
}
switch(aTransferId)
{
case KIfc1BulkTransferOutId1:
case KIfc1BulkTransferOutId2:
case KIfc2BulkTransferOutId1:
case KIfc2BulkTransferOutId2:
iTransferComplete |= aTransferId;
OstTraceExt2(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP01, "Transfer OUT %d completed (Transfer Completion Aggregation Mask 0x%x)", aTransferId, iTransferComplete);
break; //switch(aTransferId)
case KIfc1BulkTransferInId1:
case KIfc1BulkTransferInId2:
case KIfc2BulkTransferInId1:
case KIfc2BulkTransferInId2:
iTransferComplete |= aTransferId;
OstTraceExt2(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP02, "Transfer OUT %d completed (Transfer Completion Aggregation Mask 0x%x)", aTransferId, iTransferComplete);
break; //switch(aTransferId)
default:
iTransferComplete = 0; //reset
err = KUnexpectedTransferID;
msg.Format(_L("<Error %d> Unexpected transfer ID, GOT %d, (wanted one of:- %d, %d, %d, %d, %d, %d, %d, or%d)"),
err, aTransferId,
KIfc1BulkTransferInId1,
KIfc1BulkTransferInId2,
KIfc2BulkTransferInId1,
KIfc2BulkTransferInId2,
KIfc1BulkTransferOutId1,
KIfc1BulkTransferOutId2,
KIfc2BulkTransferOutId1,
KIfc2BulkTransferOutId2
);
break; //switch(aTransferId)
}
// Transfer Out Response
if(err==KErrNone && iTimeElapsed[0] == 0 && (iTransferComplete & KIfc1BulkTransferOutIdMask) == KIfc1BulkTransferOutIdMask)
//Record time elapsed for Interface 1 if not yet recorded.
{
RecordTime(0);
}
if(err==KErrNone && iTimeElapsed[1] == 0 && (iTransferComplete & KIfc2BulkTransferOutIdMask) == KIfc2BulkTransferOutIdMask)
//Record time elapsed for Interface 2 if not yet recorded.
{
RecordTime(1);
}
if(err==KErrNone && (iTransferComplete & KBulkTransferOutIdMask) == KBulkTransferOutIdMask)
{
OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP03, "All OUT Transfers Completed Successfully: Transfer Completion Aggregation Mask 0x%x", iTransferComplete);
//Leave validation to the point at which all transfers have completed.
}
// Transfer In Response
if(err==KErrNone && iTimeElapsed[2] == 0 && (iTransferComplete & KIfc1BulkTransferInIdMask) == KIfc1BulkTransferInIdMask)
//Record time elapsed for Interface 1 if not yet recorded.
{
RecordTime(2);
}
if(err==KErrNone && iTimeElapsed[3] == 0 && (iTransferComplete & KIfc2BulkTransferInIdMask) == KIfc2BulkTransferInIdMask)
//Record time elapsed for Interface 2 if not yet recorded.
{
RecordTime(3);
}
if(err==KErrNone && (iTransferComplete & KBulkTransferInIdMask) == KBulkTransferInIdMask)
{
// ok, compare data rcvd now
OstTrace1(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP04, "All IN Transfers Completed Successfully: Transfer Completion Aggregation Mask 0x%x", iTransferComplete);
TPtrC8 data1(iIfc1InTransfer[0]->DataPolled());
TPtrC8 data2(iIfc1InTransfer[1]->DataPolled());
TPtrC8 data3(iIfc2InTransfer[0]->DataPolled());
TPtrC8 data4(iIfc2InTransfer[1]->DataPolled());
//Validate first transfer on Interface 1 for number of bytes originally written.
if(ValidateData(data1, KLiteralFrench4(), KHostNumWriteBytes1) == EFalse)
{
OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP05, "Validation failure 1st transfer, Interface 1");
err = KErrCompletion; //indicates data validation failure
break; //switch(iCaseStep)
}
//Validate second transfer on Interface 1 for number of bytes originally written.
if(ValidateData(data2, KLiteralFrench4(), KHostNumWriteBytes1, KHostNumWriteBytes2) == EFalse)
{
OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP06, "Validation failure 2nd transfer, Interface 1");
err = KErrCompletion; //indicates data validation failure
break; //switch(iCaseStep)
}
//Validate first transfer on Interface 2 for number of bytes originally written.
if(ValidateData(data3, KLiteralEnglish2(), KHostNumWriteBytes1) == EFalse)
{
OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP07, "Validation failure 1st transfer, Interface 2");
err = KErrCompletion; //indicates data validation failure
break; //switch(iCaseStep)
}
//Validate second transfer on Interface 2 for number of bytes originally written.
if(ValidateData(data4, KLiteralEnglish2(), KHostNumWriteBytes1, KHostNumWriteBytes2) == EFalse)
{
OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP08, "Validation failure 2nd transfer, Interface 2");
err = KErrCompletion; //indicates data validation failure
break; //switch(iCaseStep)
}
// Comparison is a match
OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP09, "Comparison for IN transfer is a match");
}
break; //switch(iCaseStep)
default:
err = KUndefinedStep;
msg.Format(_L("<Error %d> Undefined case step %d reached"),KUndefinedStep, iCaseStep);
break; //switch(iCaseStep)
}
if(err == KErrNone && iTransferComplete == KBulkTransferIdMask)
/*
Transfers all complete - now ask device to validate first interface's transfer OUT
*/
{
OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP10, "Checking all times against each other");
err = CheckTimes(0, 1, KMaxTimeDiffPercentage);
err = err?err:CheckTimes(0, 2, KMaxTimeDiffPercentage);
err = err?err:CheckTimes(0, 3, KMaxTimeDiffPercentage);
err = err?err:CheckTimes(1, 2, KMaxTimeDiffPercentage);
err = err?err:CheckTimes(1, 3, KMaxTimeDiffPercentage);
err = err?err:CheckTimes(2, 3, KMaxTimeDiffPercentage);
ResetTimes(0);
ResetTimes(1);
ResetTimes(2);
ResetTimes(3);
if(err==KErrNone)
{
OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP11, "Asking client for 'Validate' data written on interface 1");
iCaseStep = ERequestDeviceValidateIFC1;
TEndpointStringValidationRequest request(1,1,KLiteralFrench4(),KDeviceNumReadBytes);
iControlEp0->SendRequest(request,this);
}
}
if(err == KErrCompletion)
//indicates data validation failure
{
msg.Format(_L("<Error %d> Bulk transfer IN data received does not match Bulk Transfer OUT data"), err);
}
if(err == KErrTooBig)
//indicates timing validation failure
{
msg.Format(_L("<Error %d> Timer comparison showed too great a difference in transfer times between the two interfaces"), err);
}
if(err!=KErrNone)
{
OstTrace0(TRACE_NORMAL, CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_DUP12, msg);
iCaseStep = EFailed;
TTestCaseFailed request(err,msg);
return iControlEp0->SendRequest(request,this);
}
OstTraceFunctionExit1( CUT_PBASE_T_USBDI_0498_TRANSFERCOMPLETEL_EXIT, this );
}
int main(int argc, char** argv)
{
try
{
// Parse the command line
if (argc != 2)
{
std::cerr << "Usage: " << sys::Path::basename(argv[0])
<< " <output NITF pathname prefix>\n\n";
return 1;
}
const std::string outPathnamePrefix(argv[1]);
verifySchemaEnvVariableIsSet();
// In order to make it easier to test segmenting, let's artificially set
// the segment size really small
const size_t numCols = 200;
const size_t maxSize = numCols * 50;
six::XMLControlRegistry xmlRegistry;
xmlRegistry.addCreator(
six::DataType::DERIVED,
new six::XMLControlCreatorT<
six::sidd::DerivedXMLControl>());
six::Container container(six::DataType::DERIVED);
std::vector<six::UByte*> buffers;
// First a single segment without a legend
types::RowCol<size_t> dims1(40, numCols);
std::auto_ptr<six::Data> data1(mockupDerivedData(dims1));
const mem::ScopedArray<sys::ubyte> buffer1(new sys::ubyte[dims1.normL1()]);
std::fill_n(buffer1.get(), dims1.normL1(), 20);
container.addData(data1);
buffers.push_back(buffer1.get());
// Now a single segment with a mono legend
types::RowCol<size_t> dims2(40, numCols);
std::auto_ptr<six::Data> data2(mockupDerivedData(dims2));
const types::RowCol<size_t> legendDims(50, 50);
std::auto_ptr<six::Legend> monoLegend(new six::Legend());
monoLegend->mType = six::PixelType::MONO8I;
monoLegend->mLocation.row = 10;
monoLegend->mLocation.col = 10;
monoLegend->setDims(legendDims);
const mem::ScopedArray<sys::ubyte> buffer2(new sys::ubyte[dims2.normL1()]);
std::fill_n(buffer2.get(), dims2.normL1(), 100);
container.addData(data2, monoLegend);
buffers.push_back(buffer2.get());
// Now a multi-segment without a legend
types::RowCol<size_t> dims3(150, numCols);
std::auto_ptr<six::Data> data3(mockupDerivedData(dims3));
const mem::ScopedArray<sys::ubyte> buffer3(new sys::ubyte[dims3.normL1()]);
std::fill_n(buffer3.get(), dims3.normL1(), 60);
container.addData(data3);
buffers.push_back(buffer3.get());
// Now a multi-segment with an RGB legend
types::RowCol<size_t> dims4(155, numCols);
std::auto_ptr<six::Data> data4(mockupDerivedData(dims4));
std::auto_ptr<six::Legend> rgbLegend(new six::Legend());
rgbLegend->mType = six::PixelType::RGB8LU;
rgbLegend->mLocation.row = 10;
rgbLegend->mLocation.col = 10;
rgbLegend->setDims(legendDims);
rgbLegend->mLUT.reset(new six::LUT(256, 3));
for (size_t ii = 0, idx = 0;
ii < rgbLegend->mLUT->numEntries;
++ii, idx += 3)
{
rgbLegend->mLUT->table[idx] = ii;
rgbLegend->mLUT->table[idx + 1] = ii;
rgbLegend->mLUT->table[idx + 2] = ii;
}
const mem::ScopedArray<sys::ubyte> buffer4(new sys::ubyte[dims4.normL1()]);
std::fill_n(buffer4.get(), dims4.normL1(), 200);
container.addData(data4, rgbLegend);
buffers.push_back(buffer4.get());
// Write it out
{
six::NITFWriteControl writer;
writer.getOptions().setParameter(
six::NITFWriteControl::OPT_MAX_PRODUCT_SIZE,
str::toString(maxSize));
writer.setXMLControlRegistry(&xmlRegistry);
writer.initialize(&container);
writer.save(buffers, outPathnamePrefix + "_unblocked.nitf");
}
// Write it out with blocking
{
six::NITFWriteControl writer;
writer.getOptions().setParameter(
six::NITFWriteControl::OPT_MAX_PRODUCT_SIZE,
str::toString(maxSize));
const std::string blockSize("1024");
writer.getOptions().setParameter(
six::NITFWriteControl::OPT_NUM_ROWS_PER_BLOCK,
blockSize);
writer.getOptions().setParameter(
six::NITFWriteControl::OPT_NUM_COLS_PER_BLOCK,
blockSize);
writer.setXMLControlRegistry(&xmlRegistry);
writer.initialize(&container);
writer.save(buffers, outPathnamePrefix + "_blocked.nitf");
}
return 0;
}
catch (const except::Exception& e)
{
std::cerr << "Caught exception: " << e.getMessage() << std::endl;
return 1;
}
catch (const std::exception& e)
{
std::cerr << "Caught exception: " << e.what() << std::endl;
return 1;
}
catch (...)
{
std::cerr << "Unknown exception\n";
return 1;
}
}
