Skip to content

Commit

Permalink
uncomment folly tests
Browse files Browse the repository at this point in the history
  • Loading branch information
Bechir committed Mar 28, 2024
1 parent 04cbe99 commit d878550
Show file tree
Hide file tree
Showing 2 changed files with 158 additions and 158 deletions.
232 changes: 116 additions & 116 deletions core/test/CircularFifo.test.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,116 +1,116 @@
// #include <catch2/catch_all.hpp>

// #include "aare/CircularFifo.hpp"

// using aare::CircularFifo;

// // Only for testing. To make sure we can avoid copy constructor
// // and copy assignment

// struct MoveOnlyInt {
// int value{};

// MoveOnlyInt() = default;
// MoveOnlyInt(int i) : value(i){};
// MoveOnlyInt(const MoveOnlyInt &) = delete;
// MoveOnlyInt &operator=(const MoveOnlyInt &) = delete;
// MoveOnlyInt(MoveOnlyInt &&other) { std::swap(value, other.value); }
// MoveOnlyInt &operator=(MoveOnlyInt &&other) {
// std::swap(value, other.value);
// return *this;
// }
// bool operator==(int other) const { return value == other; }
// };

// TEST_CASE("CircularFifo can be default constructed") { CircularFifo<MoveOnlyInt> f; }

// TEST_CASE("Newly constructed fifo has the right size") {
// size_t size = 17;
// CircularFifo<MoveOnlyInt> f(size);
// CHECK(f.numFreeSlots() == size);
// CHECK(f.numFilledSlots() == 0);
// }

// TEST_CASE("Can fit size number of objects") {
// size_t size = 8;
// size_t numPushedItems = 0;
// CircularFifo<MoveOnlyInt> f(size);
// for (size_t i = 0; i < size; ++i) {
// MoveOnlyInt a;
// bool popped = f.try_pop_free(a);
// CHECK(popped);
// if (popped) {
// a.value = i;
// bool pushed = f.try_push_value(std::move(a));
// CHECK(pushed);
// if (pushed)
// numPushedItems++;
// }
// }
// CHECK(f.numFreeSlots() == 0);
// CHECK(f.numFilledSlots() == size);
// CHECK(numPushedItems == size);
// }

// TEST_CASE("Push move only type") {
// CircularFifo<MoveOnlyInt> f;
// f.push_value(5);
// }

// TEST_CASE("Push pop") {
// CircularFifo<MoveOnlyInt> f;
// f.push_value(MoveOnlyInt(1));

// auto a = f.pop_value();
// CHECK(a == 1);
// }

// TEST_CASE("Pop free and then push") {
// CircularFifo<MoveOnlyInt> f;

// auto a = f.pop_free();
// a.value = 5;
// f.push_value(std::move(a)); // Explicit move since we can't copy
// auto b = f.pop_value();

// CHECK(a == 0); // Moved from value
// CHECK(b == 5); // Original value
// }

// TEST_CASE("Skip the first value") {
// CircularFifo<MoveOnlyInt> f;

// for (int i = 0; i != 10; ++i) {
// auto a = f.pop_free();
// a.value = i + 1;
// f.push_value(std::move(a)); // Explicit move since we can't copy
// }

// auto b = f.pop_value();
// CHECK(b == 1);
// f.next();
// auto c = f.pop_value();
// CHECK(c == 3);
// }

// TEST_CASE("Use in place and move to free") {
// size_t size = 18;
// CircularFifo<MoveOnlyInt> f(size);

// //Push 10 values to the fifo
// for (int i = 0; i != 10; ++i) {
// auto a = f.pop_free();
// a.value = i + 1;
// f.push_value(std::move(a)); // Explicit move since we can't copy
// }

// auto b = f.frontPtr();
// CHECK(*b == 1);
// CHECK(f.numFilledSlots() == 10);
// CHECK(f.numFreeSlots() == size-10);
// f.next();
// auto c = f.frontPtr();
// CHECK(*c == 2);
// CHECK(f.numFilledSlots() == 9);
// CHECK(f.numFreeSlots() == size-9);
// }
#include <catch2/catch_all.hpp>

#include "aare/CircularFifo.hpp"

using aare::CircularFifo;

// Only for testing. To make sure we can avoid copy constructor
// and copy assignment

struct MoveOnlyInt {
int value{};

MoveOnlyInt() = default;
MoveOnlyInt(int i) : value(i){};
MoveOnlyInt(const MoveOnlyInt &) = delete;
MoveOnlyInt &operator=(const MoveOnlyInt &) = delete;
MoveOnlyInt(MoveOnlyInt &&other) { std::swap(value, other.value); }
MoveOnlyInt &operator=(MoveOnlyInt &&other) {
std::swap(value, other.value);
return *this;
}
bool operator==(int other) const { return value == other; }
};

TEST_CASE("CircularFifo can be default constructed") { CircularFifo<MoveOnlyInt> f; }

TEST_CASE("Newly constructed fifo has the right size") {
size_t size = 17;
CircularFifo<MoveOnlyInt> f(size);
CHECK(f.numFreeSlots() == size);
CHECK(f.numFilledSlots() == 0);
}

TEST_CASE("Can fit size number of objects") {
size_t size = 8;
size_t numPushedItems = 0;
CircularFifo<MoveOnlyInt> f(size);
for (size_t i = 0; i < size; ++i) {
MoveOnlyInt a;
bool popped = f.try_pop_free(a);
CHECK(popped);
if (popped) {
a.value = i;
bool pushed = f.try_push_value(std::move(a));
CHECK(pushed);
if (pushed)
numPushedItems++;
}
}
CHECK(f.numFreeSlots() == 0);
CHECK(f.numFilledSlots() == size);
CHECK(numPushedItems == size);
}

TEST_CASE("Push move only type") {
CircularFifo<MoveOnlyInt> f;
f.push_value(5);
}

TEST_CASE("Push pop") {
CircularFifo<MoveOnlyInt> f;
f.push_value(MoveOnlyInt(1));

auto a = f.pop_value();
CHECK(a == 1);
}

TEST_CASE("Pop free and then push") {
CircularFifo<MoveOnlyInt> f;

auto a = f.pop_free();
a.value = 5;
f.push_value(std::move(a)); // Explicit move since we can't copy
auto b = f.pop_value();

CHECK(a == 0); // Moved from value
CHECK(b == 5); // Original value
}

TEST_CASE("Skip the first value") {
CircularFifo<MoveOnlyInt> f;

for (int i = 0; i != 10; ++i) {
auto a = f.pop_free();
a.value = i + 1;
f.push_value(std::move(a)); // Explicit move since we can't copy
}

auto b = f.pop_value();
CHECK(b == 1);
f.next();
auto c = f.pop_value();
CHECK(c == 3);
}

TEST_CASE("Use in place and move to free") {
size_t size = 18;
CircularFifo<MoveOnlyInt> f(size);

//Push 10 values to the fifo
for (int i = 0; i != 10; ++i) {
auto a = f.pop_free();
a.value = i + 1;
f.push_value(std::move(a)); // Explicit move since we can't copy
}

auto b = f.frontPtr();
CHECK(*b == 1);
CHECK(f.numFilledSlots() == 10);
CHECK(f.numFreeSlots() == size-10);
f.next();
auto c = f.frontPtr();
CHECK(*c == 2);
CHECK(f.numFilledSlots() == 9);
CHECK(f.numFreeSlots() == size-9);
}
84 changes: 42 additions & 42 deletions core/test/ProducerConsumerQueue.test.cpp
View file
Original file line number Diff line number Diff line change
@@ -1,49 +1,49 @@
// #include <catch2/catch_all.hpp>
// #include "aare/ProducerConsumerQueue.hpp"
#include <catch2/catch_all.hpp>
#include "aare/ProducerConsumerQueue.hpp"

// // using arve::SimpleQueue;
// TEST_CASE("push pop"){
// using arve::SimpleQueue;
TEST_CASE("push pop"){

// folly::ProducerConsumerQueue<int> q(5);
// int a = 3;
// int b = 8;
// CHECK(q.sizeGuess() == 0);
// CHECK(q.write(a));
// CHECK(q.sizeGuess() == 1);
// CHECK(q.write(b));
// CHECK(q.sizeGuess() == 2);
// int c = 0;
folly::ProducerConsumerQueue<int> q(5);
int a = 3;
int b = 8;
CHECK(q.sizeGuess() == 0);
CHECK(q.write(a));
CHECK(q.sizeGuess() == 1);
CHECK(q.write(b));
CHECK(q.sizeGuess() == 2);
int c = 0;

// CHECK(q.read(c));
// CHECK(c == 3);
// CHECK(q.sizeGuess() == 1);
// CHECK(q.read(c));
// CHECK(c == 8);
// CHECK(q.sizeGuess() == 0);
// }
CHECK(q.read(c));
CHECK(c == 3);
CHECK(q.sizeGuess() == 1);
CHECK(q.read(c));
CHECK(c == 8);
CHECK(q.sizeGuess() == 0);
}

// TEST_CASE("Cannot push to a full queue"){
// folly::ProducerConsumerQueue<int> q(3);
// int a = 3;
// int b = 4;
// int c = 0;
// CHECK(q.write(a));
// CHECK(q.write(b));
// CHECK_FALSE(q.write(a));
TEST_CASE("Cannot push to a full queue"){
folly::ProducerConsumerQueue<int> q(3);
int a = 3;
int b = 4;
int c = 0;
CHECK(q.write(a));
CHECK(q.write(b));
CHECK_FALSE(q.write(a));

// //values are still ok
// CHECK(q.read(c));
// CHECK(c == 3);
// CHECK(q.read(c));
// CHECK(c == 4);
// }
//values are still ok
CHECK(q.read(c));
CHECK(c == 3);
CHECK(q.read(c));
CHECK(c == 4);
}

// TEST_CASE("Cannot pop from an empty queue"){
// folly::ProducerConsumerQueue<int> q(2);
// int a=0;
// CHECK_FALSE(q.read(a));
// }
TEST_CASE("Cannot pop from an empty queue"){
folly::ProducerConsumerQueue<int> q(2);
int a=0;
CHECK_FALSE(q.read(a));
}

// // TEST_CASE("fail"){
// // CHECK(false);
// // }
// TEST_CASE("fail"){
// CHECK(false);
// }

0 comments on commit d878550

Please sign in to comment.