void test_swap_aquires_both_locks() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<>> queue { 5 }, other { 4 };
	reset_counters();

	queue.swap(other);

	ASSERT_EQUAL(2, single_threaded_test_mutex::lock_count + single_threaded_test_mutex::try_lock_count);
}
void test_full_aquires_lock() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<0, 0>> queue { 5 };
	reset_counters();

	queue.full();

	ASSERT_EQUAL(1, single_threaded_test_mutex::lock_count);
}
void test_push_rvalue_aquires_lock() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<1, 1>> queue { 5 };
	reset_counters();

	queue.push(1);

	ASSERT_EQUAL(1, single_threaded_test_mutex::lock_count);
}
void test_swap_aquires_tries_multiple_times_to_try_lock() {
	BoundedQueue<int, single_threaded_count_down_mutex<3>, single_threaded_condition_variable<>> queue { 5 }, other { 4 };
	reset_counters();

	queue.swap(other);

	ASSERT_EQUAL(4, single_threaded_test_mutex::try_lock_count);
}
void test_try_push_rvalue_releases_lock() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<0, 1>> queue { 5 };
	reset_counters();

	queue.try_push(1);

	ASSERT_EQUAL(1, single_threaded_test_mutex::unlock_count);
}
Example #6
0
OSTHREAD_FUNC test6_enqueuer(void *data){
  BoundedQueue<int> *queue = (BoundedQueue<int> *) data;
  int i;
  for (i=0; i < TEST6_NOPS; ++i){
    queue->enqueue(i);
  }
  return 0;
}
void test_size_releases_lock() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<>> queue { 5 };
	reset_counters();

	queue.size();

	ASSERT_EQUAL(1, single_threaded_test_mutex::unlock_count);
}
void test_swap_releases_two_locks() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<>> queue { 5 }, other { 4 };
	reset_counters();

	queue.swap(other);

	ASSERT_EQUAL(2, single_threaded_test_mutex::unlock_count);
}
void test_pop_releases_lock() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<1, 1>> queue { 5 };
	queue.push(1);
	reset_counters();

	queue.pop();

	ASSERT_EQUAL(1, single_threaded_test_mutex::unlock_count);
}
Example #10
0
OSTHREAD_FUNC test6_dequeuer(void *data){
  BoundedQueue<int> *queue = (BoundedQueue<int> *) data;
  int i, item;
  for (i=0; i < TEST6_NOPS; ++i){
    item = queue->dequeue();
    assert(item==i);
  }
  return 0;
}
void test_try_push_for_releases_lock_on_full_queue() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<1, 0>> queue { 1 };
	queue.push(1);
	reset_counters();

	queue.try_push_for(1, std::chrono::milliseconds { 1 });

	ASSERT_EQUAL(2, single_threaded_test_mutex::unlock_count);
}
void test_try_push_for_aquires_lock_on_empty_queue() {
	int i { 1 };
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<1, 1>> queue { 5 };
	reset_counters();

	queue.try_push_for(i, std::chrono::milliseconds { 1 });

	ASSERT_EQUAL(1, single_threaded_test_mutex::lock_count);
}
void test_try_pop_for_releases_lock_on_empty_queue() {
	int result { };
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<1, 0>> queue { 5 };
	reset_counters();

	queue.try_pop_for(result, std::chrono::milliseconds { 1 });

	ASSERT_EQUAL(2, single_threaded_test_mutex::unlock_count);
}
void test_try_push_lvalue_aquires_lock() {
	int i { 1 };
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<0, 1>> queue { 5 };
	reset_counters();

	queue.try_push(i);

	ASSERT_EQUAL(1, single_threaded_test_mutex::lock_count);
}
void test_swap_successful_after_delayed_lock() {
	BoundedQueue<int, single_threaded_count_down_mutex<1>, single_threaded_condition_variable<1, 1>> queue { 5 }, other { 4 };
	other.push(17);
	reset_counters();

	queue.swap(other);

	ASSERT_EQUAL(17, queue.pop());
}
void test_try_pop_aquires_lock() {
	BoundedQueue<int, single_threaded_test_mutex, single_threaded_condition_variable<0, 1>> queue { 5 };
	queue.push(1);
	int result { };
	reset_counters();

	queue.try_pop(result);

	ASSERT_EQUAL(1, single_threaded_test_mutex::lock_count);
}
void test_capacity_is_copied_in_ctor() {
	//given
	BoundedQueue<MemoryOperationCounter> queue{4};
	queue.push(MemoryOperationCounter{});
	queue.push(MemoryOperationCounter{});

	//when
	BoundedQueue<MemoryOperationCounter> copy {queue};
	copy.push(MemoryOperationCounter{});
	copy.push(MemoryOperationCounter{});

	//then
	ASSERT(copy.full());
}
void test_queue_push_moves_element() {
	BoundedQueue<MemoryOperationCounter> queue { 1 };
	MemoryOperationCounter counter { }, expected { 2, 0, true };
	queue.push(std::move(counter));
	ASSERT_EQUAL(expected, queue.pop());
}
void test_int_queue_of_capacity_thousand_is_empty() {
	BoundedQueue<int> const queue{1000};
	ASSERTM("New queue should be empty", queue.empty());
}
void test_const_int_queue_of_capacity_thousand_is_not_full() {
	BoundedQueue<int> const queue{1000};
	ASSERTM("New queue should not be full", !queue.full());
}
void test_queue_push_copies_element() {
	BoundedQueue<MemoryOperationCounter> queue { 1 };
	MemoryOperationCounter counter { }, expected { 1 , 1, true };
	queue.push(counter);
	ASSERT_EQUAL(expected, queue.pop()); // pop moves
}
void test_int_queue_of_capacity_thousand_has_size_zero() {
	BoundedQueue<int> const queue{1000};
	ASSERT_EQUALM("New queue should be empty", 0, queue.size());
}