TEST_F(CTestInterfaceBase, put_test_case_09)
{
data_entry key1;
data_entry value1;
data_entry key2;
data_entry value2;
data_entry* p = 0;
string key_str1 = "test01key";
string key_str2 = "test02key";
string val_str1 = "test01val";
string val_str2 = "test02val";
key1.set_data(key_str1.c_str(), key_str1.size());
value1.set_data(val_str1.c_str(), val_str1.size());
key2.set_data(key_str1.c_str(), key_str1.size());
value2.set_data(val_str1.c_str(), val_str1.size());
int ret = 0;
DO_WITH_RETRY(client_handle.put(1, key1, value1, 0, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
DO_WITH_RETRY(client_handle.put(2, key2, value1, 0, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
DO_WITH_RETRY(client_handle.put(1, key2, value2, 5, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
DO_WITH_RETRY(client_handle.get(1, key2, p), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(true,compareDataValue(value2, *p));
int version = p->get_version();
delete p;
p=0;
ret = client_handle.put(1, key2, value1, 6, version + 3 );
ASSERT_NE(TAIR_RETURN_SUCCESS, ret);
DO_WITH_RETRY(client_handle.get(1, key2, p), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(true,compareDataValue(value2, *p));
ASSERT_EQ(version , p->get_version());
ASSERT_EQ(5, p->data_meta.edate);
delete p;
p=0;
ret = client_handle.remove(1, key1);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
ret = client_handle.remove(2, key2);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
ret = client_handle.remove(1, key2);
ASSERT_EQ(TAIR_RETURN_SUCCESS,ret);
};
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);
}
// -----------------------------------------------------------------------
// Abstract interface from AbstractNumericValidator
// -----------------------------------------------------------------------
void DecimalDatatypeValidator::checkContent(const XMLCh* const content
, ValidationContext* const context
, bool asBase
, MemoryManager* const manager)
{
//validate against base validator if any
DecimalDatatypeValidator *pBase = (DecimalDatatypeValidator*) this->getBaseValidator();
if (pBase)
pBase->checkContent(content, context, true, manager);
int thisFacetsDefined = getFacetsDefined();
// we check pattern first
if ( (thisFacetsDefined & DatatypeValidator::FACET_PATTERN ) != 0 )
{
// lazy construction
if (getRegex() ==0) {
try {
// REVISIT: cargillmem fMemoryManager vs manager
setRegex(new (fMemoryManager) RegularExpression(getPattern(), SchemaSymbols::fgRegEx_XOption, fMemoryManager));
}
catch (XMLException &e)
{
ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::RethrowError, e.getMessage(), manager);
}
}
if (getRegex()->matches(content, manager) ==false)
{
ThrowXMLwithMemMgr2(InvalidDatatypeValueException
, XMLExcepts::VALUE_NotMatch_Pattern
, content
, getPattern()
, manager);
}
}
// if this is a base validator, we only need to check pattern facet
// all other facet were inherited by the derived type
if (asBase)
return;
XMLCh *errorMsg = 0;
try {
XMLBigDecimal compareDataValue(content, manager);
XMLBigDecimal* compareData = &compareDataValue;
if (getEnumeration())
{
int i=0;
int enumLength = getEnumeration()->size();
for ( ; i < enumLength; i++)
{
if (compareValues(compareData, (XMLBigDecimal*) getEnumeration()->elementAt(i)) ==0 )
break;
}
if (i == enumLength)
ThrowXMLwithMemMgr1(InvalidDatatypeValueException, XMLExcepts::VALUE_NotIn_Enumeration, content, manager);
}
boundsCheck(compareData, manager);
if ( (thisFacetsDefined & DatatypeValidator::FACET_FRACTIONDIGITS) != 0 )
{
if ( compareData->getScale() > fFractionDigits )
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(compareData->getScale(), value1, BUF_LEN, 10, manager);
XMLString::binToText(fFractionDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
, XMLExcepts::VALUE_exceed_fractDigit
, compareData->getRawData()
, value1
, value2
, manager);
}
}
if ( (thisFacetsDefined & DatatypeValidator::FACET_TOTALDIGITS) != 0 )
{
if ( compareData->getTotalDigit() > fTotalDigits )
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(compareData->getTotalDigit(), value1, BUF_LEN, 10, manager);
XMLString::binToText(fTotalDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
, XMLExcepts::VALUE_exceed_totalDigit
, compareData->getRawData()
, value1
, value2
, manager);
}
/***
E2-44 totalDigits
... by restricting it to numbers that are expressible as i � 10^-n
where i and n are integers such that |i| < 10^totalDigits and 0 <= n <= totalDigits.
***/
if ( compareData->getScale() > fTotalDigits )
{
XMLCh value1[BUF_LEN+1];
XMLCh value2[BUF_LEN+1];
XMLString::binToText(compareData->getScale(), value1, BUF_LEN, 10, manager);
XMLString::binToText(fTotalDigits, value2, BUF_LEN, 10, manager);
ThrowXMLwithMemMgr3(InvalidDatatypeFacetException
, XMLExcepts::VALUE_exceed_totalDigit
, compareData->getRawData()
, value1
, value2
, manager);
}
}
}
catch (XMLException &e)
{
errorMsg = XMLString::replicate(e.getMessage(), manager);
}
if(errorMsg)
{
ArrayJanitor<XMLCh> jan(errorMsg, manager);
ThrowXMLwithMemMgr1(InvalidDatatypeFacetException, XMLExcepts::RethrowError, errorMsg, manager);
}
}
bool CTestInterfaceBase::compareDataValueWithMeta(const data_entry& v1, const data_entry& v2) {
if (compareDataValue(v1,v2) == false) return false;
return memcmp(&v1.data_meta, &v2.data_meta, sizeof(v1.data_meta)) == 0;
}
TEST_F(CTestInterfaceBase, incr_other_TestCase_01_mixed) {
data_entry key("14_01_key_01");
int area = 1;
int count = 1;
int initValue = 10;
int retValue = 0;
int ret;
client_handle.remove(area, key);
// step 1
int expect = count + initValue;
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);
// step 2
data_entry *p;
DO_WITH_RETRY(client_handle.get(area, key, p), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(1,p->get_version());
DO_WITH_RETRY(client_handle.incr(area, key, 0, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
delete p;
p = NULL;
// step 3
vector<int> itemList;
for(int i=0;i<10;++i){
itemList.push_back(i);
}
ret = client_handle.add_items(area, key, itemList, 0, 0);
ASSERT_EQ(TAIR_RETURN_CANNOT_OVERRIDE, ret);
DO_WITH_RETRY(client_handle.incr(area, key, 0, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
// step 4
vector<int> itemResult;
ret = client_handle.get_items(area, key, 0, 1, itemResult);
ASSERT_EQ(TAIR_RETURN_TYPE_NOT_MATCH, ret);
DO_WITH_RETRY(client_handle.incr(area, key, 0, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
// step 5
itemResult.clear();
ret = client_handle.get_and_remove(area, key, 0, 1, itemResult);
ASSERT_EQ(TAIR_RETURN_TYPE_NOT_MATCH, ret);
DO_WITH_RETRY(client_handle.incr(area, key, 0, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
// step 6
ret = client_handle.remove_items(area, key, 0, 1);
ASSERT_EQ(TAIR_RETURN_TYPE_NOT_MATCH, ret);
DO_WITH_RETRY(client_handle.incr(area, key, 0, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
// step 7
ret = client_handle.get_items_count(area, key);
ASSERT_EQ(TAIR_RETURN_TYPE_NOT_MATCH, ret);
DO_WITH_RETRY(client_handle.incr(area, key, 0, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
// step 8
count = 1;
expect += count;
DO_WITH_RETRY(client_handle.incr(area, key, count, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
// step 9
expect -= count;
DO_WITH_RETRY(client_handle.decr(area, key, count, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(expect, retValue);
// step 10
DO_WITH_RETRY(client_handle.remove(area, key), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ret = client_handle.get(area, key, p);
ASSERT_EQ(ret, TAIR_RETURN_DATA_NOT_EXIST);
// step 11
count = 1;
DO_WITH_RETRY(client_handle.incr(area, key, count, &retValue), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_EQ(count, retValue);
// step 12
DO_WITH_RETRY(client_handle.put(area, key, key, 0, 0), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
DO_WITH_RETRY(client_handle.get(area, key, p), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ASSERT_TRUE(compareDataValue(key, *p));
ASSERT_EQ(2,p->get_version());
delete p;
p = NULL;
// step 13
ret = client_handle.incr(area, key, count, &retValue);
ASSERT_EQ(TAIR_RETURN_CANNOT_OVERRIDE, ret);
// step 14
ret = client_handle.decr(area, key, count, &retValue);
ASSERT_EQ(TAIR_RETURN_CANNOT_OVERRIDE, ret);
// step 15
DO_WITH_RETRY(client_handle.remove(area, key), ret, TAIR_RETURN_SUCCESS);
ASSERT_EQ(TAIR_RETURN_SUCCESS, ret);
ret = client_handle.get(area, key, p);
ASSERT_EQ(TAIR_RETURN_DATA_NOT_EXIST, ret);
};
