From f1347f4a28eebe84dd9f1870795c0e6da9df2a62 Mon Sep 17 00:00:00 2001 From: konard Date: Sat, 13 Sep 2025 02:32:56 +0300 Subject: [PATCH 1/4] Initial commit with task details for issue #83 Adding CLAUDE.md with task information for AI processing. This file will be removed when the task is complete. Issue: https://github.com/linksplatform/Data/issues/83 --- CLAUDE.md | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 CLAUDE.md diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..46d1067 --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1,5 @@ +Issue to solve: https://github.com/linksplatform/Data/issues/83 +Your prepared branch: issue-83-3fdff5b3 +Your prepared working directory: /tmp/gh-issue-solver-1757719970544 + +Proceed. \ No newline at end of file From 179fdef84d5d7254e23cc973f76c90432ec223a7 Mon Sep 17 00:00:00 2001 From: konard Date: Sat, 13 Sep 2025 02:44:37 +0300 Subject: [PATCH 2/4] Implement comprehensive tests for Platform::Data::Exceptions and fix std::exception inheritance MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This commit addresses issue #83 by: - Creating comprehensive GTest-based tests for all exception classes - Fixing exception inheritance to properly derive from STL exceptions - Adding missing headers and proper constructor implementations - Implementing proper what() method override for custom exception classes - Adding fallback converter support for standalone compilation - Ensuring all exceptions can be caught as std::exception base class All exception classes now properly inherit from std::exception hierarchy: - ArgumentLinkDoesNotExistsException inherits from std::invalid_argument - ArgumentLinkHasDependenciesException inherits from std::invalid_argument - LinksLimitReachedExceptionBase inherits from std::exception - LinksLimitReachedException inherits from LinksLimitReachedExceptionBase - LinkWithSameValueAlreadyExistsException inherits from std::exception 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude --- cpp/Platform.Data.Tests/AllTests.cpp | 1 + cpp/Platform.Data.Tests/ExceptionsTests.cpp | 273 ++++++++++++++++++ .../ArgumentLinkDoesNotExistsException.h | 13 +- .../ArgumentLinkHasDependenciesException.h | 13 +- .../LinkWithSameValueAlreadyExistsException.h | 16 +- .../Exceptions/LinksLimitReachedException.h | 9 +- .../LinksLimitReachedExceptionBase.h | 14 +- .../Exceptions/Platform.Converters.Fallback.h | 22 ++ 8 files changed, 344 insertions(+), 17 deletions(-) create mode 100644 cpp/Platform.Data.Tests/ExceptionsTests.cpp create mode 100644 cpp/Platform.Data/Exceptions/Platform.Converters.Fallback.h diff --git a/cpp/Platform.Data.Tests/AllTests.cpp b/cpp/Platform.Data.Tests/AllTests.cpp index 5b3e8ed..5b8b2de 100644 --- a/cpp/Platform.Data.Tests/AllTests.cpp +++ b/cpp/Platform.Data.Tests/AllTests.cpp @@ -5,3 +5,4 @@ #include "LinksConstantsTests.cpp" #include "ILinksTests.cpp" #include "PointTests.cpp" +#include "ExceptionsTests.cpp" diff --git a/cpp/Platform.Data.Tests/ExceptionsTests.cpp b/cpp/Platform.Data.Tests/ExceptionsTests.cpp new file mode 100644 index 0000000..be0ffe7 --- /dev/null +++ b/cpp/Platform.Data.Tests/ExceptionsTests.cpp @@ -0,0 +1,273 @@ +#include +#include +#include +#include + +// Include all exception headers +#include "../Platform.Data/Exceptions/ArgumentLinkDoesNotExistsException.h" +#include "../Platform.Data/Exceptions/ArgumentLinkHasDependenciesException.h" +#include "../Platform.Data/Exceptions/LinksLimitReachedExceptionBase.h" +#include "../Platform.Data/Exceptions/LinksLimitReachedException.h" +#include "../Platform.Data/Exceptions/LinkWithSameValueAlreadyExistsException.h" + +using namespace Platform::Data::Exceptions; + +// Test ArgumentLinkDoesNotExistsException +TEST(ExceptionsTests, ArgumentLinkDoesNotExistsExceptionInheritance) +{ + // Test that it properly inherits from std::invalid_argument + ArgumentLinkDoesNotExistsException ex; + EXPECT_TRUE(dynamic_cast(&ex) != nullptr); + EXPECT_TRUE(dynamic_cast(&ex) != nullptr); +} + +TEST(ExceptionsTests, ArgumentLinkDoesNotExistsExceptionConstructors) +{ + // Test default constructor + ArgumentLinkDoesNotExistsException ex1; + EXPECT_NE(ex1.what(), nullptr); + + // Test string constructor + ArgumentLinkDoesNotExistsException ex2("Test message"); + EXPECT_STREQ(ex2.what(), "Test message"); + + // Test link constructor + ArgumentLinkDoesNotExistsException ex3(42); + std::string whatStr(ex3.what()); + EXPECT_TRUE(whatStr.find("42") != std::string::npos); + + // Test link and argument name constructor + ArgumentLinkDoesNotExistsException ex4(42, "testArg"); + std::string whatStr2(ex4.what()); + EXPECT_TRUE(whatStr2.find("42") != std::string::npos); + EXPECT_TRUE(whatStr2.find("testArg") != std::string::npos); + + // Test inner exception constructor (note: inner exception info is not stored in std::invalid_argument) + std::runtime_error inner("inner"); + ArgumentLinkDoesNotExistsException ex5("outer", inner); + EXPECT_STREQ(ex5.what(), "outer"); +} + +TEST(ExceptionsTests, ArgumentLinkDoesNotExistsExceptionThrowCatch) +{ + // Test that it can be thrown and caught as std::invalid_argument + try { + throw ArgumentLinkDoesNotExistsException(123, "testParam"); + } catch (const std::invalid_argument& e) { + std::string whatStr(e.what()); + EXPECT_TRUE(whatStr.find("123") != std::string::npos); + EXPECT_TRUE(whatStr.find("testParam") != std::string::npos); + } + + // Test that it can be caught as std::exception + try { + throw ArgumentLinkDoesNotExistsException("test message"); + } catch (const std::exception& e) { + EXPECT_STREQ(e.what(), "test message"); + } +} + +// Test ArgumentLinkHasDependenciesException +TEST(ExceptionsTests, ArgumentLinkHasDependenciesExceptionInheritance) +{ + ArgumentLinkHasDependenciesException ex; + EXPECT_TRUE(dynamic_cast(&ex) != nullptr); + EXPECT_TRUE(dynamic_cast(&ex) != nullptr); +} + +TEST(ExceptionsTests, ArgumentLinkHasDependenciesExceptionConstructors) +{ + // Test default constructor + ArgumentLinkHasDependenciesException ex1; + EXPECT_NE(ex1.what(), nullptr); + + // Test string constructor + ArgumentLinkHasDependenciesException ex2("Test message"); + EXPECT_STREQ(ex2.what(), "Test message"); + + // Test link constructor + ArgumentLinkHasDependenciesException ex3(42); + std::string whatStr(ex3.what()); + EXPECT_TRUE(whatStr.find("42") != std::string::npos); + + // Test link and parameter name constructor + ArgumentLinkHasDependenciesException ex4(42, "testParam"); + std::string whatStr2(ex4.what()); + EXPECT_TRUE(whatStr2.find("42") != std::string::npos); + EXPECT_TRUE(whatStr2.find("testParam") != std::string::npos); +} + +TEST(ExceptionsTests, ArgumentLinkHasDependenciesExceptionThrowCatch) +{ + try { + throw ArgumentLinkHasDependenciesException(123, "testParam"); + } catch (const std::invalid_argument& e) { + std::string whatStr(e.what()); + EXPECT_TRUE(whatStr.find("123") != std::string::npos); + EXPECT_TRUE(whatStr.find("testParam") != std::string::npos); + } +} + +// Test LinksLimitReachedExceptionBase +TEST(ExceptionsTests, LinksLimitReachedExceptionBaseInheritance) +{ + class TestLinksLimitReachedExceptionBase : public LinksLimitReachedExceptionBase { + public: + TestLinksLimitReachedExceptionBase(std::string message) : LinksLimitReachedExceptionBase(message) {} + }; + + TestLinksLimitReachedExceptionBase ex("test"); + EXPECT_TRUE(dynamic_cast(&ex) != nullptr); +} + +TEST(ExceptionsTests, LinksLimitReachedExceptionBaseMessage) +{ + class TestLinksLimitReachedExceptionBase : public LinksLimitReachedExceptionBase { + public: + TestLinksLimitReachedExceptionBase(std::string message) : LinksLimitReachedExceptionBase(message) {} + }; + + TestLinksLimitReachedExceptionBase ex("test message"); + EXPECT_STREQ(ex.what(), "test message"); +} + +TEST(ExceptionsTests, LinksLimitReachedExceptionBaseDefaultMessage) +{ + EXPECT_FALSE(LinksLimitReachedExceptionBase::DefaultMessage.empty()); + EXPECT_TRUE(LinksLimitReachedExceptionBase::DefaultMessage.find("лимит") != std::string::npos); +} + +// Test LinksLimitReachedException +TEST(ExceptionsTests, LinksLimitReachedExceptionInheritance) +{ + LinksLimitReachedException ex; + EXPECT_TRUE(dynamic_cast(&ex) != nullptr); + EXPECT_TRUE(dynamic_cast(&ex) != nullptr); +} + +TEST(ExceptionsTests, LinksLimitReachedExceptionConstructors) +{ + // Test default constructor + LinksLimitReachedException ex1; + std::string whatStr1(ex1.what()); + EXPECT_TRUE(whatStr1.find("лимит") != std::string::npos); + + // Test string constructor + LinksLimitReachedException ex2("Custom message"); + EXPECT_STREQ(ex2.what(), "Custom message"); + + // Test limit constructor + LinksLimitReachedException ex3(1000); + std::string whatStr3(ex3.what()); + EXPECT_TRUE(whatStr3.find("1000") != std::string::npos); + EXPECT_TRUE(whatStr3.find("лимит") != std::string::npos); +} + +TEST(ExceptionsTests, LinksLimitReachedExceptionThrowCatch) +{ + try { + throw LinksLimitReachedException(500); + } catch (const LinksLimitReachedExceptionBase& e) { + std::string whatStr(e.what()); + EXPECT_TRUE(whatStr.find("500") != std::string::npos); + } + + try { + throw LinksLimitReachedException("test"); + } catch (const std::exception& e) { + EXPECT_STREQ(e.what(), "test"); + } +} + +// Test LinkWithSameValueAlreadyExistsException +TEST(ExceptionsTests, LinkWithSameValueAlreadyExistsExceptionInheritance) +{ + LinkWithSameValueAlreadyExistsException ex; + EXPECT_TRUE(dynamic_cast(&ex) != nullptr); +} + +TEST(ExceptionsTests, LinkWithSameValueAlreadyExistsExceptionConstructors) +{ + // Test default constructor + LinkWithSameValueAlreadyExistsException ex1; + std::string whatStr1(ex1.what()); + EXPECT_TRUE(whatStr1.find("значением") != std::string::npos); + + // Test string constructor + LinkWithSameValueAlreadyExistsException ex2("Custom message"); + EXPECT_STREQ(ex2.what(), "Custom message"); +} + +TEST(ExceptionsTests, LinkWithSameValueAlreadyExistsExceptionDefaultMessage) +{ + EXPECT_FALSE(LinkWithSameValueAlreadyExistsException::DefaultMessage.empty()); + EXPECT_TRUE(LinkWithSameValueAlreadyExistsException::DefaultMessage.find("значением") != std::string::npos); +} + +TEST(ExceptionsTests, LinkWithSameValueAlreadyExistsExceptionThrowCatch) +{ + try { + throw LinkWithSameValueAlreadyExistsException("test message"); + } catch (const std::exception& e) { + EXPECT_STREQ(e.what(), "test message"); + } + + try { + throw LinkWithSameValueAlreadyExistsException(); + } catch (const std::exception& e) { + std::string whatStr(e.what()); + EXPECT_TRUE(whatStr.find("значением") != std::string::npos); + } +} + +// Test that all exceptions can be caught as std::exception +TEST(ExceptionsTests, AllExceptionsCatchableAsStdException) +{ + // Test ArgumentLinkDoesNotExistsException + try { + throw ArgumentLinkDoesNotExistsException("test"); + } catch (const std::exception& e) { + EXPECT_STREQ(e.what(), "test"); + } + + // Test ArgumentLinkHasDependenciesException + try { + throw ArgumentLinkHasDependenciesException("test"); + } catch (const std::exception& e) { + EXPECT_STREQ(e.what(), "test"); + } + + // Test LinksLimitReachedException + try { + throw LinksLimitReachedException("test"); + } catch (const std::exception& e) { + EXPECT_STREQ(e.what(), "test"); + } + + // Test LinkWithSameValueAlreadyExistsException + try { + throw LinkWithSameValueAlreadyExistsException("test"); + } catch (const std::exception& e) { + EXPECT_STREQ(e.what(), "test"); + } +} + +// Test template instantiation with different types +TEST(ExceptionsTests, TemplateInstantiationWithDifferentTypes) +{ + // Test with int + ArgumentLinkDoesNotExistsException intEx(42); + EXPECT_TRUE(dynamic_cast(&intEx) != nullptr); + + // Test with long + ArgumentLinkDoesNotExistsException longEx(123456L); + EXPECT_TRUE(dynamic_cast(&longEx) != nullptr); + + // Test with unsigned int + ArgumentLinkHasDependenciesException uintEx(42u); + EXPECT_TRUE(dynamic_cast(&uintEx) != nullptr); + + // Test LinksLimitReachedException with different types + LinksLimitReachedException sizeEx(1000); + EXPECT_TRUE(dynamic_cast(&sizeEx) != nullptr); +} \ No newline at end of file diff --git a/cpp/Platform.Data/Exceptions/ArgumentLinkDoesNotExistsException.h b/cpp/Platform.Data/Exceptions/ArgumentLinkDoesNotExistsException.h index 352f82d..31f18d8 100644 --- a/cpp/Platform.Data/Exceptions/ArgumentLinkDoesNotExistsException.h +++ b/cpp/Platform.Data/Exceptions/ArgumentLinkDoesNotExistsException.h @@ -1,17 +1,22 @@ -namespace Platform::Data::Exceptions +#pragma once +#include +#include +#include "Platform.Converters.Fallback.h" + +namespace Platform::Data::Exceptions { template class ArgumentLinkDoesNotExistsException; template class ArgumentLinkDoesNotExistsException : public std::invalid_argument { - public: ArgumentLinkDoesNotExistsException(TLinkAddress link, std::string argumentName) : std::invalid_argument(FormatMessage(link, argumentName), argumentName) { } + public: ArgumentLinkDoesNotExistsException(TLinkAddress link, std::string argumentName) : std::invalid_argument(FormatMessage(link, argumentName)) { } public: ArgumentLinkDoesNotExistsException(TLinkAddress link) : std::invalid_argument(FormatMessage(link)) { } - public: ArgumentLinkDoesNotExistsException(std::string message, const std::exception& innerException) : std::invalid_argument(message, innerException) { } + public: ArgumentLinkDoesNotExistsException(std::string message, const std::exception& innerException) : std::invalid_argument(message) { } public: ArgumentLinkDoesNotExistsException(std::string message) : std::invalid_argument(message) { } - public: ArgumentLinkDoesNotExistsException() { } + public: ArgumentLinkDoesNotExistsException() : std::invalid_argument("") { } private: static std::string FormatMessage(TLinkAddress link, std::string argumentName) { return std::string("Связь [").append(Platform::Converters::To(link)).append("] переданная в аргумент [").append(argumentName).append("] не существует."); } diff --git a/cpp/Platform.Data/Exceptions/ArgumentLinkHasDependenciesException.h b/cpp/Platform.Data/Exceptions/ArgumentLinkHasDependenciesException.h index 06f47c1..23d7cfe 100644 --- a/cpp/Platform.Data/Exceptions/ArgumentLinkHasDependenciesException.h +++ b/cpp/Platform.Data/Exceptions/ArgumentLinkHasDependenciesException.h @@ -1,17 +1,22 @@ -namespace Platform::Data::Exceptions +#pragma once +#include +#include +#include "Platform.Converters.Fallback.h" + +namespace Platform::Data::Exceptions { template class ArgumentLinkHasDependenciesException; template class ArgumentLinkHasDependenciesException : public std::invalid_argument { - public: ArgumentLinkHasDependenciesException(TLinkAddress link, std::string paramName) : std::invalid_argument(FormatMessage(link, paramName), paramName) { } + public: ArgumentLinkHasDependenciesException(TLinkAddress link, std::string paramName) : std::invalid_argument(FormatMessage(link, paramName)) { } public: ArgumentLinkHasDependenciesException(TLinkAddress link) : std::invalid_argument(FormatMessage(link)) { } - public: ArgumentLinkHasDependenciesException(std::string message, const std::exception& innerException) : std::invalid_argument(message, innerException) { } + public: ArgumentLinkHasDependenciesException(std::string message, const std::exception& innerException) : std::invalid_argument(message) { } public: ArgumentLinkHasDependenciesException(std::string message) : std::invalid_argument(message) { } - public: ArgumentLinkHasDependenciesException() { } + public: ArgumentLinkHasDependenciesException() : std::invalid_argument("") { } private: static std::string FormatMessage(TLinkAddress link, std::string paramName) { return std::string("У связи [").append(Platform::Converters::To(link)).append("] переданной в аргумент [").append(paramName).append("] присутствуют зависимости, которые препятствуют изменению её внутренней структуры."); } diff --git a/cpp/Platform.Data/Exceptions/LinkWithSameValueAlreadyExistsException.h b/cpp/Platform.Data/Exceptions/LinkWithSameValueAlreadyExistsException.h index 5b2c69d..71d992d 100644 --- a/cpp/Platform.Data/Exceptions/LinkWithSameValueAlreadyExistsException.h +++ b/cpp/Platform.Data/Exceptions/LinkWithSameValueAlreadyExistsException.h @@ -1,13 +1,21 @@ -namespace Platform::Data::Exceptions +#pragma once +#include +#include + +namespace Platform::Data::Exceptions { class LinkWithSameValueAlreadyExistsException : public std::exception { + private: std::string _message; + public: inline static std::string DefaultMessage = "Связь с таким же значением уже существует."; - public: LinkWithSameValueAlreadyExistsException(std::string message, const std::exception& innerException) : base(message, innerException) { } + public: LinkWithSameValueAlreadyExistsException(std::string message, const std::exception& innerException) : _message(message) { } - public: LinkWithSameValueAlreadyExistsException(std::string message) : base(message) { } + public: LinkWithSameValueAlreadyExistsException(std::string message) : _message(message) { } - public: LinkWithSameValueAlreadyExistsException() : base(DefaultMessage) { } + public: LinkWithSameValueAlreadyExistsException() : _message(DefaultMessage) { } + + public: const char* what() const noexcept override { return _message.c_str(); } }; } diff --git a/cpp/Platform.Data/Exceptions/LinksLimitReachedException.h b/cpp/Platform.Data/Exceptions/LinksLimitReachedException.h index 521cb35..7937232 100644 --- a/cpp/Platform.Data/Exceptions/LinksLimitReachedException.h +++ b/cpp/Platform.Data/Exceptions/LinksLimitReachedException.h @@ -1,9 +1,14 @@ -namespace Platform::Data::Exceptions +#pragma once +#include +#include "LinksLimitReachedExceptionBase.h" +#include "Platform.Converters.Fallback.h" + +namespace Platform::Data::Exceptions { template class LinksLimitReachedException; template class LinksLimitReachedException : public LinksLimitReachedExceptionBase { - public: LinksLimitReachedException(TLinkAddress limit) : this(FormatMessage(limit)) { } + public: LinksLimitReachedException(TLinkAddress limit) : LinksLimitReachedExceptionBase(FormatMessage(limit)) { } public: LinksLimitReachedException(std::string message, const std::exception& innerException) : LinksLimitReachedExceptionBase(message, innerException) { } diff --git a/cpp/Platform.Data/Exceptions/LinksLimitReachedExceptionBase.h b/cpp/Platform.Data/Exceptions/LinksLimitReachedExceptionBase.h index 37ab3c7..82a7a86 100644 --- a/cpp/Platform.Data/Exceptions/LinksLimitReachedExceptionBase.h +++ b/cpp/Platform.Data/Exceptions/LinksLimitReachedExceptionBase.h @@ -1,11 +1,19 @@ -namespace Platform::Data::Exceptions +#pragma once +#include +#include + +namespace Platform::Data::Exceptions { class LinksLimitReachedExceptionBase : public std::exception { + private: std::string _message; + public: inline static std::string DefaultMessage = "Достигнут лимит количества связей в хранилище."; - protected: LinksLimitReachedExceptionBase(std::string message, const std::exception& innerException) : base(message, innerException) { } + protected: LinksLimitReachedExceptionBase(std::string message, const std::exception& innerException) : _message(message) { } - protected: LinksLimitReachedExceptionBase(std::string message) : base(message) { } + protected: LinksLimitReachedExceptionBase(std::string message) : _message(message) { } + + public: const char* what() const noexcept override { return _message.c_str(); } }; } diff --git a/cpp/Platform.Data/Exceptions/Platform.Converters.Fallback.h b/cpp/Platform.Data/Exceptions/Platform.Converters.Fallback.h new file mode 100644 index 0000000..27c4709 --- /dev/null +++ b/cpp/Platform.Data/Exceptions/Platform.Converters.Fallback.h @@ -0,0 +1,22 @@ +#pragma once +#include + +// Try to include Platform.Converters, but provide fallback if not available +#ifdef __has_include + #if __has_include() + #include + #define HAS_PLATFORM_CONVERTERS + #endif +#endif + +// Fallback converter if Platform.Converters is not available +#ifndef HAS_PLATFORM_CONVERTERS +namespace Platform { namespace Converters { + template + TTarget To(const TSource& source) { + std::stringstream ss; + ss << source; + return ss.str(); + } +}} +#endif \ No newline at end of file From 043f0b22c5b15e970965abde9e38bbe547c14a52 Mon Sep 17 00:00:00 2001 From: konard Date: Sat, 13 Sep 2025 02:45:36 +0300 Subject: [PATCH 3/4] 'Auto-commit changes made by Claude MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude ' --- experiments/simple_exception_test.cpp | 90 ++++++++++ experiments/standalone_exception_test.cpp | 197 ++++++++++++++++++++++ experiments/test_exceptions | Bin 0 -> 118096 bytes experiments/test_real_exceptions | Bin 0 -> 51840 bytes experiments/test_real_exceptions.cpp | 83 +++++++++ 5 files changed, 370 insertions(+) create mode 100644 experiments/simple_exception_test.cpp create mode 100644 experiments/standalone_exception_test.cpp create mode 100755 experiments/test_exceptions create mode 100755 experiments/test_real_exceptions create mode 100644 experiments/test_real_exceptions.cpp diff --git a/experiments/simple_exception_test.cpp b/experiments/simple_exception_test.cpp new file mode 100644 index 0000000..2111ddf --- /dev/null +++ b/experiments/simple_exception_test.cpp @@ -0,0 +1,90 @@ +#include +#include +#include +#include + +// Mock Platform::Converters::To for testing +namespace Platform { +namespace Converters { + template + std::string To(int value) { + return std::to_string(value); + } +} +} + +// Include our exception headers +#include "../cpp/Platform.Data/Exceptions/ArgumentLinkDoesNotExistsException.h" +#include "../cpp/Platform.Data/Exceptions/ArgumentLinkHasDependenciesException.h" +#include "../cpp/Platform.Data/Exceptions/LinksLimitReachedExceptionBase.h" +#include "../cpp/Platform.Data/Exceptions/LinksLimitReachedException.h" +#include "../cpp/Platform.Data/Exceptions/LinkWithSameValueAlreadyExistsException.h" + +using namespace Platform::Data::Exceptions; + +int main() { + std::cout << "Testing exception inheritance and functionality..." << std::endl; + + try { + // Test ArgumentLinkDoesNotExistsException + std::cout << "Testing ArgumentLinkDoesNotExistsException..." << std::endl; + ArgumentLinkDoesNotExistsException ex1(42, "testParam"); + std::cout << "Message: " << ex1.what() << std::endl; + + // Test inheritance + std::exception* basePtr = &ex1; + std::cout << "Can be cast to std::exception: " << (basePtr != nullptr ? "YES" : "NO") << std::endl; + + std::invalid_argument* invalidArgPtr = dynamic_cast(&ex1); + std::cout << "Can be cast to std::invalid_argument: " << (invalidArgPtr != nullptr ? "YES" : "NO") << std::endl; + + // Test ArgumentLinkHasDependenciesException + std::cout << "\nTesting ArgumentLinkHasDependenciesException..." << std::endl; + ArgumentLinkHasDependenciesException ex2(123, "depParam"); + std::cout << "Message: " << ex2.what() << std::endl; + + // Test LinksLimitReachedException + std::cout << "\nTesting LinksLimitReachedException..." << std::endl; + LinksLimitReachedException ex3(1000); + std::cout << "Message: " << ex3.what() << std::endl; + + LinksLimitReachedExceptionBase* baseExPtr = &ex3; + std::cout << "Can be cast to LinksLimitReachedExceptionBase: " << (baseExPtr != nullptr ? "YES" : "NO") << std::endl; + + // Test LinkWithSameValueAlreadyExistsException + std::cout << "\nTesting LinkWithSameValueAlreadyExistsException..." << std::endl; + LinkWithSameValueAlreadyExistsException ex4; + std::cout << "Default message: " << ex4.what() << std::endl; + + // Test exception throwing and catching + std::cout << "\nTesting exception throwing and catching..." << std::endl; + + try { + throw ArgumentLinkDoesNotExistsException(999, "throwTest"); + } catch (const std::invalid_argument& e) { + std::cout << "Caught ArgumentLinkDoesNotExistsException as std::invalid_argument: " << e.what() << std::endl; + } + + try { + throw LinksLimitReachedException("Custom limit message"); + } catch (const std::exception& e) { + std::cout << "Caught LinksLimitReachedException as std::exception: " << e.what() << std::endl; + } + + try { + throw LinkWithSameValueAlreadyExistsException("Custom value message"); + } catch (const std::exception& e) { + std::cout << "Caught LinkWithSameValueAlreadyExistsException as std::exception: " << e.what() << std::endl; + } + + std::cout << "\nAll tests completed successfully!" << std::endl; + return 0; + + } catch (const std::exception& e) { + std::cout << "ERROR: Caught unexpected exception: " << e.what() << std::endl; + return 1; + } catch (...) { + std::cout << "ERROR: Caught unknown exception" << std::endl; + return 1; + } +} \ No newline at end of file diff --git a/experiments/standalone_exception_test.cpp b/experiments/standalone_exception_test.cpp new file mode 100644 index 0000000..410522b --- /dev/null +++ b/experiments/standalone_exception_test.cpp @@ -0,0 +1,197 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +// Simple converter mock for testing +template +std::string ToStr(const T& value) { + std::stringstream ss; + ss << value; + return ss.str(); +} + +// Standalone exception definitions for testing (without external dependencies) +namespace Platform::Data::Exceptions +{ + // ArgumentLinkDoesNotExistsException + template class ArgumentLinkDoesNotExistsException; + template + class ArgumentLinkDoesNotExistsException : public std::invalid_argument + { + public: ArgumentLinkDoesNotExistsException(TLinkAddress link, std::string argumentName) : std::invalid_argument(FormatMessage(link, argumentName)) { } + + public: ArgumentLinkDoesNotExistsException(TLinkAddress link) : std::invalid_argument(FormatMessage(link)) { } + + public: ArgumentLinkDoesNotExistsException(std::string message, const std::exception& innerException) : std::invalid_argument(message) { } + + public: ArgumentLinkDoesNotExistsException(std::string message) : std::invalid_argument(message) { } + + public: ArgumentLinkDoesNotExistsException() : std::invalid_argument("") { } + + private: static std::string FormatMessage(TLinkAddress link, std::string argumentName) { + return std::string("Связь [").append(ToStr(link)).append("] переданная в аргумент [").append(argumentName).append("] не существует."); + } + + private: static std::string FormatMessage(TLinkAddress link) { + return std::string("Связь [").append(ToStr(link)).append("] переданная в качестве аргумента не существует."); + } + }; + + // ArgumentLinkHasDependenciesException + template class ArgumentLinkHasDependenciesException; + template + class ArgumentLinkHasDependenciesException : public std::invalid_argument + { + public: ArgumentLinkHasDependenciesException(TLinkAddress link, std::string paramName) : std::invalid_argument(FormatMessage(link, paramName)) { } + + public: ArgumentLinkHasDependenciesException(TLinkAddress link) : std::invalid_argument(FormatMessage(link)) { } + + public: ArgumentLinkHasDependenciesException(std::string message, const std::exception& innerException) : std::invalid_argument(message) { } + + public: ArgumentLinkHasDependenciesException(std::string message) : std::invalid_argument(message) { } + + public: ArgumentLinkHasDependenciesException() : std::invalid_argument("") { } + + private: static std::string FormatMessage(TLinkAddress link, std::string paramName) { + return std::string("У связи [").append(ToStr(link)).append("] переданной в аргумент [").append(paramName).append("] присутствуют зависимости, которые препятствуют изменению её внутренней структуры."); + } + + private: static std::string FormatMessage(TLinkAddress link) { + return std::string("У связи [").append(ToStr(link)).append("] переданной в качестве аргумента присутствуют зависимости, которые препятствуют изменению её внутренней структуры."); + } + }; + + // LinksLimitReachedExceptionBase + class LinksLimitReachedExceptionBase : public std::exception + { + private: std::string _message; + + public: inline static std::string DefaultMessage = "Достигнут лимит количества связей в хранилище."; + + protected: LinksLimitReachedExceptionBase(std::string message, const std::exception& innerException) : _message(message) { } + + protected: LinksLimitReachedExceptionBase(std::string message) : _message(message) { } + + public: const char* what() const noexcept override { return _message.c_str(); } + }; + + // LinksLimitReachedException + template class LinksLimitReachedException; + template + class LinksLimitReachedException : public LinksLimitReachedExceptionBase + { + public: LinksLimitReachedException(TLinkAddress limit) : LinksLimitReachedExceptionBase(FormatMessage(limit)) { } + + public: LinksLimitReachedException(std::string message, const std::exception& innerException) : LinksLimitReachedExceptionBase(message, innerException) { } + + public: LinksLimitReachedException(std::string message) : LinksLimitReachedExceptionBase(message) { } + + public: LinksLimitReachedException() : LinksLimitReachedExceptionBase(DefaultMessage) { } + + private: static std::string FormatMessage(TLinkAddress limit) { + return std::string("Достигнут лимит количества связей в хранилище (").append(ToStr(limit)).append(")."); + } + }; + + // LinkWithSameValueAlreadyExistsException + class LinkWithSameValueAlreadyExistsException : public std::exception + { + private: std::string _message; + + public: inline static std::string DefaultMessage = "Связь с таким же значением уже существует."; + + public: LinkWithSameValueAlreadyExistsException(std::string message, const std::exception& innerException) : _message(message) { } + + public: LinkWithSameValueAlreadyExistsException(std::string message) : _message(message) { } + + public: LinkWithSameValueAlreadyExistsException() : _message(DefaultMessage) { } + + public: const char* what() const noexcept override { return _message.c_str(); } + }; +} + +using namespace Platform::Data::Exceptions; + +int main() { + std::cout << "Testing exception inheritance and functionality..." << std::endl; + + try { + // Test ArgumentLinkDoesNotExistsException + std::cout << "Testing ArgumentLinkDoesNotExistsException..." << std::endl; + ArgumentLinkDoesNotExistsException ex1(42, "testParam"); + std::cout << "Message: " << ex1.what() << std::endl; + + // Test inheritance + std::exception* basePtr = &ex1; + std::cout << "Can be cast to std::exception: " << (basePtr != nullptr ? "YES" : "NO") << std::endl; + + std::invalid_argument* invalidArgPtr = dynamic_cast(&ex1); + std::cout << "Can be cast to std::invalid_argument: " << (invalidArgPtr != nullptr ? "YES" : "NO") << std::endl; + + // Test ArgumentLinkHasDependenciesException + std::cout << "\nTesting ArgumentLinkHasDependenciesException..." << std::endl; + ArgumentLinkHasDependenciesException ex2(123, "depParam"); + std::cout << "Message: " << ex2.what() << std::endl; + + // Test LinksLimitReachedException + std::cout << "\nTesting LinksLimitReachedException..." << std::endl; + LinksLimitReachedException ex3(1000); + std::cout << "Message: " << ex3.what() << std::endl; + + LinksLimitReachedExceptionBase* baseExPtr = &ex3; + std::cout << "Can be cast to LinksLimitReachedExceptionBase: " << (baseExPtr != nullptr ? "YES" : "NO") << std::endl; + + // Test LinkWithSameValueAlreadyExistsException + std::cout << "\nTesting LinkWithSameValueAlreadyExistsException..." << std::endl; + LinkWithSameValueAlreadyExistsException ex4; + std::cout << "Default message: " << ex4.what() << std::endl; + + // Test exception throwing and catching + std::cout << "\nTesting exception throwing and catching..." << std::endl; + + try { + throw ArgumentLinkDoesNotExistsException(999, "throwTest"); + } catch (const std::invalid_argument& e) { + std::cout << "Caught ArgumentLinkDoesNotExistsException as std::invalid_argument: " << e.what() << std::endl; + } + + try { + throw LinksLimitReachedException("Custom limit message"); + } catch (const std::exception& e) { + std::cout << "Caught LinksLimitReachedException as std::exception: " << e.what() << std::endl; + } + + try { + throw LinkWithSameValueAlreadyExistsException("Custom value message"); + } catch (const std::exception& e) { + std::cout << "Caught LinkWithSameValueAlreadyExistsException as std::exception: " << e.what() << std::endl; + } + + // Test polymorphic behavior + std::cout << "\nTesting polymorphic behavior..." << std::endl; + std::vector> exceptions; + exceptions.push_back(std::make_unique>("poly test 1")); + exceptions.push_back(std::make_unique>("poly test 2")); + exceptions.push_back(std::make_unique>("poly test 3")); + exceptions.push_back(std::make_unique("poly test 4")); + + for (const auto& ex : exceptions) { + std::cout << "Polymorphic exception message: " << ex->what() << std::endl; + } + + std::cout << "\nAll tests completed successfully!" << std::endl; + return 0; + + } catch (const std::exception& e) { + std::cout << "ERROR: Caught unexpected exception: " << e.what() << std::endl; + return 1; + } catch (...) { + std::cout << "ERROR: Caught unknown exception" << std::endl; + return 1; + } +} \ No newline at end of file diff --git a/experiments/test_exceptions b/experiments/test_exceptions new file mode 100755 index 0000000000000000000000000000000000000000..10bdf7e094b7f5808fc911bf9e7d791f003db391 GIT binary patch literal 118096 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 Ndwt~#L5JY5_djS&>1_Z2 literal 0 HcmV?d00001 diff --git a/experiments/test_real_exceptions b/experiments/test_real_exceptions new file mode 100755 index 0000000000000000000000000000000000000000..890dc47593e76aa833e7332654169b441d1cc472 GIT binary patch literal 51840 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

dz59P>Io*437sCQ5+9 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 bYsPY0nK6eW5iP&+6z5tf6&0B*N#*|nj#sn0 literal 0 HcmV?d00001 diff --git a/experiments/test_real_exceptions.cpp b/experiments/test_real_exceptions.cpp new file mode 100644 index 0000000..e7c37a1 --- /dev/null +++ b/experiments/test_real_exceptions.cpp @@ -0,0 +1,83 @@ +#include +#include +#include +#include +#include +#include +#include + +// Include the actual exception headers +#include "../cpp/Platform.Data/Exceptions/ArgumentLinkDoesNotExistsException.h" +#include "../cpp/Platform.Data/Exceptions/ArgumentLinkHasDependenciesException.h" +#include "../cpp/Platform.Data/Exceptions/LinksLimitReachedExceptionBase.h" +#include "../cpp/Platform.Data/Exceptions/LinksLimitReachedException.h" +#include "../cpp/Platform.Data/Exceptions/LinkWithSameValueAlreadyExistsException.h" + +using namespace Platform::Data::Exceptions; + +int main() { + std::cout << "Testing real exception headers..." << std::endl; + + try { + // Test ArgumentLinkDoesNotExistsException + std::cout << "\nTesting ArgumentLinkDoesNotExistsException..." << std::endl; + ArgumentLinkDoesNotExistsException ex1(42, "testParam"); + std::cout << "Message: " << ex1.what() << std::endl; + + // Test inheritance + std::exception* basePtr = &ex1; + std::cout << "Can be cast to std::exception: " << (basePtr != nullptr ? "YES" : "NO") << std::endl; + + std::invalid_argument* invalidArgPtr = dynamic_cast(&ex1); + std::cout << "Can be cast to std::invalid_argument: " << (invalidArgPtr != nullptr ? "YES" : "NO") << std::endl; + + // Test ArgumentLinkHasDependenciesException + std::cout << "\nTesting ArgumentLinkHasDependenciesException..." << std::endl; + ArgumentLinkHasDependenciesException ex2(123, "depParam"); + std::cout << "Message: " << ex2.what() << std::endl; + + // Test LinksLimitReachedException + std::cout << "\nTesting LinksLimitReachedException..." << std::endl; + LinksLimitReachedException ex3(1000); + std::cout << "Message: " << ex3.what() << std::endl; + + LinksLimitReachedExceptionBase* baseExPtr = &ex3; + std::cout << "Can be cast to LinksLimitReachedExceptionBase: " << (baseExPtr != nullptr ? "YES" : "NO") << std::endl; + + // Test LinkWithSameValueAlreadyExistsException + std::cout << "\nTesting LinkWithSameValueAlreadyExistsException..." << std::endl; + LinkWithSameValueAlreadyExistsException ex4; + std::cout << "Default message: " << ex4.what() << std::endl; + + // Test exception throwing and catching + std::cout << "\nTesting exception throwing and catching..." << std::endl; + + try { + throw ArgumentLinkDoesNotExistsException(999, "throwTest"); + } catch (const std::invalid_argument& e) { + std::cout << "Caught ArgumentLinkDoesNotExistsException as std::invalid_argument: " << e.what() << std::endl; + } + + try { + throw LinksLimitReachedException("Custom limit message"); + } catch (const std::exception& e) { + std::cout << "Caught LinksLimitReachedException as std::exception: " << e.what() << std::endl; + } + + try { + throw LinkWithSameValueAlreadyExistsException("Custom value message"); + } catch (const std::exception& e) { + std::cout << "Caught LinkWithSameValueAlreadyExistsException as std::exception: " << e.what() << std::endl; + } + + std::cout << "\nAll tests completed successfully!" << std::endl; + return 0; + + } catch (const std::exception& e) { + std::cout << "ERROR: Caught unexpected exception: " << e.what() << std::endl; + return 1; + } catch (...) { + std::cout << "ERROR: Caught unknown exception" << std::endl; + return 1; + } +} \ No newline at end of file From 0d13856248ac29f067dafc3418371dcbc6fde3ce Mon Sep 17 00:00:00 2001 From: konard Date: Sat, 13 Sep 2025 02:45:38 +0300 Subject: [PATCH 4/4] Remove CLAUDE.md - Claude command completed --- CLAUDE.md | 5 ----- 1 file changed, 5 deletions(-) delete mode 100644 CLAUDE.md diff --git a/CLAUDE.md b/CLAUDE.md deleted file mode 100644 index 46d1067..0000000 --- a/CLAUDE.md +++ /dev/null @@ -1,5 +0,0 @@ -Issue to solve: https://github.com/linksplatform/Data/issues/83 -Your prepared branch: issue-83-3fdff5b3 -Your prepared working directory: /tmp/gh-issue-solver-1757719970544 - -Proceed. \ No newline at end of file