// Go looking for potential candidates in SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths
int ecSettings::GetRepositoryRegistryClues(wxArrayString& arstr, const wxString& pszPrefix)
{
arstr.Clear();
#ifdef __WXMSW__
wxConfig config(wxT("Windows"), wxT("Microsoft"), wxEmptyString, wxEmptyString, wxCONFIG_USE_GLOBAL_FILE);
config.SetPath(wxT("/CurrentVersion/App Paths"));
wxString key(wxT(""));
long index;
bool bMore = config.GetFirstGroup(key, index);
while (bMore)
{
if (key.Find(pszPrefix) == 0)
{
wxString value;
//wxString key2(wxString(wxT("/")) + key + wxString(wxT("/Path")));
wxString key2(key + wxString(wxT("/Path")));
if (config.Read(key2, & value))
{
arstr.Add(value);
}
}
bMore = config.GetNextGroup(key, index);
}
return arstr.GetCount();
#else
return 0;
#endif
}
TEST_F(CTestInterfaceBase, GetTestCase_08_dateExpired) {
data_entry key1("04_08_key_01");
data_entry value1("04_08_data_01");
data_entry key2("04_08_key_02");
data_entry value2("04_08_data_02");
data_entry value3("04_08_data_03");
data_entry* p;
int ret = 0;
//data1:area equals,key not equal
DO_WITH_RETRY(client_handle.put(1, key1, value1, 0, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
//data2:area not equas, key equal
DO_WITH_RETRY(client_handle.put(2, key2, value2, 0, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
DO_WITH_RETRY(client_handle.put(1, key2, value3, 1, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
sleep(2);
ret = client_handle.get(1, key2, p);
ASSERT_EQ(TAIR_RETURN_DATA_EXPIRED, ret);
client_handle.remove(1, key1);
client_handle.remove(2, key2);
client_handle.remove(1, key2);
}
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());
}
bool ArrayData::equal(const ArrayData *v2, bool strict) const {
ASSERT(v2);
int count1 = size();
int count2 = v2->size();
if (count1 != count2) return false;
if (count1 == 0) return true;
// prevent circular referenced objects/arrays or deep ones
DECLARE_THREAD_INFO;
RECURSION_INJECTION;
if (strict) {
for (ArrayIter iter1(this), iter2(v2); iter1 && iter2; ++iter1, ++iter2) {
Variant key1(iter1.first());
Variant key2(iter2.first());
if (!key1.same(key2)) return false;
Variant value1(iter1.second());
Variant value2(iter2.second());
if (!value1.same(value2)) return false;
}
} else {
for (ArrayIter iter(this); iter; ++iter) {
Variant key(iter.first());
if (!v2->exists(key)) return false;
Variant value1(iter.second());
Variant value2(v2->get(key));
if (!value1.equal(value2)) return false;
}
}
return true;
}
TYPED_TEST(CTestInterfaceItemBase,Item10_x_removeItems_05_dataExist)
{
data_entry key1("Item10TestCase_05_key_01");
data_entry key2("Item10TestCase_05_key_02");
typename TestFixture::List value_1;
typename TestFixture::List value_2;
typename TestFixture::List value_3;
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,key1,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);
ret = CTestInterfaceBase::client_handle.add_items(1,key2,value_3,0,0);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
typename TestFixture::List result_1;
typename TestFixture::List result_2;
typename TestFixture::List result_3;
ret = CTestInterfaceBase::client_handle.get_items(1,key1,0,tair_client_api::ALL_ITEMS,result_1);
ASSERT_TRUE(value_1 == result_1);
ret = CTestInterfaceBase::client_handle.get_items(2,key2,0,tair_client_api::ALL_ITEMS,result_2);
ASSERT_TRUE(value_2 == result_2);
ret = CTestInterfaceBase::client_handle.remove_items(1,key2,value_3.size() + 10,2);
ASSERT_EQ(TAIR_RETURN_OUT_OF_RANGE, ret);
ret = CTestInterfaceBase::client_handle.get_items(1,key2,0,tair_client_api::ALL_ITEMS,result_3);
ASSERT_TRUE(result_3 == value_3);
//clean
ret = CTestInterfaceBase::client_handle.remove(1,key1);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
ret = CTestInterfaceBase::client_handle.remove(2,key2);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
ret = CTestInterfaceBase::client_handle.remove(1,key2);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
}
int ArrayData::compare(const ArrayData *v2, bool strict) const {
ASSERT(v2);
int count1 = size();
int count2 = v2->size();
if (count1 < count2) return -1;
if (count1 > count2) return 1;
if (count1 == 0) return 0;
if (strict) {
for (ArrayIter iter1(this), iter2(v2); iter1 && iter2; ++iter1, ++iter2) {
Variant key1(iter1.first());
Variant key2(iter2.first());
if (!key1.same(key2)) return 1; // or -1
Variant value1(iter1.second());
Variant value2(iter2.second());
if (!value1.same(value2)) return 1; // or -1
}
} else {
for (ArrayIter iter(this); iter; ++iter) {
Variant key(iter.first());
if (!v2->exists(key)) return 1;
Variant value1(iter.second());
Variant value2(v2->get(key));
if (value1.more(value2)) return 1;
if (value1.less(value2)) return -1;
}
}
return 0;
}
TEST_F(CTestInterfaceBase, GetTestCase_07_dateNotExpire) {
data_entry key1("04_07_key_01");
data_entry value1("04_07_data_01");
data_entry key2("04_07_key_02");
data_entry value2("04_07_data_02");
data_entry value3("04_07_data_03");
data_entry* p;
int ret = 0;
//data1:area equals,key not equal
DO_WITH_RETRY(client_handle.put(1, key1, value1, 0, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
//data2:area not equas, key equal
DO_WITH_RETRY(client_handle.put(2, key2, value2, 0, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
DO_WITH_RETRY(client_handle.put(1, key2, value3, 3, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ret = client_handle.get(1, key2, p);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(true, compareDataValue(value3, *p));
delete p;
p = NULL;
client_handle.remove(1, key1);
client_handle.remove(2, key2);
client_handle.remove(1, key2);
}
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;
}
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);
}
// 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 ---------------");
}
}
void CrwMap::extract0x080a(const CiffComponent& ciffComponent,
const CrwMapInfo* crwMapInfo,
Image& image,
ByteOrder byteOrder)
{
if (ciffComponent.typeId() != asciiString) {
return extractBasic(ciffComponent, crwMapInfo, image, byteOrder);
}
// Make
ExifKey key1("Exif.Image.Make");
Value::AutoPtr value1 = Value::create(ciffComponent.typeId());
uint32_t i = 0;
for (; i < ciffComponent.size()
&& ciffComponent.pData()[i] != '\0'; ++i) {
// empty
}
value1->read(ciffComponent.pData(), ++i, byteOrder);
image.exifData().add(key1, value1.get());
// Model
ExifKey key2("Exif.Image.Model");
Value::AutoPtr value2 = Value::create(ciffComponent.typeId());
uint32_t j = i;
for (; i < ciffComponent.size()
&& ciffComponent.pData()[i] != '\0'; ++i) {
// empty
}
value2->read(ciffComponent.pData() + j, i - j + 1, byteOrder);
image.exifData().add(key2, value2.get());
} // CrwMap::extract0x080a
QString ProfilePlotView::profileKeyLabel(const std::string & key)
{
std::string lkey(key);
std::transform(lkey.begin(), lkey.end(), lkey.begin(), tolower);
if (lkey == "depth")
return tr("Depth");
if ((lkey == "temp") or (lkey == "temperature"))
return tr("Temp");
if ((lkey == "px") or (lkey == "pressure"))
return tr("Pressure");
if (lkey == "rbt")
return tr("RBT");
if (lkey == "ndl")
return tr("NDL");
if (lkey == "heartrate")
return tr("Heartrate");
if ((lkey == "heading") or (lkey == "hdg"))
return tr("Heading");
if (lkey == "bearing")
return tr("Bearing");
std::string key2(key);
std::replace(key2.begin(), key2.end(), '_', ' ');
return QString::fromStdString(boost::locale::to_title(key2));
}
bool yej_bituy (MorphInfoCR x, MorphInfoCR y, MorphInfo& tocaa) {
Bituy b;
if (lexicon_bituyim.contains( key2(x,y).str, b ) )
return b.match(x,y,tocaa);
else if (lexicon_bituyim.contains( key1(x,y).str, b))
return b.match(x,y,tocaa);
else return false;
}
std::string Num_to_Words(Int toconvert){
std::string toreturn(toconvert.sign() == -1 ? "negative " : "");
toconvert = toconvert.magnitude();
while(toconvert > 0){
size_t i( toconvert.count_digits() );
//key1 accesses words of order 10, like "thousand"
//key2 accesses the single digits words, like "one"
Int
key1(Math::exponentiate(Int(k_ten), Int(i-1))),
key2(toconvert / key1)
;
switch(i){
case 1: //One digit
toreturn += NumberWordBank.at(key2);
break;
case 2: //Two digits
if(toconvert >= 2*k_ten)
toreturn
+= NumberWordBank.at(key2 * k_ten)
+ (toconvert%k_ten > 0 ? "-" : "")
;
else if(toconvert >= k_ten){
toreturn += NumberWordBank.at(toconvert);
return toreturn;
}
break;
case 3: //Three digits
toreturn += NumberWordBank.at(key2) + ' ';
toreturn += NumberWordBank.at(key1) + ' ';
break;
default: //Four or more digits
key2 = toconvert;
key1 = 1;
while(key2.count_digits() > 3){
key1 *= k_thousand;
key2 /= k_thousand;
}
toreturn += Num_to_Words(key2) + ' ';
toreturn += NumberWordBank.at(key1) + ' ';
break;
}
//Stop adding things once toconvert is 0
if(key1*key2 == toconvert) break;
//Inserting "and"
if(
(i == 3 && toconvert%100 > 0) ||
(i >= 4 && toconvert%k_thousand < 100)
) toreturn += k_and;
toconvert -= key1*key2;
}
while(toreturn.back() == ' ') toreturn.pop_back();
return toreturn;
}
// Exercise the purgeByKeys and purge methods
static void test_explicit_purging(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 clip = SkIRect::MakeWH(100, 100);
SkImageFilter::Cache::Key key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
SkImageFilter::Cache::Key key2(1, SkMatrix::I(), clip, subset->uniqueID(), image->subset());
SkIPoint offset = SkIPoint::Make(3, 4);
cache->set(key1, image.get(), offset);
cache->set(key2, image.get(), offset);
SkDEBUGCODE(REPORTER_ASSERT(reporter, 2 == cache->count());)
void AcsAlarmTestCase::testProps()
{
acsalarm::Properties properties;
// test getProperty and setProperty methods
std::string key("key");
std::string value("value");
properties.setProperty(key, value);
CPPUNIT_ASSERT_MESSAGE("Properties::getProperty/setProperty appears to be broken", (value == properties.getProperty(key)) );
// test propertyNames method
std::string key2("key2");
std::string value2("value2");
properties.setProperty(key2, value2);
properties.setProperty(key2, value2);
std::auto_ptr< std::vector<std::string> > keys = properties.propertyNames();
CPPUNIT_ASSERT_MESSAGE("Properties::propertyNames appears to be broken", (keys->size() == 2) );
for(unsigned int i = 0; i < keys->size(); i++)
{
CPPUNIT_ASSERT_MESSAGE("Properties::propertyNames appears to be broken", (keys->at(i) == key || keys->at(i) == key2) );
}
// test copy constructor
acsalarm::Properties properties2(properties);
CPPUNIT_ASSERT_MESSAGE("Properties::Properties(&properties) - copy constructor appears to be broken", (value == properties2.getProperty(key)) );
std::auto_ptr< std::vector<std::string> > keys2 = properties2.propertyNames();
CPPUNIT_ASSERT_MESSAGE("Properties::Properties(&properties) - copy constructor appears to be broken", (keys2->size() == 2) );
for(unsigned int i = 0; i < keys2->size(); i++)
{
CPPUNIT_ASSERT_MESSAGE("Properties::(&properties) - copy constructor appears to be broken", (keys2->at(i) == key || keys2->at(i) == key2) );
}
// test == operator
CPPUNIT_ASSERT_MESSAGE("Properties:: == operator appears to be broken", (properties == properties2) );
// test = operator
acsalarm::Properties properties3 = properties2;
CPPUNIT_ASSERT_MESSAGE("Properties:: = operator appears to be broken", (value == properties3.getProperty(key)) );
std::auto_ptr< std::vector<std::string> > keys3 = properties3.propertyNames();
CPPUNIT_ASSERT_MESSAGE("Properties:: = operator appears to be broken", (keys3->size() == 2) );
for(unsigned int i = 0; i < keys3->size(); i++)
{
CPPUNIT_ASSERT_MESSAGE("Properties:: = operator appears to be broken", (keys3->at(i) == key || keys3->at(i) == key2) );
}
}
TEST(ImageKeyTest, Difference) {
srand(2000);
// coverity[dont_call]
int randomHashKey1 = rand() % 100;
ImageCacheKey key1(randomHashKey1, 0, RenderScale(1.), std::string());
U64 keyHash1 = key1.getHash();
///make a second ImageKey different to the first
// coverity[dont_call]
int randomHashKey2 = rand() % 1000 + 150;
ImageCacheKey key2(randomHashKey2, 0, RenderScale(1.), std::string());
U64 keyHash2 = key2.getHash();
ASSERT_TRUE(keyHash1 != keyHash2);
}
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;
}
TEST_F(CTestInterfaceBase, incr_TestCase_06_countAndInitValuePositive) {
data_entry key("13_06_key_01");
data_entry key2("13_06_key_02");
int area = 1;
int area2 = 2;
int count = 2;
int initValue = 1;
int expect = count + initValue;
int retValue = 0;
int ret;
// data1: area equals, key not equal
DO_WITH_RETRY(client_handle.incr(area, key2, count, &retValue, initValue, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
// data2: area not equal, key equal
DO_WITH_RETRY(client_handle.incr(area2, key, count, &retValue, initValue, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
// clear old data
client_handle.remove(area, key);
retValue = 0;
// main data
DO_WITH_RETRY(client_handle.incr(area, key, count, &retValue, initValue, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
// check other data
retValue = 0;
DO_WITH_RETRY(client_handle.incr(area, key2, 0, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
retValue = 0;
DO_WITH_RETRY(client_handle.incr(area2, key, 0, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
client_handle.remove(area, key);
client_handle.remove(area, key2);
client_handle.remove(area2, key);
};
NATRON_NAMESPACE_USING
TEST(ImageKeyTest, Equality) {
srand(2000);
// coverity[dont_call]
int randomHashKey1 = rand();
ImageCacheKey key1(randomHashKey1, 0, RenderScale(1.), std::string());
U64 keyHash1 = key1.getHash();
///make a second ImageKey equal to the first
int randomHashKey2 = randomHashKey1;
ImageCacheKey key2(randomHashKey2, 0, RenderScale(1.), std::string());
U64 keyHash2 = key2.getHash();
ASSERT_TRUE(keyHash1 == keyHash2);
}
TEST(IndexTests, DeleteTest) {
auto pool = TestingHarness::GetInstance().GetTestingPool();
std::vector<ItemPointer> locations;
// INDEX
std::unique_ptr<index::Index> index(BuildIndex());
// Single threaded test
size_t scale_factor = 1000;
LaunchParallelTest(1, InsertTest, index.get(), pool, scale_factor);
LaunchParallelTest(1, DeleteTest, index.get(), pool, scale_factor);
// Checks
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));
key0->SetValue(0, ValueFactory::GetIntegerValue(100), pool);
key0->SetValue(1, ValueFactory::GetStringValue("a"), pool);
key1->SetValue(0, ValueFactory::GetIntegerValue(100), pool);
key1->SetValue(1, ValueFactory::GetStringValue("b"), pool);
key2->SetValue(0, ValueFactory::GetIntegerValue(100), pool);
key2->SetValue(1, ValueFactory::GetStringValue("c"), pool);
locations = index->ScanKey(key0.get());
EXPECT_EQ(locations.size(), 0);
locations = index->ScanKey(key1.get());
if (index->HasUniqueKeys())
EXPECT_EQ(locations.size(), 0);
else
EXPECT_EQ(locations.size(), 2);
locations = index->ScanKey(key2.get());
EXPECT_EQ(locations.size(), 1);
EXPECT_EQ(locations[0].block, item1.block);
locations = index->ScanAllKeys();
if (index->HasUniqueKeys())
EXPECT_EQ(locations.size(), scale_factor);
else
EXPECT_EQ(locations.size(), 3 * scale_factor);
delete tuple_schema;
}
TEST(ImageKeyTest, Equality) {
srand(2000);
// coverity[dont_call]
int randomHashKey1 = rand();
SequenceTime time1 = 0;
ViewIdx view1(0);
ImageKey key1(std::string(), randomHashKey1, time1, view1, false);
U64 keyHash1 = key1.getHash();
///make a second ImageKey equal to the first
int randomHashKey2 = randomHashKey1;
SequenceTime time2 = time1;
ViewIdx view2(view1);
ImageKey key2(std::string(), randomHashKey2, time2, view2, false);
U64 keyHash2 = key2.getHash();
ASSERT_TRUE(keyHash1 == keyHash2);
}
TEST(IndexTests, MyMultiThreadedTest) {
auto pool = TestingHarness::GetInstance().GetTestingPool();
std::vector<ItemPointer> locations;
// INDEX
std::unique_ptr<index::Index> index(BuildIndex());
// Parallel Test
size_t num_threads = 15;
size_t scale_factor = 30;
LaunchParallelTest(num_threads, InsertTest, index.get(), pool, scale_factor);
LaunchParallelTest(num_threads, DeleteTest, index.get(), pool, scale_factor);
locations = index->ScanAllKeys();
if (index->HasUniqueKeys())
EXPECT_EQ(locations.size(), scale_factor);
else
EXPECT_EQ(locations.size(), 3 * num_threads * scale_factor);
std::unique_ptr<storage::Tuple> key1(new storage::Tuple(key_schema, true));
std::unique_ptr<storage::Tuple> key2(new storage::Tuple(key_schema, true));
key1->SetValue(0, ValueFactory::GetIntegerValue(100), pool);
key1->SetValue(1, ValueFactory::GetStringValue("b"), pool);
key2->SetValue(0, ValueFactory::GetIntegerValue(100), pool);
key2->SetValue(1, ValueFactory::GetStringValue("c"), pool);
locations = index->ScanKey(key1.get());
if (index->HasUniqueKeys()) {
EXPECT_EQ(locations.size(), 0);
} else {
EXPECT_EQ(locations.size(), 2 * num_threads);
}
locations = index->ScanKey(key2.get());
if (index->HasUniqueKeys()) {
EXPECT_EQ(locations.size(), num_threads);
} else {
EXPECT_EQ(locations.size(), num_threads);
}
delete tuple_schema;
}
void CrwMap::extract0x1810(const CiffComponent& ciffComponent,
const CrwMapInfo* crwMapInfo,
Image& image,
ByteOrder byteOrder)
{
if (ciffComponent.typeId() != unsignedLong || ciffComponent.size() < 28) {
return extractBasic(ciffComponent, crwMapInfo, image, byteOrder);
}
ExifKey key1("Exif.Photo.PixelXDimension");
ULongValue value1;
value1.read(ciffComponent.pData(), 4, byteOrder);
image.exifData().add(key1, &value1);
ExifKey key2("Exif.Photo.PixelYDimension");
ULongValue value2;
value2.read(ciffComponent.pData() + 4, 4, byteOrder);
image.exifData().add(key2, &value2);
} // CrwMap::extract0x1810
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;
}
wxString wxJoystick::GetProductName() const
{
wxString str;
#ifndef __WINE__
JOYCAPS joyCaps;
if (joyGetDevCaps(m_joystick, &joyCaps, sizeof(joyCaps)) != JOYERR_NOERROR)
return wxEmptyString;
wxRegKey key1(wxString::Format(wxT("HKEY_LOCAL_MACHINE\\%s\\%s\\%s"),
REGSTR_PATH_JOYCONFIG, joyCaps.szRegKey, REGSTR_KEY_JOYCURR));
key1.QueryValue(wxString::Format(wxT("Joystick%d%s"),
m_joystick + 1, REGSTR_VAL_JOYOEMNAME),
str);
wxRegKey key2(wxString::Format(wxT("HKEY_LOCAL_MACHINE\\%s\\%s"),
REGSTR_PATH_JOYOEM, str.c_str()));
key2.QueryValue(REGSTR_VAL_JOYOEMNAME, str);
#endif
return str;
}
// Ensure the cache can return a cached image
static void test_find_existing(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 clip = SkIRect::MakeWH(100, 100);
SkImageFilter::Cache::Key key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
SkImageFilter::Cache::Key key2(0, SkMatrix::I(), clip, subset->uniqueID(), subset->subset());
SkIPoint offset = SkIPoint::Make(3, 4);
cache->set(key1, image.get(), offset);
SkIPoint foundOffset;
SkSpecialImage* foundImage = cache->get(key1, &foundOffset);
REPORTER_ASSERT(reporter, foundImage);
REPORTER_ASSERT(reporter, offset == foundOffset);
REPORTER_ASSERT(reporter, !cache->get(key2, &foundOffset));
}
// Test purging when the max cache size is exceeded
static void test_internal_purge(skiatest::Reporter* reporter, const sk_sp<SkSpecialImage>& image) {
SkASSERT(image->getSize());
const size_t kCacheSize = image->getSize() + 10;
SkAutoTUnref<SkImageFilter::Cache> cache(SkImageFilter::Cache::Create(kCacheSize));
SkIRect clip = SkIRect::MakeWH(100, 100);
SkImageFilter::Cache::Key key1(0, SkMatrix::I(), clip, image->uniqueID(), image->subset());
SkImageFilter::Cache::Key key2(1, SkMatrix::I(), clip, image->uniqueID(), image->subset());
SkIPoint offset = SkIPoint::Make(3, 4);
cache->set(key1, image.get(), offset);
SkIPoint foundOffset;
REPORTER_ASSERT(reporter, cache->get(key1, &foundOffset));
// This should knock the first one out of the cache
cache->set(key2, image.get(), offset);
REPORTER_ASSERT(reporter, cache->get(key2, &foundOffset));
REPORTER_ASSERT(reporter, !cache->get(key1, &foundOffset));
}
QString SystemConfig::cpuInfo()
{
QString cpu,tmp;
QString key1("Hardware");
QString key2("BogoMIPS");
QFile file("/proc/cpuinfo");
if (!file.open(QIODevice::ReadOnly | QIODevice::Text))
return cpu;
QTextStream in(&file);
QString line = in.readLine();
while (!line.isNull())
{
if(line.contains(key1))
{
cpu.append( line.right( line.length() - line.indexOf(':') - 1 ).trimmed() );
}
if(line.contains(key2))
{
int i;
tmp.append( line.right( line.length() - line.indexOf(':') - 1 ).trimmed() );
if ( (i=tmp.indexOf(QChar('.'))) != -1)
{
tmp= tmp.left(i);
}
}
line = in.readLine();
}
file.close();
cpu.append(" ").append(tmp).append(" MHz");
return cpu;
}
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;
}
