From b3947ab87cbbae950a6152def808d379cddb0359 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Tue, 16 Sep 2025 14:51:37 +0300 Subject: [PATCH 01/44] The 'type' functions declaration added, the 'add' function declaration changed, class member variables m_rightDict, m_reverseDict declaration changed in BasicDictionary class. The VendorDictionary class declaration added. The return type changed in vendorNames function declaration, type of m_vendorNames variable declaration changed in the Dictionaries class. --- include/radproto/dictionaries.h | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/include/radproto/dictionaries.h b/include/radproto/dictionaries.h index f2ef086..3ffb7c6 100644 --- a/include/radproto/dictionaries.h +++ b/include/radproto/dictionaries.h @@ -12,8 +12,25 @@ namespace RadProto BasicDictionary() = default; std::string name(uint32_t code) const; uint32_t code(const std::string& name) const; - void add(uint32_t code, const std::string& name); + std::string type(uint32_t code) const; + std::string type(const std::string& name) const; + + void add(uint32_t code, const std::string& name, const std::string& type); void append(const BasicDictionary& basicDict); + private: + std::map> m_rightDict; + std::map> m_reverseDict; + }; + + class VendorDictionary + { + public: + VendorDictionary() = default; + std::string name(uint32_t code) const; + uint32_t code(const std::string& name) const; + + void add(uint32_t code, const std::string& name); + void append(const VendorDictionary& vendorDict); private: std::map m_rightDict; std::map m_reverseDict; @@ -38,7 +55,7 @@ namespace RadProto Dictionaries(const std::string& filePath); void append(const Dictionaries& fillingDictionaries); const BasicDictionary& attributes() const { return m_attributes; } - const BasicDictionary& vendorNames() const { return m_vendorNames; } + const VendorDictionary& vendorNames() const { return m_vendorNames; } const DependentDictionary& attributeValues() const { return m_attributeValues; } const DependentDictionary& vendorAttributes() const { return m_vendorAttributes; } const DependentDictionary& vendorAttributeValues() const { return m_vendorAttributeValues; } @@ -60,7 +77,7 @@ namespace RadProto private: BasicDictionary m_attributes; - BasicDictionary m_vendorNames; + VendorDictionary m_vendorNames; DependentDictionary m_attributeValues; DependentDictionary m_vendorAttributes; DependentDictionary m_vendorAttributeValues; From f974e43e0e767986fe6116e251e24fe3fad2e98d Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Tue, 16 Sep 2025 15:15:50 +0300 Subject: [PATCH 02/44] Return values of functions 'name' and 'code' changed, the 'type' functions definition added, the 'add' and 'append' functions definition changed in BasicDictionary class. The functions definition of VendorDictionary class added. The constructor Dictionaries changed, return type of vendorNames function changed in the Dictionaries class. --- src/dictionaries.cpp | 64 +++++++++++++++++++++++++++++++++++++++----- 1 file changed, 58 insertions(+), 6 deletions(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index f6b4a5e..eaf03c8 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -6,17 +6,65 @@ #include using BasicDictionary = RadProto::BasicDictionary; + std::string BasicDictionary::name(uint32_t code) const { - return m_rightDict.at(code); + return m_rightDict.at(code).first; +} + +std::string BasicDictionary::type(uint32_t code) const +{ + return m_rightDict.at(code).second; } uint32_t BasicDictionary::code(const std::string& name) const +{ + return m_reverseDict.at(name).first; +} + +std::string BasicDictionary::type(const std::string& name) const +{ + return m_reverseDict.at(name).second; +} + +void BasicDictionary::add(uint32_t code, const std::string& name, const std::string& type) +{ + for (const auto& entry: m_rightDict) + if (entry.second.first == name && entry.first != code) + throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); + + m_rightDict.insert_or_assign(code, std::make_pair(name, type)); + m_reverseDict.emplace(name, std::make_pair(code, type)); +} + +void BasicDictionary::append(const BasicDictionary& basicDict) +{ + for (const auto& entry: basicDict.m_rightDict) + { + for (const auto& item: m_rightDict) + if (entry.second.first == item.second.first && entry.first != item.first) + throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::append]. Attribute name " + entry.second.first + " already exists with code " + std::to_string(item.first)); + + m_rightDict.insert_or_assign(entry.first, entry.second); + } + + for (const auto& entry: basicDict.m_reverseDict) + m_reverseDict.emplace(entry.first, entry.second); +} + +using VendorDictionary = RadProto::VendorDictionary; + +std::string VendorDictionary::name(uint32_t code) const +{ + return m_rightDict.at(code); +} + +uint32_t VendorDictionary::code(const std::string& name) const { return m_reverseDict.at(name); } -void BasicDictionary::add(uint32_t code, const std::string& name) +void VendorDictionary::add(uint32_t code, const std::string& name) { for (const auto& entry: m_rightDict) if (entry.second == name && entry.first != code) @@ -26,9 +74,9 @@ void BasicDictionary::add(uint32_t code, const std::string& name) m_reverseDict.emplace(name, code); } -void BasicDictionary::append(const BasicDictionary& basicDict) +void VendorDictionary::append(const VendorDictionary& vendorDict) { - for (const auto& entry: basicDict.m_rightDict) + for (const auto& entry: vendorDict.m_rightDict) { for (const auto& item: m_rightDict) if (entry.second == item.second && entry.first != item.first) @@ -37,11 +85,12 @@ void BasicDictionary::append(const BasicDictionary& basicDict) m_rightDict.insert_or_assign(entry.first, entry.second); } - for (const auto& entry: basicDict.m_reverseDict) + for (const auto& entry: vendorDict.m_reverseDict) m_reverseDict.emplace(entry.first, entry.second); } using DependentDictionary = RadProto::DependentDictionary; + std::string DependentDictionary::name(const std::string& dependencyName, uint32_t code) const { return m_rightDict.at(std::make_pair(dependencyName, code)); @@ -77,6 +126,7 @@ void DependentDictionary::append(const DependentDictionary& dependentDict) } using Dictionaries = RadProto::Dictionaries; + Dictionaries::Dictionaries(const std::string& filePath) { std::ifstream stream(filePath); @@ -103,10 +153,12 @@ Dictionaries::Dictionaries(const std::string& filePath) { const auto& attrName = tokens[1]; const auto code = std::stoul(tokens[2]); + const auto& attrType = tokens[3]; + if (!vendorName.empty()) m_vendorAttributes.add(code, attrName, vendorName); else - m_attributes.add(code, attrName); + m_attributes.add(code, attrName, attrType); } else if (tokens[0] == "VALUE") { From 90257d63e6c8439f18885d11513d6c8726e80f32 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Tue, 16 Sep 2025 16:21:18 +0300 Subject: [PATCH 03/44] The "string" parameter added to call add function when checking the BasicDictionary class. --- tests/dictionaries_tests.cpp | 44 ++++++++++++++++++------------------ 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index a327aa8..491eef8 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -23,12 +23,12 @@ BOOST_AUTO_TEST_CASE(TestAdd) { RadProto::BasicDictionary b; - b.add(1, "User-Name"); - b.add(1, "User"); - b.add(1, "abc"); - BOOST_CHECK_THROW(b.add(2, "abc"), RadProto::Exception); - b.add(3, "def"); - b.add(1, "abc"); + b.add(1, "User-Name", "string"); + b.add(1, "User", "string"); + b.add(1, "abc", "string"); + BOOST_CHECK_THROW(b.add(2, "abc", "string"), RadProto::Exception); + b.add(3, "def", "string"); + b.add(1, "abc", "string"); BOOST_CHECK_EQUAL(b.name(1), "abc"); BOOST_CHECK_EQUAL(b.name(3), "def"); @@ -44,9 +44,9 @@ BOOST_AUTO_TEST_CASE(TestAppend) { RadProto::BasicDictionary a; - a.add(2, "def"); - a.add(3, "ghi"); - a.add(4, "User-Name"); + a.add(2, "def", "string"); + a.add(3, "ghi", "string"); + a.add(4, "User-Name", "string"); BOOST_CHECK_EQUAL(a.name(2), "def"); BOOST_CHECK_EQUAL(a.name(3), "ghi"); @@ -57,7 +57,7 @@ BOOST_AUTO_TEST_CASE(TestAppend) RadProto::BasicDictionary b; - b.add(1, "User-Name"); + b.add(1, "User-Name", "string"); BOOST_CHECK_EQUAL(b.name(1), "User-Name"); BOOST_CHECK_EQUAL(b.code("User-Name"), 1); @@ -68,7 +68,7 @@ BOOST_AUTO_TEST_CASE(TestAppend) RadProto::BasicDictionary c; - c.add(4, "User"); + c.add(4, "User", "string"); BOOST_CHECK_EQUAL(c.name(4), "User"); BOOST_CHECK_EQUAL(c.code("User"), 4); @@ -85,7 +85,7 @@ BOOST_AUTO_TEST_CASE(TestAppend) RadProto::BasicDictionary d; - d.add(4, "jkl"); + d.add(4, "jkl", "string"); BOOST_CHECK_EQUAL(d.name(4), "jkl"); BOOST_CHECK_EQUAL(d.code("jkl"), 4); @@ -103,7 +103,7 @@ BOOST_AUTO_TEST_CASE(TestAppend) RadProto::BasicDictionary e; - e.add(2, "def"); + e.add(2, "def", "string"); BOOST_CHECK_EQUAL(e.name(2), "def"); BOOST_CHECK_EQUAL(e.code("def"), 2); @@ -121,7 +121,7 @@ BOOST_AUTO_TEST_CASE(TestAppend) RadProto::BasicDictionary f; - f.add(4, "User-Name"); + f.add(4, "User-Name", "string"); BOOST_CHECK_EQUAL(f.name(4), "User-Name"); BOOST_CHECK_EQUAL(f.code("User-Name"), 4); @@ -146,11 +146,11 @@ BOOST_AUTO_TEST_CASE(TestConstructor) BOOST_CHECK_THROW(b.code(""), std::out_of_range); - b.add(1, "User-Name"); - b.add(1, "User"); - b.add(5, "ijk"); - b.add(3, "def"); - BOOST_CHECK_THROW(b.add(2, "User"), RadProto::Exception); + b.add(1, "User-Name","string"); + b.add(1, "User", "string"); + b.add(5, "ijk", "string"); + b.add(3, "def", "string"); + BOOST_CHECK_THROW(b.add(2, "User", "string"), RadProto::Exception); BOOST_CHECK_EQUAL(b.name(1), "User"); BOOST_CHECK_EQUAL(b.name(5), "ijk"); @@ -163,8 +163,8 @@ BOOST_AUTO_TEST_CASE(TestConstructor) RadProto::BasicDictionary c; - c.add(2, "def"); - c.add(5, "ghi"); + c.add(2, "def", "string"); + c.add(5, "ghi", "string"); BOOST_CHECK_EQUAL(c.name(2), "def"); BOOST_CHECK_EQUAL(c.name(5), "ghi"); @@ -175,7 +175,7 @@ BOOST_AUTO_TEST_CASE(TestConstructor) RadProto::BasicDictionary a; - a.add(2, "def"); + a.add(2, "def", "string"); BOOST_CHECK_EQUAL(a.name(2), "def"); BOOST_CHECK_EQUAL(a.code("def"), 2); From e7d19c9609db3abea807912993acfa15eec0b56e Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 17 Sep 2025 17:02:30 +0300 Subject: [PATCH 04/44] The BOOST_CHECK_EQUAL and BOOST_CHECK_THROW commands to check the 'type' functions of BasicDictionary class added. --- tests/dictionaries_tests.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index 491eef8..30388f0 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -37,6 +37,14 @@ BOOST_AUTO_TEST_CASE(TestAdd) BOOST_CHECK_EQUAL(b.code("abc"), 1); BOOST_CHECK_EQUAL(b.code("def"), 3); + BOOST_CHECK_EQUAL(b.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(b.type("User"), "string"); + BOOST_CHECK_EQUAL(b.type("abc"), "string"); + BOOST_CHECK_EQUAL(b.type("def"), "string"); + BOOST_CHECK_EQUAL(b.type(1), "string"); + BOOST_CHECK_EQUAL(b.type(3), "string"); + + BOOST_CHECK_THROW(b.type(2), std::out_of_range); BOOST_CHECK_THROW(b.name(2), std::out_of_range); } From aba8c0f6dc21f246b489a30be07daf9573e9dccf Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 17 Sep 2025 18:17:06 +0300 Subject: [PATCH 05/44] BOOST_CHECK_EQUAL command to check the 'type' functions of BasicDictionary class added in test case TestAppend. --- tests/dictionaries_tests.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index 30388f0..a522824 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -62,6 +62,12 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("def"), 2); BOOST_CHECK_EQUAL(a.code("ghi"), 3); BOOST_CHECK_EQUAL(a.code("User-Name"), 4); + BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("ghi"), "string"); + BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(3), "string"); + BOOST_CHECK_EQUAL(a.type(4), "string"); RadProto::BasicDictionary b; From 94816a8db31bc76c4076b2716a89a74f90c60635 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Thu, 18 Sep 2025 15:45:42 +0300 Subject: [PATCH 06/44] BOOST_CHECK_EQUAL command to check the 'type' functions of BasicDictionary class added in test case TestAppend. --- tests/dictionaries_tests.cpp | 43 +++++++++++++++++++++++++++++++++++- 1 file changed, 42 insertions(+), 1 deletion(-) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index a522824..71603b4 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -36,7 +36,6 @@ BOOST_AUTO_TEST_CASE(TestAdd) BOOST_CHECK_EQUAL(b.code("User"), 1); BOOST_CHECK_EQUAL(b.code("abc"), 1); BOOST_CHECK_EQUAL(b.code("def"), 3); - BOOST_CHECK_EQUAL(b.type("User-Name"), "string"); BOOST_CHECK_EQUAL(b.type("User"), "string"); BOOST_CHECK_EQUAL(b.type("abc"), "string"); @@ -75,10 +74,13 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(b.name(1), "User-Name"); BOOST_CHECK_EQUAL(b.code("User-Name"), 1); + BOOST_CHECK_EQUAL(b.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(b.type(1), "string"); BOOST_CHECK_THROW(a.append(b), RadProto::Exception); BOOST_CHECK_THROW(a.name(1), std::out_of_range); + BOOST_CHECK_THROW(a.type(1), std::out_of_range); RadProto::BasicDictionary c; @@ -86,6 +88,8 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(c.name(4), "User"); BOOST_CHECK_EQUAL(c.code("User"), 4); + BOOST_CHECK_EQUAL(c.type("User"), "string"); + BOOST_CHECK_EQUAL(c.type(4), "string"); a.append(c); @@ -96,6 +100,13 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("ghi"), 3); BOOST_CHECK_EQUAL(a.code("User"), 4); BOOST_CHECK_EQUAL(a.code("User-Name"), 4); + BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("ghi"), "string"); + BOOST_CHECK_EQUAL(a.type("User"), "string"); + BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(3), "string"); + BOOST_CHECK_EQUAL(a.type(4), "string"); RadProto::BasicDictionary d; @@ -103,6 +114,8 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(d.name(4), "jkl"); BOOST_CHECK_EQUAL(d.code("jkl"), 4); + BOOST_CHECK_EQUAL(d.type("jkl"), "string"); + BOOST_CHECK_EQUAL(d.type(4), "string"); a.append(d); @@ -114,6 +127,14 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("User"), 4); BOOST_CHECK_EQUAL(a.code("User-Name"), 4); BOOST_CHECK_EQUAL(a.code("jkl"), 4); + BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("ghi"), "string"); + BOOST_CHECK_EQUAL(a.type("User"), "string"); + BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(a.type("jkl"), "string"); + BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(3), "string"); + BOOST_CHECK_EQUAL(a.type(4), "string"); RadProto::BasicDictionary e; @@ -121,6 +142,8 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(e.name(2), "def"); BOOST_CHECK_EQUAL(e.code("def"), 2); + BOOST_CHECK_EQUAL(e.type("def"), "string"); + BOOST_CHECK_EQUAL(e.type(2), "string"); a.append(e); @@ -132,6 +155,14 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("User"), 4); BOOST_CHECK_EQUAL(a.code("User-Name"), 4); BOOST_CHECK_EQUAL(a.code("jkl"), 4); + BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("ghi"), "string"); + BOOST_CHECK_EQUAL(a.type("User"), "string"); + BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(a.type("jkl"), "string"); + BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(3), "string"); + BOOST_CHECK_EQUAL(a.type(4), "string"); RadProto::BasicDictionary f; @@ -139,6 +170,8 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(f.name(4), "User-Name"); BOOST_CHECK_EQUAL(f.code("User-Name"), 4); + BOOST_CHECK_EQUAL(f.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(f.type(4), "string"); a.append(f); @@ -150,6 +183,14 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("User-Name"), 4); BOOST_CHECK_EQUAL(a.code("User"), 4); BOOST_CHECK_EQUAL(a.code("jkl"), 4); + BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("ghi"), "string"); + BOOST_CHECK_EQUAL(a.type("User"), "string"); + BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(a.type("jkl"), "string"); + BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(3), "string"); + BOOST_CHECK_EQUAL(a.type(4), "string"); } BOOST_AUTO_TEST_CASE(TestConstructor) From 72d390c74c3056c92f50895e68767bf7c7cde872 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Thu, 18 Sep 2025 16:15:22 +0300 Subject: [PATCH 07/44] BOOST_CHECK_EQUAL command to check the 'type' functions of BasicDictionary class added in test case TestConstructor. --- tests/dictionaries_tests.cpp | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index 71603b4..c628499 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -214,7 +214,15 @@ BOOST_AUTO_TEST_CASE(TestConstructor) BOOST_CHECK_EQUAL(b.code("User"), 1); BOOST_CHECK_EQUAL(b.code("ijk"), 5); BOOST_CHECK_EQUAL(b.code("def"), 3); + BOOST_CHECK_EQUAL(b.type("User-Name"), "string"); + BOOST_CHECK_EQUAL(b.type("User"), "string"); + BOOST_CHECK_EQUAL(b.type("ijk"), "string"); + BOOST_CHECK_EQUAL(b.type("def"), "string"); + BOOST_CHECK_EQUAL(b.type(1), "string"); + BOOST_CHECK_EQUAL(b.type(5), "string"); + BOOST_CHECK_EQUAL(b.type(3), "string"); BOOST_CHECK_THROW(b.name(2), std::out_of_range); + BOOST_CHECK_THROW(b.type(2), std::out_of_range); RadProto::BasicDictionary c; @@ -225,6 +233,10 @@ BOOST_AUTO_TEST_CASE(TestConstructor) BOOST_CHECK_EQUAL(c.name(5), "ghi"); BOOST_CHECK_EQUAL(c.code("def"), 2); BOOST_CHECK_EQUAL(c.code("ghi"), 5); + BOOST_CHECK_EQUAL(c.type("def"), "string"); + BOOST_CHECK_EQUAL(c.type("ghi"), "string"); + BOOST_CHECK_EQUAL(c.type(2), "string"); + BOOST_CHECK_EQUAL(c.type(5), "string"); BOOST_CHECK_THROW(c.append(b), RadProto::Exception); @@ -234,6 +246,8 @@ BOOST_AUTO_TEST_CASE(TestConstructor) BOOST_CHECK_EQUAL(a.name(2), "def"); BOOST_CHECK_EQUAL(a.code("def"), 2); + BOOST_CHECK_EQUAL(c.type("def"), "string"); + BOOST_CHECK_EQUAL(c.type(2), "string"); c.append(a); @@ -241,6 +255,10 @@ BOOST_AUTO_TEST_CASE(TestConstructor) BOOST_CHECK_EQUAL(c.name(5), "ghi"); BOOST_CHECK_EQUAL(c.code("def"), 2); BOOST_CHECK_EQUAL(c.code("ghi"), 5); + BOOST_CHECK_EQUAL(c.type("def"), "string"); + BOOST_CHECK_EQUAL(c.type("ghi"), "string"); + BOOST_CHECK_EQUAL(c.type(2), "string"); + BOOST_CHECK_EQUAL(c.type(5), "string"); } BOOST_AUTO_TEST_SUITE_END() From 354f0bb3eee43098c77ec99e95e0c3f620883d89 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 19 Sep 2025 15:50:23 +0300 Subject: [PATCH 08/44] BOOST_AUTO_TEST_SUITE(VendorDictionaryTests) added. --- tests/dictionaries_tests.cpp | 172 +++++++++++++++++++++++++++++++++++ 1 file changed, 172 insertions(+) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index c628499..725fe1b 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -263,6 +263,178 @@ BOOST_AUTO_TEST_CASE(TestConstructor) BOOST_AUTO_TEST_SUITE_END() +BOOST_AUTO_TEST_SUITE(VendorDictionaryTests) + +BOOST_AUTO_TEST_CASE(TestAdd) +{ + RadProto::VendorDictionary b; + + b.add(1, "Vendor-Name"); + b.add(1, "Vendor"); + b.add(1, "abc"); + BOOST_CHECK_THROW(b.add(2, "abc"), RadProto::Exception); + b.add(3, "def"); + b.add(1, "abc"); + + BOOST_CHECK_EQUAL(b.name(1), "abc"); + BOOST_CHECK_EQUAL(b.name(3), "def"); + BOOST_CHECK_EQUAL(b.code("Vendor-Name"), 1); + BOOST_CHECK_EQUAL(b.code("Vendor"), 1); + BOOST_CHECK_EQUAL(b.code("abc"), 1); + BOOST_CHECK_EQUAL(b.code("def"), 3); + + BOOST_CHECK_THROW(b.name(2), std::out_of_range); +} +BOOST_AUTO_TEST_CASE(TestAppend) +{ + RadProto::VendorDictionary a; + + a.add(2, "def"); + a.add(3, "ghi"); + a.add(4, "Vendor-Name"); + + BOOST_CHECK_EQUAL(a.name(2), "def"); + BOOST_CHECK_EQUAL(a.name(3), "ghi"); + BOOST_CHECK_EQUAL(a.name(4), "Vendor-Name"); + BOOST_CHECK_EQUAL(a.code("def"), 2); + BOOST_CHECK_EQUAL(a.code("ghi"), 3); + BOOST_CHECK_EQUAL(a.code("Vendor-Name"), 4); + + RadProto::VendorDictionary b; + + b.add(1, "Vendor-Name"); + + BOOST_CHECK_EQUAL(b.name(1), "Vendor-Name"); + BOOST_CHECK_EQUAL(b.code("Vendor-Name"), 1); + + BOOST_CHECK_THROW(a.append(b), RadProto::Exception); + + BOOST_CHECK_THROW(a.name(1), std::out_of_range); + + RadProto::VendorDictionary c; + + c.add(4, "Vendor"); + + BOOST_CHECK_EQUAL(c.name(4), "Vendor"); + BOOST_CHECK_EQUAL(c.code("Vendor"), 4); + + a.append(c); + + BOOST_CHECK_EQUAL(a.name(2), "def"); + BOOST_CHECK_EQUAL(a.name(3), "ghi"); + BOOST_CHECK_EQUAL(a.name(4), "Vendor"); + BOOST_CHECK_EQUAL(a.code("def"), 2); + BOOST_CHECK_EQUAL(a.code("ghi"), 3); + BOOST_CHECK_EQUAL(a.code("Vendor"), 4); + BOOST_CHECK_EQUAL(a.code("Vendor-Name"), 4); + + RadProto::VendorDictionary d; + + d.add(4, "jkl"); + + BOOST_CHECK_EQUAL(d.name(4), "jkl"); + BOOST_CHECK_EQUAL(d.code("jkl"), 4); + + a.append(d); + + BOOST_CHECK_EQUAL(a.name(2), "def"); + BOOST_CHECK_EQUAL(a.name(3), "ghi"); + BOOST_CHECK_EQUAL(a.name(4), "jkl"); + BOOST_CHECK_EQUAL(a.code("def"), 2); + BOOST_CHECK_EQUAL(a.code("ghi"), 3); + BOOST_CHECK_EQUAL(a.code("Vendor"), 4); + BOOST_CHECK_EQUAL(a.code("Vendor-Name"), 4); + BOOST_CHECK_EQUAL(a.code("jkl"), 4); + + RadProto::VendorDictionary e; + + e.add(2, "def"); + + BOOST_CHECK_EQUAL(e.name(2), "def"); + BOOST_CHECK_EQUAL(e.code("def"), 2); + + a.append(e); + + BOOST_CHECK_EQUAL(a.name(2), "def"); + BOOST_CHECK_EQUAL(a.name(3), "ghi"); + BOOST_CHECK_EQUAL(a.name(4), "jkl"); + BOOST_CHECK_EQUAL(a.code("def"), 2); + BOOST_CHECK_EQUAL(a.code("ghi"), 3); + BOOST_CHECK_EQUAL(a.code("Vendor"), 4); + BOOST_CHECK_EQUAL(a.code("Vendor-Name"), 4); + BOOST_CHECK_EQUAL(a.code("jkl"), 4); + + RadProto::VendorDictionary f; + + f.add(4, "Vendor-Name"); + + BOOST_CHECK_EQUAL(f.name(4), "Vendor-Name"); + BOOST_CHECK_EQUAL(f.code("Vendor-Name"), 4); + + a.append(f); + + BOOST_CHECK_EQUAL(a.name(2), "def"); + BOOST_CHECK_EQUAL(a.name(3), "ghi"); + BOOST_CHECK_EQUAL(a.name(4), "Vendor-Name"); + BOOST_CHECK_EQUAL(a.code("def"), 2); + BOOST_CHECK_EQUAL(a.code("ghi"), 3); + BOOST_CHECK_EQUAL(a.code("Vendor-Name"), 4); + BOOST_CHECK_EQUAL(a.code("Vendor"), 4); + BOOST_CHECK_EQUAL(a.code("jkl"), 4); +} + +BOOST_AUTO_TEST_CASE(TestConstructor) +{ + RadProto::VendorDictionary b; + + BOOST_CHECK_THROW(b.name(0), std::out_of_range); + + BOOST_CHECK_THROW(b.code(""), std::out_of_range); + + b.add(1, "Vendor-Name"); + b.add(1, "Vendor"); + b.add(5, "ijk"); + b.add(3, "def"); + BOOST_CHECK_THROW(b.add(2, "Vendor"), RadProto::Exception); + + BOOST_CHECK_EQUAL(b.name(1), "Vendor"); + BOOST_CHECK_EQUAL(b.name(5), "ijk"); + BOOST_CHECK_EQUAL(b.name(3), "def"); + BOOST_CHECK_EQUAL(b.code("Vendor-Name"), 1); + BOOST_CHECK_EQUAL(b.code("Vendor"), 1); + BOOST_CHECK_EQUAL(b.code("ijk"), 5); + BOOST_CHECK_EQUAL(b.code("def"), 3); + BOOST_CHECK_THROW(b.name(2), std::out_of_range); + + RadProto::VendorDictionary c; + + c.add(2, "def"); + c.add(5, "ghi"); + + BOOST_CHECK_EQUAL(c.name(2), "def"); + BOOST_CHECK_EQUAL(c.name(5), "ghi"); + BOOST_CHECK_EQUAL(c.code("def"), 2); + BOOST_CHECK_EQUAL(c.code("ghi"), 5); + + BOOST_CHECK_THROW(c.append(b), RadProto::Exception); + + RadProto::VendorDictionary a; + + a.add(2, "def"); + + BOOST_CHECK_EQUAL(a.name(2), "def"); + BOOST_CHECK_EQUAL(a.code("def"), 2); + + c.append(a); + + BOOST_CHECK_EQUAL(c.name(2), "def"); + BOOST_CHECK_EQUAL(c.name(5), "ghi"); + BOOST_CHECK_EQUAL(c.code("def"), 2); + BOOST_CHECK_EQUAL(c.code("ghi"), 5); +} +BOOST_AUTO_TEST_SUITE_END() + + BOOST_AUTO_TEST_SUITE(DependentDictionaryTests) BOOST_AUTO_TEST_CASE(TestAdd) From 9415fcbdea904da713d1cc0fe6a61273cc6b7105 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Tue, 30 Sep 2025 16:54:50 +0300 Subject: [PATCH 09/44] Header file added. Check for attribute type added to functions add and append, debugging 'cout' added to function append of BasicDictionary class. --- src/dictionaries.cpp | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index eaf03c8..6810755 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -4,6 +4,7 @@ #include #include #include +#include using BasicDictionary = RadProto::BasicDictionary; @@ -30,9 +31,17 @@ std::string BasicDictionary::type(const std::string& name) const void BasicDictionary::add(uint32_t code, const std::string& name, const std::string& type) { for (const auto& entry: m_rightDict) + { if (entry.second.first == name && entry.first != code) throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); + if (entry.second.first == name && entry.first == code && entry.second.second != type) + throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with type " + entry.second.second); + + if (entry.second.first != name && entry.first == code && entry.second.second != type) + throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name2 " + name + " already exists with type " + entry.second.second); + } + m_rightDict.insert_or_assign(code, std::make_pair(name, type)); m_reverseDict.emplace(name, std::make_pair(code, type)); } @@ -41,9 +50,31 @@ void BasicDictionary::append(const BasicDictionary& basicDict) { for (const auto& entry: basicDict.m_rightDict) { + + std::cout << "entry.name: " + entry.second.first + " entry.code: " + std::to_string(entry.first) + " entry.type: " + entry.second.second + "\n"; for (const auto& item: m_rightDict) + { if (entry.second.first == item.second.first && entry.first != item.first) + { + std::cout << "name ==, code !=, entry.name: " + entry.second.first + "item.name: " + item.second.first + "\n"; throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::append]. Attribute name " + entry.second.first + " already exists with code " + std::to_string(item.first)); + } + + if (entry.second.first == item.second.first && entry.first == item.first && entry.second.second != item.second.second) + { + + std::cout << "name ==, code ==, entry.name: " + entry.second.first + "item.name: " + item.second.first + "\n"; + throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name3 " + entry.second.first + " already exists with type " + item.second.second); + } + + if (entry.second.first != item.second.first && entry.first == item.first && entry.second.second != item.second.second) + { + + std::cout << "(name !=, code ==, type !=) entry.name: " + entry.second.first + " entry.code: " + std::to_string(entry.first) + " entry.type: " + entry.second.second + " item.name: " + item.second.first + " item.code: " + std::to_string(item.first) + " item.type:" + item. second.second + "\n"; + throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name4 " + entry.second.first + " already exists with type " + item.second.second); + } + } + m_rightDict.insert_or_assign(entry.first, entry.second); } From 33d7ed258ae517d7bb3808479035f2c61a62a4e9 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Tue, 30 Sep 2025 17:29:57 +0300 Subject: [PATCH 10/44] BOOST_CHECK_EQUAL, BOOST_CHECK_THROW to check 'type' function added in the test case TestAdd, TestAppend. --- tests/dictionaries_tests.cpp | 54 ++++++++++++++++++++++++++++-------- 1 file changed, 42 insertions(+), 12 deletions(-) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index 725fe1b..4d0f775 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -27,21 +27,29 @@ BOOST_AUTO_TEST_CASE(TestAdd) b.add(1, "User", "string"); b.add(1, "abc", "string"); BOOST_CHECK_THROW(b.add(2, "abc", "string"), RadProto::Exception); + BOOST_CHECK_THROW(b.add(2, "abc", "int"), RadProto::Exception); + BOOST_CHECK_THROW(b.add(1, "abc", "int"), RadProto::Exception); b.add(3, "def", "string"); + BOOST_CHECK_THROW(b.add(3, "ghi", "int"), RadProto::Exception); b.add(1, "abc", "string"); + b.add(4, "cde", "int"); BOOST_CHECK_EQUAL(b.name(1), "abc"); BOOST_CHECK_EQUAL(b.name(3), "def"); + BOOST_CHECK_EQUAL(b.name(4), "cde"); BOOST_CHECK_EQUAL(b.code("User-Name"), 1); BOOST_CHECK_EQUAL(b.code("User"), 1); BOOST_CHECK_EQUAL(b.code("abc"), 1); BOOST_CHECK_EQUAL(b.code("def"), 3); + BOOST_CHECK_EQUAL(b.code("cde"), 4); BOOST_CHECK_EQUAL(b.type("User-Name"), "string"); BOOST_CHECK_EQUAL(b.type("User"), "string"); BOOST_CHECK_EQUAL(b.type("abc"), "string"); BOOST_CHECK_EQUAL(b.type("def"), "string"); + BOOST_CHECK_EQUAL(b.type("cde"), "int"); BOOST_CHECK_EQUAL(b.type(1), "string"); BOOST_CHECK_EQUAL(b.type(3), "string"); + BOOST_CHECK_EQUAL(b.type(4), "int"); BOOST_CHECK_THROW(b.type(2), std::out_of_range); BOOST_CHECK_THROW(b.name(2), std::out_of_range); @@ -51,7 +59,7 @@ BOOST_AUTO_TEST_CASE(TestAppend) { RadProto::BasicDictionary a; - a.add(2, "def", "string"); + a.add(2, "def", "int"); a.add(3, "ghi", "string"); a.add(4, "User-Name", "string"); @@ -61,10 +69,10 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("def"), 2); BOOST_CHECK_EQUAL(a.code("ghi"), 3); BOOST_CHECK_EQUAL(a.code("User-Name"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("def"), "int"); BOOST_CHECK_EQUAL(a.type("ghi"), "string"); BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(2), "int"); BOOST_CHECK_EQUAL(a.type(3), "string"); BOOST_CHECK_EQUAL(a.type(4), "string"); @@ -100,11 +108,11 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("ghi"), 3); BOOST_CHECK_EQUAL(a.code("User"), 4); BOOST_CHECK_EQUAL(a.code("User-Name"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("def"), "int"); BOOST_CHECK_EQUAL(a.type("ghi"), "string"); BOOST_CHECK_EQUAL(a.type("User"), "string"); BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(2), "int"); BOOST_CHECK_EQUAL(a.type(3), "string"); BOOST_CHECK_EQUAL(a.type(4), "string"); @@ -127,12 +135,12 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("User"), 4); BOOST_CHECK_EQUAL(a.code("User-Name"), 4); BOOST_CHECK_EQUAL(a.code("jkl"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("def"), "int"); BOOST_CHECK_EQUAL(a.type("ghi"), "string"); BOOST_CHECK_EQUAL(a.type("User"), "string"); BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); BOOST_CHECK_EQUAL(a.type("jkl"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(2), "int"); BOOST_CHECK_EQUAL(a.type(3), "string"); BOOST_CHECK_EQUAL(a.type(4), "string"); @@ -145,7 +153,7 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(e.type("def"), "string"); BOOST_CHECK_EQUAL(e.type(2), "string"); - a.append(e); + BOOST_CHECK_THROW(a.append(e), RadProto::Exception); BOOST_CHECK_EQUAL(a.name(2), "def"); BOOST_CHECK_EQUAL(a.name(3), "ghi"); @@ -155,12 +163,12 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("User"), 4); BOOST_CHECK_EQUAL(a.code("User-Name"), 4); BOOST_CHECK_EQUAL(a.code("jkl"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("def"), "int"); BOOST_CHECK_EQUAL(a.type("ghi"), "string"); BOOST_CHECK_EQUAL(a.type("User"), "string"); BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); BOOST_CHECK_EQUAL(a.type("jkl"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(2), "int"); BOOST_CHECK_EQUAL(a.type(3), "string"); BOOST_CHECK_EQUAL(a.type(4), "string"); @@ -183,14 +191,36 @@ BOOST_AUTO_TEST_CASE(TestAppend) BOOST_CHECK_EQUAL(a.code("User-Name"), 4); BOOST_CHECK_EQUAL(a.code("User"), 4); BOOST_CHECK_EQUAL(a.code("jkl"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "string"); + BOOST_CHECK_EQUAL(a.type("def"), "int"); BOOST_CHECK_EQUAL(a.type("ghi"), "string"); BOOST_CHECK_EQUAL(a.type("User"), "string"); BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); BOOST_CHECK_EQUAL(a.type("jkl"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "string"); + BOOST_CHECK_EQUAL(a.type(2), "int"); BOOST_CHECK_EQUAL(a.type(3), "string"); BOOST_CHECK_EQUAL(a.type(4), "string"); + + RadProto::BasicDictionary g; + + g.add(5, "ghi", "int"); + + BOOST_CHECK_EQUAL(g.name(5), "ghi"); + BOOST_CHECK_EQUAL(g.code("ghi"), 5); + BOOST_CHECK_EQUAL(g.type("ghi"), "int"); + BOOST_CHECK_EQUAL(g.type(5), "int"); + + BOOST_CHECK_THROW(a.append(g), RadProto::Exception); + + RadProto::BasicDictionary h; + + h.add(4, "jkl", "int"); + + BOOST_CHECK_EQUAL(h.name(4), "jkl"); + BOOST_CHECK_EQUAL(h.code("jkl"), 4); + BOOST_CHECK_EQUAL(h.type("jkl"), "int"); + BOOST_CHECK_EQUAL(h.type(4), "int"); + + BOOST_CHECK_THROW(a.append(h), RadProto::Exception); } BOOST_AUTO_TEST_CASE(TestConstructor) From 052b78f1bd989cd6f94ec986f75cfc2629356b04 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 15:22:25 +0300 Subject: [PATCH 11/44] Variable name type changed to code. Function name type() changed to code(). Class memeber name m_type changed to m_code. --- include/radproto/attribute.h | 30 +++++++++---------- .../{attribute_types.h => attribute_codes.h} | 0 2 files changed, 15 insertions(+), 15 deletions(-) rename include/radproto/{attribute_types.h => attribute_codes.h} (100%) diff --git a/include/radproto/attribute.h b/include/radproto/attribute.h index 0bd8777..b00410a 100644 --- a/include/radproto/attribute.h +++ b/include/radproto/attribute.h @@ -10,21 +10,21 @@ namespace RadProto class Attribute { public: - Attribute(uint8_t type); + Attribute(uint8_t code); virtual ~Attribute() = default; - uint8_t type() const { return m_type; } + uint8_t code() const { return m_code; } virtual std::string toString() const = 0; virtual std::vector toVector(const std::string& secret, const std::array& auth) const = 0; virtual Attribute* clone() const = 0; private: - uint8_t m_type; + uint8_t m_code; }; class String: public Attribute { public: - String(uint8_t type, const uint8_t* data, size_t size); - String(uint8_t type, const std::string& string); + String(uint8_t code, const uint8_t* data, size_t size); + String(uint8_t code, const std::string& string); std::string toString() const override { return m_value; } std::vector toVector(const std::string& secret, const std::array& auth) const override; String* clone() const override; @@ -35,8 +35,8 @@ namespace RadProto class Integer: public Attribute { public: - Integer(uint8_t type, const uint8_t* data, size_t size); - Integer(uint8_t type, uint32_t value); + Integer(uint8_t code, const uint8_t* data, size_t size); + Integer(uint8_t code, uint32_t value); std::string toString() const override; std::vector toVector(const std::string& secret, const std::array& auth) const override; Integer* clone() const override; @@ -47,8 +47,8 @@ namespace RadProto class IpAddress : public Attribute { public: - IpAddress(uint8_t type, const uint8_t* data, size_t size); - IpAddress(uint8_t type, const std::array& address); + IpAddress(uint8_t code, const uint8_t* data, size_t size); + IpAddress(uint8_t code, const std::array& address); std::string toString() const override; std::vector toVector(const std::string& secret, const std::array& auth) const override; IpAddress* clone() const override; @@ -59,8 +59,8 @@ namespace RadProto class Encrypted : public Attribute { public: - Encrypted (uint8_t type, const uint8_t* data, size_t size, const std::string& secret, const std::array& auth); - Encrypted(uint8_t type, const std::string& password); + Encrypted (uint8_t code, const uint8_t* data, size_t size, const std::string& secret, const std::array& auth); + Encrypted(uint8_t code, const std::string& password); std::string toString() const override { return m_value; } std::vector toVector(const std::string& secret, const std::array& auth) const override; Encrypted* clone() const override; @@ -71,8 +71,8 @@ namespace RadProto class Bytes: public Attribute { public: - Bytes(uint8_t type, const uint8_t* data, size_t size); - Bytes(uint8_t type, const std::vector& bytes); + Bytes(uint8_t code, const uint8_t* data, size_t size); + Bytes(uint8_t code, const std::vector& bytes); std::string toString() const override; std::vector toVector(const std::string& secret, const std::array& auth) const override; Bytes* clone() const override; @@ -83,8 +83,8 @@ namespace RadProto class ChapPassword: public Attribute { public: - ChapPassword(uint8_t type, const uint8_t* data, size_t size); - ChapPassword(uint8_t type, uint8_t chapId, const std::vector& chapValue); + ChapPassword(uint8_t code, const uint8_t* data, size_t size); + ChapPassword(uint8_t code, uint8_t chapId, const std::vector& chapValue); std::string toString() const override; uint8_t chapId() const { return m_chapId; } std::vector chapValue() const { return m_value; } diff --git a/include/radproto/attribute_types.h b/include/radproto/attribute_codes.h similarity index 100% rename from include/radproto/attribute_types.h rename to include/radproto/attribute_codes.h From 4abe923b3e0834a3ab8e211e33f15884e4dde563 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 15:46:00 +0300 Subject: [PATCH 12/44] Enum name Attribute_Types changed to Attribute_Codes. --- include/radproto/attribute_codes.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/radproto/attribute_codes.h b/include/radproto/attribute_codes.h index bd6466c..b61f78d 100644 --- a/include/radproto/attribute_codes.h +++ b/include/radproto/attribute_codes.h @@ -2,7 +2,7 @@ namespace RadProto { - enum Attribute_Types + enum Attribute_Codes { USER_NAME = 1, USER_PASSWORD = 2, From e57067174d9a152ef9c1483f608ac2234aeaef75 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 15:50:38 +0300 Subject: [PATCH 13/44] The value invalidAttributeType changed to invalidAttributeCode in enum class Error. --- include/radproto/error.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/include/radproto/error.h b/include/radproto/error.h index 92bfc42..a10f1a5 100644 --- a/include/radproto/error.h +++ b/include/radproto/error.h @@ -19,7 +19,7 @@ namespace RadProto numberOfBytesIsLessThan20, requestLengthIsShort, eapMessageAttributeError, - invalidAttributeType, + invalidAttributeCode, invalidAttributeSize, invalidVendorSpecificAttributeId, suchAttributeNameAlreadyExists, From b46802ac0a30a8a01054d448ceba0a4a5af210fe Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 15:55:38 +0300 Subject: [PATCH 14/44] Parameter type changed to code. Function type() changed to code(). Class memeber m_type changed to m_code. --- include/radproto/packet.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/include/radproto/packet.h b/include/radproto/packet.h index 6d5b40b..33fa0e8 100644 --- a/include/radproto/packet.h +++ b/include/radproto/packet.h @@ -13,10 +13,10 @@ namespace RadProto { public: Packet(const uint8_t* buffer, size_t size, const std::string& secret); - Packet(uint8_t type, uint8_t id, const std::array& auth, const std::vector& attributes, const std::vector& vendorSpecific); + Packet(uint8_t code, uint8_t id, const std::array& auth, const std::vector& attributes, const std::vector& vendorSpecific); Packet(const Packet& other); ~Packet(); - uint8_t type() const { return m_type; } + uint8_t code() const { return m_code; } uint8_t id() const { return m_id; }; const std::array& auth() const { return m_auth; } const std::vector& attributes() const { return m_attributes; } @@ -24,7 +24,7 @@ namespace RadProto const std::vector makeSendBuffer(const std::string& secret) const; private: - uint8_t m_type; + uint8_t m_code; uint8_t m_id; bool m_recalcAuth; std::array m_auth; From dd5fb8787198bfa249b337a76907eb85a6580ce3 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 16:06:43 +0300 Subject: [PATCH 15/44] Parameter vendorType changed to vendorAttributeCode. Function vendorType() changed to vendorAttributeCode(). Class memeber m_vendorType changed to m_vendorAttributeCode. --- include/radproto/vendor_attribute.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/include/radproto/vendor_attribute.h b/include/radproto/vendor_attribute.h index 2c4867e..4e42514 100644 --- a/include/radproto/vendor_attribute.h +++ b/include/radproto/vendor_attribute.h @@ -10,14 +10,14 @@ namespace RadProto { public: VendorSpecific(const uint8_t* data); - VendorSpecific(uint32_t vendorId, uint8_t vendorType, const std::vector& vendorValue); + VendorSpecific(uint32_t vendorId, uint8_t vendorAttributeCode, const std::vector& vendorValue); std::string toString() const; - uint8_t vendorType() const { return m_vendorType; } + uint8_t vendorAttributeCode() const { return m_vendorAttributeCode; } uint32_t vendorId() const { return m_vendorId; } std::vector toVector() const; private: uint32_t m_vendorId; - uint8_t m_vendorType; + uint8_t m_vendorAttributeCode; std::vector m_value; }; } From 994f022d8bd1e97f9c2cf3868e16f99951f9a803 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 16:13:19 +0300 Subject: [PATCH 16/44] Header file "attribute_types" changed to "attribute_codes". Function type() changed to code(). --- sample/server.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sample/server.cpp b/sample/server.cpp index 4eedd01..a0cb4bc 100644 --- a/sample/server.cpp +++ b/sample/server.cpp @@ -1,6 +1,6 @@ #include "server.h" #include "packet_codes.h" -#include "attribute_types.h" +#include "attribute_codes.h" #include #include @@ -37,11 +37,11 @@ RadProto::Packet Server::makeResponse(const RadProto::Packet& request) std::string userName; for (const auto& attribute : request.attributes()) { - if (attribute->type() == RadProto::USER_NAME) + if (attribute->code() == RadProto::USER_NAME) userName = attribute->toString(); } - if (request.type() == RadProto::ACCESS_REQUEST && userName == "test") + if (request.code() == RadProto::ACCESS_REQUEST && userName == "test") return RadProto::Packet(RadProto::ACCESS_ACCEPT, request.id(), request.auth(), attributes, vendorSpecific); return RadProto::Packet(RadProto::ACCESS_REJECT, request.id(), request.auth(), attributes, vendorSpecific); From 63dbc71a5961a1f24e070ff8feeac7f2d7fbfa4a Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 16:21:22 +0300 Subject: [PATCH 17/44] Varisble type changed to code. Function type() changed to code(). Class memeber m_type changed to m_code. --- src/attribute.cpp | 64 +++++++++++++++++++++++------------------------ 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/src/attribute.cpp b/src/attribute.cpp index 53f3fee..043f8af 100644 --- a/src/attribute.cpp +++ b/src/attribute.cpp @@ -7,20 +7,20 @@ #include using Attribute = RadProto::Attribute; -Attribute::Attribute(uint8_t type) - : m_type(type) +Attribute::Attribute(uint8_t code) + : m_code(code) { } using String = RadProto::String; -String::String(uint8_t type, const uint8_t* data, size_t size) - : Attribute(type), +String::String(uint8_t code, const uint8_t* data, size_t size) + : Attribute(code), m_value(reinterpret_cast(data), size) { } -String::String(uint8_t type, const std::string& string) - : Attribute(type), +String::String(uint8_t code, const std::string& string) + : Attribute(code), m_value(string) { } @@ -29,7 +29,7 @@ std::vector String::toVector(const std::string& /*secret*/, const std:: { std::vector attribute(m_value.length() + 2); std::copy(m_value.begin(), m_value.end(), std::next(attribute.begin(), 2)); - attribute[0] = type(); + attribute[0] = code(); attribute[1] = m_value.length() + 2; return attribute; } @@ -40,8 +40,8 @@ String* String::clone() const } using Integer = RadProto::Integer; -Integer::Integer(uint8_t type, const uint8_t* data, size_t size) - : Attribute(type), +Integer::Integer(uint8_t code, const uint8_t* data, size_t size) + : Attribute(code), m_value(0) { if (size != 4) @@ -53,8 +53,8 @@ Integer::Integer(uint8_t type, const uint8_t* data, size_t size) + data[3]; } -Integer::Integer(uint8_t type, uint32_t value) - : Attribute(type), +Integer::Integer(uint8_t code, uint32_t value) + : Attribute(code), m_value(value) { } @@ -67,7 +67,7 @@ std::string Integer::toString() const std::vector Integer::toVector(const std::string& /*secret*/, const std::array& /*auth*/) const { std::vector attribute(6); - attribute[0] = type(); + attribute[0] = code(); attribute[1] = 6; attribute[2] = m_value / (1 << 24); attribute[3] = (m_value / (1 << 16)) % 256; @@ -82,8 +82,8 @@ Integer* Integer::clone() const } using IpAddress = RadProto::IpAddress; -IpAddress::IpAddress(uint8_t type, const uint8_t* data, size_t size) - : Attribute(type) +IpAddress::IpAddress(uint8_t code, const uint8_t* data, size_t size) + : Attribute(code) { if (size != 4) throw RadProto::Exception(RadProto::Error::invalidAttributeSize); @@ -92,8 +92,8 @@ IpAddress::IpAddress(uint8_t type, const uint8_t* data, size_t size) m_value[i] = data[i]; } -IpAddress::IpAddress(uint8_t type, const std::array& address) - : Attribute(type), +IpAddress::IpAddress(uint8_t code, const std::array& address) + : Attribute(code), m_value(address) { } @@ -107,7 +107,7 @@ std::vector IpAddress::toVector(const std::string& /*secret*/, const st { std::vector attribute(6); - attribute[0] = type(); + attribute[0] = code(); attribute[1] = attribute.size(); for (size_t i = 0; i < m_value.size(); ++i) attribute[i + 2] = m_value[i]; @@ -121,8 +121,8 @@ IpAddress* IpAddress::clone() const } using Encrypted = RadProto::Encrypted; -Encrypted::Encrypted(uint8_t type, const uint8_t* data, size_t size, const std::string& secret, const std::array& auth) - : Attribute(type) +Encrypted::Encrypted(uint8_t code, const uint8_t* data, size_t size, const std::string& secret, const std::array& auth) + : Attribute(code) { if (size > 128) throw RadProto::Exception(RadProto::Error::invalidAttributeSize); @@ -154,8 +154,8 @@ Encrypted::Encrypted(uint8_t type, const uint8_t* data, size_t size, const std:: m_value.assign(plaintext.begin(), std::find(plaintext.begin(), plaintext.end(), 0)); } -Encrypted::Encrypted(uint8_t type, const std::string& password) - : Attribute(type), +Encrypted::Encrypted(uint8_t code, const std::string& password) + : Attribute(code), m_value(password) { } @@ -176,7 +176,7 @@ std::vector Encrypted::toVector(const std::string& secret, const std::a mdBuffer[i + secret.length()] = auth[i]; std::vector res(plaintext.length() + 2); - res[0] = type(); + res[0] = code(); res[1] = res.size(); auto it = std::next(res.begin(), 2); @@ -202,16 +202,16 @@ Encrypted* Encrypted::clone() const } using Bytes = RadProto::Bytes; -Bytes::Bytes(uint8_t type, const uint8_t* data, size_t size) - : Attribute(type), +Bytes::Bytes(uint8_t code, const uint8_t* data, size_t size) + : Attribute(code), m_value(size) { for (size_t i = 0; i < size; ++i) m_value[i] = data[i]; } -Bytes::Bytes(uint8_t type, const std::vector& bytes) - : Attribute(type), +Bytes::Bytes(uint8_t code, const std::vector& bytes) + : Attribute(code), m_value(bytes) { } @@ -230,7 +230,7 @@ std::vector Bytes::toVector(const std::string& /*secret*/, const std::a { std::vector attribute(m_value); attribute.insert(attribute.begin(), attribute.size() + 2); - attribute.insert(attribute.begin(), type()); + attribute.insert(attribute.begin(), code()); return attribute; } Bytes* Bytes::clone() const @@ -239,8 +239,8 @@ Bytes* Bytes::clone() const } using ChapPassword = RadProto::ChapPassword; -ChapPassword::ChapPassword(uint8_t type, const uint8_t* data, size_t size) - : Attribute(type), +ChapPassword::ChapPassword(uint8_t code, const uint8_t* data, size_t size) + : Attribute(code), m_value(size - 1) { if (size != 17) @@ -252,8 +252,8 @@ ChapPassword::ChapPassword(uint8_t type, const uint8_t* data, size_t size) m_value[i] = data[i + 1]; } -ChapPassword::ChapPassword(uint8_t type, uint8_t chapId, const std::vector& chapValue) - : Attribute(type), +ChapPassword::ChapPassword(uint8_t code, uint8_t chapId, const std::vector& chapValue) + : Attribute(code), m_chapId(chapId), m_value(chapValue) { @@ -274,7 +274,7 @@ std::vector ChapPassword::toVector(const std::string& /*secret*/, const std::vector attribute(m_value); attribute.insert(attribute.begin(), m_chapId); attribute.insert(attribute.begin(), m_value.size() + 3); - attribute.insert(attribute.begin(), type()); + attribute.insert(attribute.begin(), code()); return attribute; } From 36175ab65aa9e51385983a9c546f92ed68a6f73c Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 16:28:26 +0300 Subject: [PATCH 18/44] Case Error::invalidAttributeType changed to Error::invalidAttributeCode and corresponding message changed in function message(). --- src/error.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/error.cpp b/src/error.cpp index edba414..0a6265d 100644 --- a/src/error.cpp +++ b/src/error.cpp @@ -33,8 +33,8 @@ std::string ErrorCategory::message(int ev) const noexcept return "Request length is less than specified in the request"; case Error::eapMessageAttributeError: return "The EAP-Message attribute is present, but the Message-Authenticator attribute is missing"; - case Error::invalidAttributeType: - return "Invalid attribute type"; + case Error::invalidAttributeCode: + return "Invalid attribute code"; case Error::invalidAttributeSize: return "Invalid attribute size"; case Error::invalidVendorSpecificAttributeId: From 9f6595cb4f5b1a9a4c0813fd353ae79e598613c0 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 16:46:25 +0300 Subject: [PATCH 19/44] Header file "attribute_types.h" changed to "attribute_codes.h". Function type() changed to code(). Variable type changed to code. Class member m_type changed to m_code. --- src/packet.cpp | 48 ++++++++++++++++++++++++------------------------ 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/src/packet.cpp b/src/packet.cpp index 516d3df..a674863 100644 --- a/src/packet.cpp +++ b/src/packet.cpp @@ -1,6 +1,6 @@ #include "packet.h" #include "error.h" -#include "attribute_types.h" +#include "attribute_codes.h" #include #include @@ -8,22 +8,22 @@ using Packet = RadProto::Packet; namespace { - RadProto::Attribute* makeAttribute(uint8_t type, const uint8_t* data, size_t size, const std::string& secret, const std::array& auth) + RadProto::Attribute* makeAttribute(uint8_t code, const uint8_t* data, size_t size, const std::string& secret, const std::array& auth) { - if (type == 1 || type == 11 || type == 18 || type == 22 || type == 34 || type == 35 || type == 60 || type == 63) - return new RadProto::String(type, data, size); - else if (type == 2) - return new RadProto::Encrypted(type, data, size, secret, auth); - else if (type == 3) - return new RadProto::ChapPassword(type, data, size); - else if (type == 4 || type == 8 || type == 9 || type == 14) - return new RadProto::IpAddress(type, data, size); - else if (type == 5 || type == 6 || type == 7 || type == 10 || type == 12 || type == 13 || type == 15 || type == 16 || type == 27 || type == 28 || type == 29 || type == 37 || type == 38 || type == 61 || type == 62) - return new RadProto::Integer(type, data, size); - else if (type == 19 || type == 20 || type == 24 || type == 25 || type == 30 || type == 31 || type == 32 || type == 33 || type == 36 || type == 39 || type == 79 || type == 80) - return new RadProto::Bytes(type, data, size); - - throw RadProto::Exception(RadProto::Error::invalidAttributeType); + if (code == 1 || code == 11 || code == 18 || code == 22 || code == 34 || code == 35 || code == 60 || code == 63) + return new RadProto::String(code, data, size); + else if (code == 2) + return new RadProto::Encrypted(code, data, size, secret, auth); + else if (code == 3) + return new RadProto::ChapPassword(code, data, size); + else if (code == 4 || code == 8 || code == 9 || code == 14) + return new RadProto::IpAddress(code, data, size); + else if (code == 5 || code == 6 || code == 7 || code == 10 || code == 12 || code == 13 || code == 15 || code == 16 || code == 27 || code == 28 || code == 29 || code == 37 || code == 38 || code == 61 || code == 62) + return new RadProto::Integer(code, data, size); + else if (code == 19 || code == 20 || code == 24 || code == 25 || code == 30 || code == 31 || code == 32 || code == 33 || code == 36 || code == 39 || code == 79 || code == 80) + return new RadProto::Bytes(code, data, size); + + throw RadProto::Exception(RadProto::Error::invalidAttributeCode); } } @@ -38,7 +38,7 @@ Packet::Packet(const uint8_t* buffer, size_t size, const std::string& secret) if (size < length) throw Exception(Error::requestLengthIsShort); - m_type = buffer[0]; + m_code = buffer[0]; m_id = buffer[1]; @@ -63,20 +63,20 @@ Packet::Packet(const uint8_t* buffer, size_t size, const std::string& secret) bool messageAuthenticator = false; for (const auto& a : m_attributes) { - if (a->type() == EAP_MESSAGE) + if (a->code() == EAP_MESSAGE) eapMessage = true; - if (a->type() == MESSAGE_AUTHENTICATOR) + if (a->code() == MESSAGE_AUTHENTICATOR) messageAuthenticator = true; } if (eapMessage && !messageAuthenticator) throw Exception(Error::eapMessageAttributeError); } -Packet::Packet(uint8_t type, uint8_t id, const std::array& auth, const std::vector& attributes, const std::vector& vendorSpecific) - : m_type(type), +Packet::Packet(uint8_t code, uint8_t id, const std::array& auth, const std::vector& attributes, const std::vector& vendorSpecific) + : m_code(code), m_id(id), - m_recalcAuth(m_type == 2 || m_type == 3 || m_type == 11), + m_recalcAuth(m_code == 2 || m_code == 3 || m_code == 11), m_auth(auth), m_attributes(attributes), m_vendorSpecific(vendorSpecific) @@ -84,7 +84,7 @@ Packet::Packet(uint8_t type, uint8_t id, const std::array& auth, co } Packet::Packet(const Packet& other) - : m_type(other.m_type), + : m_code(other.m_code), m_id(other.m_id), m_recalcAuth(other.m_recalcAuth), m_auth(other.m_auth), @@ -106,7 +106,7 @@ const std::vector Packet::makeSendBuffer(const std::string& secret) con { std::vector sendBuffer(20); - sendBuffer[0] = m_type; + sendBuffer[0] = m_code; sendBuffer[1] = m_id; for (size_t i = 0; i < m_auth.size(); ++i) From 6bfd01d73ddc2e01abb8fb5e38a168d83c4d8d56 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 16:51:25 +0300 Subject: [PATCH 20/44] Function packetTypeToString changed to packetCodeToString. Parameter type changed to code in function packetCodeToString. --- src/socket.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/socket.cpp b/src/socket.cpp index a6c49bf..5ea27dd 100644 --- a/src/socket.cpp +++ b/src/socket.cpp @@ -7,9 +7,9 @@ using boost::system::error_code; namespace pls = std::placeholders; -std::string packetTypeToString(int type) +std::string packetCodeToString(int code) { - switch (type) + switch (code) { case RadProto::ACCESS_REQUEST: return "ACCESS_REQUEST"; case RadProto::ACCESS_ACCEPT: return "ACCESS_ACCEPT"; From e4a5b0290df18df64348601672c44a2b6fdad5c5 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 16:55:25 +0300 Subject: [PATCH 21/44] Header file "attribute_types.h" changed to "attribute_codes.h". --- src/utils.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/utils.cpp b/src/utils.cpp index 96a9f6c..b522a19 100644 --- a/src/utils.cpp +++ b/src/utils.cpp @@ -1,5 +1,5 @@ #include "utils.h" -#include "attribute_types.h" +#include "attribute_codes.h" #include //uint8_t, uint32_t std::string RadProto::byteToHex(uint8_t byte) From 8bad86b21716a9494a3aeceefbe65bb6852ece60 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 17:00:26 +0300 Subject: [PATCH 22/44] Header file "attribute_types.h" changed to "attribute_codes.h". Function vendorType() changed to vendorAttributeCode(). Variable vendorType changed to vendorAttributeCode. Class member m_vendorType changed to m_vendorAttributeCode. --- src/vendor_attribute.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/src/vendor_attribute.cpp b/src/vendor_attribute.cpp index 9b02055..98abe81 100644 --- a/src/vendor_attribute.cpp +++ b/src/vendor_attribute.cpp @@ -2,7 +2,7 @@ #include "vendor_attribute.h" #include "utils.h" #include "error.h" -#include "attribute_types.h" +#include "attribute_codes.h" #include using VendorSpecific = RadProto::VendorSpecific; @@ -16,7 +16,7 @@ VendorSpecific::VendorSpecific(const uint8_t* data) + data[2] * (1 << 8) + data[3]; - m_vendorType = data[4]; + m_vendorAttributeCode = data[4]; size_t vendorLength = data[5]; m_value.resize(vendorLength - 2); @@ -25,9 +25,9 @@ VendorSpecific::VendorSpecific(const uint8_t* data) m_value[i] = data[i + 6]; } -VendorSpecific::VendorSpecific(uint32_t vendorId, uint8_t vendorType, const std::vector& vendorValue) +VendorSpecific::VendorSpecific(uint32_t vendorId, uint8_t vendorAttributeCode, const std::vector& vendorValue) : m_vendorId(vendorId), - m_vendorType(vendorType), + m_vendorAttributeCode(vendorAttributeCode), m_value(vendorValue) { } @@ -41,7 +41,7 @@ std::vector VendorSpecific::toVector() const attribute[3] = (m_vendorId / (1 << 16)) % 256; attribute[4] = (m_vendorId / (1 << 8)) % 256; attribute[5] = m_vendorId % 256; - attribute[6] = vendorType(); + attribute[6] = vendorAttributeCode(); attribute[7] = m_value.size() + 2; for (size_t i = 0; i < m_value.size(); ++i) attribute[i + 8] = m_value[i]; From 0176725cf0c433f70aa972758156bb5e7d6c87eb Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 17:07:02 +0300 Subject: [PATCH 23/44] Function type() changed to code(). Function vendorType() changed to vendorAttributeCode(). --- tests/attribute_tests.cpp | 58 +++++++++++++++++++-------------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/tests/attribute_tests.cpp b/tests/attribute_tests.cpp index c0f7168..b929788 100644 --- a/tests/attribute_tests.cpp +++ b/tests/attribute_tests.cpp @@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE(StringDataConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 1); + BOOST_CHECK_EQUAL(s.code(), 1); } BOOST_AUTO_TEST_CASE(StringValueConstructor) @@ -47,7 +47,7 @@ BOOST_AUTO_TEST_CASE(StringValueConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 1); + BOOST_CHECK_EQUAL(v.code(), 1); } BOOST_AUTO_TEST_CASE(StringClone) @@ -62,7 +62,7 @@ BOOST_AUTO_TEST_CASE(StringClone) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 1); + BOOST_CHECK_EQUAL(cs->code(), 1); } BOOST_AUTO_TEST_CASE(IntegerDataConstructor) @@ -79,7 +79,7 @@ BOOST_AUTO_TEST_CASE(IntegerDataConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 5); + BOOST_CHECK_EQUAL(s.code(), 5); } BOOST_AUTO_TEST_CASE(IntegerDataConstructorThrow) @@ -100,7 +100,7 @@ BOOST_AUTO_TEST_CASE(IntegerValueConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 5); + BOOST_CHECK_EQUAL(v.code(), 5); } BOOST_AUTO_TEST_CASE(IntegerClone) @@ -115,7 +115,7 @@ BOOST_AUTO_TEST_CASE(IntegerClone) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 5); + BOOST_CHECK_EQUAL(cs->code(), 5); } BOOST_AUTO_TEST_CASE(IpAddressDataConstructor) @@ -132,7 +132,7 @@ BOOST_AUTO_TEST_CASE(IpAddressDataConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 4); + BOOST_CHECK_EQUAL(s.code(), 4); } BOOST_AUTO_TEST_CASE(IpAddressDataConstructorThrow) @@ -154,7 +154,7 @@ BOOST_AUTO_TEST_CASE(IpAddressValueConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 4); + BOOST_CHECK_EQUAL(v.code(), 4); } BOOST_AUTO_TEST_CASE(IpAddressClone) @@ -170,7 +170,7 @@ BOOST_AUTO_TEST_CASE(IpAddressClone) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 4); + BOOST_CHECK_EQUAL(cs->code(), 4); } BOOST_AUTO_TEST_CASE(EncryptedDataConstructor_PasswordLength_6) @@ -188,7 +188,7 @@ BOOST_AUTO_TEST_CASE(EncryptedDataConstructor_PasswordLength_6) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 2); + BOOST_CHECK_EQUAL(s.code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedDataConstructorThrow) @@ -220,7 +220,7 @@ BOOST_AUTO_TEST_CASE(EncryptedDataConstructor1_PasswordLength_15) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 2); + BOOST_CHECK_EQUAL(s.code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedDataConstructor_PasswordLength_16) @@ -238,7 +238,7 @@ BOOST_AUTO_TEST_CASE(EncryptedDataConstructor_PasswordLength_16) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 2); + BOOST_CHECK_EQUAL(s.code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedDataConstructor_PasswordLength_17) @@ -256,7 +256,7 @@ BOOST_AUTO_TEST_CASE(EncryptedDataConstructor_PasswordLength_17) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 2); + BOOST_CHECK_EQUAL(s.code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedValueConstructor_PasswordLength_6) @@ -271,7 +271,7 @@ BOOST_AUTO_TEST_CASE(EncryptedValueConstructor_PasswordLength_6) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 2); + BOOST_CHECK_EQUAL(v.code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedValueConstructor_PasswordLength_15) @@ -286,7 +286,7 @@ BOOST_AUTO_TEST_CASE(EncryptedValueConstructor_PasswordLength_15) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 2); + BOOST_CHECK_EQUAL(v.code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedValueConstructor_PasswordLength_16) @@ -301,7 +301,7 @@ BOOST_AUTO_TEST_CASE(EncryptedValueConstructor_PasswordLength_16) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 2); + BOOST_CHECK_EQUAL(v.code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedValueConstructor_PasswordLength_17) @@ -316,7 +316,7 @@ BOOST_AUTO_TEST_CASE(EncryptedValueConstructor_PasswordLength_17) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 2); + BOOST_CHECK_EQUAL(v.code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedClone_PasswordLength_6) @@ -333,7 +333,7 @@ BOOST_AUTO_TEST_CASE(EncryptedClone_PasswordLength_6) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 2); + BOOST_CHECK_EQUAL(cs->code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedClone_PasswordLength_15) @@ -350,7 +350,7 @@ BOOST_AUTO_TEST_CASE(EncryptedClone_PasswordLength_15) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 2); + BOOST_CHECK_EQUAL(cs->code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedClone_PasswordLength_16) @@ -367,7 +367,7 @@ BOOST_AUTO_TEST_CASE(EncryptedClone_PasswordLength_16) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 2); + BOOST_CHECK_EQUAL(cs->code(), 2); } BOOST_AUTO_TEST_CASE(EncryptedClone_PasswordLength_17) @@ -384,7 +384,7 @@ BOOST_AUTO_TEST_CASE(EncryptedClone_PasswordLength_17) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 2); + BOOST_CHECK_EQUAL(cs->code(), 2); } BOOST_AUTO_TEST_CASE(BytesDataConstructor) @@ -399,7 +399,7 @@ BOOST_AUTO_TEST_CASE(BytesDataConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 19); + BOOST_CHECK_EQUAL(s.code(), 19); } BOOST_AUTO_TEST_CASE(BytesValueConstructor) @@ -413,7 +413,7 @@ BOOST_AUTO_TEST_CASE(BytesValueConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 19); + BOOST_CHECK_EQUAL(v.code(), 19); } BOOST_AUTO_TEST_CASE(BytesClone) @@ -428,7 +428,7 @@ BOOST_AUTO_TEST_CASE(BytesClone) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 19); + BOOST_CHECK_EQUAL(cs->code(), 19); } BOOST_AUTO_TEST_CASE(ChapPasswordDataConstructor) @@ -445,7 +445,7 @@ BOOST_AUTO_TEST_CASE(ChapPasswordDataConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.type(), 3); + BOOST_CHECK_EQUAL(s.code(), 3); } BOOST_AUTO_TEST_CASE(ChapPasswordDataConstructorThrow) @@ -466,7 +466,7 @@ BOOST_AUTO_TEST_CASE(ChapPasswordValueConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.type(), 3); + BOOST_CHECK_EQUAL(v.code(), 3); } BOOST_AUTO_TEST_CASE(ChapPasswordClone) @@ -481,7 +481,7 @@ BOOST_AUTO_TEST_CASE(ChapPasswordClone) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(cs->type(), 3); + BOOST_CHECK_EQUAL(cs->code(), 3); } BOOST_AUTO_TEST_CASE(VendorSpecificDataConstructor) @@ -496,7 +496,7 @@ BOOST_AUTO_TEST_CASE(VendorSpecificDataConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(s.vendorType(), 1); + BOOST_CHECK_EQUAL(s.vendorAttributeCode(), 1); } BOOST_AUTO_TEST_CASE(VendorSpecificDataConstructorThrow) @@ -517,7 +517,7 @@ BOOST_AUTO_TEST_CASE(VendorSpecificValueConstructor) BOOST_TEST(values == expected, boost::test_tools::per_element()); - BOOST_CHECK_EQUAL(v.vendorType(), 1); + BOOST_CHECK_EQUAL(v.vendorAttributeCode(), 1); } BOOST_AUTO_TEST_SUITE_END() From 01c53d84ac7589302392b303a880dcb4d692b38f Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 17:18:21 +0300 Subject: [PATCH 24/44] Header file "attribute_types.h" changed to "attribute_codes.h". Function vendorType() changed to vendorAttributeCode().Function type() changed to code(). The set types changed to codes. TestCase(PacketDataConstructorThrowMakeAttributeInvalidType) changed to TestCase(PacketDataConstructorThrowMakeAttributeInvalidCode). --- tests/packet_tests.cpp | 172 ++++++++++++++++++++--------------------- 1 file changed, 86 insertions(+), 86 deletions(-) diff --git a/tests/packet_tests.cpp b/tests/packet_tests.cpp index afca13c..d800727 100644 --- a/tests/packet_tests.cpp +++ b/tests/packet_tests.cpp @@ -3,7 +3,7 @@ #include "radproto/packet.h" #include "radproto/attribute.h" #include "radproto/vendor_attribute.h" -#include "attribute_types.h" +#include "attribute_codes.h" #include "radproto/error.h" #include "utils.h" #include @@ -29,7 +29,7 @@ BOOST_AUTO_TEST_CASE(PacketBufferConstructorRequest) RadProto::Packet p(d.data(), d.size(), "secret"); - BOOST_CHECK_EQUAL(p.type(), 1); + BOOST_CHECK_EQUAL(p.code(), 1); BOOST_CHECK_EQUAL(p.id(), 0xd0); @@ -41,55 +41,55 @@ BOOST_AUTO_TEST_CASE(PacketBufferConstructorRequest) auto* attr0 = findAttribute(attrs, RadProto::USER_NAME); BOOST_REQUIRE(attr0 != nullptr); - BOOST_CHECK_EQUAL(attr0->type(), RadProto::USER_NAME); + BOOST_CHECK_EQUAL(attr0->code(), RadProto::USER_NAME); BOOST_CHECK_EQUAL(attr0->toString(), "test"); auto* attr1 = findAttribute(attrs, RadProto::USER_PASSWORD); BOOST_REQUIRE(attr1 != nullptr); - BOOST_CHECK_EQUAL(attr1->type(), RadProto::USER_PASSWORD); + BOOST_CHECK_EQUAL(attr1->code(), RadProto::USER_PASSWORD); BOOST_CHECK_EQUAL(attr1->toString(), "123456"); auto* attr2 = findAttribute(attrs, RadProto::NAS_IP_ADDRESS); BOOST_REQUIRE(attr2 != nullptr); - BOOST_CHECK_EQUAL(attr2->type(), RadProto::NAS_IP_ADDRESS); + BOOST_CHECK_EQUAL(attr2->code(), RadProto::NAS_IP_ADDRESS); BOOST_CHECK_EQUAL(attr2->toString(), "127.0.0.1"); auto* attr3 = findAttribute(attrs, RadProto::NAS_PORT); BOOST_REQUIRE(attr3 != nullptr); - BOOST_CHECK_EQUAL(attr3->type(), RadProto::NAS_PORT); + BOOST_CHECK_EQUAL(attr3->code(), RadProto::NAS_PORT); BOOST_CHECK_EQUAL(attr3->toString(), "1"); auto* attr4 = findAttribute(attrs, RadProto::MESSAGE_AUTHENTICATOR); BOOST_REQUIRE(attr4 != nullptr); - BOOST_CHECK_EQUAL(attr4->type(), RadProto::MESSAGE_AUTHENTICATOR); + BOOST_CHECK_EQUAL(attr4->code(), RadProto::MESSAGE_AUTHENTICATOR); BOOST_CHECK_EQUAL(attr4->toString(), "F3E000E77DEB51EB815D52373D06B71B"); auto* attr5 = findAttribute(attrs, RadProto::FRAMED_PROTOCOL); BOOST_REQUIRE(attr5 != nullptr); - BOOST_CHECK_EQUAL(attr5->type(), RadProto::FRAMED_PROTOCOL); + BOOST_CHECK_EQUAL(attr5->code(), RadProto::FRAMED_PROTOCOL); BOOST_CHECK_EQUAL(attr5->toString(), "1"); std::vector vendor = p.vendorSpecific(); BOOST_REQUIRE_EQUAL(vendor.size(), 1); BOOST_CHECK_EQUAL(vendor[0].vendorId(), 171); - BOOST_CHECK_EQUAL(vendor[0].vendorType(), 1); + BOOST_CHECK_EQUAL(vendor[0].vendorAttributeCode(), 1); BOOST_CHECK_EQUAL(vendor[0].toString(), "00000003"); - std::set types {RadProto::USER_NAME, RadProto::USER_PASSWORD, RadProto::NAS_IP_ADDRESS, RadProto::NAS_PORT, RadProto::MESSAGE_AUTHENTICATOR, RadProto::FRAMED_PROTOCOL}; + std::set codes {RadProto::USER_NAME, RadProto::USER_PASSWORD, RadProto::NAS_IP_ADDRESS, RadProto::NAS_PORT, RadProto::MESSAGE_AUTHENTICATOR, RadProto::FRAMED_PROTOCOL}; BOOST_REQUIRE_EQUAL(attrs.size(), 6); - BOOST_CHECK(types.count(attrs[0]->type()) == 1); - BOOST_CHECK(types.count(attrs[1]->type()) == 1); - BOOST_CHECK(types.count(attrs[2]->type()) == 1); - BOOST_CHECK(types.count(attrs[3]->type()) == 1); - BOOST_CHECK(types.count(attrs[4]->type()) == 1); - BOOST_CHECK(types.count(attrs[5]->type()) == 1); + BOOST_CHECK(codes.count(attrs[0]->code()) == 1); + BOOST_CHECK(codes.count(attrs[1]->code()) == 1); + BOOST_CHECK(codes.count(attrs[2]->code()) == 1); + BOOST_CHECK(codes.count(attrs[3]->code()) == 1); + BOOST_CHECK(codes.count(attrs[4]->code()) == 1); + BOOST_CHECK(codes.count(attrs[5]->code()) == 1); std::vector values = p.makeSendBuffer("secret"); @@ -106,7 +106,7 @@ BOOST_AUTO_TEST_CASE(PacketBufferConstructorResponse) RadProto::Packet p(d.data(), d.size(), "secret"); - BOOST_CHECK_EQUAL(p.type(), 2); + BOOST_CHECK_EQUAL(p.code(), 2); BOOST_CHECK_EQUAL(p.id(), 0xd0); @@ -119,48 +119,48 @@ BOOST_AUTO_TEST_CASE(PacketBufferConstructorResponse) auto* attr0 = findAttribute(attrs, RadProto::USER_NAME); BOOST_REQUIRE(attr0 != nullptr); - BOOST_CHECK_EQUAL(attr0->type(), RadProto::USER_NAME); + BOOST_CHECK_EQUAL(attr0->code(), RadProto::USER_NAME); BOOST_CHECK_EQUAL(attr0->toString(), "test"); auto* attr1 = findAttribute(attrs, RadProto::NAS_PORT); BOOST_REQUIRE(attr1 != nullptr); - BOOST_CHECK_EQUAL(attr1->type(), RadProto::NAS_PORT); + BOOST_CHECK_EQUAL(attr1->code(), RadProto::NAS_PORT); BOOST_CHECK_EQUAL(attr1->toString(), "20"); auto* attr2 = findAttribute(attrs, RadProto::NAS_IP_ADDRESS); BOOST_REQUIRE(attr2 != nullptr); - BOOST_CHECK_EQUAL(attr2->type(), RadProto::NAS_IP_ADDRESS); + BOOST_CHECK_EQUAL(attr2->code(), RadProto::NAS_IP_ADDRESS); BOOST_CHECK_EQUAL(attr2->toString(), "127.104.22.17"); auto* attr3 = findAttribute(attrs, RadProto::CALLBACK_NUMBER); BOOST_REQUIRE(attr3 != nullptr); - BOOST_CHECK_EQUAL(attr3->type(), RadProto::CALLBACK_NUMBER); + BOOST_CHECK_EQUAL(attr3->code(), RadProto::CALLBACK_NUMBER); BOOST_CHECK_EQUAL(attr3->toString(), "313233616263"); auto* attr4 = findAttribute(attrs, RadProto::CHAP_PASSWORD); BOOST_REQUIRE(attr4 != nullptr); - BOOST_CHECK_EQUAL(attr4->type(), RadProto::CHAP_PASSWORD); + BOOST_CHECK_EQUAL(attr4->code(), RadProto::CHAP_PASSWORD); BOOST_CHECK_EQUAL(attr4->toString(), "1 31323334353637383961626364656667"); std::vector vendor = p.vendorSpecific(); BOOST_REQUIRE_EQUAL(vendor.size(), 1); BOOST_CHECK_EQUAL(vendor[0].vendorId(), 171); - BOOST_CHECK_EQUAL(vendor[0].vendorType(), 1); + BOOST_CHECK_EQUAL(vendor[0].vendorAttributeCode(), 1); BOOST_CHECK_EQUAL(vendor[0].toString(), "00000003"); - std::set types {RadProto::USER_NAME, RadProto::NAS_PORT, RadProto::NAS_IP_ADDRESS, RadProto::CALLBACK_NUMBER, RadProto::CHAP_PASSWORD}; + std::set codes {RadProto::USER_NAME, RadProto::NAS_PORT, RadProto::NAS_IP_ADDRESS, RadProto::CALLBACK_NUMBER, RadProto::CHAP_PASSWORD}; BOOST_REQUIRE_EQUAL(attrs.size(), 5); - BOOST_CHECK(types.count(attrs[0]->type()) == 1); - BOOST_CHECK(types.count(attrs[1]->type()) == 1); - BOOST_CHECK(types.count(attrs[2]->type()) == 1); - BOOST_CHECK(types.count(attrs[3]->type()) == 1); - BOOST_CHECK(types.count(attrs[4]->type()) == 1); + BOOST_CHECK(codes.count(attrs[0]->code()) == 1); + BOOST_CHECK(codes.count(attrs[1]->code()) == 1); + BOOST_CHECK(codes.count(attrs[2]->code()) == 1); + BOOST_CHECK(codes.count(attrs[3]->code()) == 1); + BOOST_CHECK(codes.count(attrs[4]->code()) == 1); std::vector values = p.makeSendBuffer("secret"); @@ -185,7 +185,7 @@ BOOST_AUTO_TEST_CASE(PacketDataConstructorThrowSizeLessLength) BOOST_CHECK_THROW(RadProto::Packet p(d.data(), d.size(), "secret"), RadProto::Exception); } -BOOST_AUTO_TEST_CASE(PacketDataConstructorThrowMakeAttributeInvalidType) +BOOST_AUTO_TEST_CASE(PacketDataConstructorThrowMakeAttributeInvalidCode) { std::vector d {0x02, 0xd0, 0x00, 0x4d, 0x93, 0xa9, 0x61, 0x8b, 0x2f, 0x4c, 0x5a, 0x51, 0x65, 0x67, 0x3d, 0xb4, 0x07, 0x30, 0xa2, 0x39, 0x17, 0x06, 0x74, 0x65, 0x73, 0x74, 0x05, 0x06, 0x00, 0x00, 0x00, 0x14, 0x04, 0x06, 0x7f, 0x68, 0x16, 0x11, 0x13, 0x08, 0x31, 0x32, 0x33, 0x61, 0x62, 0x63, 0x03, 0x13, 0x01, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x1a, 0x0c, 0x00, 0x00, 0x00, 0xab, 0x01, 0x06, 0x00, 0x00, 0x00, 0x03}; @@ -205,7 +205,7 @@ BOOST_AUTO_TEST_CASE(PacketValueConstructorResponse) RadProto::Packet p(2, 208, auth, attributes, vendorSpecific); - BOOST_CHECK_EQUAL(p.type(), 2); + BOOST_CHECK_EQUAL(p.code(), 2); BOOST_CHECK_EQUAL(p.id(), 208); @@ -216,48 +216,48 @@ BOOST_AUTO_TEST_CASE(PacketValueConstructorResponse) auto* attr0 = findAttribute(attrs, RadProto::USER_NAME); BOOST_REQUIRE(attr0 != nullptr); - BOOST_CHECK_EQUAL(attr0->type(), RadProto::USER_NAME); + BOOST_CHECK_EQUAL(attr0->code(), RadProto::USER_NAME); BOOST_CHECK_EQUAL(attr0->toString(), "test"); auto* attr1 = findAttribute(attrs, RadProto::NAS_PORT); BOOST_REQUIRE(attr1 != nullptr); - BOOST_CHECK_EQUAL(attr1->type(), RadProto::NAS_PORT); + BOOST_CHECK_EQUAL(attr1->code(), RadProto::NAS_PORT); BOOST_CHECK_EQUAL(attr1->toString(), "20"); auto* attr2 = findAttribute(attrs, RadProto::NAS_IP_ADDRESS); BOOST_REQUIRE(attr2 != nullptr); - BOOST_CHECK_EQUAL(attr2->type(), RadProto::NAS_IP_ADDRESS); + BOOST_CHECK_EQUAL(attr2->code(), RadProto::NAS_IP_ADDRESS); BOOST_CHECK_EQUAL(attr2->toString(), "127.104.22.17"); auto* attr3 = findAttribute(attrs, RadProto::CALLBACK_NUMBER); BOOST_REQUIRE(attr3 != nullptr); - BOOST_CHECK_EQUAL(attr3->type(), RadProto::CALLBACK_NUMBER); + BOOST_CHECK_EQUAL(attr3->code(), RadProto::CALLBACK_NUMBER); BOOST_CHECK_EQUAL(attr3->toString(), "313233616263"); auto* attr4 = findAttribute(attrs, RadProto::CHAP_PASSWORD); BOOST_REQUIRE(attr4 != nullptr); - BOOST_CHECK_EQUAL(attr4->type(), RadProto::CHAP_PASSWORD); + BOOST_CHECK_EQUAL(attr4->code(), RadProto::CHAP_PASSWORD); BOOST_CHECK_EQUAL(attr4->toString(), "1 31323334353637383961626364656667"); std::vector vendor = p.vendorSpecific(); BOOST_REQUIRE_EQUAL(vendor.size(), 1); BOOST_CHECK_EQUAL(vendor[0].vendorId(), 171); - BOOST_CHECK_EQUAL(vendor[0].vendorType(), 1); + BOOST_CHECK_EQUAL(vendor[0].vendorAttributeCode(), 1); BOOST_CHECK_EQUAL(vendor[0].toString(), "00000003"); - std::set types {RadProto::USER_NAME, RadProto::NAS_PORT, RadProto::NAS_IP_ADDRESS, RadProto::CALLBACK_NUMBER, RadProto::CHAP_PASSWORD}; + std::set codes {RadProto::USER_NAME, RadProto::NAS_PORT, RadProto::NAS_IP_ADDRESS, RadProto::CALLBACK_NUMBER, RadProto::CHAP_PASSWORD}; BOOST_REQUIRE_EQUAL(attrs.size(), 5); - BOOST_CHECK(types.count(attrs[0]->type()) == 1); - BOOST_CHECK(types.count(attrs[1]->type()) == 1); - BOOST_CHECK(types.count(attrs[2]->type()) == 1); - BOOST_CHECK(types.count(attrs[3]->type()) == 1); - BOOST_CHECK(types.count(attrs[4]->type()) == 1); + BOOST_CHECK(codes.count(attrs[0]->code()) == 1); + BOOST_CHECK(codes.count(attrs[1]->code()) == 1); + BOOST_CHECK(codes.count(attrs[2]->code()) == 1); + BOOST_CHECK(codes.count(attrs[3]->code()) == 1); + BOOST_CHECK(codes.count(attrs[4]->code()) == 1); std::vector values = p.makeSendBuffer("secret"); @@ -279,7 +279,7 @@ BOOST_AUTO_TEST_CASE(PacketValueConstructorRequest) RadProto::Packet p(1, 208, auth, attributes, vendorSpecific); - BOOST_CHECK_EQUAL(p.type(), 1); + BOOST_CHECK_EQUAL(p.code(), 1); BOOST_CHECK_EQUAL(p.id(), 208); @@ -290,55 +290,55 @@ BOOST_AUTO_TEST_CASE(PacketValueConstructorRequest) auto* attr0 = findAttribute(attrs, RadProto::USER_NAME); BOOST_REQUIRE(attr0 != nullptr); - BOOST_CHECK_EQUAL(attr0->type(), RadProto::USER_NAME); + BOOST_CHECK_EQUAL(attr0->code(), RadProto::USER_NAME); BOOST_CHECK_EQUAL(attr0->toString(), "test"); auto* attr1 = findAttribute(attrs, RadProto::USER_PASSWORD); BOOST_REQUIRE(attr1 != nullptr); - BOOST_CHECK_EQUAL(attr1->type(), RadProto::USER_PASSWORD); + BOOST_CHECK_EQUAL(attr1->code(), RadProto::USER_PASSWORD); BOOST_CHECK_EQUAL(attr1->toString(), "123456"); auto* attr2 = findAttribute(attrs, RadProto::NAS_IP_ADDRESS); BOOST_REQUIRE(attr2 != nullptr); - BOOST_CHECK_EQUAL(attr2->type(), RadProto::NAS_IP_ADDRESS); + BOOST_CHECK_EQUAL(attr2->code(), RadProto::NAS_IP_ADDRESS); BOOST_CHECK_EQUAL(attr2->toString(), "127.0.0.1"); auto* attr3 = findAttribute(attrs, RadProto::NAS_PORT); BOOST_REQUIRE(attr3 != nullptr); - BOOST_CHECK_EQUAL(attr3->type(), RadProto::NAS_PORT); + BOOST_CHECK_EQUAL(attr3->code(), RadProto::NAS_PORT); BOOST_CHECK_EQUAL(attr3->toString(), "1"); auto* attr4 = findAttribute(attrs, RadProto::MESSAGE_AUTHENTICATOR); BOOST_REQUIRE(attr4 != nullptr); - BOOST_CHECK_EQUAL(attr4->type(), RadProto::MESSAGE_AUTHENTICATOR); + BOOST_CHECK_EQUAL(attr4->code(), RadProto::MESSAGE_AUTHENTICATOR); BOOST_CHECK_EQUAL(attr4->toString(), "F3E000E77DEB51EB815D52373D06B71B"); auto* attr5 = findAttribute(attrs, RadProto::FRAMED_PROTOCOL); BOOST_REQUIRE(attr5 != nullptr); - BOOST_CHECK_EQUAL(attr5->type(), RadProto::FRAMED_PROTOCOL); + BOOST_CHECK_EQUAL(attr5->code(), RadProto::FRAMED_PROTOCOL); BOOST_CHECK_EQUAL(attr5->toString(), "1"); std::vector vendor = p.vendorSpecific(); BOOST_REQUIRE_EQUAL(vendor.size(), 1); BOOST_CHECK_EQUAL(vendor[0].vendorId(), 171); - BOOST_CHECK_EQUAL(vendor[0].vendorType(), 1); + BOOST_CHECK_EQUAL(vendor[0].vendorAttributeCode(), 1); BOOST_CHECK_EQUAL(vendor[0].toString(), "00000003"); - std::set types {RadProto::USER_NAME, RadProto::USER_PASSWORD, RadProto::NAS_IP_ADDRESS, RadProto::NAS_PORT, RadProto::MESSAGE_AUTHENTICATOR, RadProto::FRAMED_PROTOCOL}; + std::set codes {RadProto::USER_NAME, RadProto::USER_PASSWORD, RadProto::NAS_IP_ADDRESS, RadProto::NAS_PORT, RadProto::MESSAGE_AUTHENTICATOR, RadProto::FRAMED_PROTOCOL}; BOOST_REQUIRE_EQUAL(attrs.size(), 6); - BOOST_CHECK(types.count(attrs[0]->type()) == 1); - BOOST_CHECK(types.count(attrs[1]->type()) == 1); - BOOST_CHECK(types.count(attrs[2]->type()) == 1); - BOOST_CHECK(types.count(attrs[3]->type()) == 1); - BOOST_CHECK(types.count(attrs[4]->type()) == 1); - BOOST_CHECK(types.count(attrs[5]->type()) == 1); + BOOST_CHECK(codes.count(attrs[0]->code()) == 1); + BOOST_CHECK(codes.count(attrs[1]->code()) == 1); + BOOST_CHECK(codes.count(attrs[2]->code()) == 1); + BOOST_CHECK(codes.count(attrs[3]->code()) == 1); + BOOST_CHECK(codes.count(attrs[4]->code()) == 1); + BOOST_CHECK(codes.count(attrs[5]->code()) == 1); std::vector values = p.makeSendBuffer("secret"); @@ -354,7 +354,7 @@ BOOST_AUTO_TEST_CASE(PacketCopyConstructorRequest) RadProto::Packet other(d.data(), d.size(), "secret"); RadProto::Packet p(other); - BOOST_CHECK_EQUAL(p.type(), other.type()); + BOOST_CHECK_EQUAL(p.code(), other.code()); BOOST_CHECK_EQUAL(p.id(), other.id()); @@ -364,55 +364,55 @@ BOOST_AUTO_TEST_CASE(PacketCopyConstructorRequest) auto* attr0 = findAttribute(attrs, RadProto::USER_NAME); BOOST_REQUIRE(attr0 != nullptr); - BOOST_CHECK_EQUAL(attr0->type(), RadProto::USER_NAME); + BOOST_CHECK_EQUAL(attr0->code(), RadProto::USER_NAME); BOOST_CHECK_EQUAL(attr0->toString(), "test"); auto* attr1 = findAttribute(attrs, RadProto::USER_PASSWORD); BOOST_REQUIRE(attr1 != nullptr); - BOOST_CHECK_EQUAL(attr1->type(), RadProto::USER_PASSWORD); + BOOST_CHECK_EQUAL(attr1->code(), RadProto::USER_PASSWORD); BOOST_CHECK_EQUAL(attr1->toString(), "123456"); auto* attr2 = findAttribute(attrs, RadProto::NAS_IP_ADDRESS); BOOST_REQUIRE(attr2 != nullptr); - BOOST_CHECK_EQUAL(attr2->type(), RadProto::NAS_IP_ADDRESS); + BOOST_CHECK_EQUAL(attr2->code(), RadProto::NAS_IP_ADDRESS); BOOST_CHECK_EQUAL(attr2->toString(), "127.0.0.1"); auto* attr3 = findAttribute(attrs, RadProto::NAS_PORT); BOOST_REQUIRE(attr3 != nullptr); - BOOST_CHECK_EQUAL(attr3->type(), RadProto::NAS_PORT); + BOOST_CHECK_EQUAL(attr3->code(), RadProto::NAS_PORT); BOOST_CHECK_EQUAL(attr3->toString(), "1"); auto* attr4 = findAttribute(attrs, RadProto::MESSAGE_AUTHENTICATOR); BOOST_REQUIRE(attr4 != nullptr); - BOOST_CHECK_EQUAL(attr4->type(), RadProto::MESSAGE_AUTHENTICATOR); + BOOST_CHECK_EQUAL(attr4->code(), RadProto::MESSAGE_AUTHENTICATOR); BOOST_CHECK_EQUAL(attr4->toString(), "F3E000E77DEB51EB815D52373D06B71B"); auto* attr5 = findAttribute(attrs, RadProto::FRAMED_PROTOCOL); BOOST_REQUIRE(attr5 != nullptr); - BOOST_CHECK_EQUAL(attr5->type(), RadProto::FRAMED_PROTOCOL); + BOOST_CHECK_EQUAL(attr5->code(), RadProto::FRAMED_PROTOCOL); BOOST_CHECK_EQUAL(attr5->toString(), "1"); std::vector vendor = p.vendorSpecific(); BOOST_REQUIRE_EQUAL(vendor.size(), 1); BOOST_CHECK_EQUAL(vendor[0].vendorId(), 171); - BOOST_CHECK_EQUAL(vendor[0].vendorType(), 1); + BOOST_CHECK_EQUAL(vendor[0].vendorAttributeCode(), 1); BOOST_CHECK_EQUAL(vendor[0].toString(), "00000003"); - std::set types {RadProto::USER_NAME, RadProto::USER_PASSWORD, RadProto::NAS_IP_ADDRESS, RadProto::NAS_PORT, RadProto::MESSAGE_AUTHENTICATOR, RadProto::FRAMED_PROTOCOL}; + std::set codes {RadProto::USER_NAME, RadProto::USER_PASSWORD, RadProto::NAS_IP_ADDRESS, RadProto::NAS_PORT, RadProto::MESSAGE_AUTHENTICATOR, RadProto::FRAMED_PROTOCOL}; BOOST_REQUIRE_EQUAL(attrs.size(), 6); - BOOST_CHECK(types.count(attrs[0]->type()) == 1); - BOOST_CHECK(types.count(attrs[1]->type()) == 1); - BOOST_CHECK(types.count(attrs[2]->type()) == 1); - BOOST_CHECK(types.count(attrs[3]->type()) == 1); - BOOST_CHECK(types.count(attrs[4]->type()) == 1); - BOOST_CHECK(types.count(attrs[5]->type()) == 1); + BOOST_CHECK(codes.count(attrs[0]->code()) == 1); + BOOST_CHECK(codes.count(attrs[1]->code()) == 1); + BOOST_CHECK(codes.count(attrs[2]->code()) == 1); + BOOST_CHECK(codes.count(attrs[3]->code()) == 1); + BOOST_CHECK(codes.count(attrs[4]->code()) == 1); + BOOST_CHECK(codes.count(attrs[5]->code()) == 1); std::vector values = p.makeSendBuffer("secret"); @@ -430,7 +430,7 @@ BOOST_AUTO_TEST_CASE(PacketCopyConstructorResponse) RadProto::Packet other(d.data(), d.size(), "secret"); RadProto::Packet p(other); - BOOST_CHECK_EQUAL(p.type(), other.type()); + BOOST_CHECK_EQUAL(p.code(), other.code()); BOOST_CHECK_EQUAL(p.id(), other.id()); @@ -441,48 +441,48 @@ BOOST_AUTO_TEST_CASE(PacketCopyConstructorResponse) auto* attr0 = findAttribute(attrs, RadProto::USER_NAME); BOOST_REQUIRE(attr0 != nullptr); - BOOST_CHECK_EQUAL(attr0->type(), RadProto::USER_NAME); + BOOST_CHECK_EQUAL(attr0->code(), RadProto::USER_NAME); BOOST_CHECK_EQUAL(attr0->toString(), "test"); auto* attr1 = findAttribute(attrs, RadProto::NAS_PORT); BOOST_REQUIRE(attr1 != nullptr); - BOOST_CHECK_EQUAL(attr1->type(), RadProto::NAS_PORT); + BOOST_CHECK_EQUAL(attr1->code(), RadProto::NAS_PORT); BOOST_CHECK_EQUAL(attr1->toString(), "20"); auto* attr2 = findAttribute(attrs, RadProto::NAS_IP_ADDRESS); BOOST_REQUIRE(attr2 != nullptr); - BOOST_CHECK_EQUAL(attr2->type(), RadProto::NAS_IP_ADDRESS); + BOOST_CHECK_EQUAL(attr2->code(), RadProto::NAS_IP_ADDRESS); BOOST_CHECK_EQUAL(attr2->toString(), "127.104.22.17"); auto* attr3 = findAttribute(attrs, RadProto::CALLBACK_NUMBER); BOOST_REQUIRE(attr3 != nullptr); - BOOST_CHECK_EQUAL(attr3->type(), RadProto::CALLBACK_NUMBER); + BOOST_CHECK_EQUAL(attr3->code(), RadProto::CALLBACK_NUMBER); BOOST_CHECK_EQUAL(attr3->toString(), "313233616263"); auto* attr4 = findAttribute(attrs, RadProto::CHAP_PASSWORD); BOOST_REQUIRE(attr4 != nullptr); - BOOST_CHECK_EQUAL(attr4->type(), RadProto::CHAP_PASSWORD); + BOOST_CHECK_EQUAL(attr4->code(), RadProto::CHAP_PASSWORD); BOOST_CHECK_EQUAL(attr4->toString(), "1 31323334353637383961626364656667"); std::vector vendor = p.vendorSpecific(); BOOST_REQUIRE_EQUAL(vendor.size(), 1); BOOST_CHECK_EQUAL(vendor[0].vendorId(), 171); - BOOST_CHECK_EQUAL(vendor[0].vendorType(), 1); + BOOST_CHECK_EQUAL(vendor[0].vendorAttributeCode(), 1); BOOST_CHECK_EQUAL(vendor[0].toString(), "00000003"); - std::set types {RadProto::USER_NAME, RadProto::NAS_PORT, RadProto::NAS_IP_ADDRESS, RadProto::CALLBACK_NUMBER, RadProto::CHAP_PASSWORD}; + std::set codes {RadProto::USER_NAME, RadProto::NAS_PORT, RadProto::NAS_IP_ADDRESS, RadProto::CALLBACK_NUMBER, RadProto::CHAP_PASSWORD}; BOOST_REQUIRE_EQUAL(attrs.size(), 5); - BOOST_CHECK(types.count(attrs[0]->type()) == 1); - BOOST_CHECK(types.count(attrs[1]->type()) == 1); - BOOST_CHECK(types.count(attrs[2]->type()) == 1); - BOOST_CHECK(types.count(attrs[3]->type()) == 1); - BOOST_CHECK(types.count(attrs[4]->type()) == 1); + BOOST_CHECK(codes.count(attrs[0]->code()) == 1); + BOOST_CHECK(codes.count(attrs[1]->code()) == 1); + BOOST_CHECK(codes.count(attrs[2]->code()) == 1); + BOOST_CHECK(codes.count(attrs[3]->code()) == 1); + BOOST_CHECK(codes.count(attrs[4]->code()) == 1); std::vector values = p.makeSendBuffer("secret"); From c2882749e698dc6d15bbcb4ba6496c3368e72293 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 17:26:27 +0300 Subject: [PATCH 25/44] Header file "attribute_types.h" changed to "attribute_codes.h". Function vendorType() changed to vendorAttributeCode().Function type() changed to code(). The set types changed to codes. --- tests/socket_tests.cpp | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/tests/socket_tests.cpp b/tests/socket_tests.cpp index ba1b2cd..5ca86ca 100644 --- a/tests/socket_tests.cpp +++ b/tests/socket_tests.cpp @@ -4,7 +4,7 @@ #include "radproto/error.h" #include "radproto/attribute.h" #include "radproto/vendor_attribute.h" -#include "attribute_types.h" +#include "attribute_codes.h" #include "utils.h" #include #include @@ -43,7 +43,7 @@ namespace BOOST_REQUIRE(p != std::nullopt); RadProto::Packet d = p.value(); - BOOST_CHECK_EQUAL(d.type(), 1); + BOOST_CHECK_EQUAL(d.code(), 1); BOOST_CHECK_EQUAL(d.id(), 208); @@ -56,55 +56,55 @@ namespace auto* attr0 = findAttribute(attrs, RadProto::USER_NAME); BOOST_REQUIRE(attr0 != nullptr); - BOOST_CHECK_EQUAL(attr0->type(), RadProto::USER_NAME); + BOOST_CHECK_EQUAL(attr0->code(), RadProto::USER_NAME); BOOST_CHECK_EQUAL(attr0->toString(), "test"); auto* attr1 = findAttribute(attrs, RadProto::USER_PASSWORD); BOOST_REQUIRE(attr1 != nullptr); - BOOST_CHECK_EQUAL(attr1->type(), RadProto::USER_PASSWORD); + BOOST_CHECK_EQUAL(attr1->code(), RadProto::USER_PASSWORD); BOOST_CHECK_EQUAL(attr1->toString(), "123456"); auto* attr2 = findAttribute(attrs, RadProto::NAS_IP_ADDRESS); BOOST_REQUIRE(attr2 != nullptr); - BOOST_CHECK_EQUAL(attr2->type(), RadProto::NAS_IP_ADDRESS); + BOOST_CHECK_EQUAL(attr2->code(), RadProto::NAS_IP_ADDRESS); BOOST_CHECK_EQUAL(attr2->toString(), "127.0.0.1"); auto* attr3 = findAttribute(attrs, RadProto::NAS_PORT); BOOST_REQUIRE(attr3 != nullptr); - BOOST_CHECK_EQUAL(attr3->type(), RadProto::NAS_PORT); + BOOST_CHECK_EQUAL(attr3->code(), RadProto::NAS_PORT); BOOST_CHECK_EQUAL(attr3->toString(), "1"); auto* attr4 = findAttribute(attrs, RadProto::MESSAGE_AUTHENTICATOR); BOOST_REQUIRE(attr4 != nullptr); - BOOST_CHECK_EQUAL(attr4->type(), RadProto::MESSAGE_AUTHENTICATOR); + BOOST_CHECK_EQUAL(attr4->code(), RadProto::MESSAGE_AUTHENTICATOR); BOOST_CHECK_EQUAL(attr4->toString(), "F3E000E77DEB51EB815D52373D06B71B"); auto* attr5 = findAttribute(attrs, RadProto::FRAMED_PROTOCOL); BOOST_REQUIRE(attr5 != nullptr); - BOOST_CHECK_EQUAL(attr5->type(), RadProto::FRAMED_PROTOCOL); + BOOST_CHECK_EQUAL(attr5->code(), RadProto::FRAMED_PROTOCOL); BOOST_CHECK_EQUAL(attr5->toString(), "1"); std::vector vendor = d.vendorSpecific(); BOOST_REQUIRE_EQUAL(vendor.size(), 1); BOOST_CHECK_EQUAL(vendor[0].vendorId(), 171); - BOOST_CHECK_EQUAL(vendor[0].vendorType(), 1); + BOOST_CHECK_EQUAL(vendor[0].vendorAttributeCode(), 1); BOOST_CHECK_EQUAL(vendor[0].toString(), "00000003"); - std::set types {RadProto::USER_NAME, RadProto::USER_PASSWORD, RadProto::NAS_IP_ADDRESS, RadProto::NAS_PORT, RadProto::MESSAGE_AUTHENTICATOR, RadProto::FRAMED_PROTOCOL}; + std::set codes {RadProto::USER_NAME, RadProto::USER_PASSWORD, RadProto::NAS_IP_ADDRESS, RadProto::NAS_PORT, RadProto::MESSAGE_AUTHENTICATOR, RadProto::FRAMED_PROTOCOL}; BOOST_REQUIRE_EQUAL(attrs.size(), 6); - BOOST_CHECK(types.count(attrs[0]->type()) == 1); - BOOST_CHECK(types.count(attrs[1]->type()) == 1); - BOOST_CHECK(types.count(attrs[2]->type()) == 1); - BOOST_CHECK(types.count(attrs[3]->type()) == 1); - BOOST_CHECK(types.count(attrs[4]->type()) == 1); - BOOST_CHECK(types.count(attrs[5]->type()) == 1); + BOOST_CHECK(codes.count(attrs[0]->code()) == 1); + BOOST_CHECK(codes.count(attrs[1]->code()) == 1); + BOOST_CHECK(codes.count(attrs[2]->code()) == 1); + BOOST_CHECK(codes.count(attrs[3]->code()) == 1); + BOOST_CHECK(codes.count(attrs[4]->code()) == 1); + BOOST_CHECK(codes.count(attrs[5]->code()) == 1); } } From 5532d57f2d3fb241b8eba2e5aed87a12ebf8a135 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 17:30:34 +0300 Subject: [PATCH 26/44] Parameter type changed to code. Function type() changed to code(). --- tests/utils.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/utils.cpp b/tests/utils.cpp index 004951a..52ec5cd 100644 --- a/tests/utils.cpp +++ b/tests/utils.cpp @@ -1,10 +1,10 @@ #include "utils.h" -RadProto::Attribute* findAttribute(const std::vector& attributes, RadProto::Attribute_Types type) +RadProto::Attribute* findAttribute(const std::vector& attributes, RadProto::Attribute_Codes code) { for (const auto& b : attributes) { - if (b->type() == type) + if (b->code() == code) return b; } return nullptr; From 7c6b585e3014e8d93b151ea09c852c373a8055d1 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 3 Oct 2025 17:33:23 +0300 Subject: [PATCH 27/44] Header file "attribute_types.h" changed to "attribute_codes.h". Parameter type changed to code in function findAttribute.. --- tests/utils.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/utils.h b/tests/utils.h index 1c7615a..b582641 100644 --- a/tests/utils.h +++ b/tests/utils.h @@ -1,8 +1,8 @@ #pragma once -#include "attribute_types.h" +#include "attribute_codes.h" #include "attribute.h" #include "vendor_attribute.h" -RadProto::Attribute* findAttribute(const std::vector& attributes, RadProto::Attribute_Types type); +RadProto::Attribute* findAttribute(const std::vector& attributes, RadProto::Attribute_Codes code); From df8335b24c6db4f3c4b8ba3dcc21c0e4aa5dd3fd Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Mon, 6 Oct 2025 16:25:27 +0300 Subject: [PATCH 28/44] The element suchAttributeNameWithAnotherTypeAlreadyExists added to enum Class Error. --- include/radproto/error.h | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/include/radproto/error.h b/include/radproto/error.h index a10f1a5..b9c4ef2 100644 --- a/include/radproto/error.h +++ b/include/radproto/error.h @@ -23,7 +23,8 @@ namespace RadProto invalidAttributeSize, invalidVendorSpecificAttributeId, suchAttributeNameAlreadyExists, - suchAttributeCodeAlreadyExists + suchAttributeCodeAlreadyExists, + suchAttributeNameWithAnotherTypeAlreadyExists }; class Exception: public std::runtime_error From c6ddcbffecb8b5588e374da31e3cb21b102319d9 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Mon, 6 Oct 2025 16:46:18 +0300 Subject: [PATCH 29/44] The case Error::suchAttributeNameWithAnotherTypeAlreadyExists added to function message(). --- src/error.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/error.cpp b/src/error.cpp index 0a6265d..b31d423 100644 --- a/src/error.cpp +++ b/src/error.cpp @@ -43,6 +43,8 @@ std::string ErrorCategory::message(int ev) const noexcept return "Such attribute name already exists"; case Error::suchAttributeCodeAlreadyExists: return "Such attribute code already exists"; + case Error::suchAttributeNameWithAnotherTypeAlreadyExists: + return "Such attribute name with another type already exists"; default: return "(Unrecognized error)"; } From 21cb71c44b8e2e5705beaefd6056db319754df81 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Mon, 6 Oct 2025 16:52:14 +0300 Subject: [PATCH 30/44] The Exception messages fixed in the functions BasicDictionary::append and VendorDictionary::add. --- src/dictionaries.cpp | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 6810755..3c225c9 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -64,14 +64,14 @@ void BasicDictionary::append(const BasicDictionary& basicDict) { std::cout << "name ==, code ==, entry.name: " + entry.second.first + "item.name: " + item.second.first + "\n"; - throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name3 " + entry.second.first + " already exists with type " + item.second.second); + throw Exception(Error::suchAttributeNameWithAnotherTypeAlreadyExists, "[BasicDictionary::append]. Attribute name " + entry.second.first + " already exists with type " + item.second.second); } if (entry.second.first != item.second.first && entry.first == item.first && entry.second.second != item.second.second) { std::cout << "(name !=, code ==, type !=) entry.name: " + entry.second.first + " entry.code: " + std::to_string(entry.first) + " entry.type: " + entry.second.second + " item.name: " + item.second.first + " item.code: " + std::to_string(item.first) + " item.type:" + item. second.second + "\n"; - throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name4 " + entry.second.first + " already exists with type " + item.second.second); + throw Exception(Error::suchAttributeNameWithAnotherTypeAlreadyExists, "[BasicDictionary::append]. Attribute name4 " + entry.second.first + " already exists with type " + item.second.second); } } @@ -99,7 +99,7 @@ void VendorDictionary::add(uint32_t code, const std::string& name) { for (const auto& entry: m_rightDict) if (entry.second == name && entry.first != code) - throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); + throw Exception(Error::suchAttributeNameAlreadyExists, "[VendorDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); m_rightDict.insert_or_assign(code, name); m_reverseDict.emplace(name, code); @@ -111,7 +111,7 @@ void VendorDictionary::append(const VendorDictionary& vendorDict) { for (const auto& item: m_rightDict) if (entry.second == item.second && entry.first != item.first) - throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::append]. Attribute name " + entry.second + " already exists with code " + std::to_string(item.first)); + throw Exception(Error::suchAttributeNameAlreadyExists, "[VendorDictionary::append]. Attribute name " + entry.second + " already exists with code " + std::to_string(item.first)); m_rightDict.insert_or_assign(entry.first, entry.second); } From e50e375982cdeb4ec2d7ecd5fe9cf39399b5ec6b Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Thu, 23 Oct 2025 16:15:16 +0300 Subject: [PATCH 31/44] Debugging std::cout removed and other debugging std::cout added. Exception messages changed in the VendorDictionary::add function. In the constructor Dictionary: the type of variable attrName changed to std::string; the code for search the code with a dot by the attribute added; the condition for filling dictionaries of value changed. --- src/dictionaries.cpp | 46 +++++++++++++++++++++++++++----------------- 1 file changed, 28 insertions(+), 18 deletions(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 3c225c9..484ba75 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -39,7 +39,10 @@ void BasicDictionary::add(uint32_t code, const std::string& name, const std::str throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with type " + entry.second.second); if (entry.second.first != name && entry.first == code && entry.second.second != type) + { + std::cout << "Basic add() name: " + name + " code: " + std::to_string(code) + " entry.type: " + type + "\n"; throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name2 " + name + " already exists with type " + entry.second.second); + } } m_rightDict.insert_or_assign(code, std::make_pair(name, type)); @@ -51,25 +54,20 @@ void BasicDictionary::append(const BasicDictionary& basicDict) for (const auto& entry: basicDict.m_rightDict) { - std::cout << "entry.name: " + entry.second.first + " entry.code: " + std::to_string(entry.first) + " entry.type: " + entry.second.second + "\n"; for (const auto& item: m_rightDict) { if (entry.second.first == item.second.first && entry.first != item.first) { - std::cout << "name ==, code !=, entry.name: " + entry.second.first + "item.name: " + item.second.first + "\n"; throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::append]. Attribute name " + entry.second.first + " already exists with code " + std::to_string(item.first)); } if (entry.second.first == item.second.first && entry.first == item.first && entry.second.second != item.second.second) { - - std::cout << "name ==, code ==, entry.name: " + entry.second.first + "item.name: " + item.second.first + "\n"; throw Exception(Error::suchAttributeNameWithAnotherTypeAlreadyExists, "[BasicDictionary::append]. Attribute name " + entry.second.first + " already exists with type " + item.second.second); } if (entry.second.first != item.second.first && entry.first == item.first && entry.second.second != item.second.second) { - std::cout << "(name !=, code ==, type !=) entry.name: " + entry.second.first + " entry.code: " + std::to_string(entry.first) + " entry.type: " + entry.second.second + " item.name: " + item.second.first + " item.code: " + std::to_string(item.first) + " item.type:" + item. second.second + "\n"; throw Exception(Error::suchAttributeNameWithAnotherTypeAlreadyExists, "[BasicDictionary::append]. Attribute name4 " + entry.second.first + " already exists with type " + item.second.second); } @@ -98,9 +96,10 @@ uint32_t VendorDictionary::code(const std::string& name) const void VendorDictionary::add(uint32_t code, const std::string& name) { for (const auto& entry: m_rightDict) + { if (entry.second == name && entry.first != code) - throw Exception(Error::suchAttributeNameAlreadyExists, "[VendorDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); - + throw Exception(Error::suchAttributeNameAlreadyExists, "[VendorDictionary::add]. Vendor attribute name " + name + " already exists with code " + std::to_string(entry.first)); + } m_rightDict.insert_or_assign(code, name); m_reverseDict.emplace(name, code); } @@ -111,7 +110,7 @@ void VendorDictionary::append(const VendorDictionary& vendorDict) { for (const auto& item: m_rightDict) if (entry.second == item.second && entry.first != item.first) - throw Exception(Error::suchAttributeNameAlreadyExists, "[VendorDictionary::append]. Attribute name " + entry.second + " already exists with code " + std::to_string(item.first)); + throw Exception(Error::suchAttributeNameAlreadyExists, "[VendorDictionary::append]. Vendor attribute name " + entry.second + " already exists with code " + std::to_string(item.first)); m_rightDict.insert_or_assign(entry.first, entry.second); } @@ -137,7 +136,6 @@ void DependentDictionary::add(uint32_t code, const std::string& name, const std: for (const auto& entry: m_rightDict) if (entry.second == name && entry.first.first == dependencyName && entry.first.second != code) throw Exception(Error::suchAttributeNameAlreadyExists, "[DependentDictionary::add]. Value name " + name + " of attribute " + dependencyName + " already exists with code " + std::to_string(entry.first.second)); - m_rightDict.insert_or_assign(std::make_pair(dependencyName, code), name); m_reverseDict.emplace(std::make_pair(dependencyName, name), code); } @@ -180,18 +178,30 @@ Dictionaries::Dictionaries(const std::string& filePath) if (!tokens.empty()) { + std::string attrName; if (tokens[0] == "ATTRIBUTE") { - const auto& attrName = tokens[1]; - const auto code = std::stoul(tokens[2]); - const auto& attrType = tokens[3]; - - if (!vendorName.empty()) - m_vendorAttributes.add(code, attrName, vendorName); - else - m_attributes.add(code, attrName, attrType); + std::string::size_type n = tokens[2].find("."); + if (n == std::string::npos) + { + const auto code = std::stoul(tokens[2]); + + attrName = tokens[1]; + const auto& attrType = tokens[3]; + + if (!vendorName.empty()) + { + std::cout << "VendorName: " + vendorName + " AttrName: " + attrName + " AttrCode: " + std::to_string(code) + "\n"; + m_vendorAttributes.add(code, attrName, vendorName); + } + else + { + std::cout << "AttrName: " + attrName + " AttrCode: " + std::to_string(code) + " AttrType: " + attrType + "\n"; + m_attributes.add(code, attrName, attrType); + } + } } - else if (tokens[0] == "VALUE") + else if (tokens[0] == "VALUE" && !attrName.empty()) { const auto& attrNameVal = tokens[1]; const auto& valueName = tokens[2]; From cc339fafa5f71856cf20baffb7910274f4fdacfe Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Thu, 6 Nov 2025 16:15:58 +0200 Subject: [PATCH 32/44] Functions attributeType added to class Dictionaries. --- include/radproto/dictionaries.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/include/radproto/dictionaries.h b/include/radproto/dictionaries.h index 3ffb7c6..20cbc13 100644 --- a/include/radproto/dictionaries.h +++ b/include/radproto/dictionaries.h @@ -62,6 +62,8 @@ namespace RadProto std::string attributeName(uint32_t code) const; uint32_t attributeCode(const std::string& name) const; + std::string attributeType(uint32_t code) const; + std::string attributeType(const std::string name) const; std::string vendorName(uint32_t code) const; uint32_t vendorCode(const std::string& name) const; From e3604b10e0a68970e623edb3963d789a9ed50f8b Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Thu, 6 Nov 2025 16:26:14 +0200 Subject: [PATCH 33/44] The tests changed to check attribute types. --- tests/dictionaries_tests.cpp | 571 +++++++++++++++++++++++------------ 1 file changed, 383 insertions(+), 188 deletions(-) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index 4d0f775..e34b9a6 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -23,204 +23,227 @@ BOOST_AUTO_TEST_CASE(TestAdd) { RadProto::BasicDictionary b; - b.add(1, "User-Name", "string"); - b.add(1, "User", "string"); +// 1. codes !=, names == - exception + b.add(1, "abc", "string"); BOOST_CHECK_THROW(b.add(2, "abc", "string"), RadProto::Exception); - BOOST_CHECK_THROW(b.add(2, "abc", "int"), RadProto::Exception); - BOOST_CHECK_THROW(b.add(1, "abc", "int"), RadProto::Exception); - b.add(3, "def", "string"); - BOOST_CHECK_THROW(b.add(3, "ghi", "int"), RadProto::Exception); - b.add(1, "abc", "string"); - b.add(4, "cde", "int"); + BOOST_CHECK_THROW(b.add(2, "abc", "integer"), RadProto::Exception); BOOST_CHECK_EQUAL(b.name(1), "abc"); - BOOST_CHECK_EQUAL(b.name(3), "def"); - BOOST_CHECK_EQUAL(b.name(4), "cde"); - BOOST_CHECK_EQUAL(b.code("User-Name"), 1); - BOOST_CHECK_EQUAL(b.code("User"), 1); BOOST_CHECK_EQUAL(b.code("abc"), 1); - BOOST_CHECK_EQUAL(b.code("def"), 3); - BOOST_CHECK_EQUAL(b.code("cde"), 4); - BOOST_CHECK_EQUAL(b.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(b.type("User"), "string"); BOOST_CHECK_EQUAL(b.type("abc"), "string"); - BOOST_CHECK_EQUAL(b.type("def"), "string"); - BOOST_CHECK_EQUAL(b.type("cde"), "int"); BOOST_CHECK_EQUAL(b.type(1), "string"); - BOOST_CHECK_EQUAL(b.type(3), "string"); - BOOST_CHECK_EQUAL(b.type(4), "int"); - BOOST_CHECK_THROW(b.type(2), std::out_of_range); BOOST_CHECK_THROW(b.name(2), std::out_of_range); + BOOST_CHECK_THROW(b.type(2), std::out_of_range); + + +// 2. codes ==, names !=, types == + + b.add(3, "def", "string"); + b.add(3, "ghi", "string"); + + BOOST_CHECK_EQUAL(b.name(3), "ghi"); + BOOST_CHECK_EQUAL(b.type(3), "string"); + + BOOST_CHECK_EQUAL(b.code("def"), 3); + BOOST_CHECK_EQUAL(b.code("ghi"), 3); + + BOOST_CHECK_EQUAL(b.type("def"), "string"); + BOOST_CHECK_EQUAL(b.type("ghi"), "string"); + +// 2.1. codes ==, names !=, types != + + b.add(4, "jkl", "string"); + b.add(4, "mno", "integer"); + + BOOST_CHECK_EQUAL(b.name(4), "mno"); + BOOST_CHECK_EQUAL(b.type(4), "integer"); + + BOOST_CHECK_EQUAL(b.code("jkl"), 4); + BOOST_CHECK_EQUAL(b.code("mno"), 4); + + BOOST_CHECK_EQUAL(b.type("jkl"), "string"); + BOOST_CHECK_EQUAL(b.type("mno"), "integer"); + + +// 3. codes ==, names ==, types == + + b.add(5, "cde", "integer"); + b.add(5, "cde", "integer"); + + BOOST_CHECK_EQUAL(b.name(5), "cde"); + BOOST_CHECK_EQUAL(b.type(5), "integer"); + + BOOST_CHECK_EQUAL(b.code("cde"), 5); + + BOOST_CHECK_EQUAL(b.type("cde"), "integer"); + +// 3.1. codes ==, names ==, types != + + b.add(6, "efg", "integer"); + b.add(6, "efg", "string"); + + BOOST_CHECK_EQUAL(b.name(6), "efg"); + BOOST_CHECK_EQUAL(b.type(6), "string"); + + BOOST_CHECK_EQUAL(b.code("efg"), 6); + + BOOST_CHECK_EQUAL(b.type("efg"), "string"); } BOOST_AUTO_TEST_CASE(TestAppend) { + +// 1. codes !=, names == - exception + RadProto::BasicDictionary a; - a.add(2, "def", "int"); - a.add(3, "ghi", "string"); - a.add(4, "User-Name", "string"); + a.add(1, "abc", "string"); - BOOST_CHECK_EQUAL(a.name(2), "def"); - BOOST_CHECK_EQUAL(a.name(3), "ghi"); - BOOST_CHECK_EQUAL(a.name(4), "User-Name"); - BOOST_CHECK_EQUAL(a.code("def"), 2); - BOOST_CHECK_EQUAL(a.code("ghi"), 3); - BOOST_CHECK_EQUAL(a.code("User-Name"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "int"); - BOOST_CHECK_EQUAL(a.type("ghi"), "string"); - BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "int"); - BOOST_CHECK_EQUAL(a.type(3), "string"); - BOOST_CHECK_EQUAL(a.type(4), "string"); + BOOST_CHECK_EQUAL(a.name(1), "abc"); + BOOST_CHECK_EQUAL(a.code("abc"), 1); + BOOST_CHECK_EQUAL(a.type("abc"), "string"); + BOOST_CHECK_EQUAL(a.type(1), "string"); RadProto::BasicDictionary b; - b.add(1, "User-Name", "string"); + b.add(2, "abc", "string"); - BOOST_CHECK_EQUAL(b.name(1), "User-Name"); - BOOST_CHECK_EQUAL(b.code("User-Name"), 1); - BOOST_CHECK_EQUAL(b.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(b.type(1), "string"); + BOOST_CHECK_EQUAL(b.name(2), "abc"); + BOOST_CHECK_EQUAL(b.code("abc"), 2); + BOOST_CHECK_EQUAL(b.type("abc"), "string"); + BOOST_CHECK_EQUAL(b.type(2), "string"); BOOST_CHECK_THROW(a.append(b), RadProto::Exception); - BOOST_CHECK_THROW(a.name(1), std::out_of_range); - BOOST_CHECK_THROW(a.type(1), std::out_of_range); - RadProto::BasicDictionary c; - c.add(4, "User", "string"); + c.add(2, "abc", "integer"); - BOOST_CHECK_EQUAL(c.name(4), "User"); - BOOST_CHECK_EQUAL(c.code("User"), 4); - BOOST_CHECK_EQUAL(c.type("User"), "string"); - BOOST_CHECK_EQUAL(c.type(4), "string"); + BOOST_CHECK_EQUAL(c.name(2), "abc"); + BOOST_CHECK_EQUAL(c.code("abc"), 2); + BOOST_CHECK_EQUAL(c.type("abc"), "integer"); + BOOST_CHECK_EQUAL(c.type(2), "integer"); - a.append(c); + BOOST_CHECK_THROW(a.append(c), RadProto::Exception); - BOOST_CHECK_EQUAL(a.name(2), "def"); - BOOST_CHECK_EQUAL(a.name(3), "ghi"); - BOOST_CHECK_EQUAL(a.name(4), "User"); - BOOST_CHECK_EQUAL(a.code("def"), 2); - BOOST_CHECK_EQUAL(a.code("ghi"), 3); - BOOST_CHECK_EQUAL(a.code("User"), 4); - BOOST_CHECK_EQUAL(a.code("User-Name"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "int"); - BOOST_CHECK_EQUAL(a.type("ghi"), "string"); - BOOST_CHECK_EQUAL(a.type("User"), "string"); - BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "int"); - BOOST_CHECK_EQUAL(a.type(3), "string"); - BOOST_CHECK_EQUAL(a.type(4), "string"); + BOOST_CHECK_THROW(a.name(2), std::out_of_range); + BOOST_CHECK_THROW(a.type(2), std::out_of_range); - RadProto::BasicDictionary d; - d.add(4, "jkl", "string"); +// 2. codes ==, names !=, types == - BOOST_CHECK_EQUAL(d.name(4), "jkl"); - BOOST_CHECK_EQUAL(d.code("jkl"), 4); - BOOST_CHECK_EQUAL(d.type("jkl"), "string"); - BOOST_CHECK_EQUAL(d.type(4), "string"); + RadProto::BasicDictionary d; - a.append(d); + d.add(1, "abc", "string"); - BOOST_CHECK_EQUAL(a.name(2), "def"); - BOOST_CHECK_EQUAL(a.name(3), "ghi"); - BOOST_CHECK_EQUAL(a.name(4), "jkl"); - BOOST_CHECK_EQUAL(a.code("def"), 2); - BOOST_CHECK_EQUAL(a.code("ghi"), 3); - BOOST_CHECK_EQUAL(a.code("User"), 4); - BOOST_CHECK_EQUAL(a.code("User-Name"), 4); - BOOST_CHECK_EQUAL(a.code("jkl"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "int"); - BOOST_CHECK_EQUAL(a.type("ghi"), "string"); - BOOST_CHECK_EQUAL(a.type("User"), "string"); - BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(a.type("jkl"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "int"); - BOOST_CHECK_EQUAL(a.type(3), "string"); - BOOST_CHECK_EQUAL(a.type(4), "string"); + BOOST_CHECK_EQUAL(d.name(1), "abc"); + BOOST_CHECK_EQUAL(d.type(1), "string"); + BOOST_CHECK_EQUAL(d.code("abc"), 1); + BOOST_CHECK_EQUAL(d.type("abc"), "string"); RadProto::BasicDictionary e; - e.add(2, "def", "string"); + e.add(1, "bcd", "string"); - BOOST_CHECK_EQUAL(e.name(2), "def"); - BOOST_CHECK_EQUAL(e.code("def"), 2); - BOOST_CHECK_EQUAL(e.type("def"), "string"); - BOOST_CHECK_EQUAL(e.type(2), "string"); + BOOST_CHECK_EQUAL(e.name(1), "bcd"); + BOOST_CHECK_EQUAL(e.type(1), "string"); + BOOST_CHECK_EQUAL(e.code("bcd"), 1); + BOOST_CHECK_EQUAL(e.type("bcd"), "string"); - BOOST_CHECK_THROW(a.append(e), RadProto::Exception); + d.append(e); - BOOST_CHECK_EQUAL(a.name(2), "def"); - BOOST_CHECK_EQUAL(a.name(3), "ghi"); - BOOST_CHECK_EQUAL(a.name(4), "jkl"); - BOOST_CHECK_EQUAL(a.code("def"), 2); - BOOST_CHECK_EQUAL(a.code("ghi"), 3); - BOOST_CHECK_EQUAL(a.code("User"), 4); - BOOST_CHECK_EQUAL(a.code("User-Name"), 4); - BOOST_CHECK_EQUAL(a.code("jkl"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "int"); - BOOST_CHECK_EQUAL(a.type("ghi"), "string"); - BOOST_CHECK_EQUAL(a.type("User"), "string"); - BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(a.type("jkl"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "int"); - BOOST_CHECK_EQUAL(a.type(3), "string"); - BOOST_CHECK_EQUAL(a.type(4), "string"); + BOOST_CHECK_EQUAL(d.name(1), "bcd"); + BOOST_CHECK_EQUAL(d.type(1), "string"); + BOOST_CHECK_EQUAL(d.code("abc"), 1); + BOOST_CHECK_EQUAL(d.code("bcd"), 1); + BOOST_CHECK_EQUAL(d.type("abc"), "string"); + BOOST_CHECK_EQUAL(d.type("bcd"), "string"); + +// 2.1. codes ==, names !=, types != RadProto::BasicDictionary f; - f.add(4, "User-Name", "string"); + f.add(1, "abc", "string"); - BOOST_CHECK_EQUAL(f.name(4), "User-Name"); - BOOST_CHECK_EQUAL(f.code("User-Name"), 4); - BOOST_CHECK_EQUAL(f.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(f.type(4), "string"); + BOOST_CHECK_EQUAL(f.name(1), "abc"); + BOOST_CHECK_EQUAL(f.type(1), "string"); + BOOST_CHECK_EQUAL(f.code("abc"), 1); + BOOST_CHECK_EQUAL(f.type("abc"), "string"); - a.append(f); + RadProto::BasicDictionary g; - BOOST_CHECK_EQUAL(a.name(2), "def"); - BOOST_CHECK_EQUAL(a.name(3), "ghi"); - BOOST_CHECK_EQUAL(a.name(4), "User-Name"); - BOOST_CHECK_EQUAL(a.code("def"), 2); - BOOST_CHECK_EQUAL(a.code("ghi"), 3); - BOOST_CHECK_EQUAL(a.code("User-Name"), 4); - BOOST_CHECK_EQUAL(a.code("User"), 4); - BOOST_CHECK_EQUAL(a.code("jkl"), 4); - BOOST_CHECK_EQUAL(a.type("def"), "int"); - BOOST_CHECK_EQUAL(a.type("ghi"), "string"); - BOOST_CHECK_EQUAL(a.type("User"), "string"); - BOOST_CHECK_EQUAL(a.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(a.type("jkl"), "string"); - BOOST_CHECK_EQUAL(a.type(2), "int"); - BOOST_CHECK_EQUAL(a.type(3), "string"); - BOOST_CHECK_EQUAL(a.type(4), "string"); + g.add(1, "bcd", "integer"); - RadProto::BasicDictionary g; + BOOST_CHECK_EQUAL(g.name(1), "bcd"); + BOOST_CHECK_EQUAL(g.type(1), "integer"); + BOOST_CHECK_EQUAL(g.code("bcd"), 1); + BOOST_CHECK_EQUAL(g.type("bcd"), "integer"); - g.add(5, "ghi", "int"); + f.append(g); - BOOST_CHECK_EQUAL(g.name(5), "ghi"); - BOOST_CHECK_EQUAL(g.code("ghi"), 5); - BOOST_CHECK_EQUAL(g.type("ghi"), "int"); - BOOST_CHECK_EQUAL(g.type(5), "int"); + BOOST_CHECK_EQUAL(f.name(1), "bcd"); + BOOST_CHECK_EQUAL(f.type(1), "integer"); + BOOST_CHECK_EQUAL(f.code("abc"), 1); + BOOST_CHECK_EQUAL(f.code("bcd"), 1); + BOOST_CHECK_EQUAL(f.type("abc"), "string"); + BOOST_CHECK_EQUAL(f.type("bcd"), "integer"); - BOOST_CHECK_THROW(a.append(g), RadProto::Exception); + +// 3. codes ==, names ==, types == RadProto::BasicDictionary h; - h.add(4, "jkl", "int"); + h.add(1, "abc", "string"); + + BOOST_CHECK_EQUAL(h.name(1), "abc"); + BOOST_CHECK_EQUAL(h.type(1), "string"); + BOOST_CHECK_EQUAL(h.code("abc"), 1); + BOOST_CHECK_EQUAL(h.type("abc"), "string"); + + RadProto::BasicDictionary i; + + i.add(1, "abc", "string"); + + BOOST_CHECK_EQUAL(i.name(1), "abc"); + BOOST_CHECK_EQUAL(i.type(1), "string"); + BOOST_CHECK_EQUAL(i.code("abc"), 1); + BOOST_CHECK_EQUAL(i.type("abc"), "string"); + + h.append(i); + + BOOST_CHECK_EQUAL(h.name(1), "abc"); + BOOST_CHECK_EQUAL(h.type(1), "string"); + BOOST_CHECK_EQUAL(h.code("abc"), 1); + BOOST_CHECK_EQUAL(h.type("abc"), "string"); + +// 3.1 codes ==, names ==, types != + + RadProto::BasicDictionary j; + + j.add(1, "abc", "string"); + + BOOST_CHECK_EQUAL(j.name(1), "abc"); + BOOST_CHECK_EQUAL(j.type(1), "string"); + BOOST_CHECK_EQUAL(j.code("abc"), 1); + BOOST_CHECK_EQUAL(j.type("abc"), "string"); - BOOST_CHECK_EQUAL(h.name(4), "jkl"); - BOOST_CHECK_EQUAL(h.code("jkl"), 4); - BOOST_CHECK_EQUAL(h.type("jkl"), "int"); - BOOST_CHECK_EQUAL(h.type(4), "int"); + RadProto::BasicDictionary k; - BOOST_CHECK_THROW(a.append(h), RadProto::Exception); + k.add(1, "abc", "integer"); + + BOOST_CHECK_EQUAL(k.name(1), "abc"); + BOOST_CHECK_EQUAL(k.type(1), "integer"); + BOOST_CHECK_EQUAL(k.code("abc"), 1); + BOOST_CHECK_EQUAL(k.type("abc"), "integer"); + + j.append(k); + + BOOST_CHECK_EQUAL(j.name(1), "abc"); + BOOST_CHECK_EQUAL(j.type(1), "integer"); + BOOST_CHECK_EQUAL(j.code("abc"), 1); + BOOST_CHECK_EQUAL(j.type("abc"), "integer"); } BOOST_AUTO_TEST_CASE(TestConstructor) @@ -231,64 +254,228 @@ BOOST_AUTO_TEST_CASE(TestConstructor) BOOST_CHECK_THROW(b.code(""), std::out_of_range); - b.add(1, "User-Name","string"); - b.add(1, "User", "string"); - b.add(5, "ijk", "string"); - b.add(3, "def", "string"); - BOOST_CHECK_THROW(b.add(2, "User", "string"), RadProto::Exception); +// Function add - BOOST_CHECK_EQUAL(b.name(1), "User"); - BOOST_CHECK_EQUAL(b.name(5), "ijk"); - BOOST_CHECK_EQUAL(b.name(3), "def"); - BOOST_CHECK_EQUAL(b.code("User-Name"), 1); - BOOST_CHECK_EQUAL(b.code("User"), 1); - BOOST_CHECK_EQUAL(b.code("ijk"), 5); - BOOST_CHECK_EQUAL(b.code("def"), 3); - BOOST_CHECK_EQUAL(b.type("User-Name"), "string"); - BOOST_CHECK_EQUAL(b.type("User"), "string"); - BOOST_CHECK_EQUAL(b.type("ijk"), "string"); - BOOST_CHECK_EQUAL(b.type("def"), "string"); +// 1. codes !=, names == - exception + + b.add(1, "abc", "string"); + BOOST_CHECK_THROW(b.add(2, "abc", "string"), RadProto::Exception); + BOOST_CHECK_THROW(b.add(2, "abc", "integer"), RadProto::Exception); + + BOOST_CHECK_EQUAL(b.name(1), "abc"); + BOOST_CHECK_EQUAL(b.code("abc"), 1); + BOOST_CHECK_EQUAL(b.type("abc"), "string"); BOOST_CHECK_EQUAL(b.type(1), "string"); - BOOST_CHECK_EQUAL(b.type(5), "string"); - BOOST_CHECK_EQUAL(b.type(3), "string"); + BOOST_CHECK_THROW(b.name(2), std::out_of_range); BOOST_CHECK_THROW(b.type(2), std::out_of_range); - RadProto::BasicDictionary c; - c.add(2, "def", "string"); - c.add(5, "ghi", "string"); +// 2. codes ==, names !=, types == - BOOST_CHECK_EQUAL(c.name(2), "def"); - BOOST_CHECK_EQUAL(c.name(5), "ghi"); - BOOST_CHECK_EQUAL(c.code("def"), 2); - BOOST_CHECK_EQUAL(c.code("ghi"), 5); - BOOST_CHECK_EQUAL(c.type("def"), "string"); - BOOST_CHECK_EQUAL(c.type("ghi"), "string"); - BOOST_CHECK_EQUAL(c.type(2), "string"); - BOOST_CHECK_EQUAL(c.type(5), "string"); + b.add(3, "def", "string"); + b.add(3, "ghi", "string"); - BOOST_CHECK_THROW(c.append(b), RadProto::Exception); + BOOST_CHECK_EQUAL(b.name(3), "ghi"); + BOOST_CHECK_EQUAL(b.type(3), "string"); + + BOOST_CHECK_EQUAL(b.code("def"), 3); + BOOST_CHECK_EQUAL(b.code("ghi"), 3); + + BOOST_CHECK_EQUAL(b.type("def"), "string"); + BOOST_CHECK_EQUAL(b.type("ghi"), "string"); + +// 2.1. codes ==, names !=, types != + + b.add(4, "jkl", "string"); + b.add(4, "mno", "integer"); + + BOOST_CHECK_EQUAL(b.name(4), "mno"); + BOOST_CHECK_EQUAL(b.type(4), "integer"); + + BOOST_CHECK_EQUAL(b.code("jkl"), 4); + BOOST_CHECK_EQUAL(b.code("mno"), 4); + + BOOST_CHECK_EQUAL(b.type("jkl"), "string"); + BOOST_CHECK_EQUAL(b.type("mno"), "integer"); + + +// 3. codes ==, names ==, types == + + b.add(5, "cde", "integer"); + b.add(5, "cde", "integer"); + + BOOST_CHECK_EQUAL(b.name(5), "cde"); + BOOST_CHECK_EQUAL(b.type(5), "integer"); + + BOOST_CHECK_EQUAL(b.code("cde"), 5); + + BOOST_CHECK_EQUAL(b.type("cde"), "integer"); + +// 3.1. codes ==, names ==, types != + + b.add(6, "efg", "integer"); + b.add(6, "efg", "string"); + + BOOST_CHECK_EQUAL(b.name(6), "efg"); + BOOST_CHECK_EQUAL(b.type(6), "string"); + + BOOST_CHECK_EQUAL(b.code("efg"), 6); + + BOOST_CHECK_EQUAL(b.type("efg"), "string"); + + +// Function append + +// 1. codes !=, names == - exception RadProto::BasicDictionary a; - a.add(2, "def", "string"); + a.add(1, "abc", "string"); - BOOST_CHECK_EQUAL(a.name(2), "def"); - BOOST_CHECK_EQUAL(a.code("def"), 2); - BOOST_CHECK_EQUAL(c.type("def"), "string"); - BOOST_CHECK_EQUAL(c.type(2), "string"); + BOOST_CHECK_EQUAL(a.name(1), "abc"); + BOOST_CHECK_EQUAL(a.code("abc"), 1); + BOOST_CHECK_EQUAL(a.type("abc"), "string"); + BOOST_CHECK_EQUAL(a.type(1), "string"); - c.append(a); + RadProto::BasicDictionary p; - BOOST_CHECK_EQUAL(c.name(2), "def"); - BOOST_CHECK_EQUAL(c.name(5), "ghi"); - BOOST_CHECK_EQUAL(c.code("def"), 2); - BOOST_CHECK_EQUAL(c.code("ghi"), 5); - BOOST_CHECK_EQUAL(c.type("def"), "string"); - BOOST_CHECK_EQUAL(c.type("ghi"), "string"); - BOOST_CHECK_EQUAL(c.type(2), "string"); - BOOST_CHECK_EQUAL(c.type(5), "string"); + p.add(2, "abc", "string"); + + BOOST_CHECK_EQUAL(p.name(2), "abc"); + BOOST_CHECK_EQUAL(p.code("abc"), 2); + BOOST_CHECK_EQUAL(p.type("abc"), "string"); + BOOST_CHECK_EQUAL(p.type(2), "string"); + + BOOST_CHECK_THROW(a.append(p), RadProto::Exception); + + RadProto::BasicDictionary c; + + c.add(2, "abc", "integer"); + + BOOST_CHECK_EQUAL(c.name(2), "abc"); + BOOST_CHECK_EQUAL(c.code("abc"), 2); + BOOST_CHECK_EQUAL(c.type("abc"), "integer"); + BOOST_CHECK_EQUAL(c.type(2), "integer"); + + BOOST_CHECK_THROW(a.append(c), RadProto::Exception); + + BOOST_CHECK_THROW(a.name(2), std::out_of_range); + BOOST_CHECK_THROW(a.type(2), std::out_of_range); + + +// 2. codes ==, names !=, types == + + RadProto::BasicDictionary d; + + d.add(1, "abc", "string"); + + BOOST_CHECK_EQUAL(d.name(1), "abc"); + BOOST_CHECK_EQUAL(d.type(1), "string"); + BOOST_CHECK_EQUAL(d.code("abc"), 1); + BOOST_CHECK_EQUAL(d.type("abc"), "string"); + + RadProto::BasicDictionary e; + + e.add(1, "bcd", "string"); + + BOOST_CHECK_EQUAL(e.name(1), "bcd"); + BOOST_CHECK_EQUAL(e.type(1), "string"); + BOOST_CHECK_EQUAL(e.code("bcd"), 1); + BOOST_CHECK_EQUAL(e.type("bcd"), "string"); + + d.append(e); + + BOOST_CHECK_EQUAL(d.name(1), "bcd"); + BOOST_CHECK_EQUAL(d.type(1), "string"); + BOOST_CHECK_EQUAL(d.code("abc"), 1); + BOOST_CHECK_EQUAL(d.code("bcd"), 1); + BOOST_CHECK_EQUAL(d.type("abc"), "string"); + BOOST_CHECK_EQUAL(d.type("bcd"), "string"); + +// 2.1. codes ==, names !=, types != + + RadProto::BasicDictionary f; + + f.add(1, "abc", "string"); + + BOOST_CHECK_EQUAL(f.name(1), "abc"); + BOOST_CHECK_EQUAL(f.type(1), "string"); + BOOST_CHECK_EQUAL(f.code("abc"), 1); + BOOST_CHECK_EQUAL(f.type("abc"), "string"); + + RadProto::BasicDictionary g; + + g.add(1, "bcd", "integer"); + + BOOST_CHECK_EQUAL(g.name(1), "bcd"); + BOOST_CHECK_EQUAL(g.type(1), "integer"); + BOOST_CHECK_EQUAL(g.code("bcd"), 1); + BOOST_CHECK_EQUAL(g.type("bcd"), "integer"); + + f.append(g); + + BOOST_CHECK_EQUAL(f.name(1), "bcd"); + BOOST_CHECK_EQUAL(f.type(1), "integer"); + BOOST_CHECK_EQUAL(f.code("abc"), 1); + BOOST_CHECK_EQUAL(f.code("bcd"), 1); + BOOST_CHECK_EQUAL(f.type("abc"), "string"); + BOOST_CHECK_EQUAL(f.type("bcd"), "integer"); + + +// 3. codes ==, names ==, types == + + RadProto::BasicDictionary h; + + h.add(1, "abc", "string"); + + BOOST_CHECK_EQUAL(h.name(1), "abc"); + BOOST_CHECK_EQUAL(h.type(1), "string"); + BOOST_CHECK_EQUAL(h.code("abc"), 1); + BOOST_CHECK_EQUAL(h.type("abc"), "string"); + + RadProto::BasicDictionary i; + + i.add(1, "abc", "string"); + + BOOST_CHECK_EQUAL(i.name(1), "abc"); + BOOST_CHECK_EQUAL(i.type(1), "string"); + BOOST_CHECK_EQUAL(i.code("abc"), 1); + BOOST_CHECK_EQUAL(i.type("abc"), "string"); + + h.append(i); + + BOOST_CHECK_EQUAL(h.name(1), "abc"); + BOOST_CHECK_EQUAL(h.type(1), "string"); + BOOST_CHECK_EQUAL(h.code("abc"), 1); + BOOST_CHECK_EQUAL(h.type("abc"), "string"); + +// 3.1 codes ==, names ==, types != + + RadProto::BasicDictionary j; + + j.add(1, "abc", "string"); + + BOOST_CHECK_EQUAL(j.name(1), "abc"); + BOOST_CHECK_EQUAL(j.type(1), "string"); + BOOST_CHECK_EQUAL(j.code("abc"), 1); + BOOST_CHECK_EQUAL(j.type("abc"), "string"); + + RadProto::BasicDictionary k; + + k.add(1, "abc", "integer"); + + BOOST_CHECK_EQUAL(k.name(1), "abc"); + BOOST_CHECK_EQUAL(k.type(1), "integer"); + BOOST_CHECK_EQUAL(k.code("abc"), 1); + BOOST_CHECK_EQUAL(k.type("abc"), "integer"); + + j.append(k); + + BOOST_CHECK_EQUAL(j.name(1), "abc"); + BOOST_CHECK_EQUAL(j.type(1), "integer"); + BOOST_CHECK_EQUAL(j.code("abc"), 1); + BOOST_CHECK_EQUAL(j.type("abc"), "integer"); } BOOST_AUTO_TEST_SUITE_END() @@ -657,6 +844,14 @@ BOOST_AUTO_TEST_CASE(TestAttributeCode) BOOST_CHECK_EQUAL(a.attributeCode("User-Password"), 2); } +BOOST_AUTO_TEST_CASE(TestAttributeType) +{ + RadProto::Dictionaries a("dictionary"); + + BOOST_CHECK_EQUAL(a.attributeType(1), "string"); + BOOST_CHECK_EQUAL(a.attributeType("User-Name"), "string"); +} + BOOST_AUTO_TEST_CASE(TestAttributeValueName) { RadProto::Dictionaries a("dictionary"); From bad45c1e246fc4fec42b57bef663699453bf805b Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Thu, 6 Nov 2025 16:48:30 +0200 Subject: [PATCH 34/44] Code changed to correctly fill the dictionaries and getting attribute types. --- src/dictionaries.cpp | 79 +++++++++++++++++++++++++------------------- 1 file changed, 45 insertions(+), 34 deletions(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 484ba75..d387e04 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -4,7 +4,6 @@ #include #include #include -#include using BasicDictionary = RadProto::BasicDictionary; @@ -30,27 +29,25 @@ std::string BasicDictionary::type(const std::string& name) const void BasicDictionary::add(uint32_t code, const std::string& name, const std::string& type) { + bool flag(false); for (const auto& entry: m_rightDict) { if (entry.second.first == name && entry.first != code) throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); if (entry.second.first == name && entry.first == code && entry.second.second != type) - throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with type " + entry.second.second); - - if (entry.second.first != name && entry.first == code && entry.second.second != type) - { - std::cout << "Basic add() name: " + name + " code: " + std::to_string(code) + " entry.type: " + type + "\n"; - throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name2 " + name + " already exists with type " + entry.second.second); - } + flag = true; } m_rightDict.insert_or_assign(code, std::make_pair(name, type)); + if (flag) + m_reverseDict.insert_or_assign(name, std::make_pair(code, type)); m_reverseDict.emplace(name, std::make_pair(code, type)); } void BasicDictionary::append(const BasicDictionary& basicDict) { + bool flag(false); for (const auto& entry: basicDict.m_rightDict) { @@ -62,23 +59,17 @@ void BasicDictionary::append(const BasicDictionary& basicDict) } if (entry.second.first == item.second.first && entry.first == item.first && entry.second.second != item.second.second) - { - throw Exception(Error::suchAttributeNameWithAnotherTypeAlreadyExists, "[BasicDictionary::append]. Attribute name " + entry.second.first + " already exists with type " + item.second.second); - } - - if (entry.second.first != item.second.first && entry.first == item.first && entry.second.second != item.second.second) - { - std::cout << "(name !=, code ==, type !=) entry.name: " + entry.second.first + " entry.code: " + std::to_string(entry.first) + " entry.type: " + entry.second.second + " item.name: " + item.second.first + " item.code: " + std::to_string(item.first) + " item.type:" + item. second.second + "\n"; - throw Exception(Error::suchAttributeNameWithAnotherTypeAlreadyExists, "[BasicDictionary::append]. Attribute name4 " + entry.second.first + " already exists with type " + item.second.second); - } + flag = true; } - - m_rightDict.insert_or_assign(entry.first, entry.second); } for (const auto& entry: basicDict.m_reverseDict) + { + if (flag) + m_reverseDict.insert_or_assign(entry.first, entry.second); m_reverseDict.emplace(entry.first, entry.second); + } } using VendorDictionary = RadProto::VendorDictionary; @@ -134,8 +125,10 @@ uint32_t DependentDictionary::code(const std::string& dependencyName, const std: void DependentDictionary::add(uint32_t code, const std::string& name, const std::string& dependencyName) { for (const auto& entry: m_rightDict) + { if (entry.second == name && entry.first.first == dependencyName && entry.first.second != code) throw Exception(Error::suchAttributeNameAlreadyExists, "[DependentDictionary::add]. Value name " + name + " of attribute " + dependencyName + " already exists with code " + std::to_string(entry.first.second)); + } m_rightDict.insert_or_assign(std::make_pair(dependencyName, code), name); m_reverseDict.emplace(std::make_pair(dependencyName, name), code); } @@ -179,37 +172,45 @@ Dictionaries::Dictionaries(const std::string& filePath) if (!tokens.empty()) { std::string attrName; + std::vector excludeAttrs; + if (tokens[0] == "ATTRIBUTE") { std::string::size_type n = tokens[2].find("."); if (n == std::string::npos) { const auto code = std::stoul(tokens[2]); - attrName = tokens[1]; const auto& attrType = tokens[3]; if (!vendorName.empty()) - { - std::cout << "VendorName: " + vendorName + " AttrName: " + attrName + " AttrCode: " + std::to_string(code) + "\n"; m_vendorAttributes.add(code, attrName, vendorName); - } else - { - std::cout << "AttrName: " + attrName + " AttrCode: " + std::to_string(code) + " AttrType: " + attrType + "\n"; m_attributes.add(code, attrName, attrType); - } } + else + excludeAttrs.push_back(tokens[1]); } - else if (tokens[0] == "VALUE" && !attrName.empty()) + else if (tokens[0] == "VALUE") { - const auto& attrNameVal = tokens[1]; - const auto& valueName = tokens[2]; - const auto valueCode = std::stoul(tokens[3]); - if (!vendorName.empty()) - m_vendorAttributeValues.add(valueCode, valueName, attrNameVal); - else - m_attributeValues.add(valueCode, valueName, attrNameVal); + bool flag(false); + if (!excludeAttrs.empty()) + { + for (const auto& name : excludeAttrs) + if (tokens[1] == name) + flag = true; + } + + if (!flag) + { + const auto& attrNameVal = tokens[1]; + const auto& valueName = tokens[2]; + const auto valueCode = std::stoul(tokens[3]); + if (!vendorName.empty()) + m_vendorAttributeValues.add(valueCode, valueName, attrNameVal); + else + m_attributeValues.add(valueCode, valueName, attrNameVal); + } } else if (tokens[0] == "VENDOR") m_vendorNames.add(std::stoul(tokens[2]), tokens[1]); @@ -247,6 +248,16 @@ uint32_t Dictionaries::attributeCode(const std::string& name) const return attributes().code(name); } +std::string Dictionaries::attributeType(uint32_t code) const +{ + return attributes().type(code); +} + +std::string Dictionaries::attributeType(const std::string name) const +{ + return attributes().type(name); +} + std::string Dictionaries::vendorName(uint32_t code) const { return vendorNames().name(code); From de23cf077fd31ac46e5496bfbe246e1520e90ae0 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 12 Nov 2025 14:28:39 +0200 Subject: [PATCH 35/44] The flag variable, emplace function call removed in the function add. --- src/dictionaries.cpp | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index d387e04..079f9a6 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -29,20 +29,15 @@ std::string BasicDictionary::type(const std::string& name) const void BasicDictionary::add(uint32_t code, const std::string& name, const std::string& type) { - bool flag(false); for (const auto& entry: m_rightDict) { if (entry.second.first == name && entry.first != code) throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); - if (entry.second.first == name && entry.first == code && entry.second.second != type) - flag = true; } m_rightDict.insert_or_assign(code, std::make_pair(name, type)); - if (flag) - m_reverseDict.insert_or_assign(name, std::make_pair(code, type)); - m_reverseDict.emplace(name, std::make_pair(code, type)); + m_reverseDict.insert_or_assign(name, std::make_pair(code, type)); } void BasicDictionary::append(const BasicDictionary& basicDict) From a9877fdcb1f059e4da654dc2026ad4f29c0cc659 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 12 Nov 2025 15:05:10 +0200 Subject: [PATCH 36/44] The flag variable added, check flag added, check if types are different added, the condition else added when flag is checked, function emplace added in function BasicDictionary::add. --- src/dictionaries.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 079f9a6..7f3bfba 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -29,15 +29,21 @@ std::string BasicDictionary::type(const std::string& name) const void BasicDictionary::add(uint32_t code, const std::string& name, const std::string& type) { + bool flag(false); for (const auto& entry: m_rightDict) { if (entry.second.first == name && entry.first != code) throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); + if (entry.second.first == name && entry.first == code && entry.second.second != type) + flag = true; } m_rightDict.insert_or_assign(code, std::make_pair(name, type)); - m_reverseDict.insert_or_assign(name, std::make_pair(code, type)); + if (flag) + m_reverseDict.insert_or_assign(name, std::make_pair(code, type)); + else + m_reverseDict.emplace(name, std::make_pair(code, type)); } void BasicDictionary::append(const BasicDictionary& basicDict) From ce989bf13e2eef5fa2ebdebcbdca8946634da4ef Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 12 Nov 2025 15:17:19 +0200 Subject: [PATCH 37/44] The flag variable initialization changed in function BasicDictionary::add. --- src/dictionaries.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 7f3bfba..5951b80 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -29,7 +29,7 @@ std::string BasicDictionary::type(const std::string& name) const void BasicDictionary::add(uint32_t code, const std::string& name, const std::string& type) { - bool flag(false); + bool flag = false; for (const auto& entry: m_rightDict) { if (entry.second.first == name && entry.first != code) From 4b7b07e485e47cc6a4af6505c90c8fda017b17ef Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 12 Nov 2025 15:25:21 +0200 Subject: [PATCH 38/44] The flag variable initialization changed, the condition else added when flag is checked in function BasicDictionary::append. --- src/dictionaries.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 5951b80..07b075e 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -48,7 +48,7 @@ void BasicDictionary::add(uint32_t code, const std::string& name, const std::str void BasicDictionary::append(const BasicDictionary& basicDict) { - bool flag(false); + bool flag = false; for (const auto& entry: basicDict.m_rightDict) { @@ -69,7 +69,8 @@ void BasicDictionary::append(const BasicDictionary& basicDict) { if (flag) m_reverseDict.insert_or_assign(entry.first, entry.second); - m_reverseDict.emplace(entry.first, entry.second); + else + m_reverseDict.emplace(entry.first, entry.second); } } From e8a27eee1a93fbc7253959018bc04e33346dee90 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 12 Nov 2025 15:41:13 +0200 Subject: [PATCH 39/44] The flag variable initialization changed, break command added in cycle when vector excludeAttr is checked in constructor Dictionaries. --- src/dictionaries.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 07b075e..03cb29d 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -195,12 +195,15 @@ Dictionaries::Dictionaries(const std::string& filePath) } else if (tokens[0] == "VALUE") { - bool flag(false); + bool flag = false; if (!excludeAttrs.empty()) { for (const auto& name : excludeAttrs) if (tokens[1] == name) + { flag = true; + break; + } } if (!flag) From 7422054aadbe2c5f08bf5fb9fca887044091eb16 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Thu, 13 Nov 2025 14:42:48 +0200 Subject: [PATCH 40/44] Variable flag, function emplace call removed in functions BasicDictionary::add, BasicDictionary::append. --- src/dictionaries.cpp | 26 ++------------------------ 1 file changed, 2 insertions(+), 24 deletions(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 03cb29d..b3d4a1d 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -29,49 +29,27 @@ std::string BasicDictionary::type(const std::string& name) const void BasicDictionary::add(uint32_t code, const std::string& name, const std::string& type) { - bool flag = false; for (const auto& entry: m_rightDict) - { if (entry.second.first == name && entry.first != code) throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::add]. Attribute name " + name + " already exists with code " + std::to_string(entry.first)); - if (entry.second.first == name && entry.first == code && entry.second.second != type) - flag = true; - } - m_rightDict.insert_or_assign(code, std::make_pair(name, type)); - if (flag) - m_reverseDict.insert_or_assign(name, std::make_pair(code, type)); - else - m_reverseDict.emplace(name, std::make_pair(code, type)); + m_reverseDict.insert_or_assign(name, std::make_pair(code, type)); } void BasicDictionary::append(const BasicDictionary& basicDict) { - bool flag = false; for (const auto& entry: basicDict.m_rightDict) { - for (const auto& item: m_rightDict) - { if (entry.second.first == item.second.first && entry.first != item.first) - { throw Exception(Error::suchAttributeNameAlreadyExists, "[BasicDictionary::append]. Attribute name " + entry.second.first + " already exists with code " + std::to_string(item.first)); - } - if (entry.second.first == item.second.first && entry.first == item.first && entry.second.second != item.second.second) - flag = true; - } m_rightDict.insert_or_assign(entry.first, entry.second); } for (const auto& entry: basicDict.m_reverseDict) - { - if (flag) - m_reverseDict.insert_or_assign(entry.first, entry.second); - else - m_reverseDict.emplace(entry.first, entry.second); - } + m_reverseDict.insert_or_assign(entry.first, entry.second); } using VendorDictionary = RadProto::VendorDictionary; From 4141211d71631cafc6d631ec63f735f82d72b7e8 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 19 Nov 2025 16:04:02 +0200 Subject: [PATCH 41/44] Code for determining the attribute type when the flag is set added to constructor Dictionaries. --- src/dictionaries.cpp | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index b3d4a1d..86f13f1 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -152,6 +152,7 @@ Dictionaries::Dictionaries(const std::string& filePath) if (!tokens.empty()) { std::string attrName; + std::string attrType; std::vector excludeAttrs; if (tokens[0] == "ATTRIBUTE") @@ -161,7 +162,16 @@ Dictionaries::Dictionaries(const std::string& filePath) { const auto code = std::stoul(tokens[2]); attrName = tokens[1]; - const auto& attrType = tokens[3]; + + if (tokens.size() == 5) + { + if (tokens[4] == "encrypt=1") + attrType = "encrypted"; + else + attrType = "bytes"; + } + else + attrType = tokens[3]; if (!vendorName.empty()) m_vendorAttributes.add(code, attrName, vendorName); From a12acfce5569d04394d4a6a21e8670b88793ef76 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 19 Nov 2025 16:12:09 +0200 Subject: [PATCH 42/44] Code for checking the attribute type when the flag is set added to test case TestAttributeType of test suite DictionariesTests. --- tests/dictionaries_tests.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/tests/dictionaries_tests.cpp b/tests/dictionaries_tests.cpp index e34b9a6..9eba074 100644 --- a/tests/dictionaries_tests.cpp +++ b/tests/dictionaries_tests.cpp @@ -850,6 +850,16 @@ BOOST_AUTO_TEST_CASE(TestAttributeType) BOOST_CHECK_EQUAL(a.attributeType(1), "string"); BOOST_CHECK_EQUAL(a.attributeType("User-Name"), "string"); + +// flag = "encypt=1" + + BOOST_CHECK_EQUAL(a.attributeType(2), "encrypted"); + BOOST_CHECK_EQUAL(a.attributeType("User-Password"), "encrypted"); + +// flag = "def=2" + + BOOST_CHECK_EQUAL(a.attributeType(7), "bytes"); + BOOST_CHECK_EQUAL(a.attributeType("abc"), "bytes"); } BOOST_AUTO_TEST_CASE(TestAttributeValueName) From c988a0464d7c411e1cd190d84d774d4210fd3d84 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Wed, 19 Nov 2025 16:19:56 +0200 Subject: [PATCH 43/44] Attribute User-Password changed, attribute abc added for checking the attribute type when the flag is set, added to test case TestAttributeType of test suite DictionariesTests. --- tests/dictionary.1 | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/tests/dictionary.1 b/tests/dictionary.1 index 20220b7..2f768a5 100644 --- a/tests/dictionary.1 +++ b/tests/dictionary.1 @@ -1,6 +1,7 @@ ATTRIBUTE User-Name 1 string -ATTRIBUTE User-Password 2 encrypted +ATTRIBUTE User-Password 2 string encrypt=1 ATTRIBUTE Service-Type 6 integer +ATTRIBUTE abc 7 string def=2 VALUE Service-Type Login-User 1 VALUE Service-Type Framed-User 2 From 4187f1037bf7c3bd9a8cf209d37eca79e2154931 Mon Sep 17 00:00:00 2001 From: Elena Mamontova Date: Fri, 21 Nov 2025 15:04:28 +0200 Subject: [PATCH 44/44] The attrName, attrType variables declaration moved to constructin if below in conctructor Dictionaries. --- src/dictionaries.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/dictionaries.cpp b/src/dictionaries.cpp index 86f13f1..4b772a2 100644 --- a/src/dictionaries.cpp +++ b/src/dictionaries.cpp @@ -151,8 +151,6 @@ Dictionaries::Dictionaries(const std::string& filePath) if (!tokens.empty()) { - std::string attrName; - std::string attrType; std::vector excludeAttrs; if (tokens[0] == "ATTRIBUTE") @@ -160,6 +158,8 @@ Dictionaries::Dictionaries(const std::string& filePath) std::string::size_type n = tokens[2].find("."); if (n == std::string::npos) { + std::string attrName; + std::string attrType; const auto code = std::stoul(tokens[2]); attrName = tokens[1];