C++ BoundedBuffer类代码示例

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 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());
}