From 6c004d02947c7debde8e391fcd798e56d7025e47 Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Thu, 17 Aug 2023 11:11:19 +0200 Subject: [PATCH 1/7] InputValue: Automatically determine type of value pointer --- src/scratch/inputvalue.cpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/src/scratch/inputvalue.cpp b/src/scratch/inputvalue.cpp index 300b4d3c..0f3594ca 100644 --- a/src/scratch/inputvalue.cpp +++ b/src/scratch/inputvalue.cpp @@ -3,6 +3,9 @@ #include #include #include +#include +#include +#include #include #include "inputvalue_p.h" @@ -105,6 +108,17 @@ std::shared_ptr InputValue::valuePtr() const /*! Sets the value pointer. */ void InputValue::setValuePtr(const std::shared_ptr &newValuePtr) { + if (std::dynamic_pointer_cast(newValuePtr)) + setType(Type::Broadcast); + else if (std::dynamic_pointer_cast(newValuePtr)) + setType(Type::Variable); + else if (std::dynamic_pointer_cast(newValuePtr)) + setType(Type::List); + else { + impl->valuePtr = nullptr; + return; + } + impl->valuePtr = newValuePtr; } From 91da993fcdea240e8f1a234c66edac95fe9ebe41 Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Thu, 17 Aug 2023 11:45:49 +0200 Subject: [PATCH 2/7] InputValue: Determine ID from value pointer --- src/scratch/inputvalue.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/scratch/inputvalue.cpp b/src/scratch/inputvalue.cpp index 0f3594ca..4dc167c0 100644 --- a/src/scratch/inputvalue.cpp +++ b/src/scratch/inputvalue.cpp @@ -116,10 +116,12 @@ void InputValue::setValuePtr(const std::shared_ptr &newValuePtr) setType(Type::List); else { impl->valuePtr = nullptr; + impl->valueId = ""; return; } impl->valuePtr = newValuePtr; + impl->valueId = newValuePtr->id(); } /*! Returns the ID of the value. */ From f10056f5261fae14f0df3708c5882552e2f35478 Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Thu, 17 Aug 2023 11:50:09 +0200 Subject: [PATCH 3/7] InputValue: Add a warning for unsupported value type --- src/scratch/inputvalue.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/scratch/inputvalue.cpp b/src/scratch/inputvalue.cpp index 4dc167c0..cfc8c61d 100644 --- a/src/scratch/inputvalue.cpp +++ b/src/scratch/inputvalue.cpp @@ -7,6 +7,7 @@ #include #include #include +#include #include "inputvalue_p.h" @@ -117,6 +118,7 @@ void InputValue::setValuePtr(const std::shared_ptr &newValuePtr) else { impl->valuePtr = nullptr; impl->valueId = ""; + std::cout << "warning: unsupported input value type (use InputValue::setValueBlock() to set the block)" << std::endl; return; } From d54ccbce7e45b1c5a10f14d275297c24adb80f58 Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Thu, 17 Aug 2023 11:58:11 +0200 Subject: [PATCH 4/7] InputValue: Set block ID properly --- src/scratch/inputvalue.cpp | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/scratch/inputvalue.cpp b/src/scratch/inputvalue.cpp index cfc8c61d..49f683cd 100644 --- a/src/scratch/inputvalue.cpp +++ b/src/scratch/inputvalue.cpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include #include #include @@ -86,6 +86,11 @@ const std::shared_ptr &InputValue::valueBlock() const void InputValue::setValueBlock(const std::shared_ptr &newValueBlock) { impl->valueBlock = newValueBlock; + + if (newValueBlock) + impl->valueBlockId = newValueBlock->id(); + else + impl->valueBlockId = ""; } /*! Returns the ID of the block. \see valueBlock() */ @@ -98,6 +103,7 @@ const std::string &InputValue::valueBlockId() const void InputValue::setValueBlockId(const std::string &newValueBlockId) { impl->valueBlockId = newValueBlockId; + impl->valueBlock = nullptr; } /*! Returns a pointer to the value (e. g. a variable). */ From 7c94ced1f099388ba61cb0aea1da59f7b6d20290 Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Thu, 17 Aug 2023 12:14:01 +0200 Subject: [PATCH 5/7] Input: Change the order of calls to primary value InputValue::setValueBlockId() sets the block to nullptr, so ID must be set before the block. --- src/scratch/input.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/scratch/input.cpp b/src/scratch/input.cpp index b8dd7363..3563773b 100644 --- a/src/scratch/input.cpp +++ b/src/scratch/input.cpp @@ -91,6 +91,6 @@ void Input::setValueBlock(std::shared_ptr block) /*! Sets the ID of the value block. \see setValueBlock() */ void Input::setValueBlockId(const std::string &id) { - impl->primaryValue.setValueBlockId(id); impl->primaryValue.setValueBlock(nullptr); + impl->primaryValue.setValueBlockId(id); } From 50efa7d70fe3f19e68ed3709afe5d1fb45188b74 Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Thu, 17 Aug 2023 12:15:21 +0200 Subject: [PATCH 6/7] Add InputValue test --- test/scratch_classes/CMakeLists.txt | 14 +++ test/scratch_classes/inputvalue_test.cpp | 104 +++++++++++++++++++++++ 2 files changed, 118 insertions(+) create mode 100644 test/scratch_classes/inputvalue_test.cpp diff --git a/test/scratch_classes/CMakeLists.txt b/test/scratch_classes/CMakeLists.txt index ccc5b8b7..0c46daa4 100644 --- a/test/scratch_classes/CMakeLists.txt +++ b/test/scratch_classes/CMakeLists.txt @@ -123,3 +123,17 @@ target_link_libraries( ) gtest_discover_tests(input_test) + +# inputvalue_test +add_executable( + inputvalue_test + inputvalue_test.cpp +) + +target_link_libraries( + inputvalue_test + GTest::gtest_main + scratchcpp +) + +gtest_discover_tests(inputvalue_test) diff --git a/test/scratch_classes/inputvalue_test.cpp b/test/scratch_classes/inputvalue_test.cpp new file mode 100644 index 00000000..ec8da507 --- /dev/null +++ b/test/scratch_classes/inputvalue_test.cpp @@ -0,0 +1,104 @@ +#include +#include +#include +#include +#include + +#include "../common.h" + +using namespace libscratchcpp; + +TEST(InputValueTest, Constructors) +{ + InputValue value1; + ASSERT_EQ(value1.type(), InputValue::Type::Number); + + InputValue value2(InputValue::Type::String); + ASSERT_EQ(value2.type(), InputValue::Type::String); +} + +TEST(InputTest, Type) +{ + InputValue value; + + value.setType(InputValue::Type::Color); + ASSERT_EQ(value.type(), InputValue::Type::Color); +} + +TEST(InputTest, Value) +{ + InputValue value; + ASSERT_EQ(value.value(), Value()); + + value.setValue("test"); + ASSERT_EQ(value.value().toString(), "test"); +} + +TEST(InputTest, ValueBlock) +{ + InputValue value; + ASSERT_EQ(value.valueBlock(), nullptr); + ASSERT_EQ(value.valueBlockId(), ""); + + auto block = std::make_shared("abc", ""); + value.setValueBlock(block); + ASSERT_EQ(value.valueBlock(), block); + ASSERT_EQ(value.valueBlockId(), "abc"); + + value.setValueBlock(nullptr); + ASSERT_EQ(value.valueBlock(), nullptr); + ASSERT_EQ(value.valueBlockId(), ""); + + value.setValueBlockId("hello"); + ASSERT_EQ(value.valueBlockId(), "hello"); + ASSERT_EQ(value.valueBlock(), nullptr); +} + +TEST(InputTest, ValuePtr) +{ + InputValue value1; + ASSERT_EQ(value1.valuePtr(), nullptr); + ASSERT_EQ(value1.valueId(), ""); + + auto broadcast = std::make_shared("abc", ""); + value1.setValuePtr(broadcast); + ASSERT_EQ(value1.valuePtr(), broadcast); + ASSERT_EQ(value1.valueId(), "abc"); + ASSERT_EQ(value1.type(), InputValue::Type::Broadcast); + + auto variable = std::make_shared("def", ""); + value1.setValuePtr(variable); + ASSERT_EQ(value1.valuePtr(), variable); + ASSERT_EQ(value1.valueId(), "def"); + ASSERT_EQ(value1.type(), InputValue::Type::Variable); + + auto list = std::make_shared("ghi", ""); + value1.setValuePtr(list); + ASSERT_EQ(value1.valuePtr(), list); + ASSERT_EQ(value1.valueId(), "ghi"); + ASSERT_EQ(value1.type(), InputValue::Type::List); + + auto block = std::make_shared("jkl", ""); + value1.setValuePtr(block); + ASSERT_EQ(value1.valuePtr(), nullptr); + ASSERT_EQ(value1.valueId(), ""); + ASSERT_EQ(value1.type(), InputValue::Type::List); + + value1.setValuePtr(nullptr); + ASSERT_EQ(value1.valuePtr(), nullptr); + ASSERT_EQ(value1.valueId(), ""); + ASSERT_EQ(value1.type(), InputValue::Type::List); + + InputValue value2(InputValue::Type::Integer); + + value2.setValuePtr(block); + ASSERT_EQ(value2.valuePtr(), nullptr); + ASSERT_EQ(value1.valueId(), ""); + ASSERT_EQ(value2.type(), InputValue::Type::Integer); + + value2.setValuePtr(variable); + value2.setValueId("hello"); + ASSERT_EQ(value2.valuePtr(), nullptr); + ASSERT_EQ(value2.valueId(), "hello"); + ASSERT_EQ(value2.type(), InputValue::Type::Variable); +} From 092155bc3ccbb32003a135ebf9724f9483914d7e Mon Sep 17 00:00:00 2001 From: adazem009 <68537469+adazem009@users.noreply.github.com> Date: Thu, 17 Aug 2023 12:21:14 +0200 Subject: [PATCH 7/7] Add block null check test to Input test --- test/scratch_classes/input_test.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/test/scratch_classes/input_test.cpp b/test/scratch_classes/input_test.cpp index a52f2d0c..5c9d2b4b 100644 --- a/test/scratch_classes/input_test.cpp +++ b/test/scratch_classes/input_test.cpp @@ -58,4 +58,9 @@ TEST(InputTest, ValueBlock) input.setValueBlockId("hello"); ASSERT_EQ(input.valueBlockId(), "hello"); ASSERT_EQ(input.valueBlock(), nullptr); + + input.setValueBlock(block); + input.setValueBlock(nullptr); + ASSERT_EQ(input.valueBlock(), nullptr); + ASSERT_EQ(input.valueBlockId(), ""); }