fmu-manipulation-toolbox 1.9rc6__tar.gz → 1.9rc8__tar.gz

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.9rc6
+Version: 1.9rc8
 Summary: FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units (FMUs) without recompilation or bundling them into FMU Containers
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/README.md

@@ -1,12 +1,23 @@
-![Title](fmu_manipulation_toolbox/resources/fmu_manipulation_toolbox.png)
+![](fmu_manipulation_toolbox/resources/fmu_manipulation_toolbox.png)
 
-FMU Manipulation Toolbox is a python package which help to analyse and modify a [Functional Mock-up Units (FMUs)](http://fmi-standard.org/)
-without recompilation. It is highly customizable. It can even modify the `modelDescription.xml` file.
+FMU Manipulation Toolbox is a python package which help to analyse, modify or combine
+[Functional Mock-up Units (FMUs)](http://fmi-standard.org/) without recompilation. It is highly customizable as it comes with
+a Python API.
 
-Manipulating the `modelDescription.xml` can be a dangerous thing! Communicating with the FMU-developer and adapting
-the way the FMU is generated, is preferable when possible.
+FMU Manipulation Toolbox can be used in different ways :
+- Using a Graphical User Interface: suitable for end user
+- Using a Command Line Interface: useful in 
+- Using a python API: the most efficient for automation (CI/CD, transformation scripts, ...)
 
-FMU Manipulation Toolbox also allows to group FMU's inside FMU Containers. (see [doc/container.md](doc/container.md))
+Major features:
+- Analyse FMU content: list ports and their attributes, check compliance of `ModelDescription.xml` with XSD, ...
+- Alter FMU by modifying its `modelDescription.xml` file. NOTE: manipulating this file can be a dangerous
+  thing! Communicating with the FMU-developer and adapting the way the FMU is generated is preferable when
+  possible.
+- Add binary interface. Typical use case is porting a 32bits FMUs to 64bits (or vice et versa). 
+- Nest FMUs in a [FMU Container](doc/container.md)
+
+FMI versions 2.0 and 3.0 are supported.
 
 ## Installation
 
@@ -17,29 +28,39 @@ Two options available to install FMU Manipulation Toolbox:
 - Compile and install from [github repository](https://github.com/grouperenault/fmu_manipulation_toolbox). You will need 
   - Python required packages. See [`requirements.txt`](requirements.txt).
   - C compiler (C99 or later)
-  - CMake (>= 3.16)
+  - CMake (>= 3.20)
+
 
 ### Supported platforms
-FMU Manipulation Toolbox is tested on:
-- Windows 10/11
+
+FMU Manipulation Toolbox is packaged for:
+- Windows 10/11 (primary platform)
 - Linux (Ubuntu 22.04)
+- Darwin
 
-Compilation is reported to work on:
-- MacOS (Apple Silicon and Intel)
 
 ## Graphical User Interface
 
-FMU Manipulation Toolbox is released with a GUI. You can launch it with the following command `fmutool`
-(without any option)
+FMU Manipulation Toolbox is released with a GUI. You can launch it with the following command `fmutool-gui`
 
 ![GUI](doc/gui.png "GUI")
 
+Button colors descriptions:
+- red: remove information from the `modelDescription.xml`
+- orange: alter `modelDescription.xml`
+- green: add component into the FMU or check it
+- violet: extract and save
+- blue: filter actions scope or exit
+
+**Original FMU is never modified**. Use `Save` button to get modified copy of the original FMU.
+
 
 ## Command Line Interface
 
 FMU Manipulation Toolbox comes with 2 commands:
 - `fmutool`: a versatile analysis and manipulation tool for FMU.
-- `fmucontainer`: group FMU's inside FMU Containers. (see [container/README.md](container/README.md))
+- `fmucontainer`: group FMUs inside FMU Containers. (see [container/README.md](container/README.md))
+- `fmusplit: to extract FMUs from a FMU Container.
 
 
 ### Analysis and Manipulation tool:
@@ -163,14 +184,13 @@ You can write your own FMU Manipulation scripts. Once you downloaded fmutool mod
 adding the `import` statement lets you access the API :
 
 ```python
-from fmu_manipulation_toolbox.operations import FMU, OperationExtractNames, OperationStripTopLevel,
-
-OperationRenameFromCSV
+from fmu_manipulation_toolbox.operations import ...
 ```
 
+
 ### remove toplevel bus (if any)
 
-Give a FMU with the following I/O structure
+Given a FMU with the following I/O structure
 ```
 ├── Parameters
 │   ├── Foo
@@ -194,6 +214,8 @@ The following transformation will lead into:
 
 The following code will do this transformation: 
 ```python
+from fmu_manipulation_toolbox.operations import FMU, OperationStripTopLevel
+
 fmu = FMU(r"bouncing_ball.fmu")
 operation = OperationStripTopLevel()
 fmu.apply_operation(operation)
@@ -205,8 +227,10 @@ fmu.repack(r"bouncing_ball-modified.fmu")
 The following code will dump all FMU's Scalars names into a CSV:
 
 ```python
+from fmu_manipulation_toolbox.operations import FMU, OperationSaveNamesToCSV
+
 fmu = FMU(r"bouncing_ball.fmu")
-operation = OperationExtractNames()
+operation = OperationSaveNamesToCSV()
 fmu.apply_operation(operation)
 operation.write_csv(r"bouncing_ball.csv")
 ```
@@ -224,15 +248,20 @@ g;g;4;parameter;fixed
 e;e;5;parameter;tunable
 ```
 
+
 ### Read CSV and rename FMU ports
 
-CSV file should contain- 2 columns:
+CSV file should contain 2 columns:
 1. the current name
 2. the new name
 
 ```python
+from fmu_manipulation_toolbox.operations import FMU, OperationRenameFromCSV
+
 fmu = FMU(r"bouncing_ball.fmu")
 operation = OperationRenameFromCSV(r"bouncing_ball-modified.csv")
 fmu.apply_operation(operation)
 fmu.repack(r"bouncing_ball-renamed.fmu")
 ```
+
+More operations exist in [`Operation.py`](fmu_manipulation_toolbox/operations.py)

fmu_manipulation_toolbox-1.9rc8/fmu_manipulation_toolbox/__version__.py

@@ -0,0 +1 @@
+'V1.9-rc8'

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/fmu_manipulation_toolbox/cli/fmucontainer.py

@@ -1,6 +1,8 @@
 import argparse
 import logging
+import sys
 
+from typing import *
 from pathlib import Path
 
 from .utils import setup_logger, make_wide
@@ -9,7 +11,7 @@ from ..container import FMUContainerError
 from ..version import __version__ as version
 
 
-def fmucontainer():
+def fmucontainer(command_options: Sequence[str]):
     logger = setup_logger()
 
     logger.info(f"FMUContainer version {version}")
@@ -63,7 +65,7 @@ def fmucontainer():
     parser.add_argument("-dump-json",  action="store_true", dest="dump", default=False,
                         help="Dump a JSON file for each container.")
 
-    config = parser.parse_args()
+    config = parser.parse_args(command_options)
 
     if config.debug:
         logger.setLevel(logging.DEBUG)
@@ -88,16 +90,16 @@ def fmucontainer():
                                 auto_parameter=config.auto_parameter)
         except FileNotFoundError as e:
             logger.fatal(f"Cannot read file: {e}")
-            continue
+            sys.exit(-1)
         except (FMUContainerError, AssemblyError) as e:
             logger.fatal(f"{filename}: {e}")
-            continue
+            sys.exit(-2)
 
         try:
             assembly.make_fmu(dump_json=config.dump, fmi_version=int(config.fmi_version))
         except FMUContainerError as e:
             logger.fatal(f"{filename}: {e}")
-            continue
+            sys.exit(-3)
 
 if __name__ == "__main__":
-    fmucontainer()
+    fmucontainer(sys.argv[1:])

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/fmu_manipulation_toolbox/cli/fmusplit.py

@@ -1,12 +1,15 @@
 import argparse
 import logging
+import sys
+
+from typing import *
 
 from .utils import setup_logger, make_wide
 from ..split import FMUSplitter, FMUSplitterError
 from ..version import __version__ as version
 
 
-def fmusplit():
+def fmusplit(command_options: Sequence[str]):
     logger = setup_logger()
 
     logger.info(f"FMUSplit version {version}")
@@ -24,7 +27,7 @@ def fmusplit():
                         metavar="filename.fmu", required=True,
                         help="Description of the FMU container to split.")
 
-    config = parser.parse_args()
+    config = parser.parse_args(command_options)
 
     if config.debug:
         logger.setLevel(logging.DEBUG)
@@ -35,11 +38,11 @@ def fmusplit():
             splitter.split_fmu()
         except FMUSplitterError as e:
             logger.fatal(f"{fmu_filename}: {e}")
-            continue
+            sys.exit(-1)
         except FileNotFoundError as e:
             logger.fatal(f"Cannot read file: {e}")
-            continue
+            sys.exit(-2)
 
 
 if __name__ == "__main__":
-    fmusplit()
+    fmusplit(sys.argv[1:])

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/fmu_manipulation_toolbox/cli/fmutool.py

@@ -1,6 +1,8 @@
 import argparse
 import sys
 
+from typing import *
+
 from .utils import setup_logger, make_wide
 from ..operations import (OperationSummary, OperationError, OperationRemoveRegexp,
                           OperationRemoveSources, OperationTrimUntil, OperationKeepOnlyRegexp, OperationMergeTopLevel,
@@ -12,7 +14,7 @@ from ..version import __version__ as version
 from ..help import Help
 
 
-def fmutool():
+def fmutool(command_options: Sequence[str]):
     logger = setup_logger()
 
     logger.info(f"FMU Manipulation Toolbox version {version}")
@@ -68,7 +70,7 @@ def fmutool():
     add_option('-summary', action='append_const', dest='operations_list', const=OperationSummary())
     add_option('-check', action='append_const', dest='operations_list', const=[checker() for checker in checker_list])
 
-    cli_options = parser.parse_args()
+    cli_options = parser.parse_args(command_options)
     # handle the "no operation" use case
     if not cli_options.operations_list:
         cli_options.operations_list = []
@@ -89,7 +91,16 @@ def fmutool():
         for causality in cli_options.apply_on:
             logger.info(f"     - causality = {causality}")
 
-    for operation in cli_options.operations_list:
+    # Checker operations are added as a list into operations_list
+    def operation_iterator():
+        for op in cli_options.operations_list:
+            if isinstance(op, list):
+                for sub_op in op:
+                    yield sub_op
+            else:
+                yield op
+
+    for operation in operation_iterator():
         logger.info(f"     => {operation}")
         try:
             fmu.apply_operation(operation, cli_options.apply_on)
@@ -112,4 +123,4 @@ def fmutool():
         logger.info(f"INFO    Modified FMU is not saved. If necessary use '-output' option.")
 
 if __name__ == "__main__":
-    fmutool()
+    fmutool(sys.argv[1:])

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/fmu_manipulation_toolbox/container.py

@@ -796,23 +796,26 @@ class FMUContainer:
     def make_fmu_xml_epilog_2(self, xml_file, index_offset):
         xml_file.write("  </ModelVariables>\n"
                        "\n"
-                       "  <ModelStructure>\n"
-                       "    <Outputs>\n")
+                       "  <ModelStructure>\n")
 
-        index = index_offset
-        for output in self.outputs.values():
-            if output.port.type_name in EmbeddedFMUPort.CONTAINER_TO_FMI[2]:
-                print(f'      <Unknown index="{index}"/>', file=xml_file)
-                index += 1
-        xml_file.write("    </Outputs>\n"
-                       "    <InitialUnknowns>\n")
-        index = index_offset
-        for output in self.outputs.values():
-            if output.port.type_name in EmbeddedFMUPort.CONTAINER_TO_FMI[2]:
-                print(f'      <Unknown index="{index}"/>', file=xml_file)
-                index += 1
-        xml_file.write("    </InitialUnknowns>\n"
-                       "  </ModelStructure>\n"
+
+        if self.outputs:
+            xml_file.write("    <Outputs>\n")
+            index = index_offset
+            for output in self.outputs.values():
+                if output.port.type_name in EmbeddedFMUPort.CONTAINER_TO_FMI[2]:
+                    print(f'      <Unknown index="{index}"/>', file=xml_file)
+                    index += 1
+            xml_file.write("    </Outputs>\n"
+                           "    <InitialUnknowns>\n")
+            index = index_offset
+            for output in self.outputs.values():
+                if output.port.type_name in EmbeddedFMUPort.CONTAINER_TO_FMI[2]:
+                    print(f'      <Unknown index="{index}"/>', file=xml_file)
+                    index += 1
+            xml_file.write("    </InitialUnknowns>\n")
+
+        xml_file.write("  </ModelStructure>\n"
                        "\n"
                        "</fmiModelDescription>")
 

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/fmu_manipulation_toolbox/operations.py

@@ -416,8 +416,8 @@ class OperationSummary(OperationAbstract):
                 hash_md5.update(chunk)
         digest = hash_md5.hexdigest()
         logger.info(f"| MD5Sum = {digest}")
-
-        logger.info(f"|\n| FMI properties: ")
+        logger.info(f"|")
+        logger.info(f"| FMI properties: ")
         for (k, v) in attrs.items():
             logger.info(f"|  - {k} = {v}")
         logger.info(f"|")
@@ -457,21 +457,25 @@ class OperationSummary(OperationAbstract):
 
         resource_dir = os.path.join(self.fmu.tmp_directory, "resources")
         if os.path.isdir(resource_dir):
-            logger.info("|\n| Embedded resources:")
+            logger.info("|")
+            logger.info("| Embedded resources:")
             for resource in os.listdir(resource_dir):
                 logger.info(f"|  - {resource}")
 
         extra_dir = os.path.join(self.fmu.tmp_directory, "extra")
         if os.path.isdir(extra_dir):
-            logger.info("|\n| Additional (meta-)data:")
+            logger.info("|")
+            logger.info("| Additional (meta-)data:")
             for extra in os.listdir(extra_dir):
                 logger.info(f"|  - {extra}")
 
-        logger.info("|\n| Number of ports")
+        logger.info("|")
+        logger.info("| Number of ports")
         for causality, nb_ports in self.nb_port_per_causality.items():
             logger.info(f"|  {causality} : {nb_ports}")
 
-        logger.info("|\n| [End of report]")
+        logger.info("|")
+        logger.info("| [End of report]")
 
 
 class OperationRemoveSources(OperationAbstract):

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/fmu_manipulation_toolbox/remoting.py

@@ -60,9 +60,11 @@ class OperationAddRemotingWinAbstract(OperationAbstract):
                         fmu_bin[self.bitness_to] / "license.txt")
 
     def port_attrs(self, fmu_port) -> int:
+        vr = int(fmu_port["valueReference"])
+        causality = fmu_port.get("causality", "local")
         try:
-            self.vr[fmu_port.fmi_type].append(int(fmu_port["valueReference"]))
-            if fmu_port["causality"] in ("input", "parameter"):
+            self.vr[fmu_port.fmi_type].append(vr)
+            if causality in ("input", "parameter"):
                 self.nb_input += 1
             else:
                 self.nb_output += 1

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/fmu_manipulation_toolbox/split.py

@@ -6,6 +6,8 @@ import xml.parsers.expat
 from typing import *
 from pathlib import Path
 
+from .container import EmbeddedFMUPort
+
 logger = logging.getLogger("fmu_manipulation_toolbox")
 
 
@@ -66,7 +68,7 @@ class FMUSplitter:
     def split_fmu(self):
         logger.info(f"Splitting...")
         config = self._split_fmu(fmu_filename=str(self.fmu_filename), relative_path="")
-        config_filename = self.directory / self.fmu_filename.with_suffix(".json")
+        config_filename = self.directory / self.fmu_filename.with_suffix(".json").name
         with open(config_filename, "w") as file:
             json.dump(config, file, indent=2)
         logger.info(f"Container definition saved to '{config_filename}'")
@@ -77,7 +79,7 @@ class FMUSplitter:
         if txt_filename in self.filenames_list:
             description = FMUSplitterDescription(self.zip)
             config = description.parse_txt_file(txt_filename)
-            config["name"] = fmu_filename
+            config["name"] = Path(fmu_filename).name
             for i, fmu_filename in enumerate(config["candidate_fmu"]):
                 directory = f"{relative_path}resources/{i:02x}/"
                 if directory not in self.dir_set:
@@ -134,6 +136,7 @@ class FMUSplitterDescription:
         self.current_vr = None
         self.current_name = None
         self.current_causality = None
+        self.supported_fmi_types: Tuple[str] = ()
 
     @staticmethod
     def get_line(file):
@@ -182,10 +185,12 @@ class FMUSplitterDescription:
     def parse_txt_file_header(self, file, txt_filename):
         flags = self.get_line(file).split(" ")
         if len(flags) == 1:
+            self.supported_fmi_types = ("Real", "Integer", "Boolean", "String")
             self.config["mt"] = flags[0] == "1"
             self.config["profiling"] = self.get_line(file) == "1"
             self.config["sequential"] = False
         elif len(flags) == 3:
+            self.supported_fmi_types = EmbeddedFMUPort.ALL_TYPES
             self.config["mt"] = flags[0] == "1"
             self.config["profiling"] = flags[1] == "1"
             self.config["sequential"] = flags[2] == "1"
@@ -242,7 +247,7 @@ class FMUSplitterDescription:
             logger.debug(f"Adding container port {causality}: {definition}")
 
     def parse_txt_file_ports(self, file):
-        for fmi_type in ("Real", "Integer", "Boolean", "String"):
+        for fmi_type in self.supported_fmi_types:
             nb_port_variables = self.get_line(file).split(" ")[0]
             for i in range(int(nb_port_variables)):
                 tokens = self.get_line(file).split(" ")

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/fmu_manipulation_toolbox.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fmu_manipulation_toolbox
-Version: 1.9rc6
+Version: 1.9rc8
 Summary: FMU Manipulation Toolbox is a python application for modifying Functional Mock-up Units (FMUs) without recompilation or bundling them into FMU Containers
 Home-page: https://github.com/grouperenault/fmu_manipulation_toolbox/
 Author: Nicolas.LAURENT@Renault.com

{fmu_manipulation_toolbox-1.9rc6 → fmu_manipulation_toolbox-1.9rc8}/tests/test_suite.py

@@ -1,24 +1,42 @@
 import unittest
 import sys
 from pathlib import Path
+from fmpy.simulation import simulate_fmu
+import numpy as np
 
 sys.path.insert(0, str(Path(__file__).parent.parent))
 from fmu_manipulation_toolbox.operations import *
 from fmu_manipulation_toolbox.remoting import *
 from fmu_manipulation_toolbox.container import *
 from fmu_manipulation_toolbox.assembly import *
-
+from fmu_manipulation_toolbox.cli.fmutool import fmutool
+from fmu_manipulation_toolbox.cli.fmusplit import fmusplit
+from fmu_manipulation_toolbox.cli.fmucontainer import fmucontainer
 
 class FMUManipulationToolboxTestSuite(unittest.TestCase):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.fmu_filename = "operations/bouncing_ball.fmu"
 
+    def assert_simulation(self, filename: Union[Path, str], step_size: Optional[float] = None):
+        if isinstance(filename, str):
+            filename = Path(filename)
+        result_filename = filename.with_name("results-" + filename.with_suffix(".csv").name)
+        ref_filename = result_filename.with_stem("REF-" + result_filename.stem)
+
+        result = simulate_fmu(filename, step_size=step_size, stop_time=10, relative_tolerance=1e-9,
+                              output_interval=step_size, validate=True)
+
+        np.savetxt(result_filename, result, delimiter=',', fmt="%.5e")
+
+        self.assert_identical_files(result_filename, ref_filename)
+
     def assert_identical_files(self, filename1, filename2):
         with open(filename1, mode="rt", newline=None) as a, open(filename2, mode="rt", newline=None) as b:
             self.assertTrue(all(lineA == lineB for lineA, lineB in zip(a, b)))
 
-    def assert_identical_files_but_guid(self, filename1, filename2):
+    @staticmethod
+    def assert_identical_files_but_guid(filename1, filename2):
         with open(filename1, mode="rt", newline=None) as a, open(filename2, mode="rt", newline=None) as b:
             for lineA, lineB in zip(a, b):
                 if not "guid" in lineA and not lineA == lineB:
@@ -51,10 +69,12 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
 
     @unittest.skipUnless(sys.platform.startswith("win"), "Supported only on Windows")
     def test_add_remoting_win32(self):
-        fmu = FMU(self.fmu_filename)
-        operation = OperationAddRemotingWin32()
+        fmu = FMU("remoting/bouncing_ball-win32.fmu")
+        operation = OperationAddRemotingWin64()
         fmu.apply_operation(operation)
-        fmu.repack("operations/bouncing_ball-win32.fmu")
+        fmu.repack("remoting/bouncing_ball-win64.fmu")
+        self.assert_simulation("remoting/bouncing_ball-win32.fmu")
+        self.assert_simulation("remoting/bouncing_ball-win64.fmu")
 
     def test_remove_regexp(self):
         self.assert_operation_match_ref("operations/bouncing_ball-removed.fmu",
@@ -72,6 +92,8 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
                                     "containers/bouncing_ball/bouncing/resources/container.txt")
         self.assert_identical_files("containers/bouncing_ball/REF-bouncing.json",
                                     "containers/bouncing_ball/bouncing.json")
+        if os.name == 'nt':
+            self.assert_simulation("containers/bouncing_ball/bouncing.fmu")
 
     def test_container_bouncing_ball_seq(self):
         assembly = Assembly("bouncing-seq.csv", fmu_directory=Path("containers/bouncing_ball"), mt=True, debug=True,
@@ -82,6 +104,8 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
                                     "containers/bouncing_ball/bouncing-seq/resources/container.txt")
         self.assert_identical_files("containers/bouncing_ball/REF-bouncing-seq.json",
                                     "containers/bouncing_ball/bouncing-seq.json")
+        if os.name == 'nt':
+            self.assert_simulation("containers/bouncing_ball/bouncing-seq.fmu")
 
     def test_container_bouncing_ball_profiling(self):
         assembly = Assembly("bouncing-profiling.csv", fmu_directory=Path("containers/bouncing_ball"), profiling=True,
@@ -94,6 +118,8 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
                                     "containers/bouncing_ball/bouncing-profiling.json")
         self.assert_identical_files_but_guid("containers/bouncing_ball/REF-modelDescription-profiling.xml",
                                              "containers/bouncing_ball/bouncing-profiling/modelDescription.xml")
+        if os.name == 'nt':
+            self.assert_simulation("containers/bouncing_ball/bouncing-profiling.fmu")
 
     def test_container_bouncing_ball_profiling_3(self):
         assembly = Assembly("bouncing-3.csv", fmu_directory=Path("containers/bouncing_ball"), profiling=True,
@@ -103,18 +129,24 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
                                     "containers/bouncing_ball/bouncing-3/resources/container.txt")
         self.assert_identical_files_but_guid("containers/bouncing_ball/REF-modelDescription-3.xml",
                                              "containers/bouncing_ball/bouncing-3/modelDescription.xml")
+        if os.name == 'nt':
+            self.assert_simulation("containers/bouncing_ball/bouncing-3.fmu")
 
     def test_container_ssp(self):
         assembly = Assembly("bouncing.ssp", fmu_directory=Path("containers/ssp"))
         assembly.make_fmu(dump_json=True)
         self.assert_identical_files("containers/ssp/REF-bouncing-dump.json",
                                     "containers/ssp/bouncing-dump.json")
+        if os.name == 'nt':
+            self.assert_simulation("containers/ssp/bouncing.fmu")
 
     def test_container_json_flat(self):
         assembly = Assembly("flat.json", fmu_directory=Path("containers/arch"))
         assembly.make_fmu(dump_json=True)
         self.assert_identical_files("containers/arch/REF-flat-dump.json",
                                     "containers/arch/flat-dump.json")
+        if os.name == 'nt':
+            self.assert_simulation("containers/arch/flat.fmu")
 
     def test_container_subdir_flat(self):
         container = FMUContainer("sub.fmu", fmu_directory=Path("containers/arch"))
@@ -123,18 +155,24 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
         container.get_fmu("sine.fmu")
         container.add_implicit_rule()
         container.make_fmu("sub.fmu", step_size=0.5)
+        if os.name == 'nt':
+            self.assert_simulation("containers/arch/sub.fmu")
 
     def test_container_json_hierarchical(self):
         assembly = Assembly("hierarchical.json", fmu_directory=Path("containers/arch"))
         assembly.make_fmu(dump_json=True)
         self.assert_identical_files("containers/arch/REF-hierarchical-dump.json",
                                     "containers/arch/hierarchical-dump.json")
+        if os.name == 'nt':
+            self.assert_simulation("containers/arch/hierarchical.fmu")
 
     def test_container_json_reversed(self):
         assembly = Assembly("reversed.json", fmu_directory=Path("containers/arch"))
         assembly.make_fmu(dump_json=True)
         self.assert_identical_files("containers/arch/REF-reversed-dump.json",
                                     "containers/arch/reversed-dump.json")
+        if os.name == 'nt':
+            self.assert_simulation("containers/arch/reversed.fmu")
 
     def test_container_start(self):
         assembly = Assembly("slx.json", fmu_directory=Path("containers/start"), debug=True)
@@ -143,12 +181,22 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
                                     "containers/start/container-slx/resources/container.txt")
         self.assert_identical_files_but_guid("containers/start/REF-modelDescription.xml",
                                              "containers/start/container-slx/modelDescription.xml")
+        if os.name == 'nt':
+            self.assert_simulation("containers/start/slx.fmu")
+
+    def test_container_vanderpol(self):
+        self.assert_simulation("containers/VanDerPol/VanDerPol.fmu", 0.1)
+        assembly = Assembly("VanDerPol.json", fmu_directory=Path("containers/VanDerPol"))
+        assembly.make_fmu()
+        self.assert_simulation("containers/VanDerPol/VanDerPol-Container.fmu", 0.1)
 
     def test_fmi3_pt2(self):
         assembly = Assembly("passthrough.json", fmu_directory=Path("fmi3/passthrough"), debug=True)
         assembly.make_fmu(fmi_version=2)
         self.assert_identical_files("fmi3/passthrough/REF-container.txt",
                                     "fmi3/passthrough/container-passthrough/resources/container.txt")
+        if os.name == 'nt':
+            self.assert_simulation("fmi3/passthrough/container-passthrough.fmu")
 
     def test_container_move(self):
         #bb = Assembly("bouncing.csv", fmu_directory=Path("containers/bouncing_ball"))
@@ -168,6 +216,28 @@ class FMUManipulationToolboxTestSuite(unittest.TestCase):
         for link in links_fmu0a:
             print(f"{link}")
 
+    def test_fmutool(self):
+        fmutool(['-input', 'operations/bouncing_ball.fmu', '-summary', '-check', '-dump-csv',
+                 'operations/cli-bouncing_ball.csv'])
+        self.assert_identical_files("operations/cli-bouncing_ball.csv", "operations/REF-bouncing_ball.csv")
+
+    def test_fmucontainer_csv(self):
+        fmucontainer(['-container', 'cli-bouncing.csv', '-fmu-directory', 'containers/bouncing_ball', '-mt', '-debug'])
+        self.assert_identical_files("containers/bouncing_ball/REF-container.txt",
+                                    "containers/bouncing_ball/cli-bouncing/resources/container.txt")
+
+    def test_fmucontainer_json(self):
+        fmucontainer(['-fmu-directory', 'containers/arch', '-container', 'cli-flat.json', '-dump'])
+        self.assert_identical_files("containers/arch/REF-cli-flat-dump.json",
+                                    "containers/arch/cli-flat-dump.json")
+
+    def test_fmusplit(self):
+        fmusplit(["-fmu", "containers/ssp/bouncing.fmu"])
+        self.assertTrue(Path("containers/ssp/bouncing.dir/bb_position.fmu").exists())
+        self.assertTrue(Path("containers/ssp/bouncing.dir/bb_velocity.fmu").exists())
+        self.assert_identical_files("containers/ssp/REF-split-bouncing.json",
+                                    "containers/ssp/bouncing.dir/bouncing.json")
+
 
 if __name__ == '__main__':
     unittest.main()

fmu_manipulation_toolbox-1.9rc6/fmu_manipulation_toolbox/__version__.py

@@ -1 +0,0 @@
-'V1.9-rc6'