Implement data_itemoflist

Author: adazem009

src/dev/blocks/listblocks.cpp

@@ -27,6 +27,7 @@ void ListBlocks::registerBlocks(IEngine *engine)
     engine->addCompileFunction(this, "data_deletealloflist", &compileDeleteAllOfList);
     engine->addCompileFunction(this, "data_insertatlist", &compileInsertAtList);
     engine->addCompileFunction(this, "data_replaceitemoflist", &compileReplaceItemOfList);
+    engine->addCompileFunction(this, "data_itemoflist", &compileItemOfList);
 }
 
 CompilerValue *ListBlocks::compileAddToList(Compiler *compiler)
@@ -150,3 +151,22 @@ CompilerValue *ListBlocks::compileReplaceItemOfList(Compiler *compiler)
 
     return nullptr;
 }
+
+CompilerValue *ListBlocks::compileItemOfList(Compiler *compiler)
+{
+    List *list = static_cast<List *>(compiler->field("LIST")->valuePtr().get());
+    assert(list);
+
+    if (list) {
+        CompilerValue *index = compiler->addInput("INDEX");
+        CompilerValue *min = compiler->addConstValue(-1);
+        CompilerValue *max = compiler->addListSize(list);
+        index = getListIndex(compiler, index, list, max);
+        index = compiler->createSub(index, compiler->addConstValue(1));
+        CompilerValue *cond = compiler->createAnd(compiler->createCmpGT(index, min), compiler->createCmpLT(index, max));
+        CompilerValue *item = compiler->addListItem(list, index);
+        return compiler->createSelect(cond, item, compiler->addConstValue(Value()), Compiler::StaticType::Unknown);
+    }
+
+    return nullptr;
+}

src/dev/blocks/listblocks.h

@@ -24,6 +24,7 @@ class ListBlocks : public IExtension
         static CompilerValue *compileDeleteAllOfList(Compiler *compiler);
         static CompilerValue *compileInsertAtList(Compiler *compiler);
         static CompilerValue *compileReplaceItemOfList(Compiler *compiler);
+        static CompilerValue *compileItemOfList(Compiler *compiler);
 };
 
 } // namespace libscratchcpp

test/dev/blocks/CMakeLists.txt

@@ -169,6 +169,7 @@ if (LIBSCRATCHCPP_ENABLE_LIST_BLOCKS)
       GTest::gmock_main
       scratchcpp
       scratchcpp_mocks
+      block_test_deps
     )
 
     gtest_discover_tests(list_blocks_test)

test/dev/blocks/list_blocks_test.cpp

@@ -5,12 +5,16 @@
 #include <scratchcpp/dev/test/scriptbuilder.h>
 #include <scratchcpp/script.h>
 #include <scratchcpp/thread.h>
+#include <scratchcpp/block.h>
+#include <scratchcpp/input.h>
+#include <scratchcpp/field.h>
 #include <scratchcpp/dev/executioncontext.h>
 #include <scratchcpp/dev/executablecode.h>
 #include <enginemock.h>
 #include <randomgeneratormock.h>
 
 #include "../common.h"
+#include "util.h"
 #include "dev/blocks/listblocks.h"
 
 using namespace libscratchcpp;
@@ -26,6 +30,7 @@ class ListBlocksTest : public testing::Test
             m_extension = std::make_unique<ListBlocks>();
             m_engine = m_project.engine().get();
             m_extension->registerBlocks(m_engine);
+            registerBlocks(m_engine, m_extension.get());
         }
 
         std::unique_ptr<IExtension> m_extension;
@@ -267,3 +272,67 @@ TEST_F(ListBlocksTest, ReplaceItemOfList)
     ASSERT_EQ(list1->toString(), "Lorem ipsum dolor sit -53.18");
     ASSERT_EQ(list2->toString(), "dolor world false ipsum abc lorem");
 }
+
+TEST_F(ListBlocksTest, ItemOfList)
+{
+    auto target = std::make_shared<Sprite>();
+
+    auto list = std::make_shared<List>("list", "");
+    list->append("Lorem");
+    list->append("ipsum");
+    list->append("dolor");
+    list->append(123);
+    list->append(true);
+    target->addList(list);
+
+    ScriptBuilder builder(m_extension.get(), m_engine, target);
+
+    auto addTest = [&builder](const Value &index, std::shared_ptr<List> list) {
+        builder.addBlock("test_const_string");
+        builder.addValueInput("STRING", index);
+        auto valueBlock = builder.takeBlock();
+
+        builder.addBlock("data_itemoflist");
+        builder.addObscuredInput("INDEX", valueBlock);
+        builder.addEntityField("LIST", list);
+        auto block = builder.takeBlock();
+
+        builder.addBlock("test_print");
+        builder.addObscuredInput("STRING", block);
+        return builder.currentBlock();
+    };
+
+    auto block = addTest(3, list);
+    addTest(5, list);
+    addTest(0, list);
+    addTest(6, list);
+
+    addTest("last", list);
+    addTest("random", list);
+    addTest("any", list);
+
+    builder.build();
+
+    Compiler compiler(&m_engineMock, target.get());
+    auto code = compiler.compile(block);
+    Script script(target.get(), block, &m_engineMock);
+    script.setCode(code);
+    Thread thread(target.get(), &m_engineMock, &script);
+    auto ctx = code->createExecutionContext(&thread);
+    ctx->setRng(&m_rng);
+
+    static const std::string expected =
+        "dolor\n"
+        "true\n"
+        "0\n"
+        "0\n"
+        "true\n"
+        "123\n"
+        "Lorem\n";
+
+    EXPECT_CALL(m_rng, randint(1, 5)).WillOnce(Return(4)).WillOnce(Return(1));
+    testing::internal::CaptureStdout();
+    code->run(ctx.get());
+    ASSERT_EQ(testing::internal::GetCapturedStdout(), expected);
+    ASSERT_EQ(list->toString(), "Lorem ipsum dolor 123 true");
+}

test/dev/blocks/util.cpp

@@ -35,6 +35,11 @@ void registerBlocks(IEngine *engine, IExtension *extension)
 
     engine->addCompileFunction(extension, "test_input", [](Compiler *compiler) -> CompilerValue * { return compiler->addInput("INPUT"); });
 
+    engine->addCompileFunction(extension, "test_const_string", [](Compiler *compiler) -> CompilerValue * {
+        auto input = compiler->addInput("STRING");
+        return compiler->addFunctionCall("test_const_string", Compiler::StaticType::String, { Compiler::StaticType::String }, { input });
+    });
+
     engine->addCompileFunction(extension, "test_set_var", [](Compiler *compiler) -> CompilerValue * {
         Variable *var = static_cast<Variable *>(compiler->field("VARIABLE")->valuePtr().get());
         compiler->createVariableWrite(var, compiler->addInput("VALUE"));
@@ -52,4 +57,11 @@ extern "C" bool test_condition()
     return conditionReturnValue;
 }
 
+extern "C" char *test_const_string(const char *str)
+{
+    char *ret = (char *)malloc((strlen(str) + 1) * sizeof(char));
+    strcpy(ret, str);
+    return ret;
+}
+
 } // namespace libscratchcpp