diff --git a/tests/ANSIO-UnitTest/ANSIO-UnitTest.cpp b/tests/ANSIO-UnitTest/ANSIO-UnitTest.cpp
new file mode 100644
index 0000000..99de052
--- /dev/null
+++ b/tests/ANSIO-UnitTest/ANSIO-UnitTest.cpp
@@ -0,0 +1,1335 @@
+#include <iostream>
+#include "iobox_api.h"
+#include <thread>
+#include <windows.h>
+#include <mmsystem.h>
+#include <iostream>
+#pragma comment(lib, "winmm.lib")
+
+#include <thread>
+#include <vector>
+#include <chrono>
+#include <iostream>
+#include <mutex>
+#include <atomic>
+
+// Mutex for thread-safe console output
+std::mutex consoleMutex;
+
+// Thread-safe console output function
+void SafePrint(const std::string& message) {
+    std::lock_guard<std::mutex> lock(consoleMutex);
+    std::cout << message << std::endl;
+}
+
+// Test scenario 1: Reset timeout behavior
+void TestResetTimeout(ANSCENTER::iobox_api* handle, const std::string& ip, int threadId) {
+    std::string message = "Thread " + std::to_string(threadId) + ": Starting DO1 toggle for 8 seconds";
+    SafePrint(message);
+
+    auto start = std::chrono::steady_clock::now();
+
+    int result = ToggleIoboxHandle(&handle, ip.c_str(), "DO1", 8000, 0, 1); // resetFlag = true
+
+    auto end = std::chrono::steady_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+
+    message = "Thread " + std::to_string(threadId) + ": DO1 toggle completed. Result: " +
+        std::to_string(result) + ", Duration: " + std::to_string(duration) + "ms";
+    SafePrint(message);
+}
+
+void TestResetTimeoutInterrupt(ANSCENTER::iobox_api* handle, const std::string& ip, int threadId) {
+    // Wait 3 seconds then try to reset the timeout
+    std::this_thread::sleep_for(std::chrono::milliseconds(3000));
+
+    std::string message = "Thread " + std::to_string(threadId) + ": Attempting to reset DO0 timeout";
+    SafePrint(message);
+
+    int result = ToggleIoboxHandle(&handle, ip.c_str(), "DO1", 8000, 0, 1); // resetFlag = true
+
+    message = "Thread " + std::to_string(threadId) + ": DO1 reset result: " + std::to_string(result);
+    SafePrint(message);
+}
+
+// Test scenario 2: Reject behavior
+void TestRejectBehavior(ANSCENTER::iobox_api* handle, const std::string& ip, int threadId) {
+    std::string message = "Thread " + std::to_string(threadId) + ": Starting DO2 toggle for 5 seconds";
+    SafePrint(message);
+
+    int result = ToggleIoboxHandle(&handle, ip.c_str(), "DO2", 5000, 0, 0); // resetFlag = false
+
+    message = "Thread " + std::to_string(threadId) + ": DO2 toggle completed. Result: " + std::to_string(result);
+    SafePrint(message);
+}
+
+void TestRejectAttempt(ANSCENTER::iobox_api* handle, const std::string& ip, int threadId) {
+    // Wait 2 seconds then try to toggle same channel (should be rejected)
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000));
+
+    std::string message = "Thread " + std::to_string(threadId) + ": Attempting to toggle DO2 (should be rejected)";
+    SafePrint(message);
+
+    int result = ToggleIoboxHandle(&handle, ip.c_str(), "DO2", 3000, 0, 0); // resetFlag = false
+
+    message = "Thread " + std::to_string(threadId) + ": DO2 rejection test result: " + std::to_string(result);
+    if (result == 0) {
+        message += " (CORRECTLY REJECTED)";
+    }
+    else {
+        message += " (UNEXPECTED - SHOULD HAVE BEEN REJECTED)";
+    }
+    SafePrint(message);
+}
+
+// Test scenario 3: Independent channels
+void TestIndependentChannels(ANSCENTER::iobox_api* handle, const std::string& ip, const std::string& channel, int threadId) {
+    std::string message = "Thread " + std::to_string(threadId) + ": Starting " + channel + " toggle for 4 seconds";
+    SafePrint(message);
+
+    auto start = std::chrono::steady_clock::now();
+
+    int result = ToggleIoboxHandle(&handle, ip.c_str(), channel.c_str(), 4000, 0, 1);
+
+    auto end = std::chrono::steady_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
+
+    message = "Thread " + std::to_string(threadId) + ": " + channel + " toggle completed. Result: " +
+        std::to_string(result) + ", Duration: " + std::to_string(duration) + "ms";
+    SafePrint(message);
+}
+
+// Test scenario 4: Revert flag behavior
+void TestRevertFlag(ANSCENTER::iobox_api* handle, const std::string& ip, int threadId, bool revertFlag) {
+    std::string mode = revertFlag ? "REVERT" : "NORMAL";
+    std::string message = "Thread " + std::to_string(threadId) + ": Testing DO3 with " + mode + " mode for 3 seconds";
+    SafePrint(message);
+
+    int result = ToggleIoboxHandle(&handle, ip.c_str(), "DO3", 3000, revertFlag ? 1 : 0, 1);
+
+    message = "Thread " + std::to_string(threadId) + ": DO3 " + mode + " mode completed. Result: " + std::to_string(result);
+    SafePrint(message);
+}
+
+int ToggleTest() {
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "=== MULTITHREAD TOGGLE TEST START ===\n\n";
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+        return -1;
+    }
+
+    std::string ioBoxIP = "192.168.1.34"; // Set your actual IP
+    std::string username = "admin";
+    std::string password = "1234";
+
+    std::cout << "\n2. Connect to " << ioBoxIP << "\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    std::string deviceInfo;
+    int connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+    if (connectStatus == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+    std::cout << "\n3. Testing toggle scenarios for multiple channels\n\n";
+
+    // Test Scenario 1: Reset timeout behavior
+    std::cout << "=== TEST 1: Reset Timeout Behavior ===\n";
+    std::cout << "Expected: DO1 will be ON for ~11 seconds (8s + 3s reset)\n";
+    std::vector<std::thread> threads1;
+
+    threads1.emplace_back(TestResetTimeout, infHandle, ioBoxIP, 1);
+    threads1.emplace_back(TestResetTimeoutInterrupt, infHandle, ioBoxIP, 2);
+
+    for (auto& t : threads1) {
+        t.join();
+    }
+
+    std::cout << "\n=== TEST 1 COMPLETED ===\n\n";
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // Wait between tests
+
+    // Test Scenario 2: Reject behavior
+    std::cout << "=== TEST 2: Reject Behavior ===\n";
+    std::cout << "Expected: DO2 will be ON for exactly 5 seconds, second call rejected\n";
+    std::vector<std::thread> threads2;
+
+    threads2.emplace_back(TestRejectBehavior, infHandle, ioBoxIP, 3);
+    threads2.emplace_back(TestRejectAttempt, infHandle, ioBoxIP, 4);
+
+    for (auto& t : threads2) {
+        t.join();
+    }
+
+    std::cout << "\n=== TEST 2 COMPLETED ===\n\n";
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // Wait between tests
+
+    // Test Scenario 3: Independent channels
+    std::cout << "=== TEST 3: Independent Channels ===\n";
+    std::cout << "Expected: DO3, DO4 all toggle independently for 4 seconds\n";
+    std::vector<std::thread> threads3;
+
+    threads3.emplace_back(TestIndependentChannels, infHandle, ioBoxIP, "DO3", 5);
+    threads3.emplace_back(TestIndependentChannels, infHandle, ioBoxIP, "DO4", 6);
+
+    for (auto& t : threads3) {
+        t.join();
+    }
+
+    std::cout << "\n=== TEST 3 COMPLETED ===\n\n";
+    std::this_thread::sleep_for(std::chrono::milliseconds(2000)); // Wait between tests
+
+    // Test Scenario 4: Revert flag behavior
+    std::cout << "=== TEST 4: Revert Flag Behavior ===\n";
+    std::cout << "Expected: First call turns OFF then ON, second call turns ON then OFF\n";
+    std::vector<std::thread> threads4;
+
+    threads4.emplace_back(TestRevertFlag, infHandle, ioBoxIP, 8, true);  // revert = true
+    std::this_thread::sleep_for(std::chrono::milliseconds(500)); // Small delay
+    threads4.emplace_back(TestRevertFlag, infHandle, ioBoxIP, 9, false); // revert = false
+
+    for (auto& t : threads4) {
+        t.join();
+    }
+
+    std::cout << "\n=== TEST 4 COMPLETED ===\n\n";
+
+    // Test Scenario 5: Stress test with multiple resets
+    std::cout << "=== TEST 5: Stress Test - Multiple Resets ===\n";
+    std::cout << "Expected: DO6 will have extended ON time due to multiple resets\n";
+
+    auto stressTest = [&](int threadId) {
+        std::string message = "Thread " + std::to_string(threadId) + ": Starting DO1 stress test";
+        SafePrint(message);
+
+        int result = ToggleIoboxHandle(&infHandle, ioBoxIP.c_str(), "DO1", 10000, 0, 1);
+
+        message = "Thread " + std::to_string(threadId) + ": DO1 stress test completed. Result: " + std::to_string(result);
+        SafePrint(message);
+        };
+
+    auto resetTest = [&](int threadId, int delay) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(delay));
+        std::string message = "Thread " + std::to_string(threadId) + ": Resetting DO1 timeout";
+        SafePrint(message);
+
+        int result = ToggleIoboxHandle(&infHandle, ioBoxIP.c_str(), "DO1", 5000, 0, 1);
+
+        message = "Thread " + std::to_string(threadId) + ": DO1 reset result: " + std::to_string(result);
+        SafePrint(message);
+        };
+
+    std::vector<std::thread> threads5;
+    threads5.emplace_back(stressTest, 10);
+    threads5.emplace_back(resetTest, 11, 2000);  // Reset after 2s
+    threads5.emplace_back(resetTest, 12, 6000);  // Reset after 6s
+    threads5.emplace_back(resetTest, 13, 10000); // Reset after 10s
+
+    for (auto& t : threads5) {
+        t.join();
+    }
+
+    std::cout << "\n=== TEST 5 COMPLETED ===\n\n";
+
+    std::cout << "\n4. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+
+    std::cout << "\n=== MULTITHREAD TOGGLE TEST COMPLETED ===\n";
+    return 0;
+}
+
+
+//void ListWaveOutDevicesSimple() {
+//    UINT numDevices = waveOutGetNumDevs();
+//    std::cout << "Available Audio Output Devices:\n";
+//
+//    for (UINT i = 0; i < numDevices; i++) {
+//        WAVEOUTCAPS caps;
+//        if (waveOutGetDevCaps(i, &caps, sizeof(WAVEOUTCAPS)) == MMSYSERR_NOERROR) {
+//            std::wcout << i << ": " << caps.szPname << std::endl;
+//        }
+//    }
+//}
+
+
+/*
+* 
+using ANSCENTER::iobox_api;
+iobox_api ioBoxApp((char*)"239.255.255.250", 12345);
+void userInputThread(iobox_api* api) {
+    std::string current_ip;
+
+    while (true) {
+        std::string input;
+        std::cout << std::endl;
+        std::cout << "Enter command followed by Enter: exit, scan, setup, connect, channels, disconnect, show, get, set, restart, setauthen, resetauthen" << std::endl;
+        // std::cin >> input;       // This will only get the first word
+        std::getline(std::cin, input);
+        if (input == "exit") {
+            break;
+        }
+        else if(input == "scan") {
+            std::vector<std::string> devices = api->scanNetworkDevicesMulticast(5);
+            std::cout << "Found devices: " << devices.size() << std::endl;
+            for (const std::string& device : devices) {
+                std::cout << device << std::endl;
+            }
+            continue;
+        }
+        else if(input == "setup") {
+            std::cout << "Enter IP: ";
+            std::getline(std::cin, current_ip);
+            continue;
+        }
+        else if(input == "connect") {
+            if(current_ip == "") {
+                std::cout << "Please setip address first" << std::endl;
+                continue;
+            }
+            std::string username, password;
+            std::cout << "Enter username: ";
+            std::cin >> username;
+            std::cout << "Enter password: ";
+            std::cin >> password;
+            bool connect = api->connectToIobox(current_ip, DEVICE_TCP_PORT, username, password);
+            std::cout << "Connection to " << current_ip << (connect ? " succeeded." : " failed.") << std::endl;
+            continue;
+        }
+        else if(input == "disconnect") {
+            bool disconnect = api->disconnectToIobox(current_ip);
+            std::cout << "Disconnect to " << current_ip << (disconnect ? " succeeded." : " failed.") << std::endl;
+            // current_ip = "";
+            continue;
+        }
+        else if(input == "show") {
+            api->show_profile_ioboxs();
+            continue;
+        }
+        else if(input == "get") {
+            std::string channel;
+            std::cout << "Enter channel: ";
+            std::cin >> channel;
+            std::string value = api->getValueDataStringIoboxFromChannelName(current_ip, channel);
+            std::cout << "Value of " << channel << ": " << value << std::endl;
+            continue;
+        }
+        else if(input == "set") {
+            std::string  value;
+            std::string channel;
+            std::cout << "Enter channel: ";
+            std::cin >> channel;
+            std::cout << "Enter value: ";
+            std::cin >> value;
+            bool set = api->setValueDataStringIoboxFromChannelName(current_ip, channel, value);
+            std::cout << "Set value to " << current_ip << (set ? " succeeded." : " failed.") << std::endl;
+        }
+        else if(input == "restart") {
+            std::string token = api->generateToken(current_ip);
+            bool reset = api->resetIobox(current_ip, token);
+            std::cout << "Restart " << current_ip << (reset ? " succeeded." : " failed.") << std::endl;
+        }
+        else if(input == "setauthen") {
+            std::string username, password;
+            std::cout << "Enter username: ";
+            std::cin >> username;
+            std::cout << "Enter password: ";
+            std::cin >> password;
+            bool set = api->setAuthenticationIobox(current_ip, username, password);
+            std::cout << "Set authentication to " << current_ip << (set ? " succeeded." : " failed.") << std::endl;
+        }
+        else if(input == "resetauthen") {
+            std::string token = api->generateToken(current_ip);
+            bool reset = api->resetAuthenticationIobox(current_ip, token);
+            std::cout << "Reset authentication to " << current_ip << (reset ? " succeeded." : " failed.") << std::endl;
+        }
+        else if(input == "channels") {
+            std::vector<std::string> channels = api->getDeviceChannelNames(current_ip);
+            std::cout << "Channels of " << current_ip << std::endl;
+            for(const std::string& channel : channels) {
+                std::cout << channel << std::endl;
+            }
+        }
+        else {
+            // std::cout << "Invalid command" << std::endl;
+        }
+    }
+}
+int main()
+{
+    std::thread userThread(userInputThread, &ioBoxApp);
+    userThread.join();
+
+    std::cout << "Main thread is done" << std::endl;
+    return 0;
+}
+
+*/
+
+int FullTest() {
+
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+    }
+    std::string ioBoxIP = "192.168.1.34";
+    std::string channelName = "DO1";
+    std::string value = "1";
+    std::string ChannelNames;
+    std::string username = "admin";
+    std::string password = "1234";
+    std::string deviceInfo;
+    std::string token;
+
+    std::cout << "\n2. Get Device Channels\n";
+    GetChannelNamesANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 5, ChannelNames);
+    std::cout << "Channel Names: " << ChannelNames << std::endl;
+
+    std::cout << "\n3. Generate token information\n";
+    GenerateANSIOTokenHandle_CPP(&infHandle, ioBoxIP.c_str(), token);
+    std::cout << "Token: " << token << std::endl;
+
+    std::cout << "\n4. Reset box authentication information\n";
+    int resetAuthenStatus = ResetAuthenticationANSIOHandle(&infHandle, ioBoxIP.c_str(), token.c_str());
+    if (resetAuthenStatus == 1) {
+        std::cout << "Reset authentication information successfully" << std::endl;
+    }
+    else {
+        std::cout << "Reset authentication information failed" << std::endl;
+    }
+
+    std::cout << "\n5. Connect to " << ioBoxIP<<std::endl;
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    int connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+    if (connectStatus == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+    std::cout << "\n6.1. Scan ANSDAQ devices from LAN\n";
+    std::string deviceAddresses;
+    ScanANSIOHandle_CPP(&infHandle, 5, deviceAddresses);
+    std::cout << "Found devices: " << deviceAddresses << std::endl;
+
+    std::cout << "\n6.2. Scan ANSDAQ devices from LAN (Unicast)\n";
+    std::string unicastDeviceAddresses;
+    ScanANSIOUnicastHandle_CPP(&infHandle, 5, unicastDeviceAddresses);
+    std::cout << "Found devices: " << unicastDeviceAddresses << std::endl;
+
+    std::cout << "\n7. Connect to " << ioBoxIP << std::endl;;
+
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+    if (connectStatus == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+
+    std::cout << "\n8. Change username and password\n";
+    std::string newUsername = "admin";
+    std::string newPassword = "1234";
+    std::cout << "New Username:" << newUsername << " New Password:" << newPassword << std::endl;
+    int changeAuthenticationStatus = SetAuthenticationANSIOHandle(&infHandle, ioBoxIP.c_str(), newUsername.c_str(), newPassword.c_str());
+    if (changeAuthenticationStatus == 1) {
+        std::cout << "Changed authentication information successfully" << std::endl;
+    }
+    else {
+        std::cout << "Changed authentication information failed" << std::endl;
+    }
+    std::cout << "\n9. Disconnect the IOBOX and reconnect with it via new authentication\n";
+    int disconnectStatus1 = DisconnectANSIOHandle(&infHandle, ioBoxIP.c_str());
+    if (disconnectStatus1 == 1) {
+        std::cout << "Disconnected from IOBox successfully" << std::endl;
+    }
+    else {
+        std::cout << "Disconnection from IOBox failed" << std::endl;
+    }
+    int connectStatus1 = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, newUsername.c_str(), newPassword.c_str(), deviceInfo);
+    if (connectStatus1 == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+    std::cout << "\n10. Get Device Channels\n";
+    GetChannelNamesANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 5, ChannelNames);
+    std::cout << "Channel Names: " << ChannelNames << std::endl;
+
+    std::cout << "\n11. Set Value 1 to Channel D01\n";
+
+    int setValueStatus = SetValueANSIOHandle(&infHandle, ioBoxIP.c_str(), channelName.c_str(), value.c_str());
+    if (setValueStatus == 1) {
+        std::cout << "Value set successfully" << std::endl;
+    }
+    else {
+        std::cout << "Value set failed" << std::endl;
+    }
+    value = "";
+    std::cout << "\n12. Get Value from Channel D01\n";
+
+    GetValueANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), channelName.c_str(), value);
+    std::cout << "Value of " << channelName << ": " << value << std::endl;
+
+    std::cout << "\n13. Disconnect from device:" << ioBoxIP<<std::endl;
+
+    int disconnectStatus = DisconnectANSIOHandle(&infHandle, ioBoxIP.c_str());
+    if (disconnectStatus == 1) {
+        std::cout << "Disconnected from IOBox successfully" << std::endl;
+    }
+    else {
+        std::cout << "Disconnection from IOBox failed" << std::endl;
+    }
+    std::cout << "\n14. Reset OI BOX "<< ioBoxIP << std::endl;
+
+    int resetStatus = ResetANSIOHandle(&infHandle, ioBoxIP.c_str(), token.c_str());
+    if (resetStatus == 1) {
+        std::cout << "Reset IOBox successfully" << std::endl;
+    }
+    else {
+        std::cout << "Reset IOBox failed" << std::endl;
+    }
+
+    std::cout << "\n15. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+    return 0;
+
+}
+
+
+int GenTokenTest() {
+
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+    }
+    std::string ioBoxIP = "192.168.1.34";
+    std::string channelName = "DO1";
+    std::string value = "1";
+    std::string ChannelNames;
+    std::string username = "admin";
+    std::string password = "1234";
+    std::string deviceInfo;
+    std::string token = "IIO001234ANS IOBOX";
+
+    std::cout << "\n2. Get Device Channels\n";
+    GetChannelNamesANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 5, ChannelNames);
+    std::cout << "Channel Names: " << ChannelNames << std::endl;
+
+    //std::cout << "\n3. Generate token information\n";
+    //GenerateANSIOTokenHandle_CPP(&infHandle, ioBoxIP.c_str(), token);
+    //std::cout << "Token: " << token << std::endl;
+
+    std::cout << "\n4. Reset box authentication information\n";
+    int resetAuthenStatus = ResetAuthenticationANSIOHandle(&infHandle, ioBoxIP.c_str(), token.c_str());
+    if (resetAuthenStatus == 1) {
+        std::cout << "Reset authentication information successfully" << std::endl;
+    }
+    else {
+        std::cout << "Reset authentication information failed" << std::endl;
+    }
+    std::cout << "\n5. Reset  ANSDAQ object\n";
+
+    int resetStatus = ResetANSIOHandle(&infHandle, ioBoxIP.c_str(), token.c_str());
+    if (resetStatus == 1) {
+        std::cout << "Reset IOBox successfully" << std::endl;
+    }
+    else {
+        std::cout << "Reset IOBox failed" << std::endl;
+    }
+
+    std::cout << "\n5. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+    return 0;
+
+}
+int testTimeStamp() {
+    for (size_t i = 0; i < 1000; i++)
+    {
+        long m_pts = std::chrono::duration_cast<std::chrono::milliseconds>(
+            std::chrono::system_clock::now().time_since_epoch()
+        ).count();
+        std::cout << "Time Stamp: " << m_pts << std::endl;
+		std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    return 0;
+
+
+}
+
+// Structure to store device ID and device name
+struct DeviceInfo {
+    UINT deviceID;
+    std::wstring deviceName;
+};
+
+// Function to list available audio output devices and store them with their IDs
+void ListWaveOutDevices(std::vector<DeviceInfo>& deviceList) {
+    UINT numDevices = waveOutGetNumDevs();
+    std::cout << "Available Audio Output Devices:\n";
+
+    for (UINT i = 0; i < numDevices; i++) {
+        WAVEOUTCAPS caps;
+        if (waveOutGetDevCaps(i, &caps, sizeof(WAVEOUTCAPS)) == MMSYSERR_NOERROR) {
+            std::wcout << i << ": " << caps.szPname << std::endl;
+            deviceList.push_back({ i, caps.szPname });  // Store device ID and name
+        }
+    }
+}
+
+// Function to find device ID by device name
+UINT GetDeviceIDByName(const std::vector<DeviceInfo>& deviceList, const std::wstring& deviceName) {
+    for (const auto& device : deviceList) {
+        if (device.deviceName == deviceName) {
+            return device.deviceID;
+        }
+    }
+    return UINT(-1);  // Return invalid ID if not found
+}
+
+// Function to play a WAV file on a selected device by name
+bool PlayWavOnDevice(const std::string& filename, const std::wstring& deviceName) {
+    // Initialize device list and find device ID by name
+    std::vector<DeviceInfo> deviceList;
+    ListWaveOutDevices(deviceList);
+    UINT deviceID = GetDeviceIDByName(deviceList, deviceName);
+
+    if (deviceID == UINT(-1)) {
+        //std::cerr << "Device with name " << deviceName << " not found.\n";
+        return false;
+    }
+
+    HWAVEOUT hWaveOut;
+    WAVEFORMATEX wfx = { 0 };
+    MMCKINFO chunk, formatChunk;
+    HMMIO hMmio;
+    MMIOINFO mmioInfo = { 0 };
+
+    // Open WAV file
+    hMmio = mmioOpenA((LPSTR)filename.c_str(), &mmioInfo, MMIO_READ);
+    if (!hMmio) {
+        std::cerr << "Failed to open WAV file: " << filename << std::endl;
+        return false;
+    }
+
+    // Locate the RIFF chunk
+    chunk.fccType = mmioFOURCC('W', 'A', 'V', 'E');
+    if (mmioDescend(hMmio, &chunk, NULL, MMIO_FINDRIFF) != MMSYSERR_NOERROR) {
+        std::cerr << "Invalid WAV file.\n";
+        mmioClose(hMmio, 0);
+        return false;
+    }
+
+    // Locate the 'fmt ' chunk
+    formatChunk.ckid = mmioFOURCC('f', 'm', 't', ' ');
+    if (mmioDescend(hMmio, &formatChunk, &chunk, MMIO_FINDCHUNK) != MMSYSERR_NOERROR) {
+        std::cerr << "Failed to locate format chunk.\n";
+        mmioClose(hMmio, 0);
+        return false;
+    }
+
+    // Read WAV format
+    mmioRead(hMmio, (HPSTR)&wfx, sizeof(WAVEFORMATEX));
+    mmioAscend(hMmio, &formatChunk, 0);
+
+    // Open audio output device
+    if (waveOutOpen(&hWaveOut, deviceID, &wfx, 0, 0, CALLBACK_NULL) != MMSYSERR_NOERROR) {
+        std::cerr << "Failed to open audio device ID: " << deviceID << std::endl;
+        mmioClose(hMmio, 0);
+        return false;
+    }
+
+    // Locate the 'data' chunk
+    MMCKINFO dataChunk;
+    dataChunk.ckid = mmioFOURCC('d', 'a', 't', 'a');
+    if (mmioDescend(hMmio, &dataChunk, &chunk, MMIO_FINDCHUNK) != MMSYSERR_NOERROR) {
+        std::cerr << "Failed to locate data chunk.\n";
+        waveOutClose(hWaveOut);
+        mmioClose(hMmio, 0);
+        return false;
+    }
+
+    // Read and play the audio data
+    std::vector<BYTE> audioData(dataChunk.cksize);
+    mmioRead(hMmio, (HPSTR)audioData.data(), dataChunk.cksize);
+
+    WAVEHDR waveHdr = { 0 };
+    waveHdr.lpData = (LPSTR)audioData.data();
+    waveHdr.dwBufferLength = dataChunk.cksize;
+    waveHdr.dwFlags = 0;
+
+    waveOutPrepareHeader(hWaveOut, &waveHdr, sizeof(WAVEHDR));
+    waveOutWrite(hWaveOut, &waveHdr, sizeof(WAVEHDR));
+
+    // Wait for playback to finish
+    while (!(waveHdr.dwFlags & WHDR_DONE)) {
+        Sleep(100);
+    }
+
+    // Clean up
+    waveOutUnprepareHeader(hWaveOut, &waveHdr, sizeof(WAVEHDR));
+    waveOutClose(hWaveOut);
+    mmioClose(hMmio, 0);
+
+    std::cout << "Playback finished.\n";
+    return true;
+}
+
+int UpdateFirmwareTest() {
+
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+    }
+    std::string ioBoxIP = "192.168.1.34";
+    std::string channelName = "DO1";
+    std::string value = "1";
+    std::string ChannelNames;
+    std::string username = "admin";
+    std::string password = "1234";
+    std::string deviceInfo;
+    std::string token;
+    int connectStatus;
+    std::cout << "\n2. Get Device Channels\n";
+    GetChannelNamesANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 5, ChannelNames);
+    std::cout << "Channel Names: " << ChannelNames << std::endl;
+
+    std::cout << "\n3. Generate token information\n";
+    GenerateANSIOTokenHandle_CPP(&infHandle, ioBoxIP.c_str(), token);
+    std::cout << "Token: " << token << std::endl;
+
+    std::cout << "\n4. Reset box authentication information\n";
+    int resetAuthenStatus = ResetAuthenticationANSIOHandle(&infHandle, ioBoxIP.c_str(), token.c_str());
+    if (resetAuthenStatus == 1) {
+        std::cout << "Reset authentication information successfully" << std::endl;
+    }
+    else {
+        std::cout << "Reset authentication information failed" << std::endl;
+    }
+
+    std::cout << "\n5. Connect to 192.168.1.32\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+    if (connectStatus == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+
+    std::cout << "\n6.1. Scan ANSDAQ devices from LAN\n";
+    std::string deviceAddresses;
+    ScanANSIOHandle_CPP(&infHandle, 5, deviceAddresses);
+    std::cout << "Found devices: " << deviceAddresses << std::endl;
+
+
+    //std::cout << "\n6.2. Scan ANSDAQ devices from LAN (Unicast)\n";
+    //std::string unicastDeviceAddresses;
+    //ScanANSIOUnicastHandle_CPP(&infHandle, 5, unicastDeviceAddresses);
+    //std::cout << "Found devices: " << unicastDeviceAddresses << std::endl;
+
+    std::cout << "\n7. Connect to 192.168.1.32\n";
+
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+    if (connectStatus == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+
+   
+   /* std::cout << "\n8. Update 192.168.1.32 firmware\n";
+
+	std::string firmwarePath = "C:\\Projects\\ANSVIS\\Documentation\\IOBOX\\esp_iobox_device_fw15.bin";
+    int firmwareUpdateStatus = OTAANSIOFirmwareDevice(& infHandle, ioBoxIP.c_str(), firmwarePath.c_str(), "esp");
+	if (firmwareUpdateStatus == 1) {
+		std::cout << "Firmware update successfully" << std::endl;
+	}
+	else {
+		std::cout << "Firmware update failed" << std::endl;
+	}
+    
+    std::cout << "\n9. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }*/
+    return 0;
+
+}
+int ConnectTest() {
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+    }
+    std::string ioBoxIP = "192.168.1.34";
+    std::string channelName = "DO1";
+    std::string value = "1";
+    std::string ChannelNames;
+    std::string username = "admin";
+    std::string password = "1234";
+    std::string deviceInfo;
+    std::string token = "IIO001234ANS IOBOX";
+
+    std::cout << "\n2. Connect to 192.168.1.34\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    
+    int connectStatus;
+    for (int i = 0; i < 100; i++) {
+        connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+        if (connectStatus == 1) {
+            std::cout << "Connected to IOBox successfully" << std::endl;
+            std::cout << "Device Info: " << deviceInfo << std::endl;
+        }
+        else {
+            std::cout << "Connection to IOBox failed" << std::endl;
+        }
+    }
+    int setValueStatus = 0;
+	for (int i = 0; i < 100; i++) {
+        std::cout << "\n3. Set Value 1 to Channel D01\n";
+        value = "1";
+        setValueStatus = SetValueANSIOHandle(&infHandle, ioBoxIP.c_str(), channelName.c_str(), value.c_str());
+        if (setValueStatus == 1) {
+            std::cout << "Value set successfully" << std::endl;
+        }
+        else {
+            std::cout << "Value set failed" << std::endl;
+        }
+        value = "";
+        std::cout << "\n4. Get Value from Channel D01\n";
+
+        GetValueANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), channelName.c_str(), value);
+        std::cout << "Value of " << channelName << ": " << value << std::endl;
+		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+        
+        value = "0";
+        setValueStatus = SetValueANSIOHandle(&infHandle, ioBoxIP.c_str(), channelName.c_str(), value.c_str());
+        if (setValueStatus == 1) {
+            std::cout << "Value set successfully" << std::endl;
+        }
+        else {
+            std::cout << "Value set failed" << std::endl;
+        }
+        value = "";
+        std::cout << "\n4. Get Value from Channel D01\n";
+
+        GetValueANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), channelName.c_str(), value);
+        std::cout << "Value of " << channelName << ": " << value << std::endl;
+        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
+	}
+   
+    std::cout << "\n4.1. Scan ANSDAQ devices from LAN\n";
+    std::string deviceAddresses;
+    ScanANSIOHandle_CPP(&infHandle, 5, deviceAddresses);
+    std::cout << "Found devices: " << deviceAddresses << std::endl;
+
+    std::cout << "\n5. Disconnect from device 192.168.1.34\n";
+
+    int disconnectStatus = DisconnectANSIOHandle(&infHandle, ioBoxIP.c_str());
+    if (disconnectStatus == 1) {
+        std::cout << "Disconnected from IOBox successfully" << std::endl;
+    }
+    else {
+        std::cout << "Disconnection from IOBox failed" << std::endl;
+    }
+
+    std::cout << "\n6. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+    return 0;
+
+}
+int StressTest() {
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+    }
+    std::string ioBoxIP = "192.168.1.34";
+    std::string channelName = "DO1";
+    std::string value = "1";
+    std::string ChannelNames;
+    std::string username = "admin";
+    std::string password = "1234";
+    std::string deviceInfo;
+    std::string token = "IIO001234ANS IOBOX";
+    std::string deviceAddresses;
+	std::string unicastDeviceAddresses;
+    std::cout << "\n2. Connect to 192.168.1.34\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+
+    int connectStatus;
+    for (int i = 0; i < 100; i++) {
+       
+        std::cout << "\n3.1.1 Scan ANSDAQ devices from LAN multicast\n";
+        ScanANSIOHandle_CPP(&infHandle, 5, deviceAddresses);
+        std::cout << "Found devices: " << deviceAddresses << std::endl;
+        std::cout << "\n3.1.2 Scan ANSDAQ devices from LAN Unicast\n";
+
+        ScanANSIOUnicastHandle_CPP(&infHandle, 5, unicastDeviceAddresses);
+        std::cout << "Found devices: " << unicastDeviceAddresses << std::endl;
+
+        std::cout << "\n3.2. Connect to device\n";
+
+        connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+        if (connectStatus == 1) {
+            std::cout << "Connected to IOBox successfully" << std::endl;
+            std::cout << "Device Info: " << deviceInfo << std::endl;
+        }
+        else {
+            std::cout << "Connection to IOBox failed" << std::endl;
+        }
+        std::cout << "\n3.3. Get device channel names\n";
+        
+        GetChannelNamesANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 5, ChannelNames);
+        std::cout << "Channel Names: " << ChannelNames << std::endl;
+        std::cout << "\n3.4. Disconnect from device\n";
+
+        int disconnectStatus = DisconnectANSIOHandle(&infHandle, ioBoxIP.c_str());
+        if (disconnectStatus == 1) {
+            std::cout << "Disconnected from IOBox successfully" << std::endl;
+        }
+        else {
+            std::cout << "Disconnection from IOBox failed" << std::endl;
+        }
+    }
+    
+
+
+    
+
+    std::cout << "\n4. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+    return 0;
+
+}
+int AdvancedConnectionTest() {
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+    }
+    std::string ioBoxIP = "";// "192.168.1.34";
+    std::string channelName = "DO1";
+    std::string value = "1";
+    std::string ChannelNames;
+    std::string username = "admin";
+    std::string password = "1234";
+    std::string deviceInfo;
+    std::string token = "IIO001234ANS IOBOX";
+    std::string deviceAddresses;
+    std::cout << "\n2. Connect to 192.168.1.34\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+
+	int connection = AdvancedConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502,"e831cd6e2163", username.c_str(), password.c_str(), deviceAddresses);
+	if (connection == 1) {
+		std::cout << "Connected to IOBox successfully" << std::endl;
+		std::cout << "Device Info: " << deviceAddresses << std::endl;
+	}
+	else {
+		std::cout << "Connection to IOBox failed" << std::endl;
+	}
+
+
+    std::cout << "\n4. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+    return 0;
+
+}
+
+int AdvancedScan() {
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+    }
+    std::string ioBoxIP = "";// "192.168.1.34";
+    std::string channelName = "DO1";
+    std::string value = "1";
+    std::string ChannelNames;
+    std::string username = "admin";
+    std::string password = "1234";
+    std::string deviceInfo;
+    std::string token = "IIO001234ANS IOBOX";
+    std::string deviceAddresses;
+    std::cout << "\n2. Connect to 192.168.1.34\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+
+    int connection = AdvancedScanANSIOHandle_CPP(&infHandle,5, deviceAddresses);
+    if (connection == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceAddresses << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+
+
+    std::cout << "\n4. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+    return 0;
+
+}
+int AdvancedStaticScan() {
+    std::string deviceAddresses;
+    int connection = AdvancedStaticScanANSIOHandle_CPP(5, deviceAddresses);
+    if (connection == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceAddresses << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+
+    return 0;
+
+}
+int TestSetGet() {
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+
+    std::cout << "1. Create ANSDAQ object\n";
+    ANSCENTER::iobox_api* infHandle= new ANSCENTER::iobox_api(multicastIPAddress, multicastPort);
+
+
+
+    std::string ioBoxIP = "192.168.1.34"; // Set your actual IP
+    std::string username = "admin";
+    std::string password = "1234";
+
+    std::cout << "\n2. Connect to " << ioBoxIP << "\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    std::string deviceInfo =infHandle->connectToIobox(ioBoxIP, 502, username, password);
+
+    if (!deviceInfo.empty()) {
+        std::cout << "Connected to IOBox successfully\n";
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed\n";
+	}
+
+    std::string channelName = "DO1";
+    std::string value = "1";
+    bool setValueStatus;
+    for (int i = 0; i <= 2000; i++) {
+		std::cout << "\nIteration: " << i+1 << "\n";
+        channelName = "DO1";
+        value = "1";
+        std::cout << "\n Set Value 1 to Channel D01\n";
+        setValueStatus = infHandle->setValue(ioBoxIP, channelName, value);     
+         infHandle->getValue(ioBoxIP, channelName, value);
+        if (value!="1") {
+            std::cout << "FAILED TO SET VALUE 1\n";
+            break;
+        }
+        Sleep(2000);
+        value = "0";
+        std::cout << "\n Set Value 0 to Channel D01\n";
+        setValueStatus = infHandle->setValue(ioBoxIP, channelName, value); 
+        infHandle->getValue(ioBoxIP, channelName, value);
+        if (value != "0") {
+            std::cout << "FAILED TO SET VALUE 0\n";
+            break;
+        }
+    }
+   
+
+    std::cout << "\n5. Disconnect from device: " << ioBoxIP << "\n";
+    bool disconnectStatus = infHandle->disconnectToIoboxWithResetOutputs(ioBoxIP);
+    if (disconnectStatus) {
+        std::cout << "Disconnected from IOBox successfully\n";
+    }
+    else {
+        std::cout << "Disconnection from IOBox failed\n";
+    }
+    std::cout << "\n6. Release ANSDAQ object\n";
+    delete infHandle;
+    std::cout << "Handle released successfully\n";
+	return 0;
+}
+int SimpleToggleTest() {
+
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "=== MULTITHREAD TOGGLE TEST START ===\n\n";
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+        return -1;
+    }
+
+    std::string ioBoxIP = "192.168.1.34"; // Set your actual IP
+    std::string username = "admin";
+    std::string password = "1234";
+
+    std::cout << "\n2. Connect to " << ioBoxIP << "\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    std::string deviceInfo;
+    int connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+    if (connectStatus == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+    std::cout << "\n3. Testing toggle scenarios for multiple channels\n\n";
+
+    for (int i = 0; i < 1000; i++) {
+        bool toggleResult=ToggleIoboxHandle(&infHandle, ioBoxIP.c_str(), "DO1", 5000, false, true);
+        if (!toggleResult) break;
+		std::cout << "\n--- Toggle iteration " << i + 1 << " completed ---\n" << std::endl;
+    
+    }
+    
+    int disconnectStatus = DisconnectANSIOHandle(&infHandle, ioBoxIP.c_str());
+    if (disconnectStatus == 1) {
+        std::cout << "Disconnected from IOBox successfully" << std::endl;
+    }
+    else {
+        std::cout << "Disconnection from IOBox failed" << std::endl;
+    }
+    std::cout << "\n5. Reset OI BOX " << ioBoxIP << std::endl;
+
+ 
+
+    std::cout << "\n6. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+    return 0;
+
+}
+
+int AsyncToggleTest() {
+
+    ANSCENTER::iobox_api* infHandle;
+    std::string multicastIPAddress = "239.255.255.250";
+    int multicastPort = 12345;
+
+    std::cout << "=== MULTITHREAD TOGGLE TEST START ===\n\n";
+
+    std::cout << "1. Create ANSDAQ object\n";
+    int createHandle = CreateANSIOHandle(&infHandle, multicastIPAddress.c_str(), multicastPort);
+    if (createHandle == 1) {
+        std::cout << "Handle created successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle creation failed" << std::endl;
+        return -1;
+    }
+
+    std::string ioBoxIP = "192.168.1.34"; // Set your actual IP
+    std::string username = "admin";
+    std::string password = "1234";
+
+    std::cout << "\n2. Connect to " << ioBoxIP << "\n";
+    std::cout << "Username:" << username << " Password:" << password << std::endl;
+    std::string deviceInfo;
+    int connectStatus = ConnectANSIOHandle_CPP(&infHandle, ioBoxIP.c_str(), 502, username.c_str(), password.c_str(), deviceInfo);
+    if (connectStatus == 1) {
+        std::cout << "Connected to IOBox successfully" << std::endl;
+        std::cout << "Device Info: " << deviceInfo << std::endl;
+    }
+    else {
+        std::cout << "Connection to IOBox failed" << std::endl;
+    }
+    std::cout << "\n3. Testing toggle scenarios for 5s channels\n\n";
+    bool toggleResult = false;
+    for (int i = 0; i < 1000; i++) {
+        toggleResult = ToggleIoboxHandleAsync(&infHandle, ioBoxIP.c_str(), "DO1", 5000, false, true);
+        Sleep(6000); // Let the async toggle run for a while
+        if (!toggleResult) {
+            std::cout << "Toggle operation failed to start." << std::endl;
+        }
+        else {
+            std::cout << "Toggle operation started successfully." << std::endl;
+        }
+    }
+
+
+    int disconnectStatus = DisconnectANSIOHandle(&infHandle, ioBoxIP.c_str());
+    if (disconnectStatus == 1) {
+        std::cout << "Disconnected from IOBox successfully" << std::endl;
+    }
+    else {
+        std::cout << "Disconnection from IOBox failed" << std::endl;
+    }
+    std::cout << "\n5. Reset OI BOX " << ioBoxIP << std::endl;
+
+
+
+    std::cout << "\n6. Release ANSDAQ object\n";
+    int releaseStatus = ReleaseANSIOHandle(&infHandle);
+    if (releaseStatus == 1) {
+        std::cout << "Handle released successfully" << std::endl;
+    }
+    else {
+        std::cout << "Handle release failed" << std::endl;
+    }
+    return 0;
+
+}
+int main() {
+    
+    //AsyncToggleTest();
+    //SimpleToggleTest();
+    //TestSetGet();
+    //ToggleTest();//
+   // AdvancedStaticScan();
+    //AdvancedScan();
+    //AdvancedConnectionTest();
+    //StressTest();
+    //ConnectTest();
+    //UpdateFirmwareTest();
+	//ConnectTest();
+    //GenTokenTest();
+    FullTest();
+   // testTimeStamp();
+    //ListWaveOutDevices();
+
+    // List devices and store them
+    //std::vector<DeviceInfo> deviceList;
+    //ListWaveOutDevices(deviceList);
+
+    //// Ask the user to choose a device by name
+    //std::wcout << "Enter the device name to use for playback: ";
+    //std::wstring deviceName;
+    //std::getline(std::wcin, deviceName);  // Get the device name as a string
+
+    //// Play a WAV file on the selected device
+    //std::string filePath = "test.wav"; // Replace with the actual WAV file path
+    //PlayWavOnDevice(filePath, deviceName);
+
+    return 0;
+}
diff --git a/tests/ANSIO-UnitTest/CMakeLists.txt b/tests/ANSIO-UnitTest/CMakeLists.txt
new file mode 100644
index 0000000..2750015
--- /dev/null
+++ b/tests/ANSIO-UnitTest/CMakeLists.txt
@@ -0,0 +1,23 @@
+# ANSIO Unit Test
+add_executable(ANSIO-UnitTest
+    ANSIO-UnitTest.cpp
+)
+
+target_include_directories(ANSIO-UnitTest PRIVATE
+    ${CMAKE_SOURCE_DIR}/integrations/ANSIO
+    ${CMAKE_SOURCE_DIR}/integrations/ANSIO/IOBox
+    ${SHARED_INCLUDE_DIR}
+)
+
+target_link_libraries(ANSIO-UnitTest
+    PRIVATE ANSIO
+    PRIVATE ANSLicensingSystem
+    PRIVATE anslicensing
+    PRIVATE labview
+)
+
+if(WIN32)
+    target_link_libraries(ANSIO-UnitTest PRIVATE ${WIN_COMMON_LIBS})
+endif()
+
+target_compile_definitions(ANSIO-UnitTest PRIVATE UNICODE _UNICODE)
diff --git a/tests/ANSLS-UnitTest/ANSLS-UnitTest.cpp b/tests/ANSLS-UnitTest/ANSLS-UnitTest.cpp
new file mode 100644
index 0000000..12f798e
--- /dev/null
+++ b/tests/ANSLS-UnitTest/ANSLS-UnitTest.cpp
@@ -0,0 +1,346 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string>
+#include <exception>
+#include <iostream>
+#include"ANSLicense.h"
+
+//#include <Windows.h>
+//#include <Wincrypt.h>
+
+int ANSFinalTemplate_ActivationExample() {
+	std::string  privateKey = "AQlSAiRTNtS7X20=";
+	std::string URL = "http://localhost:3001/";
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+	//std::string licenseTempatePath = "C:\\Projects\\ANLS\\LicenseTemplates\\ANSFinalTemplate.xml";
+	//bool loaded = ansHelper.LoadLicenseTemplate(licenseTempatePath);
+	//std::cout << "Load license template from file:" << loaded << std::endl;
+	// For fun to get HWID
+	std::string hwid = ansHelper.GetCurrentHardwareId();
+	std::cout << "HWID:" << hwid << std::endl;
+	std::string registrationName = "Alex Nguyen";
+	int productId = 1002;
+	int enableFeature = 1;
+	// Generate key based on productId
+	std::string generatedKey = ansHelper.GenerateKey(productId, registrationName, enableFeature, false);
+	std::cout << "Key:" << generatedKey << std::endl;
+	bool isLicenseKeyValid = ansHelper.IsLicenseKeyValid(generatedKey, registrationName);
+	std::cout << "Is license key valid:" << isLicenseKeyValid << std::endl;
+	enableFeature = 0;
+	bool result = ansHelper.CheckLicenseKey(generatedKey, registrationName, productId, enableFeature);
+	std::cout << "validation result:" << result << std::endl;
+	std::cout << "enable feature:" << enableFeature << std::endl;
+	std::string activationKey = "";
+	int validationResult;
+	validationResult = ansHelper.ValidateLicense(generatedKey, registrationName, activationKey);
+	validationResult = ansHelper.ActivateLicense(generatedKey, registrationName, activationKey);
+	std::cout << "validation result:" << validationResult << std::endl;
+	std::cout << "activation Key:" << activationKey << std::endl;
+	std::string   trialKey = "7JBVC-PGKW4-BCLXF-ERTJQ-JKHBT-KVLHR";
+	std::string licenseData = ansHelper.GetLicenseData(trialKey);
+	std::cout << "License Data" << licenseData << std::endl;
+	std::string offlineActivationData = "";
+	int resultOL= ansHelper.GenerateOfflineActivationData(generatedKey, registrationName, offlineActivationData);
+	std::cout << "Offline Activation Data" << offlineActivationData << std::endl;
+	return 0;
+}
+int GenerateKey() {
+	
+		std::string  privateKey = "AQlSAiRTNtS7X20=";
+		std::string URL = "http://localhost:3001/";
+		ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+		std::string licenseTempatePath = "C:\\Projects\\ANLS\\LicenseTemplates\\ANSFinalTemplate.xml";
+		bool loaded = ansHelper.LoadLicenseTemplate(licenseTempatePath);
+		std::cout << "Load license template from file:" << loaded << std::endl;
+		// For fun to get HWID
+		std::string hwid = ansHelper.GetCurrentHardwareId();
+		std::cout << "HWID:" << hwid << std::endl;
+		std::string registrationName = "Thinh Nguyen";
+		int productId = 1002;
+		int enableFeature = 12;
+		int efea = 0;
+		// Generate key based on productId
+		std::string generatedKey = ansHelper.GenerateKey(productId, registrationName, enableFeature, false);
+		std::cout << "Key:" << generatedKey << std::endl;
+		bool valid= ansHelper.CheckLicenseKey(generatedKey,registrationName, productId, efea);
+		std::cout << "License Valid:" << valid << " - feature:"<<efea<<std::endl;
+		std::string st = std::to_string(efea);
+		std::cout << "st:" << st<< std::endl;
+		std::string licenseData= ansHelper.GetLicenseData(generatedKey);
+		std::cout << "License Data:" << licenseData << std::endl;
+
+		// Activate license key
+		std::string licenseKey = "YGYSC-ABEE2-7UWKA-P9KQY-DJ95M-9TL5W";
+		std::string activationKey = "";
+		int validationResult = ansHelper.ActivateLicense(generatedKey, registrationName, activationKey);
+		std::cout << "Activation Ket:" << activationKey << std::endl;
+
+		return 0;
+
+}
+int ActivateOfflineLicense() {
+	//std::string  privateKey = "AQlSAiRTNtS7X20=";
+	//std::string URL = "http://localhost:3001/";
+	std::string  privateKey = "AQlSAiRTNtS7X20=";
+	std::string URL = "https://licensingservice.anscenter.com/";
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+
+	std::string hwid = ansHelper.GetCurrentHardwareId();
+	std::cout << "HWID:" << hwid << std::endl;
+	std::string registrationName = "Alex Nguyen";
+	int productId = 1002;
+	int enableFeature = 1;
+
+
+	std::string activationKey;
+	std::string licenseKey = ansHelper.GenerateKey(productId, registrationName, enableFeature, false);
+	std::cout << "Key:" << licenseKey << std::endl;
+
+	int result = ansHelper.ActivateLicenseWithCustomHWID(licenseKey, registrationName, hwid,activationKey);
+	std::cout << "Result:" << result << std::endl;
+
+	std::cout << "Actication Key:" << activationKey << std::endl;
+	//int result = ansHelper.InstallOfflineLicense(licenseKey, registrationName, activationKey);
+	//std::cout << "Offline Activation Data:" << result << std::endl;
+
+	return 0;
+}
+int ExtractModelZipFileTest() {
+	std::string zipFileName = "C:\\Projects\\Models\\ansgenericodcpu.zip"; // Replace with your ZIP file path
+	std::string modelOutputFolder;
+	ANSCENTER::ANSLSHelper::ExtractModelZipFile(zipFileName,"","MyTest", modelOutputFolder);
+	std::cout << "Model output folder:" << modelOutputFolder << std::endl;
+	std::string zipFilename = "C:\\Projects\\Models\\MyTest1.zip";
+	ANSCENTER::ANSLSHelper::ZipFolerWithPassword(modelOutputFolder, zipFilename, "Sh7O7nUe7vJ/417W0gWX+dSdfcP9hUqtf/fEqJGqxYL3PedvHubJag==");
+	return 0;
+}
+int GetLicenseDataExample() {
+
+	std::string  privateKey = "AQlSAiRTNtS7X20=";
+	std::string URL = "http://localhost:3001/";
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+	std::string licenseTempatePath = "C:\\Projects\\ANLS\\LicenseTemplates\\ANSFinalTemplate.xml";
+	bool loaded = ansHelper.LoadLicenseTemplate(licenseTempatePath);
+	std::cout << "Load license template from file:" << loaded << std::endl;
+	std::string licenseKey = "HE2JL-9JSFA-2QQ9K-FGSQQ-64KK9";
+	std::string licenseData = ansHelper.GetLicenseData(licenseKey);
+	std::cout << "License Data:" << licenseData << std::endl;
+
+	return 0;
+
+}
+int TestLocalTemplate() {
+
+	std::string  privateKey = "AQnZnrKokD4Qvbc=";
+	std::string URL =  "https://licensingservice.anscenter.com/"; //"http://localhost:3001/"
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+	std::string licenseTempatePath = "C:\\Projects\\ANLS\\LicenseTemplates\\ANSFinalTemplate.xml";
+	bool loaded = ansHelper.LoadLicenseTemplate(licenseTempatePath);
+	std::cout << "Load license template from file:" << loaded << std::endl;
+	// For fun to get HWID
+	std::string hwid = ansHelper.GetCurrentHardwareId();
+	std::cout << "HWID:" << hwid << std::endl;
+	std::string registrationName = "ANSVIS";
+	int productId = 1002;
+	int enableFeature = 0;
+	int efea = 0;
+
+	std::string licenseKey = "7NBZA-FMVEN-ZDZ4K-KXFBK-TUUES-8PHMA";//ansHelper.GenerateKey(productId, registrationName, enableFeature, false);
+
+	std::string licenseData = ansHelper.GetLicenseData(licenseKey);
+	std::cout << "License Data:" << licenseData << std::endl;
+
+	// Activate license key
+	std::string activationKey = "";
+	int validationResult = ansHelper.ActivateLicense(licenseKey, registrationName, activationKey);
+	std::cout << "Activation Ket:" << activationKey << std::endl;
+
+	return 0;
+
+}
+int GenerateOfflineActivationData() {
+
+	std::string  privateKey = "AQlSAiRTNtS7X20=";
+	std::string URL = "http://localhost:3001/";
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+	std::string licenseTempatePath = "C:\\Projects\\ANLS\\LicenseTemplates\\ANSFinalTemplate.xml";
+	bool loaded = ansHelper.LoadLicenseTemplate(licenseTempatePath);
+	std::cout << "Load license template from file:" << loaded << std::endl;
+	// For fun to get HWID
+	std::string hwid = ansHelper.GetCurrentHardwareId();
+	std::cout << "HWID:" << hwid << std::endl;
+	std::string registrationName = "Thinh Nguyen";
+	int productId = 1002;
+	int enableFeature = 12;
+	int efea = 0;
+	
+	// Generate key based on productId
+	std::string generatedKey = ansHelper.GenerateKey(productId, registrationName, enableFeature, false);
+	std::cout << "Key:" << generatedKey << std::endl;
+	std::string offlineActivationData = "";
+	// Generate offline activationd data
+	ansHelper.GenerateOfflineActivationData(generatedKey, registrationName, offlineActivationData);
+	std::cout << "Offline Activation Data:" << offlineActivationData << std::endl;
+
+	return 0;
+
+}
+int PrepareEgdeModel() {
+	std::string zipFileName = "C:\\Projects\\AICamera\\Documentation\\Model\\GenericModel.zip"; // Replace with your ZIP file path
+	std::string configContent = "";
+	std::string labelMapContent = "";
+	std::string modelZipFileContent = "";
+	ANSCENTER::ANSLSHelper::PrepareEdgeModel(zipFileName, "", "egde123", "GenericModel", "3456", configContent, labelMapContent, modelZipFileContent);
+
+	std::cout << "configContent:" << configContent << std::endl;
+	std::cout << "labelMapContent:" << labelMapContent << std::endl;
+	std::cout << "modelZipFileContent:" << modelZipFileContent << std::endl;
+
+	return 0;
+}
+int ValidateExample() {
+
+	std::string  privateKey = "AQlSAiRTNtS7X20=";
+	std::string URL =  "https://licensingservice.anscenter.com/";
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+	std::string licenseTempatePath = "C:\\Projects\\ANLS\\LicenseTemplates\\ANSFinalTemplate.xml";
+	bool loaded = ansHelper.LoadLicenseTemplate(licenseTempatePath);
+	std::cout << "Load license template from file:" << loaded << std::endl;
+	// For fun to get HWID
+	std::string hwid = ansHelper.GetCurrentHardwareId();
+	std::cout << "HWID:" << hwid << std::endl;
+	std::string registrationName = "ANSVIS";
+	std::string licenseKey = "7NB8A-V5DSA-YKHHX-52JGM-UJCQE-3K9VL";//GV6SA-AAA7W-6YSWG-9QRRN-QKUAF-EHYMH
+	std::string activationKey;
+	// Generate key based on productId
+	std::string licenseData = ansHelper.GetLicenseData(licenseKey);
+	std::cout << "licenseData:" << licenseData << std::endl;
+
+	ansHelper.ValidateLicense(licenseKey, registrationName, activationKey);
+	std::cout << "activationKey:" << activationKey << std::endl;
+	bool validationResult = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey,10, registrationName);
+	std::cout << "validationResult:" << validationResult << std::endl;
+
+	return 0;
+
+}
+int getSystemInformation() {
+	std::string systemInfo=ANSCENTER::ANSLSHelper::GetSystemHardwareInformation();
+	std::cout << "system info:" << systemInfo << std::endl;
+	std::string validationData = "QU5OSFVCLUxWAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==";
+	std::string decodedData = ANSCENTER::ANSLicenseHelper::DecodeValidationData(validationData.c_str());
+	std::cout << "validation data:" << decodedData << std::endl;
+	std::string licenseString = ANSCENTER::ANSLicenseHelper::ListLicenses();
+	std::cout << "Licenses=" << licenseString << std::endl;
+	return 1;
+}
+int ModelConversionTest() {
+	std::string modelZipFile = "C:\\Programs\\TrainingAIs\\ODHUB\\New folder\\Mask_1.zip";
+	std::string modelPassword = "Sh7O7nUe7vJ/417W0gWX+dSdfcP9hUqtf/fEqJGqxYL3PedvHubJag==";
+	int result = ANSModelConversion(modelZipFile.c_str(), modelPassword.c_str());
+	std::cout << "Model conversion result:" << result << std::endl;
+	return 0;
+}
+
+int RemoveTrialLicenseKey() {
+	std::string registrationName = "ANSVIS";
+	bool result = ANSCENTER::ANSLicenseHelper::RemoveTrialLicenseKeys(registrationName);
+	std::cout << "Remove trial license key:" << result << std::endl;
+	return 0;
+}
+
+
+int ActivateOfflineLicenseCHWID() {
+	std::string  privateKey = "AQlSAiRTNtS7X20=";
+	std::string URL = "https://licensingservice.anscenter.com/";
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+
+	std::string hwid = "HZ47Y-MDEFC-CCTBB-JVCGJ-Y3AHA";
+	std::string registrationName = "ANSTS";
+	int productId = 1008;
+	int enableFeature = 1;
+
+	std::string activationKey;
+	std::string licenseKey = "8ABZB-MDY6K-CSL85-NXH4L-GL6G3-U9E3S";
+	std::cout << "Key:" << licenseKey << std::endl;
+
+	int result = ansHelper.ActivateLicenseWithCustomHWID(licenseKey, registrationName, hwid, activationKey);
+	std::cout << "Result:" << result << std::endl;
+
+	std::cout << "Actication Key:" << activationKey << std::endl;
+	//int result = ansHelper.InstallOfflineLicense(licenseKey, registrationName, activationKey);
+	//std::cout << "Offline Activation Data:" << result << std::endl;
+
+	return 0;
+}
+int InstallOfflineActivationKey() {
+	std::string  privateKey = "AQlSAiRTNtS7X20=";
+	std::string URL = "https://licensingservice.anscenter.com/";
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+	std::string registrationName = "ANSTS";
+	std::string activationKey = "GGNAA-AGA9T-TH74A-BSX63-N3Y6W-7277F";
+	std::string licenseKey = "8AB2A-GJVND-K4SXB-W5S2D-E4ZA8-45ZFK";
+	int result = ansHelper.InstallOfflineLicense(licenseKey, registrationName, activationKey);
+	std::cout << "Offline Activation Data:" << result << std::endl;
+	return 0;
+}
+// Test validate license with invalid license key
+int TestValidateExample() {
+
+	std::string  privateKey = "AQlSAiRTNtS7X20=";
+	std::string URL = "https://licensingservice.anscenter.com/";
+	ANSCENTER::ANSLSHelper ansHelper(privateKey, URL);
+	//std::string licenseTempatePath = "C:\\Projects\\ANLS\\LicenseTemplates\\ANSFinalTemplate.xml";
+	//bool loaded = ansHelper.LoadLicenseTemplate(licenseTempatePath);
+	//std::cout << "Load license template from file:" << loaded << std::endl;
+	// For fun to get HWID
+	std::string systemhwid = ansHelper.GetCurrentHardwareId();
+	//std::string hwid =  "HZ47Y-MDEFC-CCTBB-JVLYU-JLAEA";// ansHelper.GetCurrentHardwareId();
+	//std::cout << "HWID:" << hwid << std::endl;
+	std::cout << "System HWID:" << systemhwid << std::endl;
+	//std::string registrationName = "ANSTS";
+	//std::string licenseKey = "8ABTB-BPEQE-H3BR5-G53JX-8LW2N-MMXA2";// "8AB3A-3HVJX-YMU4T-7KXX4-B3XYS-A249S";// "7NB8A-V5DSA-YKHHX-52JGM-UJCQE-3K9VL";//GV6SA-AAA7W-6YSWG-9QRRN-QKUAF-EHYMH
+	//std::string activationKey;
+	//// Generate key based on productId
+	//std::string licenseData = ansHelper.GetLicenseData(licenseKey);
+	//std::cout << "licenseData:" << licenseData << std::endl;
+
+	////ansHelper.ValidateLicenseWithCustomHWID(licenseKey, registrationName, hwid,activationKey);
+	//ansHelper.ValidateLicense(licenseKey, registrationName, activationKey);
+
+	//std::cout << "activationKey:" << activationKey << std::endl;
+	//bool validationResult = ANSCENTER::ANSLicenseHelper::LicenseVerification(licenseKey, 10, registrationName);
+	//std::cout << "validationResult:" << validationResult << std::endl;
+
+	return 0;
+
+}
+
+int main()
+{
+	TestValidateExample();
+	//std::cout << "_MSC_VER: " << _MSC_VER << std::endl;
+	//std::cout << "Start tesing..." << std::endl;
+	//RemoveTrialLicenseKey();
+	//getSystemInformation();
+	//ValidateExample();
+	//GenerateOfflineActivationData();
+	//TestLocalTemplate();
+	//GetLicenseDataExample();
+	//GenerateKey();
+	//ANSFinalTemplate_ActivationExample();
+	//InstallOfflineActivationKey();
+	//ActivateOfflineLicenseCHWID();
+	//ActivateOfflineLicense();	
+	// Utility
+	//ANSCENTER::EngineType engineType = ANSCENTER::ANSLicenseHelper::CheckHardwareInformation();
+	//std::cout << "Engine Type:" << engineType << std::endl;
+	//ExtractModelZipFileTest();
+	//PrepareEgdeModel();
+	std::cin.get();
+	//ModelConversionTest();
+	//getSystemInformation();
+	//ExtractModelZipFileTest();
+	std::cout << "End of program" << std::endl;
+}
+
diff --git a/tests/ANSLS-UnitTest/CMakeLists.txt b/tests/ANSLS-UnitTest/CMakeLists.txt
new file mode 100644
index 0000000..ea95ad8
--- /dev/null
+++ b/tests/ANSLS-UnitTest/CMakeLists.txt
@@ -0,0 +1,19 @@
+# ANSLS (ANSLicensingSystem) Unit Test
+add_executable(ANSLS-UnitTest
+    ANSLS-UnitTest.cpp
+)
+
+target_include_directories(ANSLS-UnitTest PRIVATE
+    ${SHARED_INCLUDE_DIR}
+)
+
+target_link_libraries(ANSLS-UnitTest
+    PRIVATE ANSLicensingSystem
+    PRIVATE labview
+)
+
+if(WIN32)
+    target_link_libraries(ANSLS-UnitTest PRIVATE ${WIN_COMMON_LIBS})
+endif()
+
+target_compile_definitions(ANSLS-UnitTest PRIVATE UNICODE _UNICODE)
diff --git a/tests/ANSODTRE-UnitTest/ANSODTRE-UnitTest.cpp b/tests/ANSODTRE-UnitTest/ANSODTRE-UnitTest.cpp
new file mode 100644
index 0000000..ec7e519
--- /dev/null
+++ b/tests/ANSODTRE-UnitTest/ANSODTRE-UnitTest.cpp
@@ -0,0 +1,491 @@
+
+#include "ANSODTraininingEngine.h"
+#include "ANSYOLOTrainingEngine.h"
+#include "ANSYOLOCLTrainingEngine.h"
+#include "ANSYOLOSEGTrainingEngine.h"
+#include "ANSTrainingEngine.h"
+#include <fstream>
+#include <sstream>
+#include <string>
+std::string readFileContent(const std::string& filePath) {
+	std::ifstream fileStream(filePath);
+	if (fileStream.is_open()) {
+		std::string content((std::istreambuf_iterator<char>(fileStream)),
+			std::istreambuf_iterator<char>());
+		return content;
+	}
+
+}
+int TestANSODTRE() {// For Older ODHUB version
+	ANSCENTER::ANSODTRE ansEngine;
+	std::string projectDirectory = "C:\\ProgramData\\Sh7O7nUe7vJ";
+	std::string engineFolderDir = "C:\\ProgramData\\ANSCENTER\\Shared";
+	std::string modelTemplateDir = "C:\\ProgramData\\ANSCENTER\\Shared";
+	bool initResult = ansEngine.Init("", projectDirectory, engineFolderDir, modelTemplateDir, "",true);
+	std::cout << "Init Result" << initResult << std::endl;
+	std::vector<std::string> projects = ansEngine.GetProjects();
+	if (projects.size() > 0) {
+		for (int i = 0; i < projects.size(); i++) {
+			std::cout << "Project Name:" << projects[i] << std::endl;
+			std::vector<std::string> experiments = ansEngine.GetProjectExperiments(projects[i]);
+			if (experiments.size() > 0) {
+				for (int i = 0; i < experiments.size(); i++) {
+					std::cout << "-- Project Experiment:" << experiments[i] << std::endl;
+				}
+			}
+		}
+	}
+
+	projects = ansEngine.GetProjects();
+	if (projects.size() > 0) {
+		for (int i = 0; i < projects.size(); i++) {
+			std::cout << "Project Name:" << projects[i] << std::endl;
+			std::vector<std::string> experiments = ansEngine.GetProjectExperiments(projects[i]);
+			if (experiments.size() > 0) {
+				for (int i = 0; i < experiments.size(); i++) {
+					std::cout << "-- Project Experiment:" << experiments[i] << std::endl;
+				}
+			}
+		}
+	}
+
+	// Set the working directory
+	bool setWorkingDirectory = ansEngine.SetWorkingDirectory("C:\\Programs\\AITraining\\LPDetection");
+	if (!setWorkingDirectory)std::cout << "Working Directory Not Set" << std::endl;
+
+
+	//1. Create a project
+	bool createdProject = ansEngine.CreateProject("LicensePlate");
+	if (!createdProject)std::cout << "Project Not Created" << std::endl;
+
+	//2. Browse to the working directory
+
+	projectDirectory = ansEngine.GetProjectDirectory();
+	std::cout << "Project Directory:" << projectDirectory << std::endl;
+
+	bool dataUploaded = ansEngine.UploadTrainingData("LicensePlate");
+	if (!dataUploaded)std::cout << "Cannot upload data" << std::endl;
+
+	//3. Create a training engine
+
+	bool createEngine = ansEngine.CreateTrainingEngine("LicensePlate", 1, 0, 2000, 32, 0.001);
+	if (!createEngine)std::cout << "Cannot create engine" << std::endl;
+
+	std::string projectExperimentStatus = ansEngine.GetProjectExperimentStatus("LicensePlate", 1);
+	std::cout << projectExperimentStatus << std::endl;
+
+	std::string trainingCommand = ansEngine.GenerateTrainingCommand("LicensePlate", 1, 0);
+	std::cout << "Training Command:" << trainingCommand << std::endl;
+
+	//4. Evaluate the model
+	std::string evaluateModelCommand = ansEngine.EvaluateModel("LicensePlate", 1);
+	std::cout << "Evaluation Result:" << evaluateModelCommand << std::endl;
+
+	//5. Download the model
+	std::string saveModelPath = "C:\\Programs\\AITraining\\LPDetection\\Models";
+	ansEngine.DownloadModel("LicensePlate", 1, saveModelPath);
+	return 0;
+}
+int TestANSYLTRE() {// For New Yolo version
+	ANSCENTER::ANYLTRE ansEngine;
+	std::string projectDirectory = "";
+	std::string engineFolderDir = "";
+	std::string modelTemplateDir = "";
+	bool initResult = ansEngine.Init("", projectDirectory, engineFolderDir, modelTemplateDir, "",true);
+	std::cout << "Init Result" << initResult << std::endl;
+	std::vector<std::string> projects = ansEngine.GetProjects();
+	if (projects.size() > 0) {
+		for (int i = 0; i < projects.size(); i++) {
+			std::cout << "Project Name:" << projects[i] << std::endl;
+			std::vector<std::string> experiments = ansEngine.GetProjectExperiments(projects[i]);
+			if (experiments.size() > 0) {
+				for (int i = 0; i < experiments.size(); i++) {
+					std::cout << "-- Project Experiment:" << experiments[i] << std::endl;
+				}
+			}
+		}
+	}
+
+	projects = ansEngine.GetProjects();
+	if (projects.size() > 0) {
+		for (int i = 0; i < projects.size(); i++) {
+			std::cout << "Project Name:" << projects[i] << std::endl;
+			std::vector<std::string> experiments = ansEngine.GetProjectExperiments(projects[i]);
+			if (experiments.size() > 0) {
+				for (int i = 0; i < experiments.size(); i++) {
+					std::cout << "-- Project Experiment:" << experiments[i] << std::endl;
+				}
+			}
+		}
+	}
+
+	//// Set the working directory
+	bool setWorkingDirectory = ansEngine.SetWorkingDirectory("C:\\Programs\\TrainingToolTest\\CocoTest");
+	if (!setWorkingDirectory)std::cout << "Working Directory Not Set" << std::endl;
+
+
+	////1. Create a project
+	bool createdProject = ansEngine.CreateProject("CocoTest");
+	if (!createdProject)std::cout << "Project Not Created" << std::endl;
+
+	////2. Browse to the working directory
+	projectDirectory = ansEngine.GetProjectDirectory();
+	std::cout << "Project Directory:" << projectDirectory << std::endl;
+
+	bool dataUploaded = ansEngine.UploadTrainingData("CocoTest");
+	if (!dataUploaded)std::cout << "Cannot upload data" << std::endl;
+
+	//////3. Create a training engine
+
+	bool createEngine = ansEngine.CreateTrainingEngine("CocoTest", 1, 0, 2000, 32, 0.001);
+	if (!createEngine)std::cout << "Cannot create engine" << std::endl;
+
+	std::string projectExperimentStatus = ansEngine.GetProjectExperimentStatus("CocoTest", 1);
+	std::cout << projectExperimentStatus << std::endl;
+
+	std::string trainingCommand = ansEngine.GenerateTrainingCommand("CocoTest", 1, 0);
+	std::cout << "Training Command:" << trainingCommand << std::endl;
+
+	//// 4. Evaluate the model
+	std::string evaluateModelCommand = ansEngine.EvaluateModel("CocoTest", 1);
+	std::cout << "Evaluation Result:" << evaluateModelCommand << std::endl;
+
+	//// 5. Download the model
+	std::string saveModelPath = "C:\\Programs\\TrainingToolTest\\CocoTest\\Models";
+	ansEngine.DownloadModel("CocoTest", 1, saveModelPath, 0);
+	ansEngine.DownloadModel("CocoTest", 1, saveModelPath, 1);
+
+	return 0;
+}
+int TestANSYLCLTRE() {// For Classfication
+	ANSCENTER::ANYLCLTRE ansEngine;
+	std::string projectDirectory = "";
+	std::string engineFolderDir = "";
+	std::string modelTemplateDir = "";
+	bool initResult = ansEngine.Init("", projectDirectory, engineFolderDir, modelTemplateDir, "", true);
+	std::cout << "Init Result" << initResult << std::endl;
+	std::vector<std::string> projects = ansEngine.GetProjects();
+	if (projects.size() > 0) {
+		for (int i = 0; i < projects.size(); i++) {
+			std::cout << "Project Name:" << projects[i] << std::endl;
+			std::vector<std::string> experiments = ansEngine.GetProjectExperiments(projects[i]);
+			if (experiments.size() > 0) {
+				for (int i = 0; i < experiments.size(); i++) {
+					std::cout << "-- Project Experiment:" << experiments[i] << std::endl;
+				}
+			}
+		}
+	}
+
+	projects = ansEngine.GetProjects();
+	if (projects.size() > 0) {
+		for (int i = 0; i < projects.size(); i++) {
+			std::cout << "Project Name:" << projects[i] << std::endl;
+			std::vector<std::string> experiments = ansEngine.GetProjectExperiments(projects[i]);
+			if (experiments.size() > 0) {
+				for (int i = 0; i < experiments.size(); i++) {
+					std::cout << "-- Project Experiment:" << experiments[i] << std::endl;
+				}
+			}
+		}
+	}
+
+	//// Set the working directory
+	bool setWorkingDirectory = ansEngine.SetWorkingDirectory("C:\\Programs\\TrainingToolTest\\Classification\\FMTest");
+	if (!setWorkingDirectory)std::cout << "Working Directory Not Set" << std::endl;
+
+
+	////1. Create a project
+	bool createdProject = ansEngine.CreateProject("FireNSmokeClassifier");
+	if (!createdProject)std::cout << "Project Not Created" << std::endl;
+
+	////2. Browse to the working directory
+	//projectDirectory = ansEngine.GetProjectDirectory();
+	//std::cout << "Project Directory:" << projectDirectory << std::endl;
+
+	//bool dataUploaded = ansEngine.UploadTrainingData("FMTest");
+	//if (!dataUploaded)std::cout << "Cannot upload data" << std::endl;
+
+	//////3. Create a training engine
+
+	bool createEngine = ansEngine.CreateTrainingEngine("FireNSmokeClassifier", 1, 0, 2000, 32, 0.001);
+	if (!createEngine)std::cout << "Cannot create engine" << std::endl;
+
+	std::string projectExperimentStatus = ansEngine.GetProjectExperimentStatus("FireNSmokeClassifier", 1);
+	std::cout << projectExperimentStatus << std::endl;
+
+	std::string trainingCommand = ansEngine.GenerateTrainingCommand("FireNSmokeClassifier", 1, 0);
+	std::cout << "Training Command:" << trainingCommand << std::endl;
+
+	//// 4. Evaluate the model
+	std::string evaluateModelCommand = ansEngine.EvaluateModel("FireNSmokeClassifier", 1);
+	std::cout << "Evaluation Result:" << evaluateModelCommand << std::endl;
+
+	//// 5. Download the model
+	std::string saveModelPath = "C:\\Programs\\TrainingToolTest\\Classification\\FMTest\\Models";
+	//ansEngine.DownloadModel("FireNSmokeClassifier", 1, saveModelPath, 0);
+	ansEngine.DownloadModel("FireNSmokeClassifier", 1, saveModelPath, 1);
+
+	return 0;
+}
+
+int TestANSTRE() {// 
+	ANSCENTER::ANYLTRE ansEngine;
+	std::string projectDirectory = "";
+	std::string engineFolderDir = "";
+	std::string modelTemplateDir = "";
+	ANSCENTER::ANSTRE* infHandle;
+	int trainingEngineType = 1;
+	// Create the handle
+	bool initResult = CreateANSTREHandle(&infHandle, "", projectDirectory.c_str(), engineFolderDir.c_str(), modelTemplateDir.c_str(), "", trainingEngineType,true);
+	std::cout << "Init Result" << initResult << std::endl;
+
+	std::string strProjects;
+	ANSTRE_GetProjects_CPP(&infHandle, strProjects);
+	std::cout << "Projects:" << strProjects << std::endl;
+
+
+	//// Set the working directory
+	bool setWorkingDirectory=ANSTRE_SetWorkingDirectory(&infHandle, "C:\\Programs\\AITraining\\LPDetection");
+	if (!setWorkingDirectory)std::cout << "Working Directory Not Set" << std::endl;
+	
+	////1. Create a project
+	bool createdProject =ANSTRE_CreateProject(&infHandle, "LicensePlate");
+	if (!createdProject)std::cout << "Project Not Created" << std::endl;
+
+	////2. Browse to the working directory
+	ANSTRE_GetProjectDirectory_CPP(&infHandle, projectDirectory);
+	std::cout << "Project Directory:" << projectDirectory << std::endl;
+
+	std::string trainingResultFile ="C:\\Projects\\ANLS\\Documents\\trainingResults.txt";
+	std::string trainingResuls= readFileContent(trainingResultFile);
+	std::string parsedResults;
+	ANSTRE_ParseTrainingResults_CPP(&infHandle, trainingResuls.c_str(), parsedResults);
+	std::cout << "Parsed Results:" << parsedResults << std::endl;
+
+
+	bool dataUploaded = ANSTRE_UploadTrainingData(&infHandle, "LicensePlate");
+	if (!dataUploaded)std::cout << "Cannot upload data" << std::endl;
+
+	//////3. Create a training engine
+	bool createEngine = ANSTRE_CreateTrainingEngine(&infHandle, "LicensePlate", 1, 0, 2000, 32, 0.001);
+	if (!createEngine)std::cout << "Cannot create engine" << std::endl;
+
+	std::string projectExperimentStatus;
+	ANSTRE_GetProjectExperimentStatus_CPP(&infHandle, "LicensePlate", 1, projectExperimentStatus);
+	std::cout << projectExperimentStatus << std::endl;
+
+	std::string trainingCommand;
+	ANSTRE_GenerateTrainingCommand_CPP(&infHandle, "LicensePlate", 1, 0, trainingCommand);
+	std::cout << "Training Command:" << trainingCommand << std::endl;
+
+	//// 4. Evaluate the model
+	std::string mAPResult;
+	ANSTRE_EvaluateModel_CPP(&infHandle, "LicensePlate", 1, mAPResult);
+	std::cout << "Evaluation Result:" << mAPResult << std::endl;
+
+	//// 5. Download the model
+	std::string saveModelPath = "C:\\Programs\\AITraining\\LPDetection\\Models";
+	ANSTRE_DownloadModel(&infHandle, "LicensePlate", 1, saveModelPath.c_str(), 0);
+	if(trainingEngineType==1) ANSTRE_DownloadModel(&infHandle, "LicensePlate", 1, saveModelPath.c_str(), 1);
+
+	return 0;
+}
+int FaceMaskDetection() {// 
+	ANSCENTER::ANYLTRE ansEngine;
+	std::string projectDirectory = "";
+	std::string engineFolderDir = "";
+	std::string modelTemplateDir = "C:\\Program Files\\ANSCENTER\\ANS Object Detection\\data";
+	ANSCENTER::ANSTRE* infHandle;
+	int trainingEngineType = 0;
+	// Create the handle
+	bool initResult = CreateANSTREHandle(&infHandle, "", projectDirectory.c_str(), engineFolderDir.c_str(), modelTemplateDir.c_str(), "", trainingEngineType,true);
+	std::cout << "Init Result" << initResult << std::endl;
+
+	std::string strProjects;
+	ANSTRE_GetProjects_CPP(&infHandle, strProjects);
+	std::cout << "Projects:" << strProjects << std::endl;
+
+
+	//// Set the working directory
+	bool setWorkingDirectory = ANSTRE_SetWorkingDirectory(&infHandle, "C:\\Programs\\AITraining\\Mask");
+	if (!setWorkingDirectory)std::cout << "Working Directory Not Set" << std::endl;
+
+	////1. Create a project
+	bool createdProject = ANSTRE_CreateProject(&infHandle, "Face Mask 5");
+	if (!createdProject)std::cout << "Project Not Created" << std::endl;
+
+	////2. Browse to the working directory
+	ANSTRE_GetProjectDirectory_CPP(&infHandle, projectDirectory);
+	std::cout << "Project Directory:" << projectDirectory << std::endl;
+
+	bool dataUploaded = ANSTRE_UploadTrainingData(&infHandle, "Face Mask 5");
+	if (!dataUploaded)std::cout << "Cannot upload data" << std::endl;
+
+	//////3. Create a training engine
+	bool createEngine = ANSTRE_CreateTrainingEngine (& infHandle, "Face Mask 5", 1, 3, 2000, 1, 0.001);
+	if (!createEngine)std::cout << "Cannot create engine" << std::endl;
+
+	std::string projectExperimentStatus;
+	ANSTRE_GetProjectExperimentStatus_CPP(&infHandle, "Face Mask 5", 1, projectExperimentStatus);
+	std::cout << projectExperimentStatus << std::endl;
+
+	std::string trainingCommand;
+	ANSTRE_GenerateTrainingCommand_CPP(& infHandle, "Face Mask 5", 1, 3, trainingCommand);
+	std::cout << "Training Command:" << trainingCommand << std::endl;
+
+	//// 4. Evaluate the model
+	std::string mAPResult;
+	ANSTRE_EvaluateModel_CPP(&infHandle, "Face_Mask_3", 1, mAPResult);
+	std::cout << "Evaluation Result:" << mAPResult << std::endl;
+
+	//// 5. Download the model
+	std::string saveModelPath = "C:\\Programs\\AITraining\\Mask\\Models";
+	ANSTRE_DownloadModel(&infHandle, "LicensePlate", 1, saveModelPath.c_str(), 0);
+	if (trainingEngineType == 1) ANSTRE_DownloadModel(&infHandle, "Face Mask 5", 1, saveModelPath.c_str(), 1);
+	return 0;
+}
+int FallDetection() {
+	ANSCENTER::ANYLTRE ansEngine;
+	std::string projectDirectory = "";
+	std::string engineFolderDir = "";
+	std::string modelTemplateDir = "";
+	ANSCENTER::ANSTRE* infHandle;
+	int trainingEngineType = 0; // Using the Yolov8
+	// Create the handle
+	bool initResult = CreateANSTREHandle(&infHandle, "", projectDirectory.c_str(), engineFolderDir.c_str(), modelTemplateDir.c_str(), "", trainingEngineType,false);
+	std::cout << "Init Result" << initResult << std::endl;
+
+
+	int engineInstalled= ANSTRE_CheckEngine(&infHandle);
+	std::cout << "Engine Installed:" << engineInstalled << std::endl;
+	std::string strProjects;
+	ANSTRE_GetProjects_CPP(&infHandle, strProjects);
+	std::cout << "Projects:" << strProjects << std::endl;
+
+	//// Set the working directory
+	bool setWorkingDirectory = ANSTRE_SetWorkingDirectory(&infHandle, "C:\\Programs\\TrainingWorkingStation\\Projects\\FallDetection");
+	if (!setWorkingDirectory)std::cout << "Working Directory Not Set" << std::endl;
+
+	////1. Create a project
+	bool createdProject = ANSTRE_CreateProject(&infHandle, "Fall Detection");
+	if (!createdProject)std::cout << "Project Not Created" << std::endl;
+
+	////2. Browse to the working directory
+	ANSTRE_GetProjectDirectory_CPP(&infHandle, projectDirectory);
+	std::cout << "Project Directory:" << projectDirectory << std::endl;
+
+	bool dataUploaded = ANSTRE_UploadTrainingData(&infHandle, "Fall Detection");
+	if (!dataUploaded)std::cout << "Cannot upload data" << std::endl;
+
+	//////3. Create a training engine
+	bool createEngine = ANSTRE_CreateTrainingEngine(&infHandle, "Fall Detection", 1, 3, 2000, 1, 0.001);
+	if (!createEngine)std::cout << "Cannot create engine" << std::endl;
+
+	std::string projectExperimentStatus;
+	ANSTRE_GetProjectExperimentStatus_CPP(&infHandle, "Fall Detection", 1, projectExperimentStatus);
+	std::cout << projectExperimentStatus << std::endl;
+
+	std::string trainingCommand;
+	ANSTRE_GenerateTrainingCommand_CPP(&infHandle, "Fall Detection", 1, 3, trainingCommand);
+	std::cout << "Training Command:" << trainingCommand << std::endl;
+
+	//// 4. Evaluate the model
+	std::string mAPResult;
+	ANSTRE_EvaluateModel_CPP(&infHandle, "Fall Detection", 1, mAPResult);
+	std::cout << "Evaluation Result:" << mAPResult << std::endl;
+
+	//// 5. Download the model
+	std::string saveModelPath = "C:\\Programs\\TrainingWorkingStation\\Projects\\FallDetection\\Models";
+	ANSTRE_DownloadModel(&infHandle, "FallDetection", 1, saveModelPath.c_str(), 0);
+	if (trainingEngineType == 1) ANSTRE_DownloadModel(&infHandle, "Fall Detection", 1, saveModelPath.c_str(), 1);
+
+	return 0;
+}
+
+// Segmentaion
+int TestSegmentationEngine() {// For New Yolo version
+	ANSCENTER::ANYLSEGTRE ansEngine;
+	std::string projectDirectory = "";
+	std::string engineFolderDir = "";
+	std::string modelTemplateDir = "";
+	bool initResult = ansEngine.Init("", projectDirectory, engineFolderDir, modelTemplateDir, "", true);
+	std::cout << "Init Result" << initResult << std::endl;
+	std::vector<std::string> projects = ansEngine.GetProjects();
+	if (projects.size() > 0) {
+		for (int i = 0; i < projects.size(); i++) {
+			std::cout << "Project Name:" << projects[i] << std::endl;
+			std::vector<std::string> experiments = ansEngine.GetProjectExperiments(projects[i]);
+			if (experiments.size() > 0) {
+				for (int i = 0; i < experiments.size(); i++) {
+					std::cout << "-- Project Experiment:" << experiments[i] << std::endl;
+				}
+			}
+		}
+	}
+
+	projects = ansEngine.GetProjects();
+	if (projects.size() > 0) {
+		for (int i = 0; i < projects.size(); i++) {
+			std::cout << "Project Name:" << projects[i] << std::endl;
+			std::vector<std::string> experiments = ansEngine.GetProjectExperiments(projects[i]);
+			if (experiments.size() > 0) {
+				for (int i = 0; i < experiments.size(); i++) {
+					std::cout << "-- Project Experiment:" << experiments[i] << std::endl;
+				}
+			}
+		}
+	}
+
+	//// Set the working directory
+	bool setWorkingDirectory = ansEngine.SetWorkingDirectory("C:\\Programs\\TrainingToolTest\\SegmentationEngine\\SegmeTxtYolo");
+	if (!setWorkingDirectory)std::cout << "Working Directory Not Set" << std::endl;
+
+
+	////1. Create a project
+	bool createdProject = ansEngine.CreateProject("SegmentationTest");
+	if (!createdProject)std::cout << "Project Not Created" << std::endl;
+
+	////2. Browse to the working directory
+	projectDirectory = ansEngine.GetProjectDirectory();
+	std::cout << "Project Directory:" << projectDirectory << std::endl;
+
+	bool dataUploaded = ansEngine.UploadTrainingData("SegmentationTest");
+	if (!dataUploaded)std::cout << "Cannot upload data" << std::endl;
+
+	//////3. Create a training engine
+
+	bool createEngine = ansEngine.CreateTrainingEngine("SegmentationTest", 1, 0, 2000, 32, 0.001);
+	if (!createEngine)std::cout << "Cannot create engine" << std::endl;
+
+	std::string projectExperimentStatus = ansEngine.GetProjectExperimentStatus("SegmentationTest", 1);
+	std::cout << projectExperimentStatus << std::endl;
+
+	std::string trainingCommand = ansEngine.GenerateTrainingCommand("SegmentationTest", 1, 0);
+	std::cout << "Training Command:" << trainingCommand << std::endl;
+
+	//// 4. Evaluate the model
+	std::string evaluateModelCommand = ansEngine.EvaluateModel("SegmentationTest", 1);
+	std::cout << "Evaluation Result:" << evaluateModelCommand << std::endl;
+
+	//// 5. Download the model
+	std::string saveModelPath = "C:\\Programs\\TrainingToolTest\\SegmentationEngine\\SegmeTxtYolo\\Models";
+	ansEngine.DownloadModel("SegmentationTest", 1, saveModelPath, 0);
+	ansEngine.DownloadModel("SegmentationTest", 1, saveModelPath, 1);
+
+	return 0;
+}
+
+int main()
+{
+	TestSegmentationEngine();	
+	//TestANSYLTRE();
+	//TestANSYLCLTRE();
+	//FallDetection();
+	//TestANSTRE();
+	//FaceMaskDetection();
+	//TestANSTRE();
+	//TestANSODTRE();
+	//TestANSYLTRE();
+	return 0;
+}
\ No newline at end of file
diff --git a/tests/ANSODTRE-UnitTest/CMakeLists.txt b/tests/ANSODTRE-UnitTest/CMakeLists.txt
new file mode 100644
index 0000000..b645509
--- /dev/null
+++ b/tests/ANSODTRE-UnitTest/CMakeLists.txt
@@ -0,0 +1,21 @@
+# ANSODTRE (ANSTrainingEngine) Unit Test
+add_executable(ANSODTRE-UnitTest
+    ANSODTRE-UnitTest.cpp
+)
+
+target_include_directories(ANSODTRE-UnitTest PRIVATE
+    ${CMAKE_SOURCE_DIR}/modules/ANSTrainingEngine
+    ${SHARED_INCLUDE_DIR}
+)
+
+target_link_libraries(ANSODTRE-UnitTest
+    PRIVATE ANSTrainingEngine
+    PRIVATE ANSLicensingSystem
+    PRIVATE anslicensing
+)
+
+if(WIN32)
+    target_link_libraries(ANSODTRE-UnitTest PRIVATE ${WIN_COMMON_LIBS})
+endif()
+
+target_compile_definitions(ANSODTRE-UnitTest PRIVATE UNICODE _UNICODE)
diff --git a/tests/ANSONVIF-UnitTest/ANSONVIF-UnitTest.cpp b/tests/ANSONVIF-UnitTest/ANSONVIF-UnitTest.cpp
new file mode 100644
index 0000000..0fbda3b
--- /dev/null
+++ b/tests/ANSONVIF-UnitTest/ANSONVIF-UnitTest.cpp
@@ -0,0 +1,65 @@
+#include <iostream>
+#include "ANSONVIF.h"
+#include "ANSOpenCV.h"
+int OnvifTest() {
+	ANSCENTER::ANSOnvifClient* infHandle;
+	std::vector<std::string> profileList;
+	CreateANSOnvifHandle(&infHandle, "");
+	SearchANSOnvifSpecificProfiles(&infHandle, "192.168.1.87", 8000, "admin", "admin123", profileList);
+	for (int i = 0; i < profileList.size(); i++) {
+		std::cout << "Profile:" << profileList.at(i) << std::endl;
+	}
+	ReleaseANSOnvifHandle(&infHandle);
+
+	std::cout << "Hello World!\n";
+}
+int OnvifSearchDevicesTest() {
+	ANSCENTER::ANSOnvifClient* infHandle;
+	std::vector<std::string> deviceList;
+	CreateANSOnvifHandle(&infHandle, "");
+	std::cout << "Start searching devices on the network. Please wait..." << std::endl;
+	for (int j = 0; j < 1; j++) {
+		sleep(1);//sleep for 1 second
+		int result = SearchANSOnvifDevices(&infHandle, 30,deviceList);
+		if (deviceList.size() > 0) {
+			for (int i = 0; i < deviceList.size(); i++) {
+				std::cout << "Device [" << i << "] address: " << deviceList.at(i) << std::endl;
+			}
+		}
+		std::cout << "Search device procedure is done." << std::endl;
+	}
+	std::vector<std::string> profileList;
+
+	SearchANSOnvifSpecificProfiles(&infHandle, "192.168.1.87", 8000, "admin", "admin123", profileList);
+	for (int i = 0; i < profileList.size(); i++) {
+		std::cout << "Profile:" << profileList.at(i) << std::endl;
+	}
+
+	std::cout << "Start searching devices on the network. Please wait..." << std::endl;
+	for (int j = 0; j < 1; j++) {
+		sleep(1);//sleep for 1 second
+		int result = SearchANSOnvifDevices(&infHandle, 15,deviceList);
+		if (deviceList.size() > 0) {
+			for (int i = 0; i < deviceList.size(); i++) {
+				std::cout << "Device [" << i << "] address: " << deviceList.at(i) << std::endl;
+			}
+		}
+		std::cout << "Search device procedure is done." << std::endl;
+	}
+
+	ReleaseANSOnvifHandle(&infHandle);
+	return 0;
+}
+int main()
+{
+	ANSCENTER::ANSOPENCV::InitCameraNetwork();
+
+
+	OnvifSearchDevicesTest();
+	OnvifTest();
+	return 0;
+
+	ANSCENTER::ANSOPENCV::DeinitCameraNetwork();
+
+}
+
diff --git a/tests/ANSONVIF-UnitTest/CMakeLists.txt b/tests/ANSONVIF-UnitTest/CMakeLists.txt
new file mode 100644
index 0000000..54ad1e5
--- /dev/null
+++ b/tests/ANSONVIF-UnitTest/CMakeLists.txt
@@ -0,0 +1,42 @@
+# ANSONVIF Unit Test
+add_executable(ANSONVIF-UnitTest
+    ANSONVIF-UnitTest.cpp
+)
+
+target_include_directories(ANSONVIF-UnitTest PRIVATE
+    ${CMAKE_SOURCE_DIR}/integrations/ANSONVIF
+    ${ANLS_ROOT}/ONVIF/include
+    ${CMAKE_SOURCE_DIR}/modules/ANSCV
+    ${CMAKE_SOURCE_DIR}/MediaClient
+    ${CMAKE_SOURCE_DIR}/MediaClient/media
+    ${CMAKE_SOURCE_DIR}/MediaClient/rtsp
+    ${CMAKE_SOURCE_DIR}/MediaClient/rtp
+    ${CMAKE_SOURCE_DIR}/MediaClient/bm
+    ${CMAKE_SOURCE_DIR}/MediaClient/http
+    ${CMAKE_SOURCE_DIR}/MediaClient/directx
+    ${CMAKE_SOURCE_DIR}/MediaClient/rtmp
+    ${CMAKE_SOURCE_DIR}/MediaClient/librtmp
+    ${CMAKE_SOURCE_DIR}/MediaClient/srt
+    ${CMAKE_SOURCE_DIR}/MediaClient/ffmpeg/include
+    ${CMAKE_SOURCE_DIR}/MediaClient/openssl/include
+    ${CMAKE_SOURCE_DIR}/MediaClient/libsrt/include
+    ${ANLS_ROOT}/TurboJpeg
+    ${SHARED_INCLUDE_DIR}
+)
+
+target_link_libraries(ANSONVIF-UnitTest
+    PRIVATE ANSONVIF
+    PRIVATE ANSCV
+    PRIVATE ANSLicensingSystem
+    PRIVATE anslicensing
+    PRIVATE labview
+    PRIVATE opencv
+    PRIVATE CUDA::cudart
+    PRIVATE CUDA::nvjpeg
+)
+
+if(WIN32)
+    target_link_libraries(ANSONVIF-UnitTest PRIVATE ${WIN_COMMON_LIBS})
+endif()
+
+target_compile_definitions(ANSONVIF-UnitTest PRIVATE UNICODE _UNICODE)
diff --git a/tests/ANSRabbitMQ-UnitTest/ANSRabbitMQ-UnitTest.cpp b/tests/ANSRabbitMQ-UnitTest/ANSRabbitMQ-UnitTest.cpp
new file mode 100644
index 0000000..52d3e84
--- /dev/null
+++ b/tests/ANSRabbitMQ-UnitTest/ANSRabbitMQ-UnitTest.cpp
@@ -0,0 +1,395 @@
+// ANSRabbitMQ-UnitTest.cpp : This file contains the 'main' function. Program execution begins and ends there.
+//
+
+#include <iostream>
+#include "ANSRabbitMQ.h"
+
+int localRabbitMQTest() {
+	// Create an instance of the ANSRabbitMQ class
+	ANSCENTER::ANSRABBITMQ* rabbitMQ = new ANSCENTER::ANSRABBITMQ();
+	// Initialize the RabbitMQ connection
+	const char* licenseKey = "your_license_key_here"; // Replace with your actual license key
+	int result = CreateANSRabbitMQHandle(&rabbitMQ, licenseKey);
+	if (result == 0) {
+		std::cerr << "Failed to create ANSRabbitMQ handle. Error code: " << result << std::endl;
+		return -1;
+	}
+	// Connect to RabbitMQ server
+	const char* hostname = "127.0.0.1"; // Replace with your RabbitMQ server hostname
+	int port = 5672; // Replace with your RabbitMQ server port
+	const char* vhost = "/"; // Replace with your RabbitMQ virtual host
+	int channelMax = 0; // Set to 0 for default
+	int frameMax = 131072; // Set to 0 for default
+	int heartBeat = 0; // Set to 0 for default
+	const char* userName = "guest"; // Replace with your RabbitMQ username
+	const char* password = "guest"; // Replace with your RabbitMQ password
+	// Set up the exchange and queue names
+	const char* exchange_name = "ans_exchange"; // Replace with your RabbitMQ exchange name
+	const char* exchange_type = "direct"; // Replace with your RabbitMQ exchange type
+	const char* queue_name = "ans_queue"; // Replace with your RabbitMQ queue name
+	const char* binding_key = "ans_binding_key"; // Replace with your RabbitMQ routing key
+	int passive = 0; // Set to 0 for non-passive
+	int durable = 1; // Set to 1 for durable
+	int auto_delete = 0; // Set to 0 for non-auto-delete
+	int internalVal = 0; // Set to 0 for non-internal
+	int channel = 1; // Set to 1 for the first channel
+	int useSSL = 0; // Set to 0 for no SSL
+	// Set up the exchange and queue
+	result = Connect(&rabbitMQ, hostname, port, vhost, channel, userName, password, useSSL);
+	if (result != 1) {
+		std::cerr << "Failed to connect to RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	int createChannel = CreateChannel(&rabbitMQ, exchange_name, exchange_type, queue_name, binding_key, passive, durable, auto_delete, internalVal);
+	if (createChannel != 1) {
+		std::cerr << "Failed to connect to RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+
+	// Publish a message to a queue
+	int rate_limit = 0; // Set to 0 for no rate limit
+	int message_count = 1; // Number of messages to publish
+	std::string exchange_name_str = exchange_name; // Exchange name
+	std::string routing_key_str = binding_key; // Routing key
+
+	std::string message = "Hello again - New message"; // Message to publish
+	result = Publish(&rabbitMQ, exchange_name_str.c_str(), routing_key_str.c_str(), message.c_str());
+	if (result != 1) {
+		std::cerr << "Failed to publish message to RabbitMQ queue. Error code: " << result << std::endl;
+		Disconnect(&rabbitMQ);
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+
+	// Get a message from the queue
+	std::string queue_name_str = queue_name; // Queue name
+	std::string received_message;
+	int ack_mode = 0; // Set to 1 for manual acknowledgment
+	result = GetQueueMessage_CPP(&rabbitMQ, queue_name_str.c_str(), ack_mode, received_message);
+	if (result != 1) {
+		std::cerr << "Failed to get message from RabbitMQ queue. Error code: " << result << std::endl;
+		Disconnect(&rabbitMQ);
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	// Print the received message
+	std::cout << "Received message from RabbitMQ queue: " << received_message << std::endl;
+
+
+	// Disconnect from RabbitMQ server
+	result = Disconnect(&rabbitMQ);
+	if (result != 1) {
+		std::cerr << "Failed to disconnect from RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	// Release the ANSRabbitMQ handle
+	result = ReleaseANSRabbitMQHandle(&rabbitMQ);
+	if (result != 1) {
+		std::cerr << "Failed to release ANSRabbitMQ handle. Error code: " << result << std::endl;
+		return -1;
+	}
+	// Clean up
+	delete rabbitMQ;
+	// Print success message
+	std::cout << "RabbitMQ test completed successfully!" << std::endl;
+}
+
+int AWSRabbitMQTest() {
+	// Create an instance of the ANSRabbitMQ class
+	ANSCENTER::ANSRABBITMQ* rabbitMQ = new ANSCENTER::ANSRABBITMQ();
+	// Initialize the RabbitMQ connection
+	const char* licenseKey = "your_license_key_here"; // Replace with your actual license key
+	int result = CreateANSRabbitMQHandle(&rabbitMQ, licenseKey);
+	if (result == 0) {
+		std::cerr << "Failed to create ANSRabbitMQ handle. Error code: " << result << std::endl;
+		return -1;
+	}
+	// Connect to RabbitMQ server
+	const char* hostname = "b-96dcdde7-e67b-4096-9a46-45421b21f43a.mq.ap-southeast-2.on.aws"; // Replace with your RabbitMQ server hostname
+	int port = 5671; // Replace with your RabbitMQ server port
+	const char* cacert = "C:\\Projects\\ANSVIS\\Documentation\\RabbitMQ_AWS\\AmazonRootCA1.pem";
+
+	const char* vhost = "/"; // Replace with your RabbitMQ virtual host
+	int channelMax = 0; // Set to 0 for default
+	int frameMax = 131072; // Set to 0 for default
+	int heartBeat = 0; // Set to 0 for default
+	const char* userName = "anscenter"; // Replace with your RabbitMQ username
+	const char* password = "Focus20@#ma&!"; // Replace with your RabbitMQ password
+	// Set up the exchange and queue names
+	const char* exchange_name = "ans_exchange"; // Replace with your RabbitMQ exchange name
+	const char* exchange_type = "direct"; // Replace with your RabbitMQ exchange type
+	const char* queue_name = "ans_queue"; // Replace with your RabbitMQ queue name
+	const char* binding_key = "ans_binding_key"; // Replace with your RabbitMQ routing key
+	int passive = 0; // Set to 0 for non-passive
+	int durable = 1; // Set to 1 for durable
+	int auto_delete = 0; // Set to 0 for non-auto-delete
+	int internalVal = 0; // Set to 0 for non-internal
+	int channel = 1; // Set to 1 for the first channel
+	int useSSL = 1; // Set to 0 for no SSL
+
+	int setupConfigure = ConfigureSSL(&rabbitMQ, cacert, "", "", 1, 1);
+	// Set up the exchange and queue
+	result = Connect(&rabbitMQ, hostname, port, vhost, channel, userName, password, useSSL);
+	if (result != 1) {
+		std::cerr << "Failed to connect to RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	int createChannel = CreateChannel(&rabbitMQ, exchange_name, exchange_type, queue_name, binding_key, passive, durable, auto_delete, internalVal);
+	if (createChannel != 1) {
+		std::cerr << "Failed to connect to RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+
+	// Publish a message to a queue
+	int rate_limit = 0; // Set to 0 for no rate limit
+	int message_count = 1; // Number of messages to publish
+	std::string exchange_name_str = exchange_name; // Exchange name
+	std::string routing_key_str = binding_key; // Routing key
+
+	std::string message = "Hello again - New message"; // Message to publish
+	result = Publish(&rabbitMQ, exchange_name_str.c_str(), routing_key_str.c_str(), message.c_str());
+	if (result != 1) {
+		std::cerr << "Failed to publish message to RabbitMQ queue. Error code: " << result << std::endl;
+		Disconnect(&rabbitMQ);
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+
+	// Get a message from the queue
+	std::string queue_name_str = queue_name; // Queue name
+	std::string received_message;
+	int ack_mode = 0; // Set to 1 for manual acknowledgment
+	result = GetQueueMessage_CPP(&rabbitMQ, queue_name_str.c_str(), ack_mode, received_message);
+	if (result != 1) {
+		std::cerr << "Failed to get message from RabbitMQ queue. Error code: " << result << std::endl;
+		Disconnect(&rabbitMQ);
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	// Print the received message
+	std::cout << "Received message from RabbitMQ queue: " << received_message << std::endl;
+
+
+	// Disconnect from RabbitMQ server
+	result = Disconnect(&rabbitMQ);
+	if (result != 1) {
+		std::cerr << "Failed to disconnect from RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	// Release the ANSRabbitMQ handle
+	result = ReleaseANSRabbitMQHandle(&rabbitMQ);
+	if (result != 1) {
+		std::cerr << "Failed to release ANSRabbitMQ handle. Error code: " << result << std::endl;
+		return -1;
+	}
+	// Clean up
+	delete rabbitMQ;
+	// Print success message
+	std::cout << "RabbitMQ test completed successfully!" << std::endl;
+}
+
+int AWSRabbitMQTest1() {
+	// Create an instance of the ANSRabbitMQ class
+	ANSCENTER::ANSRABBITMQ* rabbitMQ = new ANSCENTER::ANSRABBITMQ();
+	// Initialize the RabbitMQ connection
+	const char* licenseKey = "your_license_key_here"; // Replace with your actual license key
+	int result = CreateANSRabbitMQHandle(&rabbitMQ, licenseKey);
+	if (result == 0) {
+		std::cerr << "Failed to create ANSRabbitMQ handle. Error code: " << result << std::endl;
+		return -1;
+	}
+	// Connect to RabbitMQ server
+	const char* hostname = "b-96dcdde7-e67b-4096-9a46-45421b21f43a.mq.ap-southeast-2.on.aws"; // Replace with your RabbitMQ server hostname
+	int port = 5671; // Replace with your RabbitMQ server port
+	const char* cacert = "C:\\Projects\\ANSVIS\\Documentation\\RabbitMQ_AWS\\AmazonRootCA1.pem";
+
+	const char* vhost = "aibox"; // Replace with your RabbitMQ virtual host
+	int channelMax = 0; // Set to 0 for default
+	int frameMax = 131072; // Set to 0 for default
+	int heartBeat = 0; // Set to 0 for default
+	const char* userName = "ansaibox"; // Replace with your RabbitMQ username
+	const char* password = "AnsSYD20@$"; // Replace with your RabbitMQ password
+	// Set up the exchange and queue names
+	const char* exchange_name = "ans_exchange"; // Replace with your RabbitMQ exchange name
+	const char* exchange_type = "direct"; // Replace with your RabbitMQ exchange type
+	const char* queue_name = "ans_queue"; // Replace with your RabbitMQ queue name
+	const char* binding_key = "ans_binding_key"; // Replace with your RabbitMQ routing key
+	int passive = 0; // Set to 0 for non-passive
+	int durable = 1; // Set to 1 for durable
+	int auto_delete = 0; // Set to 0 for non-auto-delete
+	int internalVal = 0; // Set to 0 for non-internal
+	int channel = 1; // Set to 1 for the first channel
+	int useSSL = 1; // Set to 0 for no SSL
+
+	int setupConfigure = ConfigureSSL(&rabbitMQ, cacert, "", "", 1, 1);
+	// Set up the exchange and queue
+	result = Connect(&rabbitMQ, hostname, port, vhost, channel, userName, password, useSSL);
+	if (result != 1) {
+		std::cerr << "Failed to connect to RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	int createChannel = CreateChannel(&rabbitMQ, exchange_name, exchange_type, queue_name, binding_key, passive, durable, auto_delete, internalVal);
+	if (createChannel != 1) {
+		std::cerr << "Failed to connect to RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+
+	// Publish a message to a queue
+	int rate_limit = 0; // Set to 0 for no rate limit
+	int message_count = 1; // Number of messages to publish
+	std::string exchange_name_str = exchange_name; // Exchange name
+	std::string routing_key_str = binding_key; // Routing key
+
+	std::string message = "Hello again - New message"; // Message to publish
+	result = Publish(&rabbitMQ, exchange_name_str.c_str(), routing_key_str.c_str(), message.c_str());
+	if (result != 1) {
+		std::cerr << "Failed to publish message to RabbitMQ queue. Error code: " << result << std::endl;
+		Disconnect(&rabbitMQ);
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+
+	// Get a message from the queue
+	std::string queue_name_str = queue_name; // Queue name
+	std::string received_message;
+	int ack_mode = 0; // Set to 1 for manual acknowledgment
+	result = GetQueueMessage_CPP(&rabbitMQ, queue_name_str.c_str(), ack_mode, received_message);
+	if (result != 1) {
+		std::cerr << "Failed to get message from RabbitMQ queue. Error code: " << result << std::endl;
+		Disconnect(&rabbitMQ);
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	// Print the received message
+	std::cout << "Received message from RabbitMQ queue: " << received_message << std::endl;
+
+
+	// Disconnect from RabbitMQ server
+	result = Disconnect(&rabbitMQ);
+	if (result != 1) {
+		std::cerr << "Failed to disconnect from RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	// Release the ANSRabbitMQ handle
+	result = ReleaseANSRabbitMQHandle(&rabbitMQ);
+	if (result != 1) {
+		std::cerr << "Failed to release ANSRabbitMQ handle. Error code: " << result << std::endl;
+		return -1;
+	}
+	// Clean up
+	delete rabbitMQ;
+	// Print success message
+	std::cout << "RabbitMQ test completed successfully!" << std::endl;
+}
+
+
+int SynologyRabbitMQTest() {
+	// Create an instance of the ANSRabbitMQ class
+	ANSCENTER::ANSRABBITMQ* rabbitMQ = new ANSCENTER::ANSRABBITMQ();
+	// Initialize the RabbitMQ connection
+	const char* licenseKey = "your_license_key_here"; // Replace with your actual license key
+	int result = CreateANSRabbitMQHandle(&rabbitMQ, licenseKey);
+	if (result == 0) {
+		std::cerr << "Failed to create ANSRabbitMQ handle. Error code: " << result << std::endl;
+		return -1;
+	}
+	// Connect to RabbitMQ server
+	const char* hostname = "anscenter.ddns.net";// "125.168.44.233";// "192.168.1.45"; // Replace with your RabbitMQ server hostname
+	int port = 5672; // Replace with your RabbitMQ server port
+	const char* cacert = "C:\\Projects\\ANSVIS\\Documentation\\RabbitMQ_AWS\\AmazonRootCA1.pem";
+
+	const char* vhost = "aibox"; // Replace with your RabbitMQ virtual host
+	int channelMax = 0; // Set to 0 for default
+	int frameMax = 131072; // Set to 0 for default
+	int heartBeat = 0; // Set to 0 for default
+	const char* userName = "ansaibox"; // Replace with your RabbitMQ username
+	const char* password = "AnsSYD20@$"; // Replace with your RabbitMQ password
+	// Set up the exchange and queue names
+	const char* exchange_name = "ans_exchange"; // Replace with your RabbitMQ exchange name
+	const char* exchange_type = "direct"; // Replace with your RabbitMQ exchange type
+	const char* queue_name = "ans_queue"; // Replace with your RabbitMQ queue name
+	const char* binding_key = "ans_binding_key"; // Replace with your RabbitMQ routing key
+	int passive = 0; // Set to 0 for non-passive
+	int durable = 1; // Set to 1 for durable
+	int auto_delete = 0; // Set to 0 for non-auto-delete
+	int internalVal = 0; // Set to 0 for non-internal
+	int channel = 1; // Set to 1 for the first channel
+	int useSSL = 1; // Set to 0 for no SSL
+
+	int setupConfigure = ConfigureSSL(&rabbitMQ, cacert, "", "", 1, 1);
+	// Set up the exchange and queue
+	result = Connect(&rabbitMQ, hostname, port, vhost, channel, userName, password, useSSL);
+	if (result != 1) {
+		std::cerr << "Failed to connect to RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	int createChannel = CreateChannel(&rabbitMQ, exchange_name, exchange_type, queue_name, binding_key, passive, durable, auto_delete, internalVal);
+	if (createChannel != 1) {
+		std::cerr << "Failed to connect to RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+
+	// Publish a message to a queue
+	int rate_limit = 0; // Set to 0 for no rate limit
+	int message_count = 1; // Number of messages to publish
+	std::string exchange_name_str = exchange_name; // Exchange name
+	std::string routing_key_str = binding_key; // Routing key
+
+	std::string message = "Hello again - New message"; // Message to publish
+	result = Publish(&rabbitMQ, exchange_name_str.c_str(), routing_key_str.c_str(), message.c_str());
+	if (result != 1) {
+		std::cerr << "Failed to publish message to RabbitMQ queue. Error code: " << result << std::endl;
+		Disconnect(&rabbitMQ);
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+
+	// Get a message from the queue
+	std::string queue_name_str = queue_name; // Queue name
+	std::string received_message;
+	int ack_mode = 0; // Set to 1 for manual acknowledgment
+	result = GetQueueMessage_CPP(&rabbitMQ, queue_name_str.c_str(), ack_mode, received_message);
+	if (result != 1) {
+		std::cerr << "Failed to get message from RabbitMQ queue. Error code: " << result << std::endl;
+		Disconnect(&rabbitMQ);
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	// Print the received message
+	std::cout << "Received message from RabbitMQ queue: " << received_message << std::endl;
+
+
+	// Disconnect from RabbitMQ server
+	result = Disconnect(&rabbitMQ);
+	if (result != 1) {
+		std::cerr << "Failed to disconnect from RabbitMQ server. Error code: " << result << std::endl;
+		ReleaseANSRabbitMQHandle(&rabbitMQ);
+		return -1;
+	}
+	// Release the ANSRabbitMQ handle
+	result = ReleaseANSRabbitMQHandle(&rabbitMQ);
+	if (result != 1) {
+		std::cerr << "Failed to release ANSRabbitMQ handle. Error code: " << result << std::endl;
+		return -1;
+	}
+	// Clean up
+	delete rabbitMQ;
+	// Print success message
+	std::cout << "RabbitMQ test completed successfully!" << std::endl;
+}
+int main()
+{
+	SynologyRabbitMQTest();
+}
+
diff --git a/tests/ANSRabbitMQ-UnitTest/CMakeLists.txt b/tests/ANSRabbitMQ-UnitTest/CMakeLists.txt
new file mode 100644
index 0000000..329a591
--- /dev/null
+++ b/tests/ANSRabbitMQ-UnitTest/CMakeLists.txt
@@ -0,0 +1,23 @@
+# ANSRabbitMQ Unit Test
+add_executable(ANSRabbitMQ-UnitTest
+    ANSRabbitMQ-UnitTest.cpp
+)
+
+target_include_directories(ANSRabbitMQ-UnitTest PRIVATE
+    ${CMAKE_SOURCE_DIR}/integrations/ANSRabbitMQ
+    ${ANSLIBS_DIR}/RabbitMQ/include
+    ${SHARED_INCLUDE_DIR}
+)
+
+target_link_libraries(ANSRabbitMQ-UnitTest
+    PRIVATE ANSRabbitMQ
+    PRIVATE ANSLicensingSystem
+    PRIVATE anslicensing
+    PRIVATE labview
+)
+
+if(WIN32)
+    target_link_libraries(ANSRabbitMQ-UnitTest PRIVATE ${WIN_COMMON_LIBS})
+endif()
+
+target_compile_definitions(ANSRabbitMQ-UnitTest PRIVATE UNICODE _UNICODE)
diff --git a/tests/ANSUtilities-UnitTest/ANSUtilities-UnitTest.cpp b/tests/ANSUtilities-UnitTest/ANSUtilities-UnitTest.cpp
new file mode 100644
index 0000000..659d772
--- /dev/null
+++ b/tests/ANSUtilities-UnitTest/ANSUtilities-UnitTest.cpp
@@ -0,0 +1,400 @@
+#include <iostream>
+#include "ANSUtilities.h"
+#include "ANSLLM.h"
+#include "CkCrypt2.h"
+#include <fstream>
+#include <sstream>
+#include <string>
+#include <opencv2/opencv.hpp>
+
+#include <CkHttp.h>
+#include <CkJsonObject.h>
+#include <CkHttpResponse.h>
+#include <CkGlobal.h>
+
+void EncrypyionExample(void)
+{
+	std::string encryptedString = "";
+    //std::string inputKey = "mikael.holmstrom@anscenter.comAA";
+    std::string inputKey = "sale@anscenter.com.au";
+    std::string inputString = "https://anspushnotification.s3.ap-southeast-2.amazonaws.com/Events/20250113_154146_221140160_643.jpg";
+    AESEncryptionCpp(inputString.c_str(), inputKey.c_str(), encryptedString);
+	std::cout << "Encrypted String:" << encryptedString << std::endl;
+	//std::string NewEncryptionString = "DRqCU8fsgYZcwyjMdMwnEDStSVk13htAIznm1iee8ri0js1RJqN4/q7dMtK5HyQcOWPnQThN8971lFZwRB2baMOxhvyB/xyvP3mzjvPoTH98kvO1UxBltbi0xrlTKIO8xg1i7Iw07zhmSJzxRNz18A==";
+	std::string decryptedString = "";
+	AESDecryptionCpp(encryptedString.c_str(), inputKey.c_str(), decryptedString);
+	std::cout << "Decrypted String:" << decryptedString << std::endl;
+}
+int Test() {
+    ANSCENTER::ANSUtilities* Handle;
+
+    int result = CreateANSUtilityHandle(&Handle, "");
+
+    std::cout << "Intialisation:" << result << std::endl;
+    std::string arnTopic = "";
+    //CreateAWSSNSTopicCpp(&Handle, "MyTopicFromC",arnTopic);
+    //std::cout << "Topic ARN:" << arnTopic << std::endl;
+
+
+    // delete the topic
+    //arnTopic = "arn:aws:sns:ap-southeast-2:654654292871:MyTopicFromC";//arn:aws:sns:ap-southeast-2:654654292871:MyTopicFromC
+    //bool deleteResult= DeleteAWSSNSTopic(&Handle, arnTopic.c_str());
+    //std::cout << "Delete Topic:" << deleteResult << std::endl;
+    //+34623225024
+    // Send message
+    std::string messageId = "";
+    bool SendMessageResult = SendMessageToPhoneNumberCpp(&Handle, "+34623225024", "Hi Mr Mikael Holmstrom, this is the test message from ANS AI Box", messageId);
+
+    std::cout << "Send Message:" << SendMessageResult << std::endl;
+    std::cout << "Message ID:" << messageId << std::endl;
+}
+int uploadFileToGoogleStorage() {
+	ANSCENTER::ANSUtilities* Handle;
+	int result = CreateANSUtilityHandle(&Handle, "");
+	std::cout << "Intialisation:" << result << std::endl;
+	std::string googleTokenJsonfile = "C:\\Projects\\ANSVIS\\Documentation\\ImageStorage\\gcs_uploader_key.json";
+	std::string bucketName = "ansaibox-image-storage";
+	std::string objectName = "public-images/myTest2.jpg";
+	cv::Mat image = cv::imread("C:\\Programs\\DemoAssets\\NV\\test.jpg");
+
+    // Read json file to text first
+    std::ifstream file(googleTokenJsonfile); // Open the JSON file
+    if (!file) {
+        std::cerr << "Error: Cannot open file!" << std::endl;
+        return 1;
+    }
+
+    std::stringstream buffer;
+    buffer << file.rdbuf(); // Read file content into buffer
+    std::string jsonString = buffer.str(); // Convert buffer to std::string
+
+    std::cout << "JSON Content:\n" << jsonString << std::endl;
+	bool authResult = AuthenticateGCS(&Handle, jsonString.c_str());
+	std::cout << "Authenticate:" << authResult << std::endl;
+
+	bool uploadResult = UploadImageToGCS(& Handle, bucketName.c_str(), objectName.c_str(), image);
+	std::cout << "Upload Image:" << uploadResult << std::endl;
+	ReleaseANSUtilityHandle(&Handle);
+}
+void SendEmailExample(void)
+{
+    std::string smtpServer = "smtp.office365.com";
+	int smtpPort = 587;
+    std::string smtpUser =  "noreply@anscenter.com";
+    std::string smtpPassword = "PW";//
+	std::string subjectContent = "This is the test";
+	std::string bodyHTMLContent = "<html> <body><b>Test Email</b> <img src = \"http://www.chilkatsoft.com/images/dude.gif\"></body></html>";
+	std::string bodyTextContent = "";
+	std::string fromEmailSender = "noreply@anscenter.com";
+    std::string toEmails = "nghia.nguyen@anscenter.com;kate.truong@anscenter.com";
+    std::string ccEmails = "support@anscenter.com;sale@anscenter.com";
+	std::string bccEmails = "admin@anscenter.com";
+	int resultSent = SendEmail(smtpServer.c_str(), smtpPort, smtpUser.c_str(), smtpPassword.c_str(),
+                               subjectContent.c_str(), bodyHTMLContent.c_str(), bodyTextContent.c_str(), fromEmailSender.c_str(),
+                               toEmails.c_str(), ccEmails.c_str(), bccEmails.c_str());
+
+	std::cout << "Send Email Result:" << resultSent << std::endl;
+}
+int ANSLLMTest() {
+    std::cout << "Running ANSLLM Test..." << std::endl;
+	ANSCENTER::ANSLLM ansllm;
+	std::string licenseKey = "";
+    std::string apiKey = "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";
+    // Initialize with license key
+    ansllm.Initialize(licenseKey);
+    ansllm.SetLLMProvider("openai");
+    ansllm.SetApiKey(apiKey);
+	//std::vector<std::string> modelList = ansllm.GetModelList();
+	//std::cout << "Available Models:" << std::endl;
+	//for (const auto& model : modelList) {
+	//	std::cout << model << std::endl;
+	//}
+
+	// Set model
+	ansllm.SetModel("gpt-5.2");
+	ansllm.CreateConversation("You are a helpful assistant.", "Respond only with markdown.", "TestConversation");
+	ansllm.InputAddText("Say Hello.");
+
+
+	std::string response = ansllm.Ask("text");
+    std::cout << "Response from ANSLLM: " << response << std::endl;
+    
+    // ask others
+	std::string prompt2 = "Please tell me a person whose name is Sophie";
+	ansllm.InputAddText(prompt2);
+
+    std::string response2 = ansllm.Ask("text");
+	std::cout << "Response from ANSLLM: " << response2 << std::endl;
+
+    ansllm.InputAddText("Describe what you see in the following image.");
+    ansllm.InputAddImageUrl("https://www.chilkatsoft.com/images/starfish.jpg", "");
+
+    std::string response3 = ansllm.Ask("text");
+    std::cout << "Response from ANSLLM: " << response3 << std::endl;
+
+
+    return 0;
+}
+
+int ANSAWSTest() {
+    std::cout << "Running ANSAWS Test..." << std::endl;
+    ANSCENTER::ANSAWSS3* awsHandle = nullptr;
+    // Initialize AWS S3 handle
+    if (CreateANSAWSHandle(&awsHandle,"") != 1) {
+        std::cerr << "Failed to create AWS S3 handle." << std::endl;
+        return 1;
+    }
+	std::string baseDomain = "amazonaws.com";
+	std::string bucketRegion = "ap-southeast-2";
+	std::string serviceName = "s3";
+	std::string bucketName = "anspushnotification";
+
+	int port = 443;
+	bool bTls = true;
+	bool autoReconnect = true;
+	// Connect to AWS S3
+	int awsPath = 0;
+    if (ConnectANSAWSHandle(&awsHandle, baseDomain.c_str(), bucketRegion.c_str(), serviceName.c_str(), port, bTls, autoReconnect, &awsPath) == 0) {
+        std::cerr << "Failed to connect to AWS S3." << std::endl;
+        ReleaseANSAWSHandle(&awsHandle);
+        return 1;
+	}
+	std::cout << "Connected. AWS path style: " << (awsPath ? "true" : "false") << std::endl;
+
+	// Set authentication
+	std::string accessKey = "AKIAZQ3DPYODSHZCECS4";
+	std::string secretKey = "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";
+	if (SetAuthenticationANSAWSHandle(&awsHandle, accessKey.c_str(), secretKey.c_str()) != 1) {
+		std::cerr << "Failed to set AWS S3 authentication." << std::endl;
+		ReleaseANSAWSHandle(&awsHandle);
+		return 1;
+	}
+	// Upload a jpeg image to bucket
+	std::string jpegFilePath = "E:\\Programs\\DemoAssets\\NV\\Test.jpg";
+	std::string objectName = "test/test.jpg";
+
+	std::string uploadedUrl;
+	while (1) {
+		if (UploadBinaryDataANSAWSHandle_CPP(&awsHandle, bucketName.c_str(), jpegFilePath.c_str(), uploadedUrl) != 1) {
+			std::cerr << "Failed to upload JPEG image to AWS S3." << std::endl;
+			std::this_thread::sleep_for(std::chrono::seconds(1)); // Wait before retrying
+		}
+		else {
+			std::cout << "Successfully uploaded JPEG image to AWS S3." << std::endl;
+			break;
+		
+		}
+	}
+	std::cout << "Uploaded to: " << uploadedUrl << std::endl;
+
+
+	//// List buckets
+	//std::string bucketList = "";
+	//if (ListBucketANSAWSHandle_CPP(&awsHandle, bucketList) != 1) {
+	//	std::cerr << "Failed to list AWS S3 buckets." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+	//std::cout << "Buckets in AWS S3:" << std::endl;
+	//std::cout << bucketList << std::endl;
+
+	//// list objects in a bucket
+	//std::string bucketName = "anspushnotification";
+	//std::string prefix = "Events/ee2ejdgefcjl7j6ruhvsjlaea/";
+	//std::string bucketObjectList = "";
+
+	//if (ListBucketObjectsWithPrefixANSAWSHandle_CPP(&awsHandle, bucketName.c_str(), prefix.c_str(), bucketObjectList) != 1) {
+	//	std::cerr << "Failed to list AWS S3 bucket objects." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+	//std::cout << "Bucket objects in AWS S3:" << std::endl;
+	//std::cout << bucketObjectList << std::endl;
+
+
+	//// Create a new bucket
+	//std::string newBucketName = "my-test-bucket-a3f9d2c1w2";
+	//std::string bucketPrefix = "test-prefix/";
+	//if (CreateBucketANSAWSHandle(&awsHandle, newBucketName.c_str()) != 1) {
+	//	std::cerr << "Failed to create AWS S3 bucket." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+	//if (CreateBucketPrefixANSAWSHandle(&awsHandle, newBucketName.c_str(),bucketPrefix.c_str()) != 1) {
+	//	std::cerr << "Failed to create AWS S3 bucket prefix." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+
+	//// Delete the bucket prefix
+	//std::string deleteBucketName = "my-test-bucket-a3f9d2c1";
+	//if (DeleteBucketPrefixANSAWSHandle(&awsHandle, newBucketName.c_str(), bucketPrefix.c_str()) != 1) {
+	//	std::cerr << "Failed to delete AWS S3 bucket." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+
+	// Delete the bucket
+	//if (DeleteBucketANSAWSHandle(&awsHandle, newBucketName.c_str()) != 1) {
+	//	std::cerr << "Failed to delete AWS S3 bucket." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+
+
+	// Download an object from bucket
+	//std::string objectName = "testevent/test01.jpg";
+	//std::string downloadFilePath = "E:\\Programs\\DemoAssets\\Images";
+	//if (DownloadFileStreamANSAWSHandle(&awsHandle, bucketName.c_str(), objectName.c_str(), downloadFilePath.c_str()) != 1) {
+	//	std::cerr << "Failed to download AWS S3 bucket object." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+	//
+	// Clean up
+	ReleaseANSAWSHandle(&awsHandle);
+	return 0;
+}
+
+int ANSFTechMinIOTest() {
+	std::cout << "Running ANSFTechMinIO Test..." << std::endl;
+	ANSCENTER::ANSAWSS3* awsHandle = nullptr;
+	// Initialize AWS S3 handle
+	if (CreateANSAWSHandle(&awsHandle, "") != 1) {
+		std::cerr << "Failed to create AWS S3 handle." << std::endl;
+		return 1;
+	}
+	std::string baseDomain = "https://minio.dev.ftech.ai";
+	std::string bucketRegion = "vn1";
+	std::string serviceName = "s3";
+	std::string bucketName = "aicamera";
+
+	int port = 443;
+	bool bTls = true;
+	bool autoReconnect = true;
+	// Connect to AWS S3
+	int awsPath = 0;
+	if (ConnectANSAWSHandle(&awsHandle, baseDomain.c_str(), bucketRegion.c_str(), serviceName.c_str(), port, bTls, autoReconnect, &awsPath) == 0) {
+		std::cerr << "Failed to connect to AWS S3." << std::endl;
+		ReleaseANSAWSHandle(&awsHandle);
+		return 1;
+	}
+
+	// Set authentication
+	std::string accessKey = "aicamerapush";
+	std::string secretKey = "88fO8Y3EpMFMG1HFCCcfCE4cWh0k5KKZ";
+	if (SetAuthenticationANSAWSHandle(&awsHandle, accessKey.c_str(), secretKey.c_str()) != 1) {
+		std::cerr << "Failed to set AWS S3 authentication." << std::endl;
+		ReleaseANSAWSHandle(&awsHandle);
+		return 1;
+	}
+
+
+	// Upload a jpeg image to bucket
+	std::string jpegFilePath = "E:\\Programs\\DemoAssets\\NV\\Test.jpg";
+	std::string objectName = "test1.jpg";
+
+
+	std::string uploadedUrl;
+	if (UploadBinaryDataANSAWSHandle_CPP(&awsHandle, bucketName.c_str(), jpegFilePath.c_str(), uploadedUrl)!= 1) {
+		std::cerr << "Failed to upload JPEG image to AWS S3." << std::endl;
+		ReleaseANSAWSHandle(&awsHandle);
+		return 1;
+	}
+	
+
+	// List buckets
+	//std::string bucketList = "";
+	//if (ListBucketANSAWSHandle_CPP(&awsHandle, bucketList) != 1) {
+	//	std::cerr << "Failed to list AWS S3 buckets." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+	//std::cout << "Buckets in AWS S3:" << std::endl;
+	//std::cout << bucketList << std::endl;
+
+	// list objects in a bucket
+	//std::string bucketName = "anspushnotification";
+	//std::string prefix = "Events/ee2ejdgefcjl7j6ruhvsjlaea/";
+	//std::string bucketObjectList = "";
+
+	//if (ListBucketObjectsWithPrefixANSAWSHandle_CPP(&awsHandle, bucketName.c_str(), prefix.c_str(), bucketObjectList) != 1) {
+	//	std::cerr << "Failed to list AWS S3 bucket objects." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+	//std::cout << "Bucket objects in AWS S3:" << std::endl;
+	//std::cout << bucketObjectList << std::endl;
+
+
+	// Create a new bucket
+	//std::string newBucketName = "my-test-bucket-a3f9d2c1w2";
+	//std::string bucketPrefix = "test-prefix/";
+	//if (CreateBucketANSAWSHandle(&awsHandle, newBucketName.c_str()) != 1) {
+	//	std::cerr << "Failed to create AWS S3 bucket." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+	//if (CreateBucketPrefixANSAWSHandle(&awsHandle, newBucketName.c_str(),bucketPrefix.c_str()) != 1) {
+	//	std::cerr << "Failed to create AWS S3 bucket prefix." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+
+	//// Delete the bucket prefix
+	//std::string deleteBucketName = "my-test-bucket-a3f9d2c1";
+	//if (DeleteBucketPrefixANSAWSHandle(&awsHandle, newBucketName.c_str(), bucketPrefix.c_str()) != 1) {
+	//	std::cerr << "Failed to delete AWS S3 bucket." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+
+	// Delete the bucket
+	//if (DeleteBucketANSAWSHandle(&awsHandle, newBucketName.c_str()) != 1) {
+	//	std::cerr << "Failed to delete AWS S3 bucket." << std::endl;
+	//	ReleaseANSAWSHandle(&awsHandle);
+	//	return 1;
+	//}
+
+
+	// Clean up
+	ReleaseANSAWSHandle(&awsHandle);
+	return 0;
+}
+
+int ANSLLMOllamaTest() {
+	std::cout << "Running ANSLLM Ollama Test..." << std::endl;
+	ANSCENTER::ANSLLM ansllm;
+	std::string licenseKey = "";
+
+	// Initialize with local Ollama enabled
+	ansllm.Initialize(licenseKey, true);
+
+	// Set the Ollama model (must be already pulled via 'ollama pull llama3.2')
+	ansllm.SetModel("llama3.2");
+	ansllm.CreateConversation("You are a helpful assistant.", "Respond only with markdown.", "TestConversation");
+	ansllm.InputAddText("Why is the sky blue?");
+
+	std::string response = ansllm.Ask("text");
+	std::cout << "Response from ANSLLM (Ollama): " << response << std::endl;
+
+	// Ask another question
+	ansllm.InputAddText("Say Hello.");
+	std::string response2 = ansllm.Ask("text");
+	std::cout << "Response from ANSLLM (Ollama): " << response2 << std::endl;
+
+	return 0;
+}
+
+int main()
+{
+	ANSLLMOllamaTest();
+	//ANSAWSTest();
+	//ANSFTechMinIOTest();
+	//ANSAWSTest();
+    //ANSLLMTest();
+    //SendEmailExample();
+	//uploadFileToGoogleStorage();
+   // EncrypyionExample();
+}
+
diff --git a/tests/ANSUtilities-UnitTest/CMakeLists.txt b/tests/ANSUtilities-UnitTest/CMakeLists.txt
new file mode 100644
index 0000000..2270ff1
--- /dev/null
+++ b/tests/ANSUtilities-UnitTest/CMakeLists.txt
@@ -0,0 +1,25 @@
+# ANSUtilities Unit Test
+add_executable(ANSUtilities-UnitTest
+    ANSUtilities-UnitTest.cpp
+)
+
+target_include_directories(ANSUtilities-UnitTest PRIVATE
+    ${CMAKE_SOURCE_DIR}/modules/ANSUtilities
+    ${CMAKE_SOURCE_DIR}/modules/ANSLLM
+    ${SHARED_INCLUDE_DIR}
+)
+
+target_link_libraries(ANSUtilities-UnitTest
+    PRIVATE ANSUtilities
+    PRIVATE ANSLLM
+    PRIVATE ANSLicensingSystem
+    PRIVATE anslicensing
+    PRIVATE opencv
+    PRIVATE chilkat
+)
+
+if(WIN32)
+    target_link_libraries(ANSUtilities-UnitTest PRIVATE ${WIN_COMMON_LIBS} crypt32 dnsapi)
+endif()
+
+target_compile_definitions(ANSUtilities-UnitTest PRIVATE UNICODE _UNICODE)
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index b3610ca..7fe9cac 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -4,3 +4,9 @@ add_subdirectory(ANSODEngine-UnitTest)
 add_subdirectory(ANSFR-UnitTest)
 add_subdirectory(ANSLPR-UnitTest)
 add_subdirectory(ANSOCR-UnitTest)
+add_subdirectory(ANSUtilities-UnitTest)
+add_subdirectory(ANSRabbitMQ-UnitTest)
+add_subdirectory(ANSIO-UnitTest)
+add_subdirectory(ANSLS-UnitTest)
+add_subdirectory(ANSONVIF-UnitTest)
+add_subdirectory(ANSODTRE-UnitTest)