Seich
/
arduino_midi_library
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

cleanup: Dedupe RingBuffer implementation in mocks

This commit is contained in:
Francois Best 2018-11-07 12:08:12 +01:00
parent a9e0db5b73
commit faa7bade0b
6 changed files with 15 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
test/mocks/CMakeLists.txt
View File

@ -4,8 +4,11 @@ add_library(test-mocks STATIC
test-mocks.cpp test-mocks.cpp
test-mocks.h test-mocks.h
test-mocks_Namespace.h test-mocks_Namespace.h
test-mocks_Defs.h
test-mocks_SerialMock.cpp test-mocks_SerialMock.cpp
test-mocks_SerialMock.hpp test-mocks_SerialMock.hpp
test-mocks_SerialMock.h test-mocks_SerialMock.h
) )
target_link_libraries(test-mocks
midi
)

10
test/mocks/test-mocks_Defs.h
View File

@ -1,10 +0,0 @@
#pragma once
#include "test-mocks.h"
#include <inttypes.h>
BEGIN_TEST_MOCKS_NAMESPACE
typedef uint8_t uint8;
END_TEST_MOCKS_NAMESPACE

38
test/mocks/test-mocks_SerialMock.h
View File

@ -1,39 +1,11 @@
#pragma once #pragma once
#include "test-mocks.h" #include "test-mocks.h"
#include "test-mocks_Defs.h" #include <inttypes.h>
#include <src/midi_RingBuffer.h>
BEGIN_TEST_MOCKS_NAMESPACE BEGIN_TEST_MOCKS_NAMESPACE
template<typename DataType, int Size>
class RingBuffer
{
public:
RingBuffer();
~RingBuffer();
public:
int getLength() const;
bool isEmpty() const;
public:
void write(DataType inData);
void write(const DataType* inData, int inSize);
void clear();
public:
DataType peek() const;
DataType read();
void read(DataType* outData, int inSize);
private:
DataType mData[Size];
DataType* mWriteHead;
DataType* mReadHead;
};
// -----------------------------------------------------------------------------
template<int BufferSize> template<int BufferSize>
class SerialMock class SerialMock
{ {
@ -44,14 +16,14 @@ public:
public: // Arduino Serial API public: // Arduino Serial API
void begin(int inBaudrate); void begin(int inBaudrate);
int available() const; int available() const;
void write(uint8 inData); void write(uint8_t inData);
uint8 read(); uint8_t read();
public: // Test Helpers API public: // Test Helpers API
void moveTxToRx(); // Simulate loopback void moveTxToRx(); // Simulate loopback
public: public:
typedef RingBuffer<uint8, BufferSize> Buffer; typedef midi::RingBuffer<uint8_t, BufferSize> Buffer;
Buffer mTxBuffer; Buffer mTxBuffer;
Buffer mRxBuffer; Buffer mRxBuffer;
int mBaudrate; int mBaudrate;

101
test/mocks/test-mocks_SerialMock.hpp
View File

@ -2,103 +2,6 @@
BEGIN_TEST_MOCKS_NAMESPACE BEGIN_TEST_MOCKS_NAMESPACE
template<typename DataType, int Size>
RingBuffer<DataType, Size>::RingBuffer()
: mWriteHead(mData)
, mReadHead(mData)
{
memset(mData, DataType(0), Size * sizeof(DataType));
}
template<typename DataType, int Size>
RingBuffer<DataType, Size>::~RingBuffer()
{
}
// -----------------------------------------------------------------------------
template<typename DataType, int Size>
int RingBuffer<DataType, Size>::getLength() const
{
if (mReadHead == mWriteHead)
{
return 0;
}
else if (mWriteHead > mReadHead)
{
return int(mWriteHead - mReadHead);
}
else
{
return int(mWriteHead - mData) + Size - int(mReadHead - mData);
}
}
template<typename DataType, int Size>
bool RingBuffer<DataType, Size>::isEmpty() const
{
return mReadHead == mWriteHead;
}
// -----------------------------------------------------------------------------
template<typename DataType, int Size>
void RingBuffer<DataType, Size>::write(DataType inData)
{
*mWriteHead++ = inData;
if (mWriteHead >= mData + Size)
{
mWriteHead = mData;
}
}
template<typename DataType, int Size>
void RingBuffer<DataType, Size>::write(const DataType* inData, int inSize)
{
for (int i = 0; i < inSize; ++i)
{
write(inData[i]);
}
}
template<typename DataType, int Size>
void RingBuffer<DataType, Size>::clear()
{
memset(mData, DataType(0), Size * sizeof(DataType));
mReadHead = mData;
mWriteHead = mData;
}
// -----------------------------------------------------------------------------
template<typename DataType, int Size>
DataType RingBuffer<DataType, Size>::peek() const
{
return *mReadHead;
}
template<typename DataType, int Size>
DataType RingBuffer<DataType, Size>::read()
{
const DataType data = *mReadHead++;
if (mReadHead >= mData + Size)
{
mReadHead = mData;
}
return data;
}
template<typename DataType, int Size>
void RingBuffer<DataType, Size>::read(DataType* outData, int inSize)
{
for (int i = 0; i < inSize; ++i)
{
outData[i] = read();
}
}
// =============================================================================
template<int BufferSize> template<int BufferSize>
SerialMock<BufferSize>::SerialMock() SerialMock<BufferSize>::SerialMock()
{ {
@ -126,13 +29,13 @@ int SerialMock<BufferSize>::available() const
} }
template<int BufferSize> template<int BufferSize>
void SerialMock<BufferSize>::write(uint8 inData) void SerialMock<BufferSize>::write(uint8_t inData)
{ {
mTxBuffer.write(inData); mTxBuffer.write(inData);
} }
template<int BufferSize> template<int BufferSize>
uint8 SerialMock<BufferSize>::read() uint8_t SerialMock<BufferSize>::read()
{ {
return mRxBuffer.read(); return mRxBuffer.read();
} }

10
test/unit-tests/CMakeLists.txt
View File

@ -3,14 +3,13 @@ include(CMakeToolsHelpers OPTIONAL)
project(unit-tests) project(unit-tests)
include_directories( include_directories(
${unit-tests_SOURCE_DIR} "${unit-tests_SOURCE_DIR}"
${gtest_SOURCE_DIR}/include "${gtest_SOURCE_DIR}/include"
${gmock_SOURCE_DIR}/include "${gmock_SOURCE_DIR}/include"
"../../external/midi-usb/src" "${ROOT_SOURCE_DIR}/external/midi-usb/src"
) )
add_executable(unit-tests add_executable(unit-tests
unit-tests.cpp unit-tests.cpp
unit-tests.h unit-tests.h
unit-tests_Namespace.h unit-tests_Namespace.h
@ -20,7 +19,6 @@ add_executable(unit-tests
tests/unit-tests_Settings.h tests/unit-tests_Settings.h
tests/unit-tests_SysExCodec.cpp tests/unit-tests_SysExCodec.cpp
tests/unit-tests_RingBuffer.cpp tests/unit-tests_RingBuffer.cpp
tests/unit-tests_SerialMock.cpp
tests/unit-tests_MidiInput.cpp tests/unit-tests_MidiInput.cpp
tests/unit-tests_MidiInputCallbacks.cpp tests/unit-tests_MidiInputCallbacks.cpp
tests/unit-tests_MidiOutput.cpp tests/unit-tests_MidiOutput.cpp

64
test/unit-tests/tests/unit-tests_SerialMock.cpp
View File

@ -1,64 +0,0 @@
#include "unit-tests.h"
#include <test/mocks/test-mocks_SerialMock.h>
BEGIN_UNNAMED_NAMESPACE
USING_NAMESPACE_TEST_MOCKS
using namespace testing;
TEST(RingBufferMock, initialState)
{
typedef RingBuffer<uint8, 32> Buffer;
Buffer buffer;
EXPECT_EQ(buffer.getLength(), 0);
EXPECT_EQ(buffer.isEmpty(), true);
buffer.clear();
EXPECT_EQ(buffer.getLength(), 0);
EXPECT_EQ(buffer.isEmpty(), true);
}
TEST(RingBufferMock, uint8)
{
typedef RingBuffer<uint8, 8> Buffer;
Buffer buffer;
buffer.write(42);
EXPECT_EQ(buffer.getLength(), 1);
EXPECT_EQ(buffer.isEmpty(), false);
const uint8 read = buffer.read();
EXPECT_EQ(read, 42);
EXPECT_EQ(buffer.getLength(), 0);
EXPECT_EQ(buffer.isEmpty(), true);
const uint8 data[] = "Hello, World!";
buffer.write(data, 13);
EXPECT_EQ(buffer.getLength(), 5); // 13 % 8
EXPECT_EQ(buffer.isEmpty(), false);
uint8 output[8] = { 0 };
buffer.read(output, 8);
const uint8 expected[8] = {
'o', 'r', 'l', 'd', '!', ',', ' ', 'W',
};
EXPECT_THAT(output, ContainerEq(expected));
buffer.clear();
EXPECT_EQ(buffer.getLength(), 0);
EXPECT_EQ(buffer.isEmpty(), true);
}
TEST(RingBufferMock, uint32)
{
typedef RingBuffer<uint32_t, 32> Buffer;
Buffer buffer;
buffer.write(42);
EXPECT_EQ(buffer.getLength(), 1);
EXPECT_EQ(buffer.isEmpty(), false);
const uint8 read = buffer.read();
EXPECT_EQ(read, 42);
EXPECT_EQ(buffer.getLength(), 0);
EXPECT_EQ(buffer.isEmpty(), true);
}
END_UNNAMED_NAMESPACE