void test_const_buffer_back_throws_after_push_pop() {
BoundedBuffer<int> buffer { 5 };
buffer.push(5);
buffer.pop();
auto const & constBuffer = buffer;
ASSERT_THROWS(constBuffer.back(), std::logic_error);
}
void IntelligentDocInfo::LoadIntelligentDocumentInfo()
{
m_vHashRevision.clear();
BoundedBuffer buf = m_DocumentStore.ReadDataBlock(INTELLIGENT_DOC_INFO_VER_1);
if(buf.GetMaxSize() == 0)
return;
int iPos(0);
while (iPos < HASH_ENTRY_TABLE_SIZE)
{
int iHashCode = buf.ReadIntAt(iPos);
iPos += sizeof(int);
int iRevisionNumber = buf.ReadIntAt(iPos);
iPos += sizeof(int);
HashRevPair hrPair;
hrPair.first = iHashCode;
hrPair.second = iRevisionNumber;
if(hrPair.first != 0)
m_vHashRevision.push_back(hrPair);
else
iPos = HASH_ENTRY_TABLE_SIZE;
}
LoadReplyInfo();
}
void test_const_buffer_back_gets_last_element_of_two_pushs() {
BoundedBuffer<int> buffer { 5 };
buffer.push(1);
buffer.push(2);
auto const & constBuffer = buffer;
ASSERT_EQUAL(2, constBuffer.back());
}
void test_const_buffer_front_throws_after_push_pop() {
BoundedBuffer<int, 5> buffer { };
buffer.push(5);
buffer.pop();
auto const & constBuffer = buffer;
ASSERT_THROWS(constBuffer.front(), std::logic_error);
}
void* consumer_run(void *arg) {
while (true) {
BoundedBuffer* buffer = (BoundedBuffer*) arg;
int val = buffer->get();
sleep(2);
}
}
void test_const_buffer_front_gets_first_element_of_pushs() {
BoundedBuffer<int> buffer { 5 };
buffer.push(1);
buffer.push(2);
auto const & constBuffer = buffer;
ASSERT_EQUAL(1, constBuffer.front());
}
void TestBoundedBuffer::TestReadBuffer()
{
BoundedBuffer buf (NULL, 10);
buf.WriteStringAt(0, _T("abc"), 3);
BoundedBuffer newbuf(buf.ReadBufferAt(0, 3));
assertMessage(newbuf.m_iMaxSize == 3, _T("Failed to read the buffer"));
assertMessage(newbuf.ReadStringAt(0, 3) == _T("abc"), _T("Failed to read the buffer"));
}
void test_buffer_after_swap_argument_has_this_content() {
std::vector<int> frontValues { }, expectedValues { 1, 2, 3 };
BoundedBuffer<int> buffer { 5 }, otherBuffer { 5 };
buffer.push(1);
buffer.push(2);
buffer.push(3);
buffer.swap(otherBuffer);
3_times([&]() {frontValues.push_back(otherBuffer.front()); otherBuffer.pop();});
ASSERT_EQUAL(expectedValues, frontValues);
}
void* producer_run(void* arg){
BoundedBuffer* buffer = (BoundedBuffer*) arg;
string s = "0123456789";
int i = 0;
while(true){
buffer->put(s[i] - '0');
i = (i + 1) % 10;
sleep(1);
}
}
void producer(int id, BoundedBuffer& buffer){
for(int i = 0; i < 75; ++i){
buffer.deposit(i);
std::cout << "Produced " << id << " produced " << i << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}
void consumer(int id, BoundedBuffer& buffer){
for(int i = 0; i < 50; ++i){
int value = buffer.fetch();
std::cout << "Consumer " << id << " fetched " << value << std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(250));
}
}
void Producer::run () {
int i;
while(!theEnd) {
char d = produce();
myBuffer->append(d);
for(i=0;i<1000;i++);
}
}
void Consumer::run () {
int i = 0, j;
while(!theEnd) {
char d = myBuffer->take();
consume(d);
if (i++ == 40) {
Thread::sleep(92);
i = 0;
}else for(j=0;j<200;j++);
}
while (myBuffer->fullCount()||Producer::num){
char d = myBuffer->take();
consume(d);
dispatch();
}
intLock
cout<<endl<<"Happy End"<<endl;
intUnlock
}
void Consumer::run () {
int i = 0, j;
while(!theEnd) {
char d = myBuffer->take();
consume(d);
if (i++ == 40) {
sleepSem.wait(92);
i = 0;
}else for(j=0;j<200;j++);
}
while (myBuffer->fullCount()){
for(j=0;j<200;j++);
char d = myBuffer->take();
consume(d);
}
intLock
cout<<endl<<"Happy End";
intUnlock
}
void TestBoundedBuffer::TestResizeBuffer()
{
BoundedBuffer buf (NULL, 10);
buf.WriteStringAt(0, _T("abcdefghij"), 10);
buf.ResizeBuffer(5);
assertMessage(buf.m_iMaxSize == 5, _T("Resize failed"));
assertMessage(buf.ReadStringAt(0, 5) == _T("abcde"), _T("Buffer contents should not be lost after resize"));
buf.ResizeBuffer(15);
assertMessage(buf.m_iMaxSize == 15, _T("Resize failed"));
assertMessage(buf.ReadStringAt(0, 5) == _T("abcde"), _T("Buffer contents should not be lost after resize"));
for(int i = 5; i < 15; ++i)
{
assertMessage(buf.ReadCharAt(i) == 0, _T("Failed to null out the new bytes"));
}
}
void TestBoundedBuffer::TestWriteBuffer()
{
unsigned char MasterBuf [100];
unsigned char NotMasterBuf [200];
BoundedBuffer master (MasterBuf, 100);
BoundedBuffer smaller (NotMasterBuf, 50);
BoundedBuffer bigger (NotMasterBuf, 200);
master.ClearBuffer();
smaller.ClearBuffer();
smaller.WriteStringAt(0, _T("Hello Smaller"), 13);
master.WriteBufferAt(0, smaller);
assertMessage(CStdString((char*)(master.m_pBuf)) == _T("Hello Smaller"), _T("Failed to write the buffer"));
assertThrows(master.WriteBufferAt(0, bigger), Workshare::Exception);
assertMessage(CStdString((char*)(master.m_pBuf)) == _T("Hello Smaller"), _T("The buffer should throw without changing state if the incomming buffer is too large"));
}
void test_buffer_fronts_in_sequence_of_push_pop() {
BoundedBuffer<int> buffer { 5 };
std::vector<int> frontValues { }, expectedValues { 1, 1, 1, 2, 2, 3, 4, 4, 5 };
buffer.push(1);
frontValues.push_back(buffer.front());
buffer.push(2);
frontValues.push_back(buffer.front());
buffer.push(3);
frontValues.push_back(buffer.front());
buffer.pop();
frontValues.push_back(buffer.front());
buffer.push(4);
frontValues.push_back(buffer.front());
buffer.pop();
frontValues.push_back(buffer.front());
buffer.pop();
frontValues.push_back(buffer.front());
buffer.push(5);
frontValues.push_back(buffer.front());
buffer.pop();
frontValues.push_back(buffer.front());
ASSERT_EQUAL(expectedValues, frontValues);
}
void test_make_bounded_buffer_from_two_mixed_arguments_second_element_moved() {
MemoryOperationCounter expected{1, 0, true};
MemoryOperationCounter lvalue{};
BoundedBuffer<MemoryOperationCounter> buffer = BoundedBuffer<MemoryOperationCounter>::make_buffer(lvalue, MemoryOperationCounter{});
ASSERT_EQUAL(expected, buffer.back());
}
void test_const_buffer_back_gets_element_of_push() {
BoundedBuffer<int> buffer { 5 };
buffer.push(5);
auto const & constBuffer = buffer;
ASSERT_EQUAL(5, constBuffer.back());
}
void test_buffer_is_not_empty_after_push_rvalue() {
BoundedBuffer<int> buffer { 5 };
buffer.push(5);
ASSERTM("Buffer should not be empty after push", !buffer.empty());
}
void test_buffer_front_throws_after_push_pop() {
BoundedBuffer<int> buffer { 5 };
buffer.push(5);
buffer.pop();
ASSERT_THROWS(buffer.front(), std::logic_error);
}
void test_buffer_front_gets_first_element_of_pushs() {
BoundedBuffer<int> buffer { 5 };
buffer.push(1);
buffer.push(2);
ASSERT_EQUAL(1, buffer.front());
}
void test_buffer_back_gets_element_of_push() {
BoundedBuffer<int> buffer { 5 };
buffer.push(5);
ASSERT_EQUAL(5, buffer.back());
}
void test_buffer_size_is_fifty_after_fifty_pushs() {
BoundedBuffer<int> buffer { 75 };
50_times([&]() {buffer.push(5);});
ASSERT_EQUAL(50, buffer.size());
}
void test_buffer_size_is_one_after_push() {
BoundedBuffer<int> buffer { 2 };
buffer.push(1);
ASSERT_EQUAL(1, buffer.size());
}
void test_buffer_of_size_two_is_full_after_two_pushs() {
BoundedBuffer<int> buffer { 2 };
2_times([&]() {buffer.push(5);});
ASSERTM("Buffer of size two should be full after two pushs", buffer.full());
}
void test_make_bounded_buffer_from_two_rvalue_arguments_second_element_copied() {
MemoryOperationCounter expected{0, 1, true};
MemoryOperationCounter lvalue{};
BoundedBuffer<MemoryOperationCounter> buffer = BoundedBuffer<MemoryOperationCounter>::make_buffer(MemoryOperationCounter{}, lvalue);
ASSERT_EQUAL(expected, buffer.back());
}
void test_buffer_is_empty_after_one_push_and_pop() {
BoundedBuffer<int> buffer { 5 };
buffer.push(5);
buffer.pop();
ASSERTM("Buffer should be empty after one push and pop", buffer.empty());
}
void test_buffer_wrap_around_behavior_back() {
BoundedBuffer<int> buffer { 3 };
std::vector<int> backValues { }, expectedValues { 1, 2, 2, 3, 4, 4, 4, 5, 5, 6, 7, 7, 7 };
buffer.push(1);
backValues.push_back(buffer.back());
buffer.push(2);
backValues.push_back(buffer.back());
buffer.pop();
backValues.push_back(buffer.back());
buffer.push(3);
backValues.push_back(buffer.back());
buffer.push(4);
backValues.push_back(buffer.back());
buffer.pop();
backValues.push_back(buffer.back());
buffer.pop();
backValues.push_back(buffer.back());
buffer.push(5);
backValues.push_back(buffer.back());
buffer.pop();
backValues.push_back(buffer.back());
buffer.push(6);
backValues.push_back(buffer.back());
buffer.push(7);
backValues.push_back(buffer.back());
buffer.pop();
backValues.push_back(buffer.back());
buffer.pop();
backValues.push_back(buffer.back());
ASSERT_EQUAL(expectedValues, backValues);
}
void test_make_bounded_buffer_from_two_mixed_arguments_first_element_moved() {
MemoryOperationCounter expected{1, 0, true};
MemoryOperationCounter lvalue{};
BoundedBuffer<MemoryOperationCounter> buffer = BoundedBuffer<MemoryOperationCounter>::make_buffer(MemoryOperationCounter{}, lvalue);
ASSERT_EQUAL(expected, buffer.front());
}
