void fit_smart_ptr_tests::test_case_make_shared()
{
const fit_smart_ptr<int> ptr1 = smart_make_shared<int>(45);
assert(ptr1.use_count() == 1);
char foo = 45;
const fit_smart_ptr<char> ptr2 = smart_make_shared<char>(foo);
assert(ptr2.use_count() == 1);
const char foo2 = 45;
const auto ptr3 = smart_make_shared<char>(foo2);
assert(ptr3.use_count() == 1);
const auto dummy_ptr1 = smart_make_shared<dummy>();
assert(dummy_ptr1.use_count() == 1);
const auto dummy_ptr2 = smart_make_shared<dummy>(1);
assert(dummy_ptr2.use_count() == 1);
const auto dummy_ptr3 = smart_make_shared<dummy>(1, 3.14);
assert(dummy_ptr3.use_count() == 1);
const auto dummy_ptr4 = smart_make_shared<dummy>(1, 3.14, *dummy_ptr3);
assert(dummy_ptr4.use_count() == 1);
}
void smart_ptr_tests::test_case_move_semantics()
{
smart_ptr<int> ptr(new int(-123));
assert(*ptr == -123);
assert(ptr.use_count() == 1);
auto ptr2 = std::move(ptr);
assert(*ptr2 == -123);
assert(ptr == nullptr);
assert(ptr.use_count() == 0);
assert(ptr2.use_count() == 1);
auto ptr3 = ptr2;
assert(*ptr3 == -123);
assert(ptr3.use_count() == 2);
assert(ptr2.use_count() == 2);
ptr = ptr3;
assert(ptr3.use_count() == 3);
assert(ptr2.use_count() == 3);
assert(ptr.use_count() == 3);
ptr = std::move(ptr3);
assert(ptr3.use_count() == 0);
assert(ptr3 == nullptr);
assert(ptr2.use_count() == 2);
assert(ptr.use_count() == 2);
auto ptr4 = std::move(ptr2);
assert(ptr4.use_count() == 2);
assert(ptr3 == nullptr);
assert(ptr3.use_count() == 0);
assert(ptr2 == nullptr);
assert(ptr2.use_count() == 0);
assert(ptr.use_count() == 2);
}
void remove_k_from_last (List<T>& l, int k)
{
if (k < 0) {
return;
}
auto x = l.head;
auto y = x;
//position y;
while (y && k >= 0) {
y = y->next;
--k;
}
if (!y) {
return;
}
while (y->next) {
x = x->next;
y = y->next;
}
auto a = x->next;
debug(a.use_count());
//remove x->next;
x->next = x->next->next;
debug(a.use_count());
return;
}
void StreamStore::cleanUpStreams()
{
std::lock_guard<std::mutex> guard(this->_mtx);
_log->verbose(1, "Start removing unused streams");
int counter = 0;
for (int i=0; i < this->streams.size(); ++i)
{
auto stream = this->streams.at(i);
_log->info("Checking stream '%v', reference count %v", stream->toString(), stream.use_count());
if (stream.use_count() == 2)
{
_log->info("Remove unused stream '%v'", stream->toString());
++counter;
this->streams.erase(this->streams.begin() + i);
--i;
}
}
_log->info("Clean up information store: '%v' streams are removed", counter);
}
void fit_smart_ptr_tests::test_case_copy_and_assignment()
{
auto ptr1 = smart_make_shared<char>(45);
assert(*ptr1 == 45);
assert(ptr1.use_count() == 1);
fit_smart_ptr<char> ptr2(nullptr);
fit_smart_ptr<char> ptr3(nullptr);
auto ptr4(ptr1);
assert(*ptr4 == 45);
assert(ptr4.use_count() == 2);
assert(ptr1.use_count() == 2);
ptr2 = ptr4;
assert(*ptr2 == 45);
ptr3 = ptr1;
assert(*ptr3 == 45);
*ptr1 = 123;
assert(*ptr2 == 123);
ptr3 = ptr1;
assert(*ptr3 == 123);
// nullptr is r-value so move operator=
ptr4 = fit_smart_ptr<char>(nullptr);
ptr4 = nullptr;
ptr3 = fit_smart_ptr<char>(nullptr);
ptr1 = ptr2 = ptr3;
fit_smart_ptr<char> ptr5 = smart_make_shared<char>(12);
ptr5 = ptr5 = ptr5;
assert(*ptr5 == 12);
}
void LruCacheTest::SyncTryPut(TestCache & cache, wstring const & key, int version, bool expectedSuccess)
{
auto entry = make_shared<TestCacheEntry>(key, version);
auto originalEntry = entry;
bool success = cache.TryPutOrGet(entry);
if (success)
{
VERIFY_IS_TRUE_FMT(entry == originalEntry, "TryPut({0}): {1}, {2}", key, entry.get(), originalEntry.get());
}
else
{
VERIFY_IS_TRUE_FMT(entry != originalEntry, "TryPut({0}): {1}, {2}", key, entry.get(), originalEntry.get());
}
VERIFY_IS_TRUE_FMT(
key == entry->GetKey() && success == expectedSuccess,
"TryPut({0}, {1}): {2}, {3}", key, expectedSuccess, entry->GetKey(), success);
if (expectedSuccess)
{
VERIFY_IS_TRUE_FMT(entry.use_count() == 3, "TryPut({0}) use_count({1}) != 3", key, entry.use_count());
}
}
TEST(SHARED_PTR_CASE, CTOR)
{
shared_ptr<int> intsp(new int(3));
shared_ptr<helpPrint> test1sp(new helpPrint(1,2));
auto test1sp2 = test1sp;
std::cout << "use_count:" << test1sp2.use_count() << std::endl;
}
int main(int argc, char *argv[])
{
// case 2 - initialize with noisy
auto sp = std_compat::shared_ptr<Noisy>(new Noisy());
auto new_sp = std_compat::shared_ptr<Noisy>(new Noisy());
std::cout << new_sp.use_count() << std::endl;
std::cout << sp.use_count() << std::endl;
// assign now
new_sp = sp;
std::cout << new_sp.use_count() << std::endl;
std::cout << sp.use_count() << std::endl;
return 0;
}
TEST(OptionalTest, DtorTest) {
auto val = std::make_shared<int>(292);
leap::optional<std::shared_ptr<int>> optVal;
optVal = val;
ASSERT_EQ(2UL, val.use_count()) << "Value was not copied properly into an optional field";
ASSERT_EQ(292, **optVal) << "Optional value did not point to the correct destination";
optVal = {};
ASSERT_TRUE(val.unique()) << "Optional value did not correctly release resources on destruction";
}
TEST(Variant, MoveCasts) {
{
auto res = unsafe_cast_or_null<DummyResource>(
Variant(makeSmartPtr<DummyResource>()));
EXPECT_NE(res, nullptr);
auto res2 = dyn_cast<DummyResource>(
Variant(makeSmartPtr<DummyResource>()));
EXPECT_NE(res2, nullptr);
auto res3 = dyn_cast<File>(
Variant(makeSmartPtr<DummyResource>()));
EXPECT_EQ(res3, nullptr);
}
{
auto res = unsafe_cast_or_null<c_Vector>(
Variant(makeSmartPtr<c_Vector>()));
EXPECT_NE(res, nullptr);
auto res2 = dyn_cast<c_Vector>(
Variant(makeSmartPtr<c_Vector>()));
EXPECT_NE(res2, nullptr);
auto res3 = dyn_cast<c_Map>(
Variant(makeSmartPtr<c_Vector>()));
EXPECT_EQ(res3, nullptr);
}
{
auto dummy = makeSmartPtr<DummyResource>();
dummy->incRefCount(); // the RefData constructor steals it's input.
auto ref = SmartPtr<RefData>::attach(
RefData::Make(*Variant(dummy).asTypedValue()));
Variant dummyRef(ref);
EXPECT_FALSE(ref->hasExactlyOneRef());
auto res = cast<DummyResource>(dummyRef);
EXPECT_EQ(res, dummy);
}
{
auto dummy = makeSmartPtr<DummyResource>();
dummy->incRefCount(); // the RefData constructor steals it's input.
Variant dummyRef(
SmartPtr<RefData>::attach(RefData::Make(*Variant(dummy).asTypedValue())));
//EXPECT_TRUE(dummyRef.getRefData()->hasExactlyOneRef());
auto res = cast<DummyResource>(std::move(dummyRef));
EXPECT_EQ(res, dummy);
}
{
auto dummy = makeSmartPtr<DummyResource>();
dummy->incRefCount(); // the RefData constructor steals it's input.
auto ref = SmartPtr<RefData>::attach(
RefData::Make(*Variant(dummy).asTypedValue()));
Variant dummyRef(ref.get());
EXPECT_FALSE(ref->hasExactlyOneRef());
auto res = cast<DummyResource>(std::move(dummyRef));
EXPECT_EQ(res, dummy);
EXPECT_TRUE(dummyRef.isNull());
EXPECT_EQ(dummy.use_count(), 2);
}
}
TEST_F(GroupByTests, group_by_scan_using_table_2) {
auto t = io::Loader::shortcuts::load("test/10_30_group.tbl");
{
auto gs = std::make_shared<GroupByScan>();
gs->addInput(t);
gs->addField(0);
auto hs = std::make_shared<HashBuild>();
hs->addInput(t);
hs->addField(0);
hs->setKey("groupby");
auto group_map = hs->execute()->getResultHashTable();
gs->addInput(group_map);
const auto& result = gs->execute()->getResultTable();
ASSERT_EQ(result->size(), t->size());
hyrise::access::GroupByScan gs2;
gs2.addInput(t);
gs2.addField(1);
hyrise::access::HashBuild hs2;
hs2.addInput(t);
hs2.addField(1);
hs2.setKey("groupby");
auto group_map2 = hs2.execute()->getResultHashTable();
gs2.addInput(group_map2);
const auto& result2 = gs2.execute()->getResultTable();
SortScan s;
s.addInput(result2);
s.setSortField(0);
const auto& r2 = s.execute()->getResultTable();
auto reference = io::Loader::shortcuts::load("test/reference/group_by_scan_using_table_2.tbl");
SortScan s2;
s2.addInput(reference);
s2.setSortField(0);
const auto& ref2 = s2.execute()->getResultTable();
ASSERT_TABLE_EQUAL(r2, ref2);
}
ASSERT_EQ(1u, t.use_count());
}
TEST(OptionalTest, PlacementConstruct) {
leap::optional<std::shared_ptr<int>> optVal;
optVal.emplace(new int{ 1001 });
ASSERT_EQ(1001, **optVal) << "Optional value did not correctly placement construct a unique pointer";
auto val = *optVal;
ASSERT_EQ(2UL, val.use_count());
optVal.emplace(new int{ 2001 });
ASSERT_EQ(2001, **optVal) << "Optional value did not take on a new value properly in emplace while holding a value";
ASSERT_TRUE(val.unique()) << "Optional value did not correctly release its existing value on emplace construction";
}
std::shared_ptr<AblLinkWrapper>
AblLinkWrapper::getSharedInstance(double bpm) {
auto ptr = shared_instance.lock();
if (!ptr) {
ptr.reset(new AblLinkWrapper(bpm));
shared_instance = ptr;
} else {
printf("Using existing Link instance with ref count %d.\n", ptr.use_count());
}
return ptr;
}
// Get use count of two shareds pointing to same data
void shared_12()
{
{
assert_ck(0, 0);
auto u0 = shared_test(test_behavior::init());
assert_ck(1, 0);
{
auto u1 = u0;
assert_ck(1, 0);
assert(u0.use_count() == 2);
assert(u1.use_count() == 2);
}
assert_ck(1, 0);
assert(u0.use_count() == 1);
}
assert_ck(1, 1);
}
/// Test that the pool works for enable_shared_from_this objects, even if
/// we do not provide the allocator
TEST(test_shared_pool, enable_shared_from_this)
{
{
recycle::shared_pool<dummy_three> pool;
auto o1 = pool.allocate();
EXPECT_EQ(o1.use_count(), 1);
EXPECT_EQ(dummy_three::m_count, 1);
}
EXPECT_EQ(dummy_three::m_count, 0);
}
void Get(){
manager.add(sysPtr(new TestSystem3(3,1)));
manager.add(sysPtr(new TestSystem1(1,1)));
manager.add(sysPtr(new TestSystem2(2,1)));
EXPECT_EQ(1,manager.systems[0].use_count());
EXPECT_EQ(1,manager.systems[1].use_count());
EXPECT_EQ(1,manager.systems[2].use_count());
auto i = manager.get(1);
EXPECT_EQ(2,i.use_count());
EXPECT_EQ(1,i->id());
auto j = manager.get(2);
EXPECT_EQ(2,j.use_count());
EXPECT_EQ(2,j->id());
auto k = manager.get(3);
EXPECT_EQ(2,k.use_count());
EXPECT_EQ(3,k->id());
//check the shared_ptrs update as expected
manager.update(1.3);
EXPECT_EQ(1,dynamic_cast<TestSystem1*>(i.get())->testVal);
EXPECT_EQ(-1,dynamic_cast<TestSystem2*>(j.get())->testVal);
EXPECT_EQ(1,dynamic_cast<TestSystem3*>(k.get())->testVal);
}
int main()
{
auto sp = cp5::SharedPointer<int>{ new int(42) };
auto sp2 = sp;
std::cout << *sp << std::endl;
std::cout << sp.use_count() << std::endl;
auto string_ptr = cp5::SharedPointer<std::string>{ new std::string{ "Yue" } };
std::cout << *string_ptr << std::endl;
std::cout << string_ptr->size() << std::endl;
return 0;
}
void fit_smart_ptr_tests::test_case_use_count()
{
auto ptr1 = smart_make_shared<char>(45);
assert(ptr1.use_count() == 1);
fit_smart_ptr<char> ptr2(nullptr);
fit_smart_ptr<char> ptr3(nullptr);
auto ptr4(ptr1);
assert(ptr4.use_count() == 2);
assert(ptr3.use_count() == 0);
assert(ptr2.use_count() == 0);
assert(ptr1.use_count() == 2);
ptr2 = ptr4;
assert(ptr4.use_count() == 3);
assert(ptr3.use_count() == 0);
assert(ptr2.use_count() == 3);
assert(ptr1.use_count() == 3);
ptr3 = ptr1;
assert(ptr3.use_count() == 4);
assert(ptr4.use_count() == 4);
assert(ptr2.use_count() == 4);
assert(ptr1.use_count() == 4);
*ptr1 = 123;
assert(ptr3.use_count() == 4);
assert(ptr4.use_count() == 4);
assert(ptr2.use_count() == 4);
assert(ptr1.use_count() == 4);
// testing overloading for nullptr
ptr4 = nullptr;
assert(ptr4.use_count() == 0);
assert(ptr3.use_count() == 3);
assert(ptr2.use_count() == 3);
assert(ptr1.use_count() == 3);
// NULL is r-value so move operator=
ptr3 = fit_smart_ptr<char>(nullptr);
assert(ptr4.use_count() == 0);
assert(ptr3.use_count() == 0);
assert(ptr2.use_count() == 2);
assert(ptr1.use_count() == 2);
ptr1 = ptr2 = ptr3;
assert(ptr4.use_count() == 0);
assert(ptr3.use_count() == 0);
assert(ptr2.use_count() == 0);
assert(ptr1.use_count() == 0);
}
void empty (shapevector* sv){
for (std::shared_ptr<Shape> s : *sv) {
std::cout << "b4 empty, usecount = " << s.use_count() << std::endl;
s.reset();
std::cout << "after empty, usecount = " << s.use_count() << std::endl;
}
for (int i = 0;i<sv->size();i++){
//auto s = dynamic_cast<std::shared_ptr<Shape>*>( sv->pop_back() );
auto s = ( sv->back() );
sv->pop_back();
std::cout << i << " pooped, count= " << s.use_count() << std::endl;
}
}
/**
* @return true if the given client is present in any imaginable local search
*/
bool
RoomManager::ClientIsKnown(const ClientID clientID) const {
std::vector<RoomRef> rooms = GetRooms();
for (auto it=rooms.begin(); it!=rooms.end(); ++it) {
if (it->use_count() > 0) {
const Room* r=it->get();
if(r->GetOccupantList().Contains(clientID)) {
return true;
}
if(r->GetObserverList().Contains(clientID)) {
return true;
}
}
}
return false;
}
~Packet()
{
// keep the object alive
auto local_impl = impl;
// call .reset while this object is still alive
impl.reset();
// if this was the last instance then we recycle it
if (local_impl && local_impl->owner && local_impl.use_count() == 1)
{
impl = local_impl;
impl->recycle_packet(*this);
}
}
void thread_detach_impl(std::shared_ptr<std::mutex> mutexP, size_t& count) {
std::lock_guard<std::mutex> lock(*mutexP);
auto threadExecuted = std::make_shared<bool>(false);
Thread myThread;
myThread.start([threadExecuted, &count, mutex = mutexP]() {
std::lock_guard<std::mutex> lock(*mutex);
*threadExecuted = true;
count = threadExecuted.use_count();
});
BOOST_CHECK(!*threadExecuted);
myThread.detach();
}
TEST_F(AutoConstructTest, CanConstructRvalueCtor) {
auto originalPtr = std::make_shared<int>(555);
// Make a unique pointer to a shared pointer, and pass it in:
{
AutoCreateContext ctxt;
CurrentContextPusher pshr(ctxt);
std::unique_ptr<std::shared_ptr<int>> forwarded{new std::shared_ptr<int>(originalPtr)};
AutoConstruct<CanOnlyAcceptMovedInput> coami(std::move(forwarded));
// Should have the correct number of references, no more and no less
ASSERT_EQ(2UL, originalPtr.use_count()) << "Forwarding unique pointer did not correctly";
}
ASSERT_TRUE(originalPtr.unique()) << "Memory leak detected due to incorrect forwarding of a unique pointer";
}
void AddSystem(){
EXPECT_EQ(0,manager.systems.size());
manager.add(sysPtr(new TestSystem3(3,1)));
manager.add(sysPtr(new TestSystem1(1,1)));
manager.add(sysPtr(new TestSystem2(2,1)));
EXPECT_EQ(3,manager.systems.size());
EXPECT_EQ(1,manager.systems[0]->id());
EXPECT_EQ(1,manager.systems[0]->getPriority());
EXPECT_EQ(2,manager.systems[1]->id());
EXPECT_EQ(2,manager.systems[1]->getPriority());
EXPECT_EQ(3,manager.systems[2]->id());
EXPECT_EQ(3,manager.systems[2]->getPriority());
//make sure copies aren't added
//manager.add(sysPtr(new TestSystem1(1,1)));
//EXPECT_EQ(3,manager.systems.size());
//make sure shared_ptr is operating as expected
EXPECT_EQ(1,manager.systems[0].use_count());
EXPECT_EQ(1,manager.systems[1].use_count());
EXPECT_EQ(1,manager.systems[2].use_count());
auto i = manager.systems[0];
EXPECT_EQ(2,i.use_count());
}
int main()
{
{
boost::local_shared_ptr< int > pi = boost::make_local_shared< int >();
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( *pi == 0 );
}
{
boost::local_shared_ptr< int > pi = boost::make_local_shared_noinit< int >();
BOOST_TEST( pi.get() != 0 );
}
{
boost::local_shared_ptr< int > pi = boost::make_local_shared< int >( 5 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( *pi == 5 );
}
BOOST_TEST( X::instances == 0 );
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >();
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 0 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared_noinit< X >();
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 0 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1+2 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1+2+3 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1+2+3+4 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1+2+3+4+5 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1+2+3+4+5+6 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1+2+3+4+5+6+7 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7, 8 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
{
boost::local_shared_ptr< X > pi = boost::make_local_shared< X >( 1, 2, 3, 4, 5, 6, 7, 8, 9 );
boost::weak_ptr<X> wp( pi );
BOOST_TEST( X::instances == 1 );
BOOST_TEST( pi.get() != 0 );
BOOST_TEST( pi.local_use_count() == 1 );
BOOST_TEST( use_count( pi ) == 1 );
BOOST_TEST( pi->v == 1+2+3+4+5+6+7+8+9 );
pi.reset();
BOOST_TEST( X::instances == 0 );
}
return boost::report_errors();
}
bool unique() const // nothrow
{
return use_count() == 1;
}
inline bool unique() const
{
return use_count() == 1;
}
std::vector<ObservedFile<WinWatchTowerDriver>*> WinWatchTowerDriver::waitAndProcessEvents(
ObservedFileList<WinWatchTowerDriver>* list,
QMutexLocker* lock,
std::vector<ObservedFile<WinWatchTowerDriver>*>* /* not needed in WinWatchTowerDriver */,
int timeout_ms )
{
std::vector<ObservedFile<WinWatchTowerDriver>*> files_to_notify { };
ULONG_PTR key = 0;
DWORD num_bytes = 0;
LPOVERLAPPED lpOverlapped = 0;
if ( timeout_ms == 0 )
timeout_ms = INFINITE;
lock->unlock();
LOG(logDEBUG) << "waitAndProcessEvents now blocking...";
BOOL status = GetQueuedCompletionStatus( hCompPort_,
&num_bytes,
&key,
&lpOverlapped,
timeout_ms );
lock->relock();
LOG(logDEBUG) << "Event (" << status << ") key: " << std::hex << key;
if ( key ) {
// Extract the dir from the completion key
auto dir_record_ptr = dir_records_[key - 1];
LOG(logDEBUG) << "use_count = " << dir_record_ptr.use_count();
if ( std::shared_ptr<WinWatchedDirRecord> dir_record = dir_record_ptr.lock() )
{
LOG(logDEBUG) << "Got event for dir " << dir_record.get();
WinNotificationInfoList notification_info(
dir_record->buffer_,
dir_record->buffer_length_ );
for ( auto notification : notification_info ) {
std::string file_path = dir_record->path_ + shortstringize( notification.fileName() );
LOG(logDEBUG) << "File is " << file_path;
auto file = list->searchByName( file_path );
if ( file )
{
files_to_notify.push_back( file );
}
}
// Re-listen for changes
status = ReadDirectoryChangesW(
dir_record->handle_,
dir_record->buffer_,
dir_record->buffer_length_,
false,
FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE,
&buffer_length_,// not set when using asynchronous mechanisms...
&overlapped_,
NULL ); // no completion routine
}
else {
LOG(logWARNING) << "Looks like our dir_record disappeared!";
}
}
else {
LOG(logDEBUG) << "Signaled";
}
{
QMutexLocker lk( &action_mutex_ );
if ( scheduled_action_ ) {
(*scheduled_action_)();
scheduled_action_ = nullptr;
action_done_cv_.wakeAll();
}
}
/*
// Just in case someone is waiting for an action to complete
QMutexLocker lk( &action_mutex_ );
scheduled_action_ = nullptr;
action_done_cv_.wakeAll();
*/
return files_to_notify;
}
void fit_smart_ptr_tests::test_case_move_semantics()
{
auto ptr = smart_make_shared<char>(-123);
assert(*ptr == -123);
assert(ptr.use_count() == 1);
auto ptr2 = std::move(ptr);
assert(*ptr2 == -123);
assert(ptr == nullptr);
assert(ptr.use_count() == 0);
assert(ptr2.use_count() == 1);
auto ptr3 = ptr2;
assert(*ptr3 == -123);
assert(ptr3.use_count() == 2);
assert(ptr2.use_count() == 2);
ptr = ptr3;
assert(ptr3.use_count() == 3);
assert(ptr2.use_count() == 3);
assert(ptr.use_count() == 3);
ptr = std::move(ptr3);
assert(ptr3.use_count() == 0);
assert(ptr3 == nullptr);
assert(ptr2.use_count() == 2);
assert(ptr.use_count() == 2);
auto ptr4 = std::move(ptr2);
assert(ptr4.use_count() == 2);
assert(ptr3 == nullptr);
assert(ptr3.use_count() == 0);
assert(ptr2 == nullptr);
assert(ptr2.use_count() == 0);
assert(ptr.use_count() == 2);
}
// network -> reliability layer -> protocol decapsulation -> SSL -> app
void up_stack(PACKET& recv)
{
UseCount use_count(up_stack_reentry_level);
if (decapsulate(recv))
up_sequenced();
}
