void testNoDefaultConstructor() { Deque<NoDefaultConstructor> deque; deque.reserve(8); for(int i = 0; i < 5; ++i) { deque.push_back(NoDefaultConstructor(i)); SINVARIANT(deque.back().v == i); SINVARIANT(deque.size() == static_cast<size_t>(i + 1)); INVARIANT(NoDefaultConstructor::ndc_count == i + 1, format("%d != %d + 1") % NoDefaultConstructor::ndc_count % i); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.front().v == i); deque.pop_front(); deque.push_back(NoDefaultConstructor(i)); SINVARIANT(deque.back().v == i); SINVARIANT(deque.size() == 5); SINVARIANT(NoDefaultConstructor::ndc_count == 5); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.front().v == i); deque.pop_front(); SINVARIANT(deque.size() == static_cast<size_t>(4 - i)); SINVARIANT(NoDefaultConstructor::ndc_count == 4 - i); } SINVARIANT(NoDefaultConstructor::ndc_count == 0); }
void testPushBack() { Deque<int> deque; SINVARIANT(deque.empty()); deque.reserve(8); SINVARIANT(deque.empty() && deque.capacity() == 8); for(int i = 0; i < 5; ++i) { deque.push_back(i); SINVARIANT(deque.back() == i); SINVARIANT(deque.size() == static_cast<size_t>(i + 1)); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.at(i) == i); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.front() == i); deque.pop_front(); deque.push_back(i); SINVARIANT(deque.back() == i); SINVARIANT(deque.size() == 5); } for(int i = 0; i < 5; ++i) { SINVARIANT(deque.at(i) == i); } { Deque<int>::iterator i = deque.begin(); int j = 0; while(i != deque.end()) { INVARIANT(*i == j, format("%d != %d") % *i % j); ++i; ++j; } } vector<int> avec; for(int i = 5; i < 10; ++i) { avec.push_back(i); } deque.push_back(avec); for(int i = 0; i < 10; ++i) { SINVARIANT(deque.front() == i); deque.pop_front(); } SINVARIANT(deque.empty()); }
void update(int64_t packet_raw, int packet_size, const Int64TimeField &packet_at, const string &filename) { LintelLogDebug("IPRolling::packet", format("UPD %d %d") % packet_raw % packet_size); if (!packets_in_flight.empty()) { int64_t cur_back_ts_raw = packets_in_flight.back().timestamp_raw; INVARIANT(packet_raw >= cur_back_ts_raw, format("out of order by %.4fs in %s; %d < %d") % packet_at.rawToDoubleSeconds(cur_back_ts_raw - packet_raw) % filename % packet_raw % cur_back_ts_raw); } while ((packet_raw - cur_time_raw) > interval_width_raw) { // update statistics for the interval from cur_time to cur_time + interval_width // all packets in p_i_f must have been received in that interval double bw = cur_bytes_in_queue * MiB_per_second_convert; MiB_per_second.add(bw); double pps = packets_in_flight.size() * kpackets_per_second_convert; kpackets_per_second.add(pps); LintelLogDebug("IPRolling::detail", format("[%d..%d[: %.0f, %d -> %.6g %.6g") % cur_time_raw % (cur_time_raw + update_step_raw) % cur_bytes_in_queue % packets_in_flight.size() % bw % pps); cur_time_raw += update_step_raw; while (! packets_in_flight.empty() && packets_in_flight.front().timestamp_raw < cur_time_raw) { cur_bytes_in_queue -= packets_in_flight.front().packetsize; packets_in_flight.pop_front(); } } packets_in_flight.push_back(packetTimeSize(packet_raw, packet_size)); cur_bytes_in_queue += packet_size; }
TEST(Deque, dont_try_suicide) { Deque d; d.push_front(1); d = d; CHECK(1 == d.pop_front()); }
TEST(EmptyDequeTest, Random) { std::deque<int> control; Deque<int> deque; for (size_t i = 0; i < CHUNK_COUNT; ++i) { clock_t time = clock(); for (size_t c = 0; c < CHUNK_SIZE; ++c) { int operand = rand(); switch (rand() % 4) { case 0: deque.push_back(operand); control.push_back(operand); break; case 1: deque.push_front(operand); control.push_front(operand); break; case 2: if (control.size() == 0) { break; } EXPECT_EQ(deque.pop_front(), control.front()); control.pop_front(); break; case 3: if (control.size() == 0) { break; } EXPECT_EQ(deque.pop_back(), control.back()); control.pop_back(); break; } } std::cout << clock() - time << std::endl; } }
TEST(Deque, pop_front) { Deque d; d.push_front(0); CHECK(1 == d.size()); CHECK(0 == d.pop_front()); CHECK(0 == d.size()); }
TEST(Deque, copy_construction) { Deque d; d.push_front(1); Deque d2 = d; d.pop_front(); CHECK(1 == d2.pop_front()); }
TEST(Deque, assignment_operator) { Deque d; d.push_front(1); Deque d2; d2 = d; d.pop_front(); CHECK(1 == d2.pop_front()); }
int main() { cout << "It runs!" << endl; //create a stack & show it works Stack<int> s; s.pop(); s.print(); cout<<"Empty? "<<s.empty()<<endl; cout<<s.size()<<endl; for(int i=0; i<10; i++) { s.push(2*i+1); s.print(); cout<<s.size()<<endl<<endl; } cout<<"Empty? "<<s.empty()<<endl; cout<<"The top is "<<(s.top())<<endl; for(int i=0; i<12; i++) { s.pop(); s.print(); } cout<<"The top is "<<(s.top())<<endl; //create a queue & show it works Queue<int> q; q.print(); cout<<"Empty? "<<q.empty()<<endl; cout<<q.size()<<endl; for(int i=0; i<10; i++) { q.push(2*i+1); q.print(); cout<<q.size()<<endl<<endl; } cout<<"Empty? "<<q.empty()<<endl; cout<<"The front is "<<(q.front())<<endl; cout<<"The rear is "<<(q.back())<<endl; for(int i=0; i<12; i++) { q.pop(); q.print(); } cout<<"The front is "<<(q.front())<<endl; cout<<"The rear is "<<(q.back())<<endl; Deque<int> d; d.print(); for(int i=0; i<10; i++) { d.push_back(i); d.print(); } for(int i=0; i<10; i++) { if(i%2==0) {cout<<"back"<<endl; d.pop_back();} else{cout<<"front"<<endl; d.pop_front();} d.print(); } }
TEST (Deque, double_test) { Deque<double> d; d.push_front(0.1); d.push_back(1.1); d.push_back(2.1); d.push_back(3.1); CHECK ( 4 == d.size() ); CHECK ( 0.1 == d.pop_front() ); CHECK ( 3.1 == d.pop_back() ); }
TEST(Deque, doit) { Deque d; d.push_front(0); d.push_back(1); d.push_back(2); d.push_back(3); CHECK(4 == d.size()); CHECK(0 == d.pop_front()); CHECK(3 == d.pop_back()); }
int main(){ Deque *d = new Deque(); d->push_front(1); d->push_back(2); d->push_back(3); d->push_front(0); d->pop_front(); d->pop_back(); d->print(); delete d; return 0; }
// verify that the destructor is called on pop_front. void testDestroy() { Deque<Thing> things; for(uint32_t i = 0; i < 10; ++i) { INVARIANT(Thing::thing_count == i, format("%d != %d") % Thing::thing_count % i); things.push_back(Thing()); } for(uint32_t i = 0; i < 10; ++i) { SINVARIANT(Thing::thing_count == (10-i)); things.pop_front(); } SINVARIANT(Thing::thing_count == 0); }
void HyperDijkstra::visitAdjacencyMap(AdjacencyMap& amap, TreeAction* action, bool useDistance) { typedef std::deque<HyperGraph::Vertex*> Deque; Deque q; // scans for the vertices without the parent (whcih are the roots of the trees) and applies the action to them. for (AdjacencyMap::iterator it=amap.begin(); it!=amap.end(); ++it) { AdjacencyMapEntry& entry(it->second); if (! entry.parent()) { action->perform(it->first,0,0); q.push_back(it->first); } } //std::cerr << "q.size()" << q.size() << endl; int count=0; while (! q.empty()) { HyperGraph::Vertex* parent=q.front(); q.pop_front(); ++count; AdjacencyMap::iterator parentIt=amap.find(parent); if (parentIt==amap.end()) { continue; } //cerr << "parent= " << parent << " parent id= " << parent->id() << "\t children id ="; HyperGraph::VertexSet& childs(parentIt->second.children()); for (HyperGraph::VertexSet::iterator childsIt=childs.begin(); childsIt!=childs.end(); ++childsIt) { HyperGraph::Vertex* child=*childsIt; //cerr << child->id(); AdjacencyMap::iterator adjacencyIt=amap.find(child); assert (adjacencyIt!=amap.end()); HyperGraph::Edge* edge=adjacencyIt->second.edge(); assert(adjacencyIt->first==child); assert(adjacencyIt->second.child()==child); assert(adjacencyIt->second.parent()==parent); if (! useDistance) { action->perform(child, parent, edge); } else { action->perform(child, parent, edge, adjacencyIt->second.distance()); } q.push_back(child); } //cerr << endl; } }
void ConvertPaletted::run(const Vector<SharedPtr<Option>>& arguments) { if (arguments.size() == 1) { StringBuffer sb; sb << "wrong number of arguments" << EndOfLine; throw RuntimeError(sb.str()); } SDL_Init(0); IMG_Init(IMG_INIT_PNG); Deque<String> queue; RegexFilter filter("^(?:.*" REGEX_DIRSEP ")?(?:tris|tile)[0-9]+\\.bmp$"); /// @todo Do *not* assume the path is relative. Ensure that it is absolute by a system function. for (const auto& argument : arguments) { if (argument->getType() != Option::Type::UnnamedValue) { StringBuffer sb; sb << "unrecognized argument" << EndOfLine; throw RuntimeError(sb.str()); } auto pathnameArgument = static_pointer_cast<UnnamedValue>(argument); queue.emplace_back(FileSystem::sanitize(pathnameArgument->getValue())); } while (!queue.empty()) { String path = queue[0]; queue.pop_front(); switch (FileSystem::stat(path)) { case FileSystem::PathStat::File: if (filter(path)) { convert(path); } break; case FileSystem::PathStat::Directory: FileSystem::recurDir(path, queue); break; case FileSystem::PathStat::Failure: break; // stat complains default: { StringBuffer sb; sb << "skipping '" << path << "' - not a file or directory" << EndOfLine; cerr << sb.str(); } } } IMG_Quit(); SDL_Quit(); }
//--------------------Linear solution---------------------- void minimumValues(int v[], int k) { Deque<int> d = Deque<int>(); // In the queue I store positions, no elements for (int i = 0; i < N; i++) { if (i >= k) // Until we have not consider a subarray, we can not print the minimums. cout << v[d.front()] << " "; while (!d.empty() && v[d.back()] >= v[i]) { // While the queue is not empty and the element I want to insert is // greater or equal than the last one I extract the last element d.pop_back(); } d.push_back(i); // I insert the new element if (d.front() <= i - k) //This remove the minimum once is out of the subarray d.pop_front(); } cout << v[d.front()] << endl; }
int main() { #if 0 CString cstr; cstr.init("abc"); cstr.print(); printf("\n"); Deque<CString> deque; deque.init(); deque.push_back(cstr); CString ps; ps = "102"; cstr.init("def"); deque.push_back(cstr); deque.print(); deque.back(0, ps); ps.print(); printf("\n"); #endif #if 1 setlocale(LC_ALL, ""); initscr(); keypad(stdscr,true); curs_set(0); // KEY_UP // KEY_DOWN //Deque<string> deque; Deque<CString> deque; deque.init(); move(0,0); int fail_time=1; while(1) { char str[128]; getstr(str); move(0,0); //std::string s(str); CString s; s.init(str); if (deque.push_back(s) == false) { mvprintw(20, 0, "push back fail ## %d", fail_time++); deque.pop_front(); deque.push_back(s); } deque.print(); int index=0; noecho(); //string ps; CString ps; while(1) { mvprintw(17, 0, "index: %d", index); refresh(); int ch = getch(); switch(ch) { case KEY_UP: { ++index; if (deque.back(index, ps) == true) { mvprintw(0, 15, "%s", ps.c_str()); } else --index; break; } case KEY_DOWN: { --index; if (deque.back(index, ps) == true) { mvprintw(0, 15, "%s", ps.c_str()); } else { //mvprintw(17, 5, "back fail"); ++index; } break; } case 'q': { goto end; } default: { ungetch(ch); move(0, 0); goto outer; break; } } mvprintw(17, 0, "index: %d", index); refresh(); } outer: echo(); } end: endwin(); #endif return 0; }
void test_deque() { const size_t SIZE = 10; Deque<int, SIZE> deque; cout << "--> testing push_back..." << endl; for (size_t i = 0; i < SIZE; i++) { try { deque.push_back(i); } catch (std::overflow_error &e) { cout << "i: " << i << endl; cout << e.what() << endl; } } deque.traverse(print); cout << endl; cout << "size: " << deque.size() << endl; deque.print_mark(); cout << "--> testing pop_back..." << endl; while (!deque.empty()) { deque.pop_back(); } deque.traverse(print); cout << endl; cout << "size: " << deque.size() << endl; deque.print_mark(); cout << "--> testing push_front..." << endl; for (size_t i = 0; i < SIZE; i++) { try { deque.push_front(i); } catch (std::overflow_error &e) { cout << "i: " << i << endl; cout << e.what() << endl; } } deque.traverse(print); cout << endl; cout << "size: " << deque.size() << endl; deque.print_mark(); cout << "--> testing pop_front..." << endl; while (!deque.empty()) { deque.pop_front(); } deque.traverse(print); cout << endl; cout << "size: " << deque.size() << endl; deque.print_mark(); }
void testIteratorOperations() { Deque<int> deque; MersenneTwisterRandom rng; int n_ops = rng.randInt(100); for (int i = 0; i < n_ops; ++i) { if (rng.randInt(10) < 3 && !deque.empty()) { deque.pop_front(); } else { deque.push_back(rng.randInt()); } } // Test iterator unary operators { for (Deque<int>::iterator it = deque.begin(); it != deque.end(); ) { Deque<int>::iterator it1 = it; Deque<int>::iterator it2 = it; SINVARIANT(it1 == it2); Deque<int>::iterator it3 = it1++; INVARIANT(it3 == it && it3 != it1 && it1 != it2, "return unchanged && return different from iterator && iterator changed"); Deque<int>::iterator it4 = ++it2; INVARIANT(it4 != it && it4 == it1 && it2 == it1, "return changed && return == updated && two updates same"); it = it4; } } // Test distance operators Deque<int>::iterator it_forward = deque.begin(); Deque<int>::iterator it_backward = deque.end(); ptrdiff_t dist_from_start = 0; // start can be .begin() or .end() ptrdiff_t dist_from_finish = deque.end() - deque.begin(); // finish can be .end() or .begin() for (; it_forward != deque.end(); ++dist_from_start, --dist_from_finish) { SINVARIANT(it_backward - it_forward == dist_from_finish - dist_from_start); SINVARIANT(it_forward + dist_from_finish == deque.end()); SINVARIANT(it_backward - dist_from_finish == deque.begin()); SINVARIANT((it_forward < it_backward) == (dist_from_start < dist_from_finish)); SINVARIANT((it_forward <= it_backward) == (dist_from_start <= dist_from_finish)); SINVARIANT((it_forward > it_backward) == (dist_from_start > dist_from_finish)); SINVARIANT((it_forward >= it_backward) == (dist_from_start >= dist_from_finish)); Deque<int>::iterator temp_a(it_forward); Deque<int>::iterator temp_b; temp_b = it_backward; SINVARIANT(temp_b - temp_a == dist_from_finish - dist_from_start); temp_a += dist_from_finish; SINVARIANT(temp_a == deque.end()); temp_b -= dist_from_finish; SINVARIANT(temp_b == deque.begin()); if (rng.randBool()) { // Exercise both variants of the increment/decrement operators ++it_forward; --it_backward; } else { it_forward++; it_backward--; } } SINVARIANT(it_backward == deque.begin()); SINVARIANT(static_cast<size_t>(dist_from_start) == deque.size()); SINVARIANT(dist_from_finish == 0); }
void DequeTest() { Deque<int> testq; Deque<int> testBad(256); for(int i=0;i<512;i++) { testBad.push_back(i); } for(int i=0;i<512;i++) { INVARIANT(testBad.empty() == false && testBad.front() == i, "simple test failed?!"); testBad.pop_front(); } // test empty->size1->empty for(int size1=1;size1<2000;size1++) { INVARIANT(testq.empty()==true,"internal"); for(int j=0;j<size1;j++) { testq.push_back(j); INVARIANT(testq.empty()==false,"internal"); } for(int j=0;j<size1;j++) { INVARIANT(testq.empty()==false,"internal"); INVARIANT(testq.front() == j, boost::format("Internal Error: %d/%d") % size1 % j); testq.pop_front(); } INVARIANT(testq.empty()==true,"internal"); } printf("pass empty->full->empty tests\n"); // test empty->size1, size2 add/remove, ->empty for(int size1=1;size1<150;size1++) { for(int size2=1;size2<400;size2++) { INVARIANT(testq.empty()==true,"internal"); for(int j=0;j<size1;j++) { testq.push_back(j); INVARIANT(testq.empty()==false,"internal"); } for(int j=0;j<size2;j++) { INVARIANT(testq.empty()==false,"internal"); INVARIANT(testq.front() == j, boost::format("Internal Error: %d/%d/%d") % size1 % size2 %j); testq.pop_front(); testq.push_back((j+size1)); } for(int j=size2;j<size1+size2;j++) { INVARIANT(testq.empty()==false,"internal"); int t = testq.front(); testq.pop_front(); INVARIANT(t == j, boost::format("Internal Error: %d/%d/%d/%d") % t % size1 % size2 % j); } INVARIANT(testq.empty()==true,"internal"); } } printf("pass partial fill tests\n"); }
int main(int argc, char *argv[]) { Deque *deque; char line[4096]; size_t len; void *data; size_t size; if (argc == 1) { deque = Memory_Deque_create(); } else if (argc == 2 && argv[1][0] != '-') { deque = File_Deque_create(argv[1]); } else { printf("Usage:\n" " test-deque -- use the in-memory deque\n" " test-deque <path> -- use the file-based deque\n" "\n" "Commands:\n" " destroy -- destroy the deque and exit\n" " empty -- report if the deque is empty\n" " size -- print number of elements in the deque\n" " push_back -- add element at the back\n" " push_front -- add element at the front\n" " get_back -- print element at the back\n" " get_front -- print element at the front\n" " pop_back -- remove element at the back\n" " pop_front -- remove element at the front\n"); return 1; } if (deque == NULL) { fprintf(stderr, "Unable to create deque!\n"); exit(1); } while (fgets(line, sizeof(line), stdin) != NULL) { /* Determine length and strip trailing newline character */ len = strlen(line); if (len == 0) break; if (line[len - 1] == '\n') { line[len - 1] = '\0'; len -= 1; } if (strcmp(line, "destroy") == 0) { break; } else if (strcmp(line, "empty") == 0) { printf("empty=%s\n", deque->empty(deque) ? "true" : "false"); } else if (strcmp(line, "size") == 0) { printf("size=%ld\n", (long)deque->size(deque)); } else if (strncmp(line, "push_back ", 10) == 0) { if (!deque->push_back(deque, line + 10, len - 10)) printf("push_back failed!\n"); } else if (strncmp(line, "push_front ", 11) == 0) { if (!deque->push_front(deque, line + 11, len - 11)) printf("push_front failed!\n"); } else if (strcmp(line, "get_back") == 0) { if (!deque->get_back(deque, &data, &size)) printf("get_back failed!\n"); else { fwrite(data, size, 1, stdout); fputc('\n', stdout); } } else if (strcmp(line, "get_front") == 0) { if (!deque->get_front(deque, &data, &size)) printf("get_front failed!\n"); else { fwrite(data, size, 1, stdout); fputc('\n', stdout); } } else if (strcmp(line, "pop_back") == 0) { if (!deque->pop_back(deque)) printf("pop_back failed!\n"); } else if (strcmp(line, "pop_front") == 0) { if (!deque->pop_front(deque)) printf("pop_front failed!\n"); } else { printf("Unrecognized input line: %s!\n", line); } } deque->destroy(deque); return 0; }