Add Field test

src/scratch/field.cpp

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 #include <scratchcpp/field.h>
+#include <scratchcpp/entity.h>
 
 #include "field_p.h"
 
@@ -58,6 +59,11 @@ std::shared_ptr<Entity> Field::valuePtr() const
 void Field::setValuePtr(const std::shared_ptr<Entity> &newValuePtr)
 {
     impl->valuePtr = newValuePtr;
+
+    if (newValuePtr)
+        impl->valueId = newValuePtr->id();
+    else
+        impl->valueId = "";
 }
 
 /*! Returns the ID of the value (e. g. a variable). */

src/scratch/field_p.cpp

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
+#include <scratchcpp/entity.h>
+
 #include "field_p.h"
 
 using namespace libscratchcpp;
@@ -9,6 +11,8 @@ FieldPrivate::FieldPrivate(const std::string &name, const Value &value, std::sha
     value(value),
     valuePtr(valuePtr)
 {
+    if (valuePtr)
+        valueId = valuePtr->id();
 }
 
 FieldPrivate::FieldPrivate(const std::string &name, const Value &value, const std::string &valueId) :

test/scratch_classes/CMakeLists.txt

@@ -137,3 +137,17 @@ target_link_libraries(
 )
 
 gtest_discover_tests(inputvalue_test)
+
+# field_test
+add_executable(
+  field_test
+  field_test.cpp
+)
+
+target_link_libraries(
+  field_test
+  GTest::gtest_main
+  scratchcpp
+)
+
+gtest_discover_tests(field_test)

test/scratch_classes/field_test.cpp

@@ -0,0 +1,81 @@
+#include <scratchcpp/field.h>
+#include <scratchcpp/broadcast.h>
+#include <scratchcpp/variable.h>
+#include <scratchcpp/list.h>
+
+#include "../common.h"
+
+using namespace libscratchcpp;
+
+class FieldTest : public testing::Test
+{
+    public:
+        void SetUp() override
+        {
+            m_broadcast = std::make_shared<Broadcast>("broadcast", "");
+            m_variable = std::make_shared<Variable>("variable", "");
+            m_list = std::make_shared<List>("list", "");
+        }
+
+        std::shared_ptr<Broadcast> m_broadcast;
+        std::shared_ptr<Variable> m_variable;
+        std::shared_ptr<List> m_list;
+};
+
+TEST_F(FieldTest, Constructors)
+{
+    Field field1("VARIABLE", "");
+    ASSERT_EQ(field1.name(), "VARIABLE");
+    ASSERT_EQ(field1.value().toString(), "");
+    ASSERT_EQ(field1.valuePtr(), nullptr);
+    ASSERT_EQ(field1.valueId(), "");
+
+    Field field2("VARIABLE", "variable1", m_variable);
+    ASSERT_EQ(field2.name(), "VARIABLE");
+    ASSERT_EQ(field2.value().toString(), "variable1");
+    ASSERT_EQ(field2.valuePtr(), m_variable);
+    ASSERT_EQ(field2.valueId(), "variable");
+
+    Field field3("LIST", "list1", std::string("list"));
+    ASSERT_EQ(field3.name(), "LIST");
+    ASSERT_EQ(field3.value().toString(), "list1");
+    ASSERT_EQ(field3.valuePtr(), nullptr);
+    ASSERT_EQ(field3.valueId(), "list");
+
+    Field field4("LIST", "list1", "list");
+    ASSERT_EQ(field4.name(), "LIST");
+    ASSERT_EQ(field4.value().toString(), "list1");
+    ASSERT_EQ(field4.valuePtr(), nullptr);
+    ASSERT_EQ(field4.valueId(), "list");
+}
+
+TEST_F(FieldTest, FieldId)
+{
+    Field field("", Value());
+    ASSERT_EQ(field.fieldId(), -1);
+
+    field.setFieldId(2);
+    ASSERT_EQ(field.fieldId(), 2);
+}
+
+TEST_F(FieldTest, ValuePtr)
+{
+    Field field("", Value());
+
+    field.setValuePtr(m_broadcast);
+    ASSERT_EQ(field.valuePtr(), m_broadcast);
+    ASSERT_EQ(field.valueId(), "broadcast");
+
+    field.setValuePtr(nullptr);
+    ASSERT_EQ(field.valuePtr(), nullptr);
+    ASSERT_EQ(field.valueId(), "");
+}
+
+TEST_F(FieldTest, SpecialValueId)
+{
+    Field field("", Value());
+    ASSERT_EQ(field.specialValueId(), -1);
+
+    field.setSpecialValueId(5);
+    ASSERT_EQ(field.specialValueId(), 5);
+}