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; }