BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndEraseByName, T, InMemoryStorages)
{
T ims;
Name name("/insertandremovebyname");
uint32_t content1 = 1;
shared_ptr<Data> data1 = makeData(name);
data1->setFreshnessPeriod(time::milliseconds(99999));
data1->setContent(reinterpret_cast<const uint8_t*>(&content1), sizeof(content1));
signData(data1);
ims.insert(*data1);
uint32_t content2 = 2;
shared_ptr<Data> data2 = makeData(name);
data2->setFreshnessPeriod(time::milliseconds(99999));
data2->setContent(reinterpret_cast<const uint8_t*>(&content2), sizeof(content2));
signData(data2);
ims.insert(*data2);
shared_ptr<Data> data3 = makeData("/insertandremovebyname/1");
ims.insert(*data3);
shared_ptr<Data> data4 = makeData("/insertandremovebyname/2");
ims.insert(*data4);
BOOST_CHECK_EQUAL(ims.size(), 4);
ims.erase(data1->getFullName(), false);
BOOST_CHECK_EQUAL(ims.size(), 3);
}
//
// ::doFormat_x
//
void doFormat_x(ObjectVector *objects, FormatData &data)
{
switch(data.len)
{
case FL_L:
case FL_LL:
case FL_MAX:
makeData(objects, data);
makeExpr(objects, VariableType::get_bt_uns_ll());
objects->addToken(OCODE_JMP_CAL_NIL_IMM, objects->getValue("__Print_lx"));
break;
default:
if(data.flags || data.width || data.prec || data.fmt == 'x')
{
makeData(objects, data);
makeExpr(objects, VariableType::get_bt_uns());
objects->addToken(OCODE_JMP_CAL_NIL_IMM, objects->getValue("__Print_x"));
}
else
{
makeExpr(objects, VariableType::get_bt_uns());
objects->addToken(OCODE_ACSP_NUM_HEX_U);
}
break;
}
}
void IdentificationProvider::getBlockMetainfo( _2Real::bundle::BlockMetainfo &info, _2Real::bundle::TypeMetainfoCollection const& types )
{
_2Real::bundle::BlockMetainfo &counterinfo = dynamic_cast< _2Real::bundle::BlockMetainfo & >( info );
auto IDInfo = std::static_pointer_cast< const _2Real::bundle::CustomTypeMetainfo >( types.getTypeMetainfo( "ID" ) );
auto globalIDInfo = std::static_pointer_cast< const _2Real::bundle::CustomTypeMetainfo >(types.getTypeMetainfo("globalID"));
counterinfo.setBlockClass< IdentificationProvider >();
counterinfo.setDescription( "IdentificationProvider" );
_2Real::bundle::UpdatePolicyMetainfo policy = counterinfo.getUpdatePolicyMetainfo();
policy.set( _2Real::DefaultUpdatePolicy::ANY );
_2Real::bundle::InletMetainfo stringy = counterinfo.getInletMetainfo("identificator");
stringy.setDescription("name of identificator");
stringy.setDatatypeAndInitialValue(std::string("n/a"));
_2Real::bundle::InletMetainfo in = counterinfo.getInletMetainfo( "localID" );
in.setDescription( "local ID" );
in.setDatatypeAndInitialValue(IDInfo->makeData());
_2Real::bundle::OutletMetainfo out = counterinfo.getOutletMetainfo( "globalID" );
out.setDescription( "global ID" );
out.setDatatypeAndInitialValue(globalIDInfo->makeData());
}
void getTypeMetainfo( _2Real::bundle::CustomTypeMetainfo & info, _2Real::bundle::TypeMetainfoCollection const& existingTypes )
{
if ( info.getName() == "simpleType" )
{
info.setDescription( "testing simple types, that is, types where all fields are not custom types" );
info.setInitialFieldValue( "ushort_field", (uint16_t)0 );
info.setInitialFieldValue( "int_field", ( int32_t )15 );
info.setInitialFieldValue( "string_field", std::string( "poit" ) );
info.setInitialFieldValue( "vector_field", std::vector< uint16_t >() );
}
else if ( info.getName() == "complexType" )
{
// ordering is preserved
auto simpleInfo = std::static_pointer_cast< const _2Real::bundle::CustomTypeMetainfo >( existingTypes.getTypeMetainfo( "simpleType" ) );
_2Real::CustomDataItem aSimple = simpleInfo->makeCustomData();
aSimple.set( "int_field", ( int32_t )64 );
aSimple.set( "string_field", std::string( "narf" ) );
info.setDescription( "testing complex types, that is, types where at least one field is a custom type" );
info.setInitialFieldValue( "vector_field", std::vector< int >() );
info.setInitialFieldValue( "simple_field1", aSimple );
info.setInitialFieldValue( "simple_field2", std::move( aSimple ) );
info.setInitialFieldValue( "simple_field3", std::move( simpleInfo->makeData() ) );
info.setInitialFieldValue( "simple_field4", simpleInfo->makeData() );
info.setInitialFieldValue( "float_field", 10.5f );
}
}
shared_ptr<ndn::Data>
NdnDataManager::operator[]( shared_ptr<const ndn::Interest> interest )
{
Name subname = interest->getName();
auto it = subname.end()-1;
while( ( it->isVersion() || it->isSegment()
|| it->isSegmentOffset() || it->isTimestamp()
|| it->isSequenceNumber() ) && ( it-- ) != subname.begin() );
subname = subname.getPrefix( it - subname.begin() + 1 );
if( m_producers.find( subname ) != m_producers.end() )
{
// find data producer
auto producer = m_producers[subname];
// if access level is 0, no access needs to be provided
if( interest->getAuthTag().getAccessLevel() == 0 )
{
Coordinator::
producerSatisfiedRequest( interest->getName().getPrefix( 2 ),
interest->getName() );
return producer->makeData( interest );
}
// generate data packet
shared_ptr<Data> data = producer->makeData( interest );
// check that the interest's access rights
// satisfy the data's requirements
if( m_auth_manager->getTagAccess( interest->getAuthTag() )
< data->getAccessLevel() )
{
Coordinator::
producerDeniedRequest( interest->getName().getPrefix( 2 ),
interest->getName(),
"Insufficient Auth" );
return makeNack( *data );
}
// check that the data satisfies interest
if( interest->matchesData( *data ) )
{
Coordinator::
producerSatisfiedRequest( interest->getName().getPrefix(2),
interest->getName() );
return data;
}
}
Coordinator::producerOther( interest->getName().getPrefix( 2 ),
"No data matching "
+ interest->getName().toUri() );
return NULL;
};
BOOST_AUTO_TEST_CASE_TEMPLATE(SetCapacity, T, InMemoryStoragesLimited)
{
T ims;
ims.setCapacity(3);
ims.insert(*makeData("/1"));
ims.insert(*makeData("/2"));
ims.insert(*makeData("/3"));
BOOST_CHECK_EQUAL(ims.size(), 3);
ims.setCapacity(2);
BOOST_CHECK_EQUAL(ims.size(), 2);
}
BOOST_AUTO_TEST_CASE_TEMPLATE(DuplicateInsertion2, T, InMemoryStorages)
{
T ims;
shared_ptr<Data> data = makeData("/insert/duplicate");
ims.insert(*data);
ims.insert(*data);
BOOST_CHECK_EQUAL(ims.size(), 1);
shared_ptr<Data> data2 = makeData("/insert/original");
ims.insert(*data2);
BOOST_CHECK_EQUAL(ims.size(), 2);
}
BOOST_AUTO_TEST_CASE_TEMPLATE(Iterator, T, InMemoryStorages)
{
T ims;
BOOST_CONCEPT_ASSERT((boost::InputIterator<InMemoryStorage::const_iterator>));
for (int i = 0; i < 10; i++) {
std::ostringstream convert;
convert << i;
Name name("/" + convert.str());
shared_ptr<Data> data = makeData(name);
ims.insert(*data);
}
InMemoryStorage::const_iterator it = ims.begin();
InMemoryStorage::const_iterator tmp1 = it;
BOOST_REQUIRE(tmp1 == it);
InMemoryStorage::const_iterator tmp2 = tmp1++;
BOOST_REQUIRE(tmp2 != tmp1);
tmp2 = ++tmp1;
BOOST_REQUIRE(tmp2 == tmp1);
int i = 0;
for (;it != ims.end(); it++) {
std::ostringstream convert;
convert << i;
Name name("/" + convert.str());
BOOST_CHECK_EQUAL(it->getName(), name);
BOOST_CHECK_EQUAL((*it).getName(), name);
i++;
}
}
static void testKnnNearestIndices() {
unsigned nObs;
unsigned nDims;
double *inputsP;
double *targetsP;
makeData(&nObs, &nDims, &inputsP, &targetsP);
const unsigned nNeighbors = 2;
unsigned nnIndices[nNeighbors];
// queryIndex == 0
Knn_nearest_indices(nObs, nDims, inputsP, nNeighbors, nnIndices, 0);
EXPECT_EQ_UNSIGNED(1, nnIndices[0]);
EXPECT_EQ_UNSIGNED(2, nnIndices[1]);
// queryIndex == 1
Knn_nearest_indices(nObs, nDims, inputsP, nNeighbors, nnIndices, 1);
EXPECT_EQ_UNSIGNED(0, nnIndices[0]);
EXPECT_EQ_UNSIGNED(2, nnIndices[1]);
// queryIndex == 2
Knn_nearest_indices(nObs, nDims, inputsP, nNeighbors, nnIndices, 2);
EXPECT_EQ_UNSIGNED(1, nnIndices[0]);
EXPECT_EQ_UNSIGNED(3, nnIndices[1]);
// queryIndex == 3
Knn_nearest_indices(nObs, nDims, inputsP, nNeighbors, nnIndices, 3);
EXPECT_EQ_UNSIGNED(2, nnIndices[0]); // NOTE: order does not matter
EXPECT_EQ_UNSIGNED(1, nnIndices[1]);
}
// find(rightmost) hit
BOOST_FIXTURE_TEST_CASE(Rightmost, CsBenchmarkFixture)
{
constexpr size_t N_CHILDREN = 10;
constexpr size_t N_INTERESTS = CS_CAPACITY / N_CHILDREN;
constexpr size_t REPEAT = 4;
std::vector<shared_ptr<Interest>> interestWorkload = makeInterestWorkload(N_INTERESTS);
for (auto&& interest : interestWorkload) {
interest->setChildSelector(1);
for (size_t j = 0; j < N_CHILDREN; ++j) {
Name name = interest->getName();
name.appendNumber(j);
shared_ptr<Data> data = makeData(name);
cs.insert(*data, false);
}
}
BOOST_REQUIRE(cs.size() == N_INTERESTS * N_CHILDREN);
time::microseconds d = timedRun([&] {
for (size_t j = 0; j < REPEAT; ++j) {
for (const auto& interest : interestWorkload) {
find(*interest);
}
}
});
std::cout << "find(rightmost) " << (N_INTERESTS * N_CHILDREN * REPEAT) << ": " << d << std::endl;
}
BOOST_AUTO_TEST_CASE_TEMPLATE(PublisherKeySelector2, T, InMemoryStorages)
{
T ims;
Name name("/insert/withkey");
shared_ptr<Data> data = makeData(name);
ims.insert(*data);
Name name2("/insert/withkey2");
shared_ptr<Data> data2 = make_shared<Data>(name2);
Name keyName("/somewhere/key");
const ndn::KeyLocator locator(keyName);
ndn::SignatureSha256WithRsa fakeSignature;
fakeSignature.setValue(makeEmptyBlock(tlv::SignatureValue));
fakeSignature.setKeyLocator(locator);
data2->setSignature(fakeSignature);
data2->wireEncode();
ims.insert(*data2);
shared_ptr<Interest> interest = makeInterest(name2);
interest->setPublisherPublicKeyLocator(locator);
shared_ptr<const Data> found = ims.find(*interest);
BOOST_CHECK(found != nullptr);
BOOST_CHECK_EQUAL(found->getName(), data2->getName());
}
void finish(){
if( likenbut ){
CellCardImpl* host = dynamic_cast<CellCardImpl*>(parent_deck.lookup_cell_card( likeness_cell_n ));
if(host->likenbut){
host->finish(); // infinite recursion if cells are circularly defined... but our users wouldn't do that, right?
}
geom = host->geom;
universe = host->universe;
lat_type = host->lat_type;
material = host->material;
rho = host->rho;
importances = host->importances;
if( host->trcl->hasData()){
trcl = host->trcl->clone();
}
if( host->hasFill()){
fill = host->fill->clone();
}
if( host->isLattice()){
lattice = host->lattice->clone();
}
makeData();
likenbut = false;
}
if( lat_type != NONE && lattice == NULL ){
setupLattice();
}
}
BOOST_AUTO_TEST_CASE_TEMPLATE(EraseCanonical, T, InMemoryStorages)
{
T ims;
shared_ptr<Data> data = makeData("/a");
ims.insert(*data);
shared_ptr<Data> data2 = makeData("/b");
ims.insert(*data2);
shared_ptr<Data> data3 = makeData("/c");
ims.insert(*data3);
shared_ptr<Data> data4 = makeData("/d");
ims.insert(*data4);
shared_ptr<Data> data5 = makeData("/c/c/1/2/3/4/5/6");
ims.insert(*data5);
shared_ptr<Data> data6 = makeData("/c/c/1/2/3");
ims.insert(*data6);
shared_ptr<Data> data7 = makeData("/c/c/1");
ims.insert(*data7);
ndn::ConstBufferPtr digest1 = ndn::crypto::computeSha256Digest(data->wireEncode().wire(),
data->wireEncode().size());
Name name("/a");
ims.erase(name);
BOOST_CHECK_EQUAL(ims.size(), 6);
}
BOOST_AUTO_TEST_CASE_TEMPLATE(InsertCanonical, T, InMemoryStorages)
{
T ims;
shared_ptr<Data> data = makeData("/a");
ims.insert(*data);
shared_ptr<Data> data2 = makeData("/b");
ims.insert(*data2);
shared_ptr<Data> data3 = makeData("/c");
ims.insert(*data3);
shared_ptr<Data> data4 = makeData("/d");
ims.insert(*data4);
shared_ptr<Data> data5 = makeData("/c/c/1/2/3/4/5/6");
ims.insert(*data5);
shared_ptr<Data> data6 = makeData("/c/c/1/2/3");
ims.insert(*data6);
shared_ptr<Data> data7 = makeData("/c/c/1");
ims.insert(*data7);
// avoid "test case [...] did not check any assertions" message from Boost.Test
BOOST_CHECK(true);
}
BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndEraseByPrefix, T, InMemoryStorages)
{
T ims;
shared_ptr<Data> data = makeData("/a");
ims.insert(*data);
shared_ptr<Data> data2 = makeData("/b");
ims.insert(*data2);
shared_ptr<Data> data3 = makeData("/c");
ims.insert(*data3);
shared_ptr<Data> data4 = makeData("/d");
ims.insert(*data4);
shared_ptr<Data> data5 = makeData("/c/c/1/2/3/4/5/6");
ims.insert(*data5);
shared_ptr<Data> data6 = makeData("/c/c/1/2/3");
ims.insert(*data6);
shared_ptr<Data> data7 = makeData("/c/c/1");
ims.insert(*data7);
BOOST_CHECK_EQUAL(ims.size(), 7);
Name name("/c");
ims.erase(name);
BOOST_CHECK_EQUAL(ims.size(), 3);
BOOST_CHECK_EQUAL(ims.getCapacity(), 5);
}
//
// ::doFormat_u
//
void doFormat_u(ObjectVector *objects, FormatData &data)
{
switch(data.len)
{
case FL_L:
case FL_LL:
case FL_MAX:
makeData(objects, data);
makeExpr(objects, VariableType::get_bt_uns_ll());
objects->addToken(OCODE_JMP_CAL_NIL_IMM, objects->getValue("__Print_lu"));
break;
default:
makeData(objects, data);
makeExpr(objects, VariableType::get_bt_uns());
objects->addToken(OCODE_JMP_CAL_NIL_IMM, objects->getValue("__Print_u"));
break;
}
}
static std::vector<shared_ptr<Data>>
makeDataWorkload(size_t count, const NameGenerator& genName = SimpleNameGenerator())
{
std::vector<shared_ptr<Data>> workload(count);
for (size_t i = 0; i < count; ++i) {
Name name = genName(i);
workload[i] = makeData(name);
}
return workload;
}
BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndNotFindByFullName, T, InMemoryStorages)
{
T ims;
Name name("/a");
uint32_t content1 = 1;
shared_ptr<Data> data1 = makeData(name);
data1->setContent(reinterpret_cast<const uint8_t*>(&content1), sizeof(content1));
signData(data1);
ims.insert(*data1);
uint32_t content2 = 2;
shared_ptr<Data> data2 = makeData(name);
data2->setContent(reinterpret_cast<const uint8_t*>(&content2), sizeof(content2));
signData(data2);
shared_ptr<const Data> found = ims.find(data2->getFullName());
BOOST_CHECK(found == nullptr);
}
BOOST_AUTO_TEST_CASE_TEMPLATE(FaceScopePolicy, T, FaceScopePolicyTests)
{
setPolicy<typename T::PolicyType>();
auto face1 = make_shared<DummyFace>("dummy://", "dummy://",
ndn::nfd::FACE_SCOPE_LOCAL);
forwarder.addFace(face1);
shared_ptr<Data> data1 = makeData("/unsolicited-from-local");
forwarder.onIncomingData(*face1, *data1);
BOOST_CHECK_EQUAL(isInCs(*data1), T::ShouldAdmitLocal::value);
auto face2 = make_shared<DummyFace>("dummy://", "dummy://",
ndn::nfd::FACE_SCOPE_NON_LOCAL);
forwarder.addFace(face2);
shared_ptr<Data> data2 = makeData("/unsolicited-from-non-local");
forwarder.onIncomingData(*face2, *data2);
BOOST_CHECK_EQUAL(isInCs(*data2), T::ShouldAdmitNonLocal::value);
}
void ComplexCounter::getBlockMetainfo( _2Real::bundle::BlockMetainfo &info, _2Real::bundle::TypeMetainfoCollection const& types )
{
_2Real::bundle::BlockMetainfo &counterinfo = dynamic_cast< _2Real::bundle::BlockMetainfo & >( info );
auto simpleInfo = std::static_pointer_cast< const _2Real::bundle::CustomTypeMetainfo >( types.getTypeMetainfo( "simpleType" ) );
auto complexInfo = std::static_pointer_cast< const _2Real::bundle::CustomTypeMetainfo >( types.getTypeMetainfo( "complexType" ) );
counterinfo.setBlockClass< ComplexCounter >();
counterinfo.setDescription( "counter" );
_2Real::bundle::UpdatePolicyMetainfo policy = counterinfo.getUpdatePolicyMetainfo();
policy.set( _2Real::DefaultUpdatePolicy::ANY );
_2Real::bundle::InletMetainfo in = counterinfo.getInletMetainfo( "increment" );
in.setDescription( "counter increment" );
in.setDatatypeAndInitialValue( simpleInfo->makeData() );
_2Real::bundle::InletMetainfo stringy = counterinfo.getInletMetainfo( "stringy" );
stringy.setDescription( "test string inlet" );
stringy.setDatatypeAndInitialValue( std::string( "yay" ) );
_2Real::bundle::InletMetainfo multi = counterinfo.getInletMetainfo( "multi" );
multi.setDescription( "test multi inlet" );
multi.setDatatypeAndInitialValue( ( uint32_t )0 );
_2Real::bundle::ParameterMetainfo param = counterinfo.getParameterMetainfo( "init" );
param.setDescription( "counter initial value" );
param.setDatatypeAndInitialValue( complexInfo->makeData() );
_2Real::bundle::OutletMetainfo out = counterinfo.getOutletMetainfo( "value" );
out.setDescription( "counter current value" );
out.setDatatypeAndInitialValue( complexInfo->makeData() );
_2Real::bundle::OutletMetainfo msg = counterinfo.getOutletMetainfo( "msg" );
msg.setDescription( "a test message" );
msg.setDatatypeAndInitialValue( std::string( "NARF" ) );
_2Real::bundle::OutletMetainfo test = counterinfo.getOutletMetainfo( "test" );
test.setDescription( "a test int" );
test.setDatatypeAndInitialValue( (uint32_t)0 );
}
BOOST_AUTO_TEST_CASE_TEMPLATE(ChildSelector, T, InMemoryStorages)
{
T ims;
shared_ptr<Data> data = makeData("/a");
ims.insert(*data);
shared_ptr<Data> data2 = makeData("/b");
ims.insert(*data2);
shared_ptr<Data> data4 = makeData("/d");
ims.insert(*data4);
shared_ptr<Data> data5 = makeData("/c/c");
ims.insert(*data5);
shared_ptr<Data> data6 = makeData("/c/f");
ims.insert(*data6);
shared_ptr<Data> data7 = makeData("/c/n");
ims.insert(*data7);
shared_ptr<Interest> interest = makeInterest("/c");
interest->setChildSelector(1);
shared_ptr<const Data> found = ims.find(*interest);
BOOST_CHECK_EQUAL(found->getName(), "/c/n");
shared_ptr<Interest> interest2 = makeInterest("/c");
interest2->setChildSelector(0);
shared_ptr<const Data> found2 = ims.find(*interest2);
BOOST_CHECK_EQUAL(found2->getName(), "/c/c");
}
BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndNotFindByName, T, InMemoryStorages)
{
T ims;
Name name("/insert/and/find");
shared_ptr<Data> data = makeData(name);
ims.insert(*data);
Name name2("/not/find");
shared_ptr<const Data> found = ims.find(name2);
BOOST_CHECK(found == nullptr);
}
int main(int argc,char *argv[])
{
int test = 1;
Partio::ParticlesDataMutable* foo=makeData();
{
testCloneParticleFixedAttributes(foo, test);
testCloneParticleDataAttributes(foo, test);
}
foo->release();
return 0;
}
BOOST_AUTO_TEST_CASE_TEMPLATE(ChildSelector2, T, InMemoryStorages)
{
T ims;
shared_ptr<Data> data = makeData("/a/b/1");
ims.insert(*data);
shared_ptr<Data> data2 = makeData("/a/b/2");
ims.insert(*data2);
shared_ptr<Data> data3 = makeData("/a/z/1");
ims.insert(*data3);
shared_ptr<Data> data4 = makeData("/a/z/2");
ims.insert(*data4);
shared_ptr<Interest> interest = makeInterest("/a");
interest->setChildSelector(1);
shared_ptr<const Data> found = ims.find(*interest);
BOOST_CHECK_EQUAL(found->getName(), "/a/z/1");
}
BOOST_AUTO_TEST_CASE_TEMPLATE(ExcludeSelector, T, InMemoryStorages)
{
T ims;
shared_ptr<Data> data = makeData("/a");
ims.insert(*data);
shared_ptr<Data> data2 = makeData("/b");
ims.insert(*data2);
shared_ptr<Data> data3 = makeData("/c/a");
ims.insert(*data3);
shared_ptr<Data> data4 = makeData("/d");
ims.insert(*data4);
shared_ptr<Data> data5 = makeData("/c/c");
ims.insert(*data5);
shared_ptr<Data> data6 = makeData("/c/f");
ims.insert(*data6);
shared_ptr<Data> data7 = makeData("/c/n");
ims.insert(*data7);
shared_ptr<Interest> interest = makeInterest("/c");
interest->setChildSelector(1);
Exclude e;
e.excludeOne (Name::Component("n"));
interest->setExclude(e);
shared_ptr<const Data> found = ims.find(*interest);
BOOST_CHECK_EQUAL(found->getName(), "/c/f");
shared_ptr<Interest> interest2 = makeInterest("/c");
interest2->setChildSelector(0);
Exclude e2;
e2.excludeOne (Name::Component("a"));
interest2->setExclude(e2);
shared_ptr<const Data> found2 = ims.find(*interest2);
BOOST_CHECK_EQUAL(found2->getName(), "/c/c");
shared_ptr<Interest> interest3 = makeInterest("/c");
interest3->setChildSelector(0);
Exclude e3;
e3.excludeOne (Name::Component("c"));
interest3->setExclude(e3);
shared_ptr<const Data> found3 = ims.find(*interest3);
BOOST_CHECK_EQUAL(found3->getName(), "/c/a");
}
BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndEvict, T, InMemoryStoragesLimited)
{
T ims(2);
Name name("/insert/1");
shared_ptr<Data> data = makeData(name);
ims.insert(*data);
Name name2("/insert/2");
shared_ptr<Data> data2 = makeData(name2);
ims.insert(*data2);
Name name3("/insert/3");
shared_ptr<Data> data3 = makeData(name3);
ims.insert(*data3);
BOOST_CHECK_EQUAL(ims.size(), 2);
shared_ptr<Interest> interest = makeInterest(name);
shared_ptr<const Data> found = ims.find(*interest);
BOOST_CHECK(found == nullptr);
}
Name
insert(uint32_t id, const Name& name,
const time::milliseconds& freshWindow = InMemoryStorage::INFINITE_WINDOW)
{
shared_ptr<Data> data = makeData(name);
data->setFreshnessPeriod(time::milliseconds(99999));
data->setContent(reinterpret_cast<const uint8_t*>(&id), sizeof(id));
signData(data);
m_ims.insert(*data, freshWindow);
return data->getFullName();
}
BOOST_AUTO_TEST_CASE_TEMPLATE(InsertAndFindByFullName, T, InMemoryStorages)
{
T ims;
Name name("/insert/and/find");
shared_ptr<Data> data = makeData(name);
ims.insert(*data);
shared_ptr<const Data> found = ims.find(data->getFullName());
BOOST_CHECK(found != nullptr);
BOOST_CHECK_EQUAL(data->getFullName(), found->getFullName());
}
static void testKnnSmooth() {
const int trace = 0;
unsigned nObs;
unsigned nDims;
double *inputsP;
double *targetsP;
makeData(&nObs, &nDims, &inputsP, &targetsP);
// smooth each target for k == 1
{
const unsigned k = 1;
double expected[] = {0.0, 1.0, 2.0, 3.0};
for (unsigned queryIndex = 0; queryIndex < nObs; queryIndex++) {
double estimate =
Knn_smooth(nObs, nDims,
inputsP, targetsP,
k, queryIndex);
if (trace) printf("queryIndex=%u\n", queryIndex);
EXPECT_EQ_DOUBLE(expected[queryIndex], estimate, 1e-10);
}
}
// smooth each target for k == 2
{
const unsigned k = 2;
double expected[] = {0.5, 0.5, 1.5, 2.5};
for (unsigned queryIndex = 0; queryIndex < nObs; queryIndex++) {
double estimate =
Knn_smooth(nObs, nDims,
inputsP, targetsP,
k, queryIndex);
if (trace) printf("queryIndex=%u\n", queryIndex);
EXPECT_EQ_DOUBLE(expected[queryIndex], estimate, 1e-10);
}
}
// smooth each target for k == 3
{
const unsigned k = 3;
double expected[] = {1.0, 1.0, 2.0, 2.0};
for (unsigned queryIndex = 0; queryIndex < nObs; queryIndex++) {
double estimate =
Knn_smooth(nObs, nDims,
inputsP, targetsP,
k, queryIndex);
if (trace) printf("queryIndex=%u\n", queryIndex);
EXPECT_EQ_DOUBLE(expected[queryIndex], estimate, 1e-10);
}
}
}
BOOST_AUTO_TEST_CASE_TEMPLATE(ImplicitDigestSelector, T, InMemoryStorages)
{
T ims;
Name name("/digest/works");
shared_ptr<Data> data = makeData(name);
ims.insert(*data);
shared_ptr<Data> data2 = makeData("/a");
ims.insert(*data2);
shared_ptr<Data> data3 = makeData("/z/z/z");
ims.insert(*data3);
ndn::ConstBufferPtr digest1 = ndn::crypto::computeSha256Digest(data->wireEncode().wire(),
data->wireEncode().size());
shared_ptr<Interest> interest = makeInterest("");
interest->setName(Name(name).appendImplicitSha256Digest(digest1->buf(), digest1->size()));
interest->setMinSuffixComponents(0);
interest->setMaxSuffixComponents(0);
shared_ptr<const Data> found = ims.find(*interest);
BOOST_REQUIRE(found != nullptr);
BOOST_CHECK_EQUAL(found->getName(), name);
shared_ptr<Interest> interest2 = makeInterest("");
uint8_t digest2[32] = {0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1};
interest2->setName(Name(name).appendImplicitSha256Digest(digest2, 32));
interest2->setMinSuffixComponents(0);
interest2->setMaxSuffixComponents(0);
shared_ptr<const Data> notfound = ims.find(*interest2);
BOOST_CHECK(notfound == nullptr);
}
