refactor(serif): refactored entire codebase into serif and sub namespaces
This commit is contained in:
@@ -1,86 +0,0 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include "DObject.h"
|
||||
#include "Metadata.h"
|
||||
|
||||
/**
|
||||
* @file DObjectTest.cpp
|
||||
* @brief Unit tests for the DObject class.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Test suite for the DObject class.
|
||||
*/
|
||||
class DObjectTest : public ::testing::Test {
|
||||
protected:
|
||||
DObject defaultObject;
|
||||
DObject initializedObject;
|
||||
|
||||
void SetUp() override {
|
||||
// Create a DObject with initial data and metadata
|
||||
DObject initializedObject(std::vector<float>{1.0f, 2.0f, 3.0f, 4.0f});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @test Verify default constructor initializes correctly.
|
||||
*/
|
||||
TEST_F(DObjectTest, DefaultConstructor) {
|
||||
EXPECT_NO_THROW(DObject());
|
||||
EXPECT_NO_THROW(auto data = defaultObject.getData());
|
||||
EXPECT_FALSE(defaultObject.isDebuggingEnabled());
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify constructor initializes with provided data and metadata.
|
||||
*/
|
||||
TEST_F(DObjectTest, ParameterizedConstructor) {
|
||||
DObject obj(std::vector<int>{1, 2, 3});
|
||||
|
||||
EXPECT_NO_THROW(obj.getData());
|
||||
EXPECT_EQ(std::get<std::vector<int>>(obj.getData()), std::vector<int>({1, 2, 3}));
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify getter and setter for data.
|
||||
*/
|
||||
TEST_F(DObjectTest, DataSetterGetter) {
|
||||
std::vector<double> newData = {3.14, 2.71, 1.61};
|
||||
EXPECT_NO_THROW(defaultObject.setData(newData));
|
||||
EXPECT_EQ(std::get<std::vector<double>>(defaultObject.getData()), newData);
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify enabling and disabling debugging.
|
||||
*/
|
||||
TEST_F(DObjectTest, DebuggingFlag) {
|
||||
EXPECT_FALSE(defaultObject.isDebuggingEnabled());
|
||||
defaultObject.setDebugging(true);
|
||||
EXPECT_TRUE(defaultObject.isDebuggingEnabled());
|
||||
defaultObject.setDebugging(false);
|
||||
EXPECT_FALSE(defaultObject.isDebuggingEnabled());
|
||||
}
|
||||
|
||||
TEST_F(DObjectTest, ErrorCodeSetteGetter) {
|
||||
int prevCode;
|
||||
prevCode = defaultObject.setErrorCode(1);
|
||||
EXPECT_EQ(prevCode, 0);
|
||||
prevCode = defaultObject.setErrorCode(2);
|
||||
EXPECT_EQ(prevCode, 1);
|
||||
int getCode;
|
||||
getCode = defaultObject.getErrorCode();
|
||||
EXPECT_EQ(getCode, 2);
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Basic Integration Test
|
||||
*/
|
||||
TEST_F(DObjectTest, IntegrationTest) {
|
||||
float data = 55.86868;
|
||||
DObject obj;
|
||||
obj.setData(data);
|
||||
float newData;
|
||||
newData = std::get<float>(obj.getData());
|
||||
EXPECT_EQ(data, newData);
|
||||
}
|
||||
|
||||
|
||||
@@ -1,89 +0,0 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include "LockableDObject.h"
|
||||
#include <thread>
|
||||
#include <vector>
|
||||
|
||||
/**
|
||||
* @file LockableDObjectTest.cpp
|
||||
* @brief Unit tests for the LockableDObject class.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Test suite for the LockableDObject class.
|
||||
*/
|
||||
class LockableDObjectTest : public ::testing::Test {
|
||||
protected:
|
||||
LockableDObject lockableObject;
|
||||
|
||||
void SetUp() override {
|
||||
// Initialize the LockableDObject for tests
|
||||
DObject& obj = lockableObject.get();
|
||||
obj.setData(42); // Set initial data
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @test Verify the default construction of LockableDObject.
|
||||
*/
|
||||
TEST_F(LockableDObjectTest, DefaultConstruction) {
|
||||
EXPECT_NO_THROW(LockableDObject obj);
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify access to the underlying DObject.
|
||||
*/
|
||||
TEST_F(LockableDObjectTest, AccessDObject) {
|
||||
DObject& obj = lockableObject.get();
|
||||
EXPECT_EQ(std::get<int>(obj.getData()), 42); // Ensure the data is accessible
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify locking and unlocking.
|
||||
*/
|
||||
TEST_F(LockableDObjectTest, LockAndUnlock) {
|
||||
EXPECT_NO_THROW(lockableObject.lock());
|
||||
EXPECT_NO_THROW(lockableObject.unlock());
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify thread safety with multiple threads.
|
||||
*/
|
||||
TEST_F(LockableDObjectTest, ThreadSafety) {
|
||||
const int numThreads = 10;
|
||||
std::vector<std::thread> threads;
|
||||
std::atomic<int> successCount{0};
|
||||
|
||||
// Each thread tries to update the data
|
||||
for (int i = 0; i < numThreads; ++i) {
|
||||
threads.emplace_back([this, i, &successCount]() {
|
||||
lockableObject.lock();
|
||||
DObject& obj = lockableObject.get();
|
||||
obj.setData(i);
|
||||
if (std::get<int>(obj.getData()) == i) {
|
||||
successCount++;
|
||||
}
|
||||
lockableObject.unlock();
|
||||
});
|
||||
}
|
||||
|
||||
for (auto& t : threads) {
|
||||
t.join();
|
||||
}
|
||||
|
||||
EXPECT_EQ(successCount, numThreads);
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify that the DObject remains consistent when accessed via LockableDObject.
|
||||
*/
|
||||
TEST_F(LockableDObjectTest, ConsistentState) {
|
||||
lockableObject.lock();
|
||||
DObject& obj = lockableObject.get();
|
||||
obj.setData(100);
|
||||
EXPECT_EQ(std::get<int>(obj.getData()), 100);
|
||||
lockableObject.unlock();
|
||||
|
||||
lockableObject.lock();
|
||||
EXPECT_EQ(std::get<int>(lockableObject.get().getData()), 100);
|
||||
lockableObject.unlock();
|
||||
}
|
||||
@@ -1,162 +0,0 @@
|
||||
#include <gtest/gtest.h>
|
||||
#include <thread>
|
||||
#include "Metadata.h"
|
||||
|
||||
/**
|
||||
* @file MetadataTest.cpp
|
||||
* @brief Unit tests and integration tests for the Metadata class.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @brief Test suite for the Metadata class.
|
||||
*/
|
||||
class MetadataTest : public ::testing::Test {
|
||||
protected:
|
||||
void SetUp() override {
|
||||
// Common setup for tests (if needed)
|
||||
}
|
||||
|
||||
void TearDown() override {
|
||||
// Clean up after tests (if needed)
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* @test Verify default constructor initializes correctly.
|
||||
*/
|
||||
TEST_F(MetadataTest, DefaultConstructor) {
|
||||
Metadata metadata;
|
||||
|
||||
int expectedByteSize = 0;
|
||||
|
||||
EXPECT_EQ(metadata.getByteSize(), expectedByteSize);
|
||||
EXPECT_EQ(metadata.getDataType(), "");
|
||||
EXPECT_TRUE(metadata.getDimensions().empty());
|
||||
EXPECT_FALSE(metadata.isDebugEnabled());
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify parameterized constructor initializes correctly.
|
||||
*/
|
||||
TEST_F(MetadataTest, ParameterizedConstructor) {
|
||||
std::vector<std::size_t> dimensions = {3, 4, 5};
|
||||
Metadata metadata(120, "float", dimensions, true);
|
||||
|
||||
int expectedByteSize = 120;
|
||||
EXPECT_EQ(metadata.getByteSize(), expectedByteSize);
|
||||
EXPECT_EQ(metadata.getDataType(), "float");
|
||||
EXPECT_EQ(metadata.getDimensions(), dimensions);
|
||||
EXPECT_TRUE(metadata.isDebugEnabled());
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify setters and getters for byte size.
|
||||
*/
|
||||
TEST_F(MetadataTest, ByteSizeSetterGetter) {
|
||||
Metadata metadata;
|
||||
metadata.setByteSize(256);
|
||||
|
||||
EXPECT_EQ(metadata.getByteSize(), 256);
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify setters and getters for data type.
|
||||
*/
|
||||
TEST_F(MetadataTest, DataTypeSetterGetter) {
|
||||
Metadata metadata;
|
||||
metadata.setDataType("double");
|
||||
|
||||
EXPECT_EQ(metadata.getDataType(), "double");
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify setters and getters for dimensions.
|
||||
*/
|
||||
TEST_F(MetadataTest, DimensionsSetterGetter) {
|
||||
Metadata metadata;
|
||||
std::vector<std::size_t> dimensions = {2, 2, 2};
|
||||
metadata.setDimensions(dimensions);
|
||||
|
||||
EXPECT_EQ(metadata.getDimensions(), dimensions);
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify setters and getters for debug flag.
|
||||
*/
|
||||
TEST_F(MetadataTest, DebugFlagSetterGetter) {
|
||||
Metadata metadata;
|
||||
metadata.setDebugEnabled(true);
|
||||
|
||||
EXPECT_TRUE(metadata.isDebugEnabled());
|
||||
|
||||
metadata.setDebugEnabled(false);
|
||||
|
||||
EXPECT_FALSE(metadata.isDebugEnabled());
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Verify metadata output with operator<<.
|
||||
*/
|
||||
TEST_F(MetadataTest, MetadataOutputOperator) {
|
||||
Metadata metadata(64, "int", {8, 8}, true);
|
||||
|
||||
std::ostringstream oss;
|
||||
oss << metadata;
|
||||
|
||||
std::string expectedOutput = "Metadata Information:\n"
|
||||
" Byte Size: 64 bytes\n"
|
||||
" Data Type: int\n"
|
||||
" Dimensions: [8, 8]\n"
|
||||
" Debug Enabled: Yes\n";
|
||||
|
||||
EXPECT_EQ(oss.str(), expectedOutput);
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Integration test: Validate metadata behavior in a multi-step scenario.
|
||||
*/
|
||||
TEST_F(MetadataTest, IntegrationScenario) {
|
||||
Metadata metadata;
|
||||
|
||||
// Step 1: Initialize metadata with some values
|
||||
metadata.setByteSize(128);
|
||||
metadata.setDataType("float");
|
||||
metadata.setDimensions({4, 4, 2});
|
||||
metadata.setDebugEnabled(true);
|
||||
|
||||
EXPECT_EQ(metadata.getByteSize(), 128);
|
||||
EXPECT_EQ(metadata.getDataType(), "float");
|
||||
EXPECT_EQ(metadata.getDimensions(), (std::vector<std::size_t>{4, 4, 2}));
|
||||
EXPECT_TRUE(metadata.isDebugEnabled());
|
||||
|
||||
// Step 2: Simulate a metadata update
|
||||
metadata.setByteSize(256);
|
||||
metadata.setDataType("double");
|
||||
metadata.setDimensions({8, 8});
|
||||
metadata.setDebugEnabled(false);
|
||||
|
||||
EXPECT_EQ(metadata.getByteSize(), 256);
|
||||
EXPECT_EQ(metadata.getDataType(), "double");
|
||||
EXPECT_EQ(metadata.getDimensions(), (std::vector<std::size_t>{8, 8}));
|
||||
EXPECT_FALSE(metadata.isDebugEnabled());
|
||||
}
|
||||
|
||||
/**
|
||||
* @test Integration test: Handling edge cases for metadata.
|
||||
*/
|
||||
TEST_F(MetadataTest, EdgeCaseHandling) {
|
||||
Metadata metadata;
|
||||
|
||||
// Case 1: Empty dimensions
|
||||
metadata.setDimensions({});
|
||||
EXPECT_TRUE(metadata.getDimensions().empty());
|
||||
|
||||
// Case 2: Large byte size
|
||||
metadata.setByteSize(static_cast<std::size_t>(-1));
|
||||
EXPECT_EQ(metadata.getByteSize(), static_cast<std::size_t>(-1));
|
||||
|
||||
// Case 3: Empty data type
|
||||
metadata.setDataType("");
|
||||
EXPECT_EQ(metadata.getDataType(), "");
|
||||
}
|
||||
|
||||
@@ -1,24 +0,0 @@
|
||||
# Test files for dobj
|
||||
test_sources = [
|
||||
'MetadataTest.cpp',
|
||||
'DObjectTest.cpp',
|
||||
'LockableDObjectTest.cpp'
|
||||
]
|
||||
|
||||
foreach test_file : test_sources
|
||||
exe_name = test_file.split('.')[0]
|
||||
message('Building test: ' + exe_name)
|
||||
|
||||
# Create an executable target for each test
|
||||
test_exe = executable(
|
||||
exe_name,
|
||||
test_file,
|
||||
dependencies: [gtest_dep, gtest_main],
|
||||
include_directories: include_directories('../../src/dobj/public'),
|
||||
link_with: libdobj, # Link the dobj library
|
||||
install_rpath: '@loader_path/../../src' # Ensure runtime library path resolves correctly
|
||||
)
|
||||
|
||||
# Add the executable as a test
|
||||
test(exe_name, test_exe)
|
||||
endforeach
|
||||
@@ -1,9 +0,0 @@
|
||||
test_file = 'testDObject.cpp'
|
||||
exe_name = test_file.split('.')[0]
|
||||
executable(
|
||||
exe_name,
|
||||
test_file,
|
||||
include_directories: include_directories('../../src/dobj/public'),
|
||||
link_with: libdobj, # Link the dobj library
|
||||
install_rpath: '@loader_path/../../src' # Ensure runtime library path resolves correctly
|
||||
)
|
||||
@@ -1,31 +0,0 @@
|
||||
#include<iostream>
|
||||
|
||||
#include "DObject.h"
|
||||
|
||||
DObject testFunction(DObject &obj);
|
||||
|
||||
int main(){
|
||||
float data = 55.86868;
|
||||
DObject obj;
|
||||
obj.setData(data);
|
||||
float newData;
|
||||
newData = std::get<float>(obj.getData());
|
||||
std::cout << "Data: " << newData << std::endl;
|
||||
std::cout << "Calling test function" << std::endl;
|
||||
DObject newObj = testFunction(obj);
|
||||
std::cout << newObj << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Test function which takes a DObject as an argument and
|
||||
// returns new DObject with an vector of 10 elements identical to the input DObject
|
||||
// This should use std::varient and auto to do some degree of type inference
|
||||
DObject testFunction(DObject &obj){
|
||||
float data = obj.getDataAs<float>();
|
||||
std::cout << "Data: " << data << std::endl;
|
||||
std::vector<std::vector<float>> newData(3, std::vector<float>(3, data));
|
||||
DObject newObj(newData);
|
||||
std::cout << obj << std::endl;
|
||||
|
||||
return newObj;
|
||||
}
|
||||
Reference in New Issue
Block a user