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;
}
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_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);
}
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);
}
/// Translate back to 'real' characters, i.e. newlines are real
/// newlines.
wxString ctConvertToMultilineText(const wxString& value)
{
wxString value1(value);
value1.Replace(wxT("\\n"), wxT("\n"));
value1.Replace(wxT("\\t"), wxT("\t"));
return value1;
}
V3MPDRCube* const
V3VrfMPDR::forwardModel(const V3MPDRCube* const curCube) {
assert (curCube); if (!curCube->getNextCube()) return 0;
// Set Pattern Values for Simulator
if (_pdrSize) {
const V3BitVecX& inputData = curCube->getInputData();
assert (inputData.size() == _pdrSize); uint32_t j = 0;
for (uint32_t i = 0; i < _vrfNtk->getInputSize(); ++i, ++j)
_pdrSim->setSource(_vrfNtk->getInput(i), inputData.bv_slice(j, j));
for (uint32_t i = 0; i < _vrfNtk->getInoutSize(); ++i, ++j)
_pdrSim->setSource(_vrfNtk->getInout(i), inputData.bv_slice(j, j));
assert (j == inputData.size());
}
// Set State Variable Values for Simulator
const V3NetVec& state = curCube->getState(); _pdrSim->setSourceFree(V3_FF, false);
V3BitVecX value0(1), value1(1); value0.set0(0); value1.set1(0);
for (uint32_t i = 0; i < state.size(); ++i)
_pdrSim->setSource(_vrfNtk->getLatch(state[i].id), (state[i].cp ? value0 : value1));
// Simulate for One Cycle
_pdrSim->simulate(); _pdrSim->updateNextStateValue();
// Return the Cube that it Reached
V3NetVec nextState; nextState.clear(); nextState.reserve(_vrfNtk->getLatchSize());
for (uint32_t i = 0; i < _vrfNtk->getLatchSize(); ++i) {
switch (_pdrSim->getSimValue(_vrfNtk->getLatch(i))[0]) {
case '0' : nextState.push_back(V3NetId::makeNetId(i, 1)); break;
case '1' : nextState.push_back(V3NetId::makeNetId(i, 0)); break;
}
}
if (existInitial(nextState)) return 0;
V3MPDRCube* const cube = new V3MPDRCube(0); assert (cube);
cube->setState(nextState); return cube;
}
void compareValue(const T1& param1, const T2& param2, const RDOType::TypeID& type1, const RDOType::TypeID& type2)
{
T1 val1 = param1;
T2 val2 = param2;
RDOValue value1(val1);
RDOValue value2(val2);
compare(value1, value2);
value1 = value2;
BOOST_CHECK(value1 == value2);
value1 = val1;
value2 = val2;
value1 += value2;
BOOST_CHECK(value1 == T1(param1 + param2));
BOOST_CHECK(value1.typeID() == type1);
value1 -= value2;
BOOST_CHECK(value1 == param1);
value1 *= value2;
BOOST_CHECK(value1 == param1 * param2);
value1 /= value2;
BOOST_CHECK(value1 == param1);
BOOST_CHECK(value1.typeID() == type2);
}
int ArrayData::compare(const ArrayData *v2) 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;
// prevent circular referenced objects/arrays or deep ones
DECLARE_THREAD_INFO;
RECURSION_INJECTION;
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(Protocol, McResultSerialize) {
{
McResult codeResult(R_DELETED);
std::string result;
StringWBuffer buffer(3, &result);
codeResult.Serialize(&buffer);
buffer.Flush();
ASSERT_EQ(result, "DELETED\r\n");
}
{
McResult errResult("Length of key is too long");
std::string result;
StringWBuffer buffer(3, &result);
errResult.Serialize(&buffer);
buffer.Flush();
ASSERT_EQ(result, "ERROR Length of key is too long\r\n");
}
{
McValue value1("user_123", 1445128601, std::vector<char>({'1', '2', '3', '4', '5', 'a'}));
McValue value2("user_876", 1446128601, std::vector<char>({'6', '7', '8', '9', '0', 'z'}));
McResult valResult(std::vector<McValue>({value1, value2}));
std::string result;
StringWBuffer buffer(3, &result);
valResult.Serialize(&buffer);
buffer.Flush();
ASSERT_EQ(result, "user_123 1445128601 6\r\n12345a\r\nuser_876 1446128601 6\r\n67890z\r\nEND\r\n");
}
}
bool
DbIndexKey::operator < (const DbIndexKey &other) const
{
// compare the values of the attributes in the keys
uint32 numAttributes = (uint32) mIndex.mAttributes.size();
uint32 valueOffset1 = 0, valueOffset2 = 0;
for (uint32 i = 0; i < numAttributes; i++) {
const MetaAttribute &metaAttribute = *mIndex.mAttributes[i];
auto_ptr<DbValue> value1(metaAttribute.createValue(mKeySection.subsection(mKeyRange),
valueOffset1));
auto_ptr<DbValue> value2(metaAttribute.createValue(other.mKeySection.subsection(other.mKeyRange),
valueOffset2));
if (metaAttribute.evaluate(value1.get(), value2.get(), CSSM_DB_LESS_THAN))
return true;
else if (metaAttribute.evaluate(value2.get(), value1.get(), CSSM_DB_LESS_THAN))
return false;
}
// if we are here, the keys are equal
return false;
}
void tst_QVersitProperty::testParameters()
{
QString typeParameterName(QLatin1String("TYPE"));
QString name(QLatin1String("type"));
QString value1(QLatin1String("home"));
mVersitProperty->insertParameter(name,value1);
QMultiHash<QString,QString> parameters = mVersitProperty->parameters();
QCOMPARE(parameters.count(), 1);
QVERIFY(parameters.contains(typeParameterName,QLatin1String("home")));
QString value2(QLatin1String("voice"));
mVersitProperty->insertParameter(name,value2);
parameters = mVersitProperty->parameters();
QCOMPARE(parameters.count(), 2);
QVERIFY(parameters.contains(typeParameterName,QLatin1String("home")));
QVERIFY(parameters.contains(typeParameterName,QLatin1String("voice")));
mVersitProperty->removeParameter(name,value1);
QCOMPARE(mVersitProperty->parameters().count(), 1);
QVERIFY(parameters.contains(typeParameterName,QLatin1String("home")));
mVersitProperty->removeParameter(name,value2);
QCOMPARE(mVersitProperty->parameters().count(), 0);
mVersitProperty->insertParameter(name, value1);
mVersitProperty->insertParameter(name, value2);
QCOMPARE(mVersitProperty->parameters().count(), 2);
mVersitProperty->removeParameters(name);
QCOMPARE(mVersitProperty->parameters().count(), 0);
}
//decrement prefix
bool test_decrementPrefix() {
bool status = false;
INT value1(TEST_VALUE_1);
int value2 = TEST_VALUE_1;
status = (--value1 == value2-1);
return status;
}
//increment prefix
bool test_incrementPrefix() {
bool status = false;
INT value1(TEST_VALUE_1);
int value2 = TEST_VALUE_1;
status = (++value1 == value2+1);
return status;
}
//decrement suffix
bool test_decrementSuffix() {
bool status = false;
INT value1(TEST_VALUE_1);
int value2 = TEST_VALUE_1;
status = (value1-- == value2);
status = status && (value1 == value2-1);
return status;
}
bool test_assignSamePrimType() {
bool status = false;
INT value1(TEST_VALUE_1);
value1 = TEST_VALUE_2;
status = (value1==TEST_VALUE_2 && value1!=TEST_VALUE_1);
return status;
}
void CStatTreeItemTotalClients::AddECValues(CECTag *tag) const
{
CECTag value1(EC_TAG_STAT_NODE_VALUE,
(uint64)(m_known->GetValue() + m_unknown->GetValue()));
tag->AddTag(value1);
CECTag value2(EC_TAG_STAT_NODE_VALUE,
(uint64)m_known->GetValue());
tag->AddTag(value2);
}
void compareStr(const T1& param1, const T2& param2)
{
T1 val1 = param1;
T2 str1 = param2;
RDOValue value1(val1);
RDOValue value2(str1);
testing(value1, value2);
}
TEST (uint256_union, big_endian_union_constructor)
{
boost::multiprecision::uint256_t value1 (1);
rai::uint256_union bytes1 (value1);
ASSERT_EQ (1, bytes1.bytes [31]);
boost::multiprecision::uint512_t value2 (1);
rai::uint512_union bytes2 (value2);
ASSERT_EQ (1, bytes2.bytes [63]);
}
bool test_subtractAssignSameType() {
bool status = false;
INT value1(TEST_VALUE_1);
INT value2(TEST_VALUE_2);
value1 -= value2;
status = (value1==TEST_VALUE_1-TEST_VALUE_2 && value2==TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1!=value2);
return status;
}
bool test_multiplyAssignSameType() {
bool status = false;
INT value1(TEST_VALUE_1);
INT value2(TEST_VALUE_2);
value1 *= value2;
status = (value1==TEST_VALUE_1*TEST_VALUE_2 && value2==TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1!=value2);
return status;
}
//divide and assign
bool test_divideAssignSamePrimType() {
bool status = false;
INT value1(TEST_VALUE_1);
int value2 = TEST_VALUE_2;
value1 /= value2;
status = (value1==TEST_VALUE_1/TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2);
return status;
}
bool test_moduloAssignCompatiblePrimType() {
bool status = false;
INT value1(TEST_VALUE_1);
long int value2 = TEST_VALUE_2;
value1 %= value2;
status = (value1==TEST_VALUE_1%TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2);
return status;
}
bool test_addAssignCompatiblePrimType() {
bool status = false;
INT value1(TEST_VALUE_1);
double value2 = TEST_VALUE_2;
value1 += value2;
status = (value1==TEST_VALUE_1+TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2);
return status;
}
bool test_addAssignSameType() {
bool status = false;
INT value1(TEST_VALUE_1);
INT value2(TEST_VALUE_2);
value1 += value2;
status = (value1==TEST_VALUE_1+TEST_VALUE_2 && value2==TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1!=value2);
return status;
}
//modulo
bool test_moduloSamePrimType() {
bool status = false;
INT value1(TEST_VALUE_1);
int value2 = TEST_VALUE_2;
INT value3(0);
value3 = value1 % value2;
status = (value3==TEST_VALUE_1%TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1==TEST_VALUE_1 && value2==TEST_VALUE_2);
return status;
}
bool test_subtractCompatiblePrimType() {
bool status = false;
INT value1(TEST_VALUE_1);
double value2 = TEST_VALUE_2;
INT value3(0);
value3 = value1 - value2;
status = (value3==TEST_VALUE_1-TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1==TEST_VALUE_1 && value2==TEST_VALUE_2);
return status;
}
bool test_multiplySameType() {
bool status = false;
INT value1(TEST_VALUE_1);
INT value2 = TEST_VALUE_2;
INT value3(0);
value3 = value1 * value2;
status = (value3==TEST_VALUE_1*TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1==TEST_VALUE_1 && value2==TEST_VALUE_2);
return status;
}
bool test_multiplyCompatiblePrimType() {
bool status = false;
INT value1(TEST_VALUE_1);
double value2 = TEST_VALUE_2;
INT value3(0);
value3 = value1 * value2;
status = (value3==TEST_VALUE_1*TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1==TEST_VALUE_1 && value2==TEST_VALUE_2);
return status;
}
bool test_divideCompatibleType() {
bool status = false;
INT value1(TEST_VALUE_1);
DOUBLE value2 = TEST_VALUE_2;
INT value3(0);
value3 = value1 / value2;
status = (value3==TEST_VALUE_1/TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1==TEST_VALUE_1 && value2==TEST_VALUE_2);
return status;
}
bool test_moduloCompatibleType() {
bool status = false;
INT value1(TEST_VALUE_1);
LONG_INT value2 = TEST_VALUE_2;
INT value3(0);
value3 = value1 % value2;
status = (value3==TEST_VALUE_1%TEST_VALUE_2 && TEST_VALUE_1!=TEST_VALUE_2 && value1==TEST_VALUE_1 && value2==TEST_VALUE_2);
return status;
}
