// DELETE HELPER FUNCTION
void DeleteTest(index::Index *index, VarlenPool *pool, size_t scale_factor) {
// Loop based on scale factor
for (size_t scale_itr = 1; scale_itr <= scale_factor; scale_itr++) {
// Delete a bunch of keys based on scale itr
std::unique_ptr<storage::Tuple> key0(new storage::Tuple(key_schema, true));
std::unique_ptr<storage::Tuple> key1(new storage::Tuple(key_schema, true));
std::unique_ptr<storage::Tuple> key2(new storage::Tuple(key_schema, true));
std::unique_ptr<storage::Tuple> key3(new storage::Tuple(key_schema, true));
std::unique_ptr<storage::Tuple> key4(new storage::Tuple(key_schema, true));
key0->SetValue(0, ValueFactory::GetIntegerValue(100 * scale_itr), pool);
key0->SetValue(1, ValueFactory::GetStringValue("a"), pool);
key1->SetValue(0, ValueFactory::GetIntegerValue(100 * scale_itr), pool);
key1->SetValue(1, ValueFactory::GetStringValue("b"), pool);
key2->SetValue(0, ValueFactory::GetIntegerValue(100 * scale_itr), pool);
key2->SetValue(1, ValueFactory::GetStringValue("c"), pool);
key3->SetValue(0, ValueFactory::GetIntegerValue(400 * scale_itr), pool);
key3->SetValue(1, ValueFactory::GetStringValue("d"), pool);
key4->SetValue(0, ValueFactory::GetIntegerValue(500 * scale_itr), pool);
key4->SetValue(1, ValueFactory::GetStringValue("e"), pool);
// DELETE
index->DeleteEntry(key0.get(), item0);
index->DeleteEntry(key1.get(), item1);
// index->DeleteEntry(key2.get(), item2);
index->DeleteEntry(key3.get(), item1);
index->DeleteEntry(key3.get(), item1);
index->DeleteEntry(key3.get(), item1);
index->DeleteEntry(key4.get(), item1);
index->DeleteEntry(key4.get(), item1);
index->DeleteEntry(key4.get(), item1);
LOG_INFO("--------------- next round delete ---------------");
}
}
int pianWHOA::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: key1(); break;
case 1: key2(); break;
case 2: key3(); break;
case 3: key4(); break;
case 4: key5(); break;
case 5: key6(); break;
case 6: key7(); break;
case 7: key8(); break;
case 8: key9(); break;
case 9: key10(); break;
case 10: key11(); break;
case 11: key12(); break;
case 12: key13(); break;
case 13: key14(); break;
case 14: key15(); break;
case 15: key16(); break;
case 16: key17(); break;
case 17: key18(); break;
case 18: tutor(); break;
default: ;
}
_id -= 19;
}
return _id;
}
void
buildHashtable ()
{
typedef std::unordered_map<KEY, VAL, HashFunc> Hashtable;
Hashtable tab;
VAL o1; KEY key1 (o1);
VAL o2; KEY key2 (o2);
VAL o3; KEY key3 (o3);
tab[key1] = o1; // store copy into hashtable
tab[key2] = o2;
tab[key3] = o3;
CHECK (!isSameObject (o1, tab[key1])); // indeed a copy...
CHECK (!isSameObject (o2, tab[key2]));
CHECK (!isSameObject (o3, tab[key3]));
CHECK (o1.getID() == tab[key1].getID()); // but "equal" by ID
CHECK (o2.getID() == tab[key2].getID());
CHECK (o3.getID() == tab[key3].getID());
CHECK (o1.getID() != tab[key2].getID());
CHECK (o1.getID() != tab[key3].getID());
CHECK (o2.getID() != tab[key3].getID());
}
TYPED_TEST(CTestInterfaceItemBase,addItemsTestCase_01_2_dataNotExist)
{
data_entry key("ItemTestCase_01_2_key_01");
data_entry key2("ItemTestCase_01_2_key_02");
typename TestFixture::List value_1;
typename TestFixture::List value_2;
typename TestFixture::List value_3;
CTestInterfaceBase::client_handle.remove(1,key);
CTestInterfaceBase::client_handle.remove(2,key2);
try {
for(uint32_t i=0;i < this->_data.size();++i){
value_1.push_back(any_cast<TypeParam> (this->_data[i]));
}
for(uint32_t i=0;i < this->_data2.size();++i){
value_2.push_back(any_cast<TypeParam> (this->_data2[i]));
}
for(uint32_t i=0;i < this->_data3.size();++i){
value_3.push_back(any_cast<TypeParam> (this->_data3[i]));
}
}catch(bad_any_cast& e){
cout << e.what() << endl;
exit(-1);
}
int ret = CTestInterfaceBase::client_handle.add_items(1,key,value_1,0,0);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
ret = CTestInterfaceBase::client_handle.add_items(2,key2,value_2,0,0);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
data_entry key3(""); //NULL
ret = CTestInterfaceBase::client_handle.add_items(1,key3,value_3,0,0);
ASSERT_EQ(TAIR_RETURN_ITEMSIZE_ERROR,ret);
typename TestFixture::List result_1;
typename TestFixture::List result_2;
typename TestFixture::List result_3;
ret = CTestInterfaceBase::client_handle.get_items(1,key,0,tair_client_api::ALL_ITEMS,result_1);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
ASSERT_TRUE(value_1 == result_1);
ret = CTestInterfaceBase::client_handle.get_items(2,key2,0,tair_client_api::ALL_ITEMS,result_2);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
ASSERT_TRUE(value_2 == result_2);
ret = CTestInterfaceBase::client_handle.get_items(1,key3,0,tair_client_api::ALL_ITEMS,result_3);
ASSERT_EQ(TAIR_RETURN_ITEMSIZE_ERROR,ret);
//clean
ret = CTestInterfaceBase::client_handle.remove(1,key);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
ret = CTestInterfaceBase::client_handle.remove(2,key2);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
}
int main(int argc,char** argv)
{
GLDebugDrawer gDebugDrawer;
///testing the btHashMap
btHashMap<btHashKey<OurValue>,OurValue> map;
OurValue value1(btVector3(2,3,4));
btHashKey<OurValue> key1(value1.getUid());
map.insert(key1,value1);
OurValue value2(btVector3(5,6,7));
btHashKey<OurValue> key2(value2.getUid());
map.insert(key2,value2);
{
OurValue value3(btVector3(7,8,9));
btHashKey<OurValue> key3(value3.getUid());
map.insert(key3,value3);
}
map.remove(key2);
const OurValue* ourPtr = map.find(key1);
for (int i=0;i<map.size();i++)
{
OurValue* tmp = map.getAtIndex(i);
//printf("tmp value=%f,%f,%f\n",tmp->m_position.getX(),tmp->m_position.getY(),tmp->m_position.getZ());
}
BasicDemo ccdDemo;
ccdDemo.initPhysics();
ccdDemo.getDynamicsWorld()->setDebugDrawer(&gDebugDrawer);
#ifdef CHECK_MEMORY_LEAKS
ccdDemo.exitPhysics();
#else
return glutmain(argc, argv,640,480,"Bullet Physics Demo. http://bullet.sf.net",&ccdDemo);
#endif
//default glut doesn't return from mainloop
return 0;
}
int rowTutor::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: playSong(); break;
case 1: stopSong(); break;
case 2: playTutorSong((*reinterpret_cast< QList<char>(*)>(_a[1]))); break;
case 3: playNoteGUI((*reinterpret_cast< char(*)>(_a[1]))); break;
case 4: noteCDown(); break;
case 5: noteDDown(); break;
case 6: noteEDown(); break;
case 7: noteFDown(); break;
case 8: noteGDown(); break;
case 9: noteHiCDown(); break;
case 10: key1(); break;
case 11: key2(); break;
case 12: key3(); break;
case 13: key4(); break;
case 14: key5(); break;
case 15: key6(); break;
case 16: key7(); break;
case 17: key8(); break;
case 18: key9(); break;
case 19: key10(); break;
case 20: key11(); break;
case 21: key12(); break;
case 22: key13(); break;
case 23: key14(); break;
case 24: key15(); break;
case 25: key16(); break;
case 26: key17(); break;
case 27: key18(); break;
default: ;
}
_id -= 28;
}
return _id;
}
static wxUint32 GetUserPreferencesMask()
{
static wxUint32 userPreferencesMask = 0;
static bool valueSet = false;
if ( valueSet )
return userPreferencesMask;
wxRegKey* pKey = NULL;
wxRegKey key1(wxRegKey::HKCU, wxT("Software\\Policies\\Microsoft\\Control Panel"));
wxRegKey key2(wxRegKey::HKCU, wxT("Software\\Policies\\Microsoft\\Windows\\Control Panel"));
wxRegKey key3(wxRegKey::HKCU, wxT("Control Panel\\Desktop"));
if ( key1.Exists() )
pKey = &key1;
else if ( key2.Exists() )
pKey = &key2;
else if ( key3.Exists() )
pKey = &key3;
if ( pKey && pKey->Open(wxRegKey::Read) )
{
wxMemoryBuffer buf;
if ( pKey->HasValue(wxT("UserPreferencesMask")) &&
pKey->QueryValue(wxT("UserPreferencesMask"), buf) )
{
if ( buf.GetDataLen() >= 4 )
{
wxUint32* p = (wxUint32*) buf.GetData();
userPreferencesMask = *p;
}
}
}
valueSet = true;
return userPreferencesMask;
}
TEST (kdbrestModelsEntryTest, SetAndGetAndAddSubkeys)
{
kdb::Key key (kdbrest::Config::instance ().getConfig ().get<std::string> ("kdb.path.configs") + std::string ("/test/key1"),
KEY_END);
kdb::Key key2 (kdbrest::Config::instance ().getConfig ().get<std::string> ("kdb.path.configs") + std::string ("/test/key1/subkey1"),
KEY_END);
kdb::Key key3 (kdbrest::Config::instance ().getConfig ().get<std::string> ("kdb.path.configs") +
std::string ("/test/key1/subkey1/subkey2"),
KEY_END);
kdb::Key key4 (kdbrest::Config::instance ().getConfig ().get<std::string> ("kdb.path.configs") + std::string ("/test/key2/subkey1"),
KEY_END);
kdbrest::model::Entry entry (key);
entry.addSubkey (key2, true);
ASSERT_EQ (entry.getSubkeys ().size (), 1);
entry.addSubkey (key3, true);
ASSERT_EQ (entry.getSubkeys ().size (), 2);
entry.addSubkey (key4, true);
ASSERT_EQ (entry.getSubkeys ().size (), 2);
ASSERT_TRUE (entry.getSubkeys ().lookup (key2));
ASSERT_TRUE (entry.getSubkeys ().lookup (key3));
kdb::KeySet ks;
ks.append (key2);
ks.append (key3);
ks.append (key4);
kdbrest::model::Entry entry2 (key);
entry2.addSubkeys (ks, true);
ASSERT_EQ (entry2.getSubkeys ().size (), 2);
ASSERT_TRUE (entry2.getSubkeys ().lookup (key2));
ASSERT_TRUE (entry2.getSubkeys ().lookup (key3));
}
int key(int keycode, t_mlx *mlx)
{
float a;
float b;
mlx->imgview->addr = ft_memset(mlx->imgview->addr, 0, mlx->w * mlx->h * 4
- 1);
mlx->imgmap->addr = ft_memset(mlx->imgmap->addr, 0, mlx->mapw * mlx->maph *
4 - 1);
a = cos(mlx->deg * (PI / 180)) / 4;
b = sin(mlx->deg * (PI / 180)) / 4;
key1(keycode, mlx, a, b);
key2(keycode, mlx, a, b);
key3(keycode, mlx, a, b);
key4(keycode, mlx, a, b);
if (keycode == 53)
str_exit(0, "ESC", mlx);
if (keycode == 0)
mlx->deg -= 5;
if (keycode == 2)
mlx->deg += 5;
draw(mlx);
return (0);
}
// If either id is different or the clip or the matrix are different the
// cached image won't be found. Even if it is caching the same bitmap.
static void test_dont_find_if_diff_key(skiatest::Reporter* reporter,
const sk_sp<SkSpecialImage>& image,
const sk_sp<SkSpecialImage>& subset) {
static const size_t kCacheSize = 1000000;
SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kCacheSize));
SkIRect clip1 = SkIRect::MakeWH(100, 100);
SkIRect clip2 = SkIRect::MakeWH(200, 200);
SkImageFilter::Cache::Key key0(0, SkMatrix::I(), clip1, image->uniqueID(), image->subset());
SkImageFilter::Cache::Key key1(1, SkMatrix::I(), clip1, image->uniqueID(), image->subset());
SkImageFilter::Cache::Key key2(0, SkMatrix::MakeTrans(5, 5), clip1,
image->uniqueID(), image->subset());
SkImageFilter::Cache::Key key3(0, SkMatrix::I(), clip2, image->uniqueID(), image->subset());
SkImageFilter::Cache::Key key4(0, SkMatrix::I(), clip1, subset->uniqueID(), subset->subset());
SkIPoint offset = SkIPoint::Make(3, 4);
cache->set(key0, image.get(), offset);
SkIPoint foundOffset;
REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
REPORTER_ASSERT(reporter, !cache->get(key2, &foundOffset));
REPORTER_ASSERT(reporter, !cache->get(key3, &foundOffset));
REPORTER_ASSERT(reporter, !cache->get(key4, &foundOffset));
}
int main(int argc, char *argv[]) {
int err = 0;
int v;
RSA *key;
unsigned char ptext[256];
unsigned char ctext[256];
static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
unsigned char ctext_ex[256];
int plen;
int clen = 0;
int num;
int n;
CRYPTO_library_init();
plen = sizeof(ptext_ex) - 1;
for (v = 0; v < 3; v++) {
key = RSA_new();
switch (v) {
case 0:
clen = key1(key, ctext_ex);
break;
case 1:
clen = key2(key, ctext_ex);
break;
case 2:
clen = key3(key, ctext_ex);
break;
default:
abort();
}
if (!RSA_check_key(key)) {
printf("%d: RSA_check_key failed\n", v);
err = 1;
goto oaep;
}
num = RSA_public_encrypt(plen, ptext_ex, ctext, key, RSA_PKCS1_PADDING);
if (num != clen) {
printf("PKCS#1 v1.5 encryption failed!\n");
err = 1;
goto oaep;
}
num = RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("PKCS#1 v1.5 decryption failed!\n");
err = 1;
} else {
printf("PKCS #1 v1.5 encryption/decryption ok\n");
}
oaep:
ERR_clear_error();
num =
RSA_public_encrypt(plen, ptext_ex, ctext, key, RSA_PKCS1_OAEP_PADDING);
if (num == -1) {
printf("No OAEP support\n");
goto next;
}
if (num != clen) {
printf("OAEP encryption failed!\n");
err = 1;
goto next;
}
num = RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("OAEP decryption (encrypted data) failed!\n");
err = 1;
} else if (memcmp(ctext, ctext_ex, num) == 0) {
printf("OAEP test vector %d passed!\n", v);
}
/* Different ciphertexts (rsa_oaep.c without -DPKCS_TESTVECT).
Try decrypting ctext_ex */
num =
RSA_private_decrypt(clen, ctext_ex, ptext, key, RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("OAEP decryption (test vector data) failed!\n");
err = 1;
} else {
printf("OAEP encryption/decryption ok\n");
}
/* Try decrypting corrupted ciphertexts */
for (n = 0; n < clen; ++n) {
int b;
unsigned char saved = ctext[n];
for (b = 0; b < 256; ++b) {
if (b == saved) {
continue;
}
ctext[n] = b;
num =
RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_OAEP_PADDING);
if (num > 0) {
printf("Corrupt data decrypted!\n");
err = 1;
}
}
}
next:
RSA_free(key);
}
if (err != 0 ||
!test_only_d_given() ||
!test_recover_crt_params() ||
!test_bad_key()) {
err = 1;
}
if (err == 0) {
printf("PASS\n");
}
return err;
}
int main (int argc, char *argv[])
{
int err = 0;
int v;
RSA *key;
unsigned char ptext[256];
unsigned char ctext[256];
//static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
static unsigned char ptext_ex[] = "hello world";
unsigned char ctext_ex[256];
int plen;
int clen = 0;
int num;
int n;
memset(ptext,0,256);
memset(ctext,0,256);
CRYPTO_malloc_debug_init ();
CRYPTO_dbg_set_options (V_CRYPTO_MDEBUG_ALL);
CRYPTO_mem_ctrl (CRYPTO_MEM_CHECK_ON);
RAND_seed (rnd_seed, sizeof rnd_seed); /* or OAEP may fail */
plen = sizeof (ptext_ex) - 1;
key = RSA_new ();
switch (v % 3)
{
case 0:
clen = key1 (key, ctext_ex);
break;
case 1:
clen = key2 (key, ctext_ex);
break;
case 2:
clen = key3 (key, ctext_ex);
break;
}
if (v / 3 >= 1)
key->flags |= RSA_FLAG_NO_CONSTTIME;
printf("before public encrypt : %s\n", ptext_ex);
num = RSA_public_encrypt (plen, ptext_ex, ctext, key, RSA_PKCS1_PADDING);
if (num != clen)
{
printf ("PKCS#1 v1.5 encryption failed!\n");
err = 1;
}
printf("after public encrypt : %s\n",ctext);
num = RSA_private_decrypt (num, ctext, ptext, key, RSA_PKCS1_PADDING);
if (num != plen || memcmp (ptext, ptext_ex, num) != 0)
{
printf ("PKCS#1 v1.5 decryption failed!\n");
err = 1;
}
else
printf ("PKCS #1 v1.5 encryption/decryption ok\n");
printf("after private decrypt : %s\n",ptext);
RSA_free (key);
CRYPTO_cleanup_all_ex_data ();
ERR_remove_thread_state (NULL);
CRYPTO_mem_leaks_fp (stderr);
return err;
}
twinkleTutor::twinkleTutor(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::twinkleTutor)
{
// set up the GUI
ui->setupUi(this);
Song = new QSound("sounds/twinkle.wav");
connect(ui->aButton, SIGNAL(clicked()), this, SLOT(key1()));
keyA = new QSound("sounds/C.wav");
connect(ui->wButton, SIGNAL(clicked()), this, SLOT(key2()));
keyW = new QSound("sounds/C#.wav");
connect(ui->sButton, SIGNAL(clicked()), this, SLOT(key3()));
keyS = new QSound("sounds/D.wav");
connect(ui->eButton, SIGNAL(clicked()), this, SLOT(key4()));
keyE = new QSound("sounds/D#.wav");
connect(ui->dButton, SIGNAL(clicked()), this, SLOT(key5()));
keyD = new QSound("sounds/E.wav");
connect(ui->fButton, SIGNAL(clicked()), this, SLOT(key6()));
keyF = new QSound("sounds/F.wav");
connect(ui->tButton, SIGNAL(clicked()), this, SLOT(key7()));
keyT = new QSound("sounds/F#.wav");
connect(ui->gButton, SIGNAL(clicked()), this, SLOT(key8()));
keyG = new QSound("sounds/G.wav");
connect(ui->yButton, SIGNAL(clicked()), this, SLOT(key9()));
keyY = new QSound("sounds/G#.wav");
connect(ui->hButton, SIGNAL(clicked()), this, SLOT(key10()));
keyH = new QSound("sounds/A.wav");
connect(ui->uButton, SIGNAL(clicked()), this, SLOT(key11()));
keyU = new QSound("sounds/A#.wav");
connect(ui->jButton, SIGNAL(clicked()), this, SLOT(key12()));
keyJ = new QSound("sounds/B.wav");
connect(ui->kButton, SIGNAL(clicked()), this, SLOT(key13()));
keyK = new QSound("sounds/HighC.wav");
connect(ui->oButton, SIGNAL(clicked()), this, SLOT(key14()));
keyO = new QSound("sounds/HiC#.wav");
connect(ui->lButton, SIGNAL(clicked()), this, SLOT(key15()));
keyL = new QSound("sounds/HiD.wav");
connect(ui->pButton, SIGNAL(clicked()), this, SLOT(key16()));
keyP = new QSound("sounds/HiD#.wav");
connect(ui->semiButton, SIGNAL(clicked()), this, SLOT(key17()));
keySemi = new QSound("sounds/HiE.wav");
connect(ui->apostButton, SIGNAL(clicked()), this, SLOT(key18()));
keyDot = new QSound("sounds/HiF.wav");
twinkle.append('C');
twinkle.append('C');
twinkle.append('G');
twinkle.append('G');
twinkle.append('A');
twinkle.append('A');
twinkle.append('G');
twinkle.append('F');
twinkle.append('F');
twinkle.append('E');
twinkle.append('E');
twinkle.append('D');
twinkle.append('D');
twinkle.append('C');
twinkle.append('G');
twinkle.append('G');
twinkle.append('F');
twinkle.append('F');
twinkle.append('E');
twinkle.append('E');
twinkle.append('D');
twinkle.append('G');
twinkle.append('G');
twinkle.append('F');
twinkle.append('F');
twinkle.append('E');
twinkle.append('E');
twinkle.append('D');
twinkle.append('C');
twinkle.append('C');
twinkle.append('G');
twinkle.append('G');
twinkle.append('A');
twinkle.append('A');
twinkle.append('G');
twinkle.append('F');
twinkle.append('F');
twinkle.append('E');
twinkle.append('E');
twinkle.append('D');
twinkle.append('D');
twinkle.append('C');
arrayCount=0;
playTutorSong(twinkle);
//enable Event Filters
installEventFilter(this);
}
int main(int argc, char *argv[])
{
int err=0;
int v;
RSA *key;
unsigned char ptext[256];
unsigned char ctext[256];
static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
unsigned char ctext_ex[256];
int plen;
int clen = 0;
int num;
int i;
plen = sizeof(ptext_ex) - 1;
for (v = 0; v < 3; v++)
{
key = RSA_new();
switch (v) {
case 0:
clen = key1(key, ctext_ex);
break;
case 1:
clen = key2(key, ctext_ex);
break;
case 2:
clen = key3(key, ctext_ex);
break;
}
num = RSA_public_encrypt(plen, ptext_ex, ctext, key, RSA_PKCS1_PADDING);
if (num != clen)
{
printf("PKCS#1 v1.5 encryption failed!\n");
err=1;
goto next;
}
num = RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0)
{
printf("PKCS#1 v1.5 decryption failed!\n");
err=1;
}
else
printf("PKCS #1 v1.5 encryption/decryption ok\n");
next:
RSA_free(key);
}
for(v=0;v<3;v++) {
key = RSA_generate_key(1024, 13, cb, NULL);
clen = RSA_public_encrypt(plen, ptext_ex, ctext, key, RSA_PKCS1_PADDING);
if(clen < 0)
printf("Encryption failed\n");
if(clen > 256)
printf("Encrypted data is larger than reserved space (%d)\n", clen);
num = RSA_private_decrypt(clen, ctext, ptext, key, RSA_PKCS1_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0)
{
printf("PKCS#1 v1.5 encrypted data cannot decrypt to original one!\n");
err=1;
}
else
printf("PKCS #1 v1.5 encryption/decryption ok\n");
RSA_free(key);
}
return err;
}
int main(int argc, char *argv[])
{
int err=0;
int v;
RSA *key;
unsigned char ptext[256];
unsigned char ctext[256];
static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
unsigned char ctext_ex[256];
int plen;
int clen = 0;
int num;
CRYPTO_malloc_debug_init();
CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
RAND_seed(rnd_seed, sizeof rnd_seed); /* or OAEP may fail */
plen = sizeof(ptext_ex) - 1;
for (v = 0; v < 3; v++)
{
key = RSA_new();
switch (v) {
case 0:
clen = key1(key, ctext_ex);
break;
case 1:
clen = key2(key, ctext_ex);
break;
case 2:
clen = key3(key, ctext_ex);
break;
}
num = RSA_public_encrypt(plen, ptext_ex, ctext, key,
RSA_PKCS1_PADDING);
if (num != clen)
{
printf("PKCS#1 v1.5 encryption failed!\n");
err=1;
goto oaep;
}
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0)
{
printf("PKCS#1 v1.5 decryption failed!\n");
err=1;
}
else
printf("PKCS #1 v1.5 encryption/decryption ok\n");
oaep:
ERR_clear_error();
num = RSA_public_encrypt(plen, ptext_ex, ctext, key,
RSA_PKCS1_OAEP_PADDING);
if (num == -1 && pad_unknown())
{
printf("No OAEP support\n");
goto next;
}
if (num != clen)
{
printf("OAEP encryption failed!\n");
err=1;
goto next;
}
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0)
{
printf("OAEP decryption (encrypted data) failed!\n");
err=1;
}
else if (memcmp(ctext, ctext_ex, num) == 0)
{
printf("OAEP test vector %d passed!\n", v);
goto next;
}
/* Different ciphertexts (rsa_oaep.c without -DPKCS_TESTVECT).
Try decrypting ctext_ex */
num = RSA_private_decrypt(clen, ctext_ex, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0)
{
printf("OAEP decryption (test vector data) failed!\n");
err=1;
}
else
printf("OAEP encryption/decryption ok\n");
next:
RSA_free(key);
}
CRYPTO_cleanup_all_ex_data();
ERR_remove_state(0);
CRYPTO_mem_leaks_fp(stderr);
return err;
}
BitmapUtils* BitmapUtils::Create(const DynamicFormat& dst_format,
const DynamicFormat& src_format,
bool need_source) {
if (!maps_initialized) {
for (const BitmapUtilsP* pp = bitmap_utils; *pp != NULL; pp++) {
BitmapUtilsP p = *pp;
const DynamicFormat& dfmt = p->GetDstFormat();
const DynamicFormat& sfmt = p->GetSrcFormat();
int dkey = dfmt.code(true);
int skey = sfmt.code(true);
unary_map[dkey] = p;
binary_map[int_pair(dkey, skey)] = p;
}
maps_initialized = true;
}
if (need_source) {
std::map<int_pair, BitmapUtils*>::const_iterator it;
// static dst, static src
int_pair key1(dst_format.code(true), src_format.code(true));
it = binary_map.find(key1);
if (it != binary_map.end())
return it->second;
// dynamic dst, static src
int_pair key2(dst_format.code(false), src_format.code(true));
it = binary_map.find(key2);
if (it != binary_map.end()) {
it->second->SetDstFormat(dst_format);
return it->second;
}
// static dst, dynamic src
int_pair key3(dst_format.code(true), src_format.code(false));
it = binary_map.find(key3);
if (it != binary_map.end()) {
it->second->SetSrcFormat(src_format);
return it->second;
}
// dynamic dst, dynamic src
int_pair key4(dst_format.code(false), src_format.code(false));
it = binary_map.find(key4);
if (it != binary_map.end()) {
it->second->SetDstFormat(dst_format);
it->second->SetSrcFormat(src_format);
return it->second;
}
}
else {
std::map<int, BitmapUtils*>::const_iterator it;
int key1 = dst_format.code(true);
it = unary_map.find(key1);
if (it != unary_map.end())
return it->second;
int key2 = dst_format.code(false);
it = unary_map.find(key2);
if (it != unary_map.end()) {
it->second->SetDstFormat(dst_format);
return it->second;
}
}
Output::Error("Couldn't find a renderer");
return NULL;
}
QSize KExiv2::getImageDimensions() const
{
try
{
long width=-1, height=-1;
// Try to get Exif.Photo tags
Exiv2::ExifData exifData(d->exifMetadata());
Exiv2::ExifKey key("Exif.Photo.PixelXDimension");
Exiv2::ExifData::iterator it = exifData.findKey(key);
if (it != exifData.end() && it->count())
width = it->toLong();
Exiv2::ExifKey key2("Exif.Photo.PixelYDimension");
Exiv2::ExifData::iterator it2 = exifData.findKey(key2);
if (it2 != exifData.end() && it2->count())
height = it2->toLong();
if (width != -1 && height != -1)
return QSize(width, height);
// Try to get Exif.Image tags
width = -1;
height = -1;
Exiv2::ExifKey key3("Exif.Image.ImageWidth");
Exiv2::ExifData::iterator it3 = exifData.findKey(key3);
if (it3 != exifData.end() && it3->count())
width = it3->toLong();
Exiv2::ExifKey key4("Exif.Image.ImageLength");
Exiv2::ExifData::iterator it4 = exifData.findKey(key4);
if (it4 != exifData.end() && it4->count())
height = it4->toLong();
if (width != -1 && height != -1)
return QSize(width, height);
#ifdef _XMP_SUPPORT_
// Try to get Xmp.tiff tags
width = -1;
height = -1;
bool wOk = false;
bool hOk = false;
QString str = getXmpTagString("Xmp.tiff.ImageWidth");
if (!str.isEmpty())
width = str.toInt(&wOk);
str = getXmpTagString("Xmp.tiff.ImageLength");
if (!str.isEmpty())
height = str.toInt(&hOk);
if (wOk && hOk)
return QSize(width, height);
// Try to get Xmp.exif tags
width = -1;
height = -1;
wOk = false;
hOk = false;
str = getXmpTagString("Xmp.exif.PixelXDimension");
if (!str.isEmpty())
width = str.toInt(&wOk);
str = getXmpTagString("Xmp.exif.PixelYDimension");
if (!str.isEmpty())
height = str.toInt(&hOk);
if (wOk && hOk)
return QSize(width, height);
#endif // _XMP_SUPPORT_
}
catch( Exiv2::Error& e )
{
d->printExiv2ExceptionError("Cannot parse image dimensions tag using Exiv2 ", e);
}
catch(...)
{
kError() << "Default exception from Exiv2";
}
return QSize();
}
int main(int argc, char *argv[])
{
int err=0;
int v;
RSA *key;
unsigned char ptext[256];
unsigned char ctext[256];
static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
unsigned char ctext_ex[256];
int plen;
int clen = 0;
int num;
int n;
ENGINE *e;
const char *engine_id = "remote";
ENGINE_load_builtin_engines();
e = ENGINE_by_id(engine_id);
if(!e)
/* the engine isn't available */
return 1;
if(!ENGINE_init(e)) {
/* the engine couldn't initialise, release 'e' */
ERR_print_errors_fp(stderr);
ENGINE_free(e);
return 1;
}
if(!ENGINE_set_default_RSA(e))
/* This should only happen when 'e' can't initialise, but the previous
* statement suggests it did. */
abort();
ENGINE_ctrl_cmd_string(e, "ADD_WORKER", "local1,127.0.0.1:1234", 0);
CRYPTO_malloc_debug_init();
CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
RAND_seed(rnd_seed, sizeof rnd_seed); /* or OAEP may fail */
plen = sizeof(ptext_ex) - 1;
for (v = 0; v < 6; v++)
{
key = RSA_new();
switch (v%3) {
case 0:
clen = key1(key, ctext_ex);
break;
case 1:
clen = key2(key, ctext_ex);
break;
case 2:
clen = key3(key, ctext_ex);
break;
}
if (v/3 >= 1) key->flags |= RSA_FLAG_NO_CONSTTIME;
num = RSA_public_encrypt(plen, ptext_ex, ctext, key,
RSA_PKCS1_PADDING);
if (num != clen)
{
printf("PKCS#1 v1.5 encryption failed!\n");
err=1;
goto oaep;
}
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0)
{
printf("PKCS#1 v1.5 decryption failed!\n");
err=1;
}
else
printf("PKCS #1 v1.5 encryption/decryption ok\n");
oaep:
ERR_clear_error();
num = RSA_public_encrypt(plen, ptext_ex, ctext, key,
RSA_PKCS1_OAEP_PADDING);
if (num == -1 && pad_unknown())
{
printf("No OAEP support\n");
goto next;
}
if (num != clen)
{
printf("OAEP encryption failed!\n");
err=1;
goto next;
}
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0)
{
printf("OAEP decryption (encrypted data) failed!\n");
err=1;
}
else if (memcmp(ctext, ctext_ex, num) == 0)
printf("OAEP test vector %d passed!\n", v);
/* Different ciphertexts (rsa_oaep.c without -DPKCS_TESTVECT).
Try decrypting ctext_ex */
num = RSA_private_decrypt(clen, ctext_ex, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0)
{
printf("OAEP decryption (test vector data) failed!\n");
err=1;
}
else
printf("OAEP encryption/decryption ok\n");
/* Try decrypting corrupted ciphertexts */
for(n = 0 ; n < clen ; ++n)
{
int b;
unsigned char saved = ctext[n];
for(b = 0 ; b < 256 ; ++b)
{
if(b == saved)
continue;
ctext[n] = b;
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if(num > 0)
{
printf("Corrupt data decrypted!\n");
err = 1;
}
}
}
next:
RSA_free(key);
}
ENGINE_finish(e);
ENGINE_free(e);
CRYPTO_cleanup_all_ex_data();
ERR_remove_state(0);
CRYPTO_mem_leaks_fp(stderr);
#ifdef OPENSSL_SYS_NETWARE
if (err) printf("ERROR: %d\n", err);
#endif
return err;
}
int main(int argc, char *argv[])
{
int err = 0;
int v;
RSA *key;
unsigned char ptext[256];
unsigned char ctext[256];
static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
unsigned char ctext_ex[256];
int plen;
int clen = 0;
int num;
int n;
CRYPTO_set_mem_debug(1);
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
RAND_seed(rnd_seed, sizeof(rnd_seed)); /* or OAEP may fail */
plen = sizeof(ptext_ex) - 1;
for (v = 0; v < 3; v++) {
key = RSA_new();
switch (v) {
case 0:
clen = key1(key, ctext_ex);
break;
case 1:
clen = key2(key, ctext_ex);
break;
case 2:
clen = key3(key, ctext_ex);
break;
}
num = RSA_public_encrypt(plen, ptext_ex, ctext, key,
RSA_PKCS1_PADDING);
if (num != clen) {
printf("PKCS#1 v1.5 encryption failed!\n");
err = 1;
goto oaep;
}
num = RSA_private_decrypt(num, ctext, ptext, key, RSA_PKCS1_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("PKCS#1 v1.5 decryption failed!\n");
err = 1;
} else
printf("PKCS #1 v1.5 encryption/decryption ok\n");
oaep:
ERR_clear_error();
num = RSA_public_encrypt(plen, ptext_ex, ctext, key,
RSA_PKCS1_OAEP_PADDING);
if (num == -1 && pad_unknown()) {
printf("No OAEP support\n");
goto next;
}
if (num != clen) {
printf("OAEP encryption failed!\n");
err = 1;
goto next;
}
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("OAEP decryption (encrypted data) failed!\n");
err = 1;
} else if (memcmp(ctext, ctext_ex, num) == 0)
printf("OAEP test vector %d passed!\n", v);
/*
* Different ciphertexts (rsa_oaep.c without -DPKCS_TESTVECT). Try
* decrypting ctext_ex
*/
num = RSA_private_decrypt(clen, ctext_ex, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num != plen || memcmp(ptext, ptext_ex, num) != 0) {
printf("OAEP decryption (test vector data) failed!\n");
err = 1;
} else
printf("OAEP encryption/decryption ok\n");
/* Try decrypting corrupted ciphertexts. */
for (n = 0; n < clen; ++n) {
ctext[n] ^= 1;
num = RSA_private_decrypt(clen, ctext, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num > 0) {
printf("Corrupt data decrypted!\n");
err = 1;
break;
}
ctext[n] ^= 1;
}
/* Test truncated ciphertexts, as well as negative length. */
for (n = -1; n < clen; ++n) {
num = RSA_private_decrypt(n, ctext, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num > 0) {
printf("Truncated data decrypted!\n");
err = 1;
break;
}
}
next:
RSA_free(key);
}
#ifndef OPENSSL_NO_CRYPTO_MDEBUG
if (CRYPTO_mem_leaks_fp(stderr) <= 0)
err = 1;
#endif
return err;
}
int ssl_test_rsa(int argc, char *argv[])
{
int err=0;
int v;
RSA *key;
unsigned char ptext[256];
unsigned char ctext[256];
static unsigned char ptext_ex[] = "\x54\x85\x9b\x34\x2c\x49\xea\x2a";
unsigned char ctext_ex[256];
int plen;
int clen = 0;
int num;
int n;
CRYPTO_malloc_debug_init();
CRYPTO_dbg_set_options(V_CRYPTO_MDEBUG_ALL);
CRYPTO_mem_ctrl(CRYPTO_MEM_CHECK_ON);
RAND_seed(rnd_seed, sizeof rnd_seed); /* or OAEP may fail */
plen = sizeof(ptext_ex) - 1;
for (v = 0; v < 6; v++)
{
key = RSA_new();
switch (v%3) {
case 0:
clen = key1(key, ctext_ex);
break;
case 1:
clen = key2(key, ctext_ex);
break;
case 2:
clen = key3(key, ctext_ex);
break;
}
if (v/3 >= 1) key->flags |= RSA_FLAG_NO_CONSTTIME;
num = RSA_public_encrypt(plen, ptext_ex, ctext, key,
RSA_PKCS1_PADDING);
if (num != clen)
{
TINYCLR_SSL_PRINTF("PKCS#1 v1.5 encryption failed!\n");
err=1;
goto oaep;
}
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_PADDING);
if (num != plen || TINYCLR_SSL_MEMCMP(ptext, ptext_ex, num) != 0)
{
TINYCLR_SSL_PRINTF("PKCS#1 v1.5 decryption failed!\n");
err=1;
}
else
TINYCLR_SSL_PRINTF("PKCS #1 v1.5 encryption/decryption ok\n");
oaep:
ERR_clear_error();
num = RSA_public_encrypt(plen, ptext_ex, ctext, key,
RSA_PKCS1_OAEP_PADDING);
if (num == -1 && pad_unknown())
{
TINYCLR_SSL_PRINTF("No OAEP support\n");
goto next;
}
if (num != clen)
{
TINYCLR_SSL_PRINTF("OAEP encryption failed!\n");
err=1;
goto next;
}
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num != plen || TINYCLR_SSL_MEMCMP(ptext, ptext_ex, num) != 0)
{
TINYCLR_SSL_PRINTF("OAEP decryption (encrypted data) failed!\n");
err=1;
}
else if (TINYCLR_SSL_MEMCMP(ctext, ctext_ex, num) == 0)
TINYCLR_SSL_PRINTF("OAEP test vector %d passed!\n", v);
/* Different ciphertexts (rsa_oaep.c without -DPKCS_TESTVECT).
Try decrypting ctext_ex */
num = RSA_private_decrypt(clen, ctext_ex, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if (num != plen || TINYCLR_SSL_MEMCMP(ptext, ptext_ex, num) != 0)
{
TINYCLR_SSL_PRINTF("OAEP decryption (test vector data) failed!\n");
err=1;
}
else
TINYCLR_SSL_PRINTF("OAEP encryption/decryption ok\n");
/* Try decrypting corrupted ciphertexts */
for(n = 0 ; n < clen ; ++n)
{
int b;
unsigned char saved = ctext[n];
for(b = 0 ; b < 256 ; ++b)
{
if(b == saved)
continue;
ctext[n] = b;
num = RSA_private_decrypt(num, ctext, ptext, key,
RSA_PKCS1_OAEP_PADDING);
if(num > 0)
{
TINYCLR_SSL_PRINTF("Corrupt data decrypted!\n");
err = 1;
}
}
}
next:
RSA_free(key);
}
CRYPTO_cleanup_all_ex_data();
ERR_remove_thread_state(NULL);
CRYPTO_mem_leaks_fp(OPENSSL_TYPE__FILE_STDERR);
#ifdef OPENSSL_SYS_NETWARE
if (err) TINYCLR_SSL_PRINTF("ERROR: %d\n", err);
#endif
return err;
}
