pythonfmu3 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.cpp

@@ -285,13 +285,16 @@ void PySlaveInstance::SetFloat64(const cppfmu::FMIValueReference* vr, std::size_
     });
 }
 
-void PySlaveInstance::SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* values)
+void PySlaveInstance::SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
-        PyObject* refs = PyList_New(nvr);
+        PyObject* refs = PyList_New(nValues);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, Py_BuildValue("i", values[i]));
         }
 
@@ -306,13 +309,15 @@ void PySlaveInstance::SetInt32(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* values)
+void PySlaveInstance::SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
-        PyObject* refs = PyList_New(nvr);
+        PyObject* refs = PyList_New(nValues);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, Py_BuildValue("L", values[i]));
         }
 
@@ -327,13 +332,15 @@ void PySlaveInstance::SetInt64(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* values)
+void PySlaveInstance::SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
-        PyObject* refs = PyList_New(nvr);
+        PyObject* refs = PyList_New(nValues);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, Py_BuildValue("K", values[i]));
         }
 
@@ -348,13 +355,15 @@ void PySlaveInstance::SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* values)
+void PySlaveInstance::SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
-        PyObject* refs = PyList_New(nvr);
+        PyObject* refs = PyList_New(nValues);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, PyBool_FromLong(values[i]));
         }
 
@@ -369,13 +378,15 @@ void PySlaveInstance::SetBoolean(const cppfmu::FMIValueReference* vr, std::size_
     });
 }
 
-void PySlaveInstance::SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* values)
+void PySlaveInstance::SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* values, std::size_t nValues)
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         PyObject* refs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
+        }
+        for (int i = 0; i < nValues; i++) {
             PyList_SetItem(refs, i, Py_BuildValue("s", values[i]));
         }
 
@@ -413,9 +424,9 @@ void PySlaveInstance::GetFloat64(const cppfmu::FMIValueReference* vr, std::size_
     });
 }
 
-void PySlaveInstance::GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* values) const
+void PySlaveInstance::GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
@@ -426,7 +437,7 @@ void PySlaveInstance::GetInt32(const cppfmu::FMIValueReference* vr, std::size_t
             handle_py_exception("[getInt32] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* value = PyList_GetItem(refs, i);
             values[i] = static_cast<cppfmu::FMIInt32>(PyLong_AsLong(value));
         }
@@ -435,9 +446,9 @@ void PySlaveInstance::GetInt32(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* values) const
+void PySlaveInstance::GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
@@ -448,7 +459,7 @@ void PySlaveInstance::GetInt64(const cppfmu::FMIValueReference* vr, std::size_t
             handle_py_exception("[getInt64] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* value = PyList_GetItem(refs, i);
             values[i] = static_cast<cppfmu::FMIInt64>(PyLong_AsLongLong(value));
         }
@@ -457,9 +468,9 @@ void PySlaveInstance::GetInt64(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* values) const
+void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
@@ -470,7 +481,7 @@ void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t
             handle_py_exception("[getUInt64] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* item = PyList_GetItem(refs, i);
             PyObject* value = PyObject_GetAttrString(item, "value");
             if (value && PyLong_Check(value))
@@ -484,9 +495,9 @@ void PySlaveInstance::GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t
     });
 }
 
-void PySlaveInstance::GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* values) const
+void PySlaveInstance::GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
             PyList_SetItem(vrs, i, Py_BuildValue("i", vr[i]));
@@ -497,7 +508,7 @@ void PySlaveInstance::GetBoolean(const cppfmu::FMIValueReference* vr, std::size_
             handle_py_exception("[getBoolean] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* value = PyList_GetItem(refs, i);
             values[i] = PyObject_IsTrue(value);
         }
@@ -506,9 +517,9 @@ void PySlaveInstance::GetBoolean(const cppfmu::FMIValueReference* vr, std::size_
     });
 }
 
-void PySlaveInstance::GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* values) const
+void PySlaveInstance::GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* values, std::size_t nValues) const
 {
-    py_safe_run([this, &vr, nvr, &values](PyGILState_STATE gilState) {
+    py_safe_run([this, &vr, nvr, &values, nValues](PyGILState_STATE gilState) {
         clearStrBuffer();
         PyObject* vrs = PyList_New(nvr);
         for (int i = 0; i < nvr; i++) {
@@ -520,7 +531,7 @@ void PySlaveInstance::GetString(const cppfmu::FMIValueReference* vr, std::size_t
             handle_py_exception("[getString] PyObject_CallMethod", gilState);
         }
 
-        for (int i = 0; i < nvr; i++) {
+        for (int i = 0; i < nValues; i++) {
             PyObject* value = PyUnicode_AsEncodedString(PyList_GetItem(refs, i), "utf-8", nullptr);
             values[i] = PyBytes_AsString(value);
             strBuffer.emplace_back(value);

pythonfmu3/pythonfmu-export/src/pythonfmu/PySlaveInstance.hpp

@@ -34,18 +34,18 @@ public:
         cppfmu::FMIFloat64& endOfStep) override;
 
     void SetFloat64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIFloat64* value, std::size_t nValues) override;
-    void SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* value) override;
-    void SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* value) override;
-    void SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* value) override;
-    void SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* value) override;
-    void SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* value) override;
+    void SetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt32* value, std::size_t nValues) override;
+    void SetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIInt64* value, std::size_t nValues) override;
+    void SetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIUInt64* value, std::size_t nValues) override;
+    void SetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, const cppfmu::FMIBoolean* value, std::size_t nValues) override;
+    void SetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString const* value, std::size_t nValues) override;
 
     void GetFloat64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIFloat64* value, std::size_t nValues) const override;
-    void GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* value) const override;
-    void GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* value) const override;
-    void GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* value) const override;
-    void GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* value) const override;
-    void GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* value) const override;
+    void GetInt32(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt32* value, std::size_t nValues) const override;
+    void GetInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIInt64* value, std::size_t nValues) const override;
+    void GetUInt64(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIUInt64* value, std::size_t nValues) const override;
+    void GetBoolean(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIBoolean* value, std::size_t nValues) const override;
+    void GetString(const cppfmu::FMIValueReference* vr, std::size_t nvr, cppfmu::FMIString* value, std::size_t nValues) const override;
 
     void GetFMUstate(fmi3FMUState& State) override;
     void SetFMUstate(const fmi3FMUState& State) override;

pythonfmu3/tests/slaves/pythonslave_arraytypes.py

@@ -0,0 +1,80 @@
+
+from pythonfmu3 import Fmi3Causality, Fmi3Variability, Dimension, Fmi3Slave, Fmi3Status, Float64, Int32, Int64, UInt64, String, Boolean
+
+import numpy as np
+
+SIZE = 10
+
+TYPES = [UInt64, Float64, Boolean, Int32, Int64]
+CAUSALITY = [Fmi3Causality.output, Fmi3Causality.input]
+
+TYPE_MAP = {
+    UInt64: np.uint64,
+    Float64: np.float64,
+    Int32: np.int32,
+    Int64: np.int64,
+    Boolean: bool
+}
+
+def var_names(var_type, causality):
+    return f"{var_type.__name__.lower()}_{causality.name.lower()}"
+
+
+def init_var(var_type, causality, array=True):
+    if array:
+        return np.zeros(SIZE, dtype=TYPE_MAP[var_type])
+    else:
+        return TYPE_MAP[var_type]()
+
+
+def create_vars(self):
+    dimensions = [Dimension(start=str(SIZE))]
+    for var_type in TYPES:
+      for causality in CAUSALITY:
+        name = var_names(var_type, causality)
+        if var_type == Float64:
+            var = var_type(name, causality=causality, variability=Fmi3Variability.continuous, dimensions=dimensions)
+        else:
+            var = var_type(name, causality=causality, variability=Fmi3Variability.discrete, dimensions=dimensions)
+        setattr(self, name, init_var(var_type, causality))
+        self.register_variable(var)
+
+
+def generate_data(self):
+    for var_type in TYPES:
+      causality = Fmi3Causality.output
+      name = var_names(var_type, causality)
+      var = getattr(self, name)
+      if var_type == Boolean:
+          data = [False, True, False, True, True, False, False, True, False, True]
+          setattr(self, name, np.array(data).astype(bool))
+      elif var_type == Int32 or var_type == Int64 or var_type == UInt64:
+          data = [1,2,3,4,5,6,7,8,9,10]
+          setattr(self, name, np.array(data).astype(TYPE_MAP[var_type]))
+      else:
+          data = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
+          setattr(self, name, np.array(data).astype(TYPE_MAP[var_type]))
+
+class ArrayTypes(Fmi3Slave):
+  
+
+  def __init__(self, **kwargs):
+      super().__init__(**kwargs)
+
+      self.author = "Tester"
+      self.description = "FMU with all basic types as arrays"
+
+      self.time = 0.0
+
+      self.register_variable(Float64("time", causality=Fmi3Causality.independent, variability=Fmi3Variability.continuous))
+      
+      create_vars(self)
+
+      generate_data(self)
+      
+
+  def do_step(self, current_time: float, step_size: float) -> Fmi3Status:
+      generate_data(self)
+      return True
+
+      

pythonfmu3/tests/test_docs.py

@@ -0,0 +1,98 @@
+import pytest
+import pathlib
+import re
+import tempfile
+
+def extract_python_code_from_md(md_file):
+    """Extract Python code blocks from markdown, excluding skip blocks"""
+    content = pathlib.Path(md_file).read_text()
+    
+    # Find all python code blocks that aren't marked as skip
+    python_blocks = []
+    
+    # Pattern to match python blocks but not python skip
+    pattern = r'```python(?!\s+skip)(?:[^\n]*)\n(.*?)\n```'
+    matches = re.findall(pattern, content, re.DOTALL)
+    
+    for match in matches:
+        # Skip blocks that are wrapped in skip-test comments
+        if '<!-- skip-test -->' not in content.split(match)[0][-100:]:
+            python_blocks.append(match)
+    
+    return python_blocks
+
+@pytest.mark.doc
+def test_readme():
+    test_dir = pathlib.Path(__file__).parent
+    fpath = test_dir.parent.parent / "README.md"
+    
+    # extract Python code
+    code_blocks = extract_python_code_from_md(fpath)
+
+    namespace = {}
+    exec("from pythonfmu3 import *", namespace)
+
+    for i, code in enumerate(code_blocks):
+        try:
+            exec(code, namespace)
+            print(f"✅ Code block {i+1} executed successfully")
+        except Exception as e:
+            pytest.fail(f"Code block {i+1} failed: {e}\nCode:\n{code}")
+    
+
+
+
+@pytest.mark.doc
+def test_cosimulation_examples():
+    """Test that all Python examples in usage.md actually work"""
+    test_dir = pathlib.Path(__file__).parent
+    usage_file = test_dir.parent.parent / "docs" / "usage.md"
+    
+    # Extract Python code
+    code_blocks = extract_python_code_from_md(usage_file)
+    
+    # Create a test namespace
+    namespace = {}
+    exec("from pythonfmu3 import *", namespace)
+    
+    # Execute each code block
+    for i, code in enumerate(code_blocks):
+        try:
+            exec(code, namespace)
+            print(f"✅ Code block {i+1} executed successfully")
+        except Exception as e:
+            pytest.fail(f"Code block {i+1} failed: {e}\nCode:\n{code}")
+            
+    assert 'LinearTransform' in namespace, "LinearTransform class not found"
+    assert 'PIDController' in namespace, "PIDController class not found"
+
+    # Test instantiation
+    lt = namespace['LinearTransform'](instance_name="test")
+    pc = namespace['PIDController'](instance_name="test")
+
+
+@pytest.mark.doc
+def test_model_exchange_examples():
+    """Test Model Exchange examples"""
+    test_dir = pathlib.Path(__file__).parent
+    mx_file = test_dir.parent.parent / "docs" / "usageMX.md"
+    
+    code_blocks = extract_python_code_from_md(mx_file)
+    
+    namespace = {}
+    exec("from pythonfmu3 import *", namespace)
+    
+    for i, code in enumerate(code_blocks):
+        try:
+            exec(code, namespace)
+        except Exception as e:
+            pytest.fail(f"MX Code block {i+1} failed: {e}")
+    
+    # Test that classes were actually created
+    assert 'VanDerPol' in namespace, "VanDerPol class not found"
+    assert 'BouncingBall' in namespace, "BouncingBall class not found"
+    
+    # Test instantiation
+    vdp = namespace['VanDerPol'](instance_name="test")
+    
+    bb = namespace['BouncingBall'](instance_name="test")

pythonfmu3/tests/test_integration.py

@@ -280,6 +280,57 @@ def test_integration_get(tmp_path):
     model.terminate()
     model.freeInstance()
 
+@pytest.mark.integration
+def test_integration_get_array(tmp_path):
+    script_file = Path(__file__).parent / "slaves/pythonslave_arraytypes.py"
+    fmu = FmuBuilder.build_FMU(script_file, dest=tmp_path, needsExecutionTool="false")
+    assert fmu.exists()
+
+    md = fmpy.read_model_description(fmu)
+    unzip_dir = fmpy.extract(fmu)
+
+    model = fmpy.fmi3.FMU3Slave(
+        guid=md.guid,
+        unzipDirectory=unzip_dir,
+        modelIdentifier=md.coSimulation.modelIdentifier,
+        instanceName='instance1')
+
+    model.instantiate()
+    model.enterInitializationMode()
+    model.exitInitializationMode()
+
+    to_test = {
+        "int32_output": [1,2,3,4,5,6,7,8,9,10],
+        "int64_output": [1,2,3,4,5,6,7,8,9,10],
+        "uint64_output": [1,2,3,4,5,6,7,8,9,10],
+        "float64_output": [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0],
+        "boolean_output": [False, True, False, True, True, False, False, True, False, True]
+    }
+
+    model_value = None
+    variables = mapped(md)
+    for key, value in to_test.items():
+        var = variables[key]
+        vrs = [var.valueReference]
+        if var.type == "Int32":
+            model_values = model.getInt32(vrs, nValues=10)
+        elif var.type == "Int64":
+            model_values = model.getInt64(vrs, nValues=10)
+        elif var.type == "UInt64":
+            model_values = model.getUInt64(vrs, nValues=10)
+        elif var.type == "Float64":
+            model_values = model.getFloat64(vrs, nValues=10)
+        elif var.type == "Boolean":
+            model_values = model.getBoolean(vrs, nValues=10)
+        else:
+            pytest.xfail("Unsupported type")
+
+        assert len(model_values) == len(value)
+        assert model_values == value
+        
+    model.terminate()
+    model.freeInstance()
+
 
 @pytest.mark.integration
 def test_integration_read_from_file(tmp_path):
@@ -367,6 +418,61 @@ def test_integration_set(tmp_path):
     model.terminate()
     model.freeInstance()
 
+@pytest.mark.integration
+def test_integration_set_array(tmp_path):
+    script_file = Path(__file__).parent / "slaves/pythonslave_arraytypes.py"
+    fmu = FmuBuilder.build_FMU(script_file, dest=tmp_path, needsExecutionTool="false")
+    assert fmu.exists()
+
+    md = fmpy.read_model_description(fmu)
+    unzip_dir = fmpy.extract(fmu)
+
+    model = fmpy.fmi3.FMU3Slave(
+        guid=md.guid,
+        unzipDirectory=unzip_dir,
+        modelIdentifier=md.coSimulation.modelIdentifier,
+        instanceName='instance1')
+
+    model.instantiate()
+    model.enterInitializationMode()
+    model.exitInitializationMode()
+
+    to_test = {
+        "int32_input": [1,2,3,4,5,6,7,8,9,10],
+        "int64_input": [1,2,3,4,5,6,7,8,9,10],
+        "uint64_input": [1,2,3,4,5,6,7,8,9,10],
+        "float64_input": [1.0,2.0,3.0,4.0,5.0,6.0,7.0,8.0,9.0,10.0],
+        "boolean_input": [False, True, False, True, True, False, False, True, False, True]
+    }
+
+    model_value = None
+    variables = mapped(md)
+    for key, value in to_test.items():
+        var = variables[key]
+        vrs = [var.valueReference]
+        if var.type == "Int32":
+            model.setInt32(vrs, value)
+            model_value = model.getInt32(vrs, nValues=10)
+        elif var.type == "Int64":
+            model.setInt64(vrs, value)
+            model_value = model.getInt64(vrs, nValues=10)
+        elif var.type == "UInt64":
+            model.setUInt64(vrs, value)
+            model_value = model.getUInt64(vrs, nValues=10)
+        elif var.type == "Float64":
+            model.setFloat64(vrs, value)
+            model_value = model.getFloat64(vrs,nValues=10)
+        elif var.type == "Boolean":
+            model.setBoolean(vrs, value)
+            model_value = model.getBoolean(vrs, nValues=10)
+        else:
+            pytest.xfail("Unsupported type")
+        
+        assert list(model_value) == value
+
+    model.terminate()
+    model.freeInstance()
+
 
 @pytest.mark.integration
 def test_simple_integration_fmpy(tmp_path):