salome.kernel 9.14.0__cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

salome/bin/salome/test/kernel/Container/testProxy.py

@@ -0,0 +1,291 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2023-2024  CEA/DEN, EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import unittest
+import os
+from salome.kernel import salome
+from salome.kernel import Engines
+import pickle
+import tempfile
+from salome.kernel import pylauncher
+from salome.kernel import KernelBasis
+
+class TestProxy(unittest.TestCase):
+    def testProxy(self):
+        """
+        [EDF27816] : This test checks two things :
+        - Capability of ContainerManager to launch a Container with overriden environement
+        - Management of proxy creation to manage big obj exchange between process (here between Container and the current process)
+        """
+        hostname = "localhost"
+        cp = pylauncher.GetRequestForGiveContainer(hostname,"container_test")
+
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            val_for_jj = "3333"
+            val_for_big_obj = str( tmpdirname )
+            val_for_thres = 100 # force proxy file
+            # Override environement for all containers launched
+            salome.cm.SetBigObjOnDiskDirectory(val_for_big_obj)
+            salome.cm.SetBigObjOnDiskThreshold(val_for_thres)
+            salome.cm.SetOverrideEnvForContainersSimple(env = [("jj",val_for_jj)])
+            cont = salome.cm.GiveContainer(cp)
+            ## Time to test it
+            script_st = """import os
+from salome.kernel import KernelBasis
+_,a = KernelBasis.GetBigObjOnDiskProtocolAndDirectory()
+b = os.environ["jj"]
+c = KernelBasis.GetBigObjOnDiskThreshold()
+j = a,b,c"""
+            pyscript = cont.createPyScriptNode("testScript",script_st)
+            a,b,c = pickle.loads(pyscript.execute(["j"],pickle.dumps(([],{}))))[0]
+            self.assertTrue( a == val_for_big_obj )
+            self.assertTrue( b == val_for_jj )
+            self.assertTrue( c == val_for_thres )
+            # check environment using POSIX API in the container process
+            for k,v in [("jj",val_for_jj)]:
+                assert( {elt.key:elt.value.value() for elt in cont.get_os_environment()}[k] == v )
+            #
+            from salome.kernel import SALOME_PyNode
+            poa = salome.orb.resolve_initial_references("RootPOA")
+            obj = SALOME_PyNode.SenderByte_i(poa,pickle.dumps( ([],{}) ))
+            id_o = poa.activate_object(obj)
+            refPtr = poa.id_to_reference(id_o)
+            script_st2 = """ob = list( range(100) )""" # size of pickled ob must be greater than val_for_thres
+            pyscript2 = cont.createPyScriptNode("testScript2",script_st2)
+            pyscript2.executeFirst(refPtr)
+            ret2 = pyscript2.executeSecond(["ob"])
+            self.assertTrue( len(ret2) == 1)
+            ret2 = ret2[0]
+            ret3 = pickle.loads( SALOME_PyNode.SeqByteReceiver(ret2).data() )
+            self.assertTrue( isinstance( ret3, SALOME_PyNode.BigObjectOnDiskList ) )
+            self.assertTrue( val_for_big_obj == os.path.dirname( ret3.getFileName().getFileName() ) )# very important part of test
+            self.assertTrue( ret3.get() == list(range(100)) )
+            fn = ret3.getFileName().getFileName()
+            self.assertTrue( os.path.exists( fn ) )
+            ret3.unlinkOnDestructor()
+            del ret3
+            import gc
+            gc.collect(0)
+            self.assertTrue( not os.path.exists( fn ) ) # at destruction of ret3 the corresponding pckl file must be destructed
+            cont.Shutdown()
+
+    def testExecCodeAtInit(self):
+        """
+        [EDF28648] : allow initialisation script at startup
+        """
+        import os
+        with tempfile.NamedTemporaryFile() as tmpFileName:
+            tmpFileName.close()
+            salome.cm.SetCodeOnContainerStartUp("""
+with open("{}","w") as f:
+  f.write("coucou")
+""".format(tmpFileName.name) )# injection of python code expected to be executed at startup
+            cp = pylauncher.GetRequestForGiveContainer("localhost","gg")
+            cont = salome.cm.GiveContainer(cp) # code is expected to be executed in process abroad -> file is supposed to contain coucou
+            cont.Shutdown()
+            salome.cm.SetCodeOnContainerStartUp("") # no more startup code for other tests
+            with open(tmpFileName.name,"r") as f:
+                self.assertTrue(f.read()=="coucou")
+            os.unlink( tmpFileName.name ) # context manager do not clean file
+
+    def testWorkingDirectoryForward(self):
+        """
+        [EDF30062] test of forward of current directory overriding entry in Catalog
+        """
+        KernelBasis.SetForwardCurrentDirectoryStatus( True ) # key point
+        hostname = "localhost"
+        cp = pylauncher.GetRequestForGiveContainer(hostname,"container_test")
+
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            os.chdir( str( tmpdirname ) )
+            cp = pylauncher.GetRequestForGiveContainer("localhost","gg")
+            cont = salome.cm.GiveContainer(cp)
+
+            pyscript2 = cont.createPyScriptNode("testScript","""import os
+ret = os.getcwd()
+""")
+            #
+            from salome.kernel import SALOME_PyNode
+            poa = salome.orb.resolve_initial_references("RootPOA")
+            obj = SALOME_PyNode.SenderByte_i(poa,pickle.dumps( ([],{}) ))
+            id_o = poa.activate_object(obj)
+            refPtr = poa.id_to_reference(id_o)
+            #
+            pyscript2.executeFirst(refPtr)
+            ret2 = pyscript2.executeSecond(["ret"])
+            #
+            ret2 = ret2[0]
+            ret3 = pickle.loads( SALOME_PyNode.SeqByteReceiver(ret2).data() )
+            self.assertEqual(ret3,str(tmpdirname)) # key point
+            #
+            cont.Shutdown()
+        ################
+        KernelBasis.SetForwardCurrentDirectoryStatus( False ) # key point
+        cp = pylauncher.GetRequestForGiveContainer(hostname,"container_test")
+
+        with tempfile.TemporaryDirectory() as tmpdirname:
+            os.chdir( str( tmpdirname ) )
+            cp = pylauncher.GetRequestForGiveContainer("localhost","gg")
+            cont = salome.cm.GiveContainer(cp)
+
+            pyscript2 = cont.createPyScriptNode("testScript","""import os
+ret = os.getcwd()
+""")
+            #
+            from salome.kernel import SALOME_PyNode
+            poa = salome.orb.resolve_initial_references("RootPOA")
+            obj = SALOME_PyNode.SenderByte_i(poa,pickle.dumps( ([],{}) ))
+            id_o = poa.activate_object(obj)
+            refPtr = poa.id_to_reference(id_o)
+            #
+            pyscript2.executeFirst(refPtr)
+            ret2 = pyscript2.executeSecond(["ret"])
+            #
+            ret2 = ret2[0]
+            ret3 = pickle.loads( SALOME_PyNode.SeqByteReceiver(ret2).data() )
+            self.assertNotEqual(ret3,str(tmpdirname)) # key point
+            #
+            cont.Shutdown()
+
+    def testAccessOfResourcesAcrossWorkers(self):
+        """
+        [EDF30157] To ease testing advanced configuration. This test checks that
+        """
+        ### start of catalog manipulation in memory
+        rmcpp = pylauncher.RetrieveRMCppSingleton()
+        res0 = pylauncher.CreateContainerResource("zFakeHost","/home/appli/fakeappli","ssh")
+        rmcpp.AddResourceInCatalogNoQuestion(res0)#<- key point is here
+        res1 = pylauncher.CreateContainerResource("zzFakeHost","/home/appli/zzfakeappli","ssh")
+        rmcpp.AddResourceInCatalogNoQuestion(res1)#<- key point is here
+        ### end of catalog manipulation in memory
+
+        ### start to check effectivity of manipulation locally
+        machines = salome.rm.ListAllResourceEntriesInCatalog()
+        localStructure = { machine : salome.rm.GetResourceDefinition2( machine ) for machine in machines }
+        ### end of check effectivity of manipulation locally
+
+        cp = pylauncher.GetRequestForGiveContainer("localhost","gg")
+        with salome.ContainerLauncherCM(cp) as cont:
+            pyscript = cont.createPyScriptNode("testScript","""
+from salome.kernel import salome
+salome.salome_init()
+machines = salome.rm.ListAllResourceEntriesInCatalog()
+structure = { machine : salome.rm.GetResourceDefinition2( machine ) for machine in machines }
+""") # retrieve the content remotely and then return it back to current process
+            from salome.kernel import SALOME_PyNode
+            import pickle
+            poa = salome.orb.resolve_initial_references("RootPOA")
+            obj = SALOME_PyNode.SenderByte_i(poa,pickle.dumps( ([],{}) ))
+            id_o = poa.activate_object(obj)
+            refPtr = poa.id_to_reference(id_o)
+            #
+            pyscript.executeFirst(refPtr)
+            ret = pyscript.executeSecond(["structure"])
+            ret = ret[0]
+            retPy = pickle.loads( SALOME_PyNode.SeqByteReceiver(ret).data() )
+
+            self.assertTrue( len(localStructure) == len(retPy) )
+            self.assertTrue( "zFakeHost" in [elt for elt in localStructure])
+            self.assertTrue( localStructure["zFakeHost"].applipath == "/home/appli/fakeappli")
+            self.assertTrue( "zzFakeHost" in [elt for elt in localStructure])
+            self.assertTrue( localStructure["zzFakeHost"].applipath == "/home/appli/zzfakeappli")
+            for k in localStructure:
+                a = pylauncher.FromEngineResourceDefinitionToCPP( localStructure[k] )
+                self.assertTrue( isinstance(a,pylauncher.ResourceDefinition_cpp) )
+                b = pylauncher.FromEngineResourceDefinitionToCPP( retPy[k] )
+                self.assertTrue( isinstance(b,pylauncher.ResourceDefinition_cpp) )
+                self.assertTrue( a==b ) #<- key point is here
+                a1 = pylauncher.ToEngineResourceDefinitionFromCPP( a )
+                b1 = pylauncher.ToEngineResourceDefinitionFromCPP( b )
+                a2 = pylauncher.FromEngineResourceDefinitionToCPP( a1 )
+                b2 = pylauncher.FromEngineResourceDefinitionToCPP( b1 )
+                self.assertTrue( a2==b2 )
+
+    def testMultiProcessCriticalSection0(self):
+        """
+        [EDF30382] : Synchro mecanism to ease test of extreme situations
+        """
+        from datetime import datetime
+        from threading import Thread
+        import contextlib
+        from salome.kernel import SALOME_PyNode
+        import time
+
+        def func(pyscript,b):
+            poa = salome.orb.resolve_initial_references("RootPOA")
+            obj = SALOME_PyNode.SenderByte_i(poa,pickle.dumps( (["b"],{"b":b} ) )) ; id_o = poa.activate_object(obj) ; refPtr = poa.id_to_reference(id_o)
+            pyscript.executeFirst(refPtr)
+            ret = pyscript.executeSecond([])
+            retPy = [ pickle.loads( SALOME_PyNode.SeqByteReceiver( elt ).data() ) for elt in ret]
+            return retPy
+
+        salome.salome_init()
+        rmcpp = pylauncher.RetrieveRMCppSingleton()
+        hostname = "localhost"
+        cps = [ pylauncher.GetRequestForGiveContainer(hostname,contName) for contName in ["container_test_lock","container_test_lock_2"]]
+        with contextlib.ExitStack() as stack:
+            conts = [stack.enter_context(salome.ContainerLauncherCM(cp)) for cp in cps] # Context Manager to automatically cleanup launched containers
+            b = salome.Barrier(3)
+            pyscript = conts[0].createPyScriptNode("testScript","""
+from datetime import datetime
+from salome.kernel import salome
+import time
+time.sleep( 2.0 )
+b.barrier()
+print("go barrier")
+print("after barrier T0 : {}".format(datetime.now()))
+with salome.LockGuardCM("SSD"):
+    print("Start CS T0 : {}".format(datetime.now()))
+    time.sleep(5)
+    print("End CS T0 : {}".format(datetime.now()))
+""")
+            pyscript2 = conts[1].createPyScriptNode("testScript","""
+from datetime import datetime
+from salome.kernel import salome
+import time
+time.sleep( 4.0 )
+b.barrier()
+print("go barrier")
+print("after barrier T1 : {}".format(datetime.now()))
+with salome.LockGuardCM("SSD"):
+    print("Start CS T1 : {}".format(datetime.now()))
+    time.sleep(5)
+    print("End CS T1 : {}".format(datetime.now()))
+""")
+            ts = [Thread( target=func, args=(ps,b) ) for ps in [pyscript,pyscript2]]
+            [t.start() for t in ts]
+            st0 = datetime.now()
+            time.sleep( 1.0 )
+            b.barrier() # wait everybody
+            print("go barrier")
+            print("after barrier Master : {}".format(datetime.now()))
+            with salome.LockGuardCM("SSD"):
+                print("In critical section")
+            [t.join() for t in ts]
+            zedelt = datetime.now() - st0
+            assert( zedelt.total_seconds() > 14.0 ) # expected max(1,2,4)+5+5 = 14s
+            pass
+    pass
+
+
+if __name__ == '__main__':
+    salome.standalone()
+    salome.salome_init()
+    unittest.main()

salome/bin/salome/test/kernel/Container/testcontainer.py

@@ -0,0 +1,106 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import unittest
+from os import getcwd
+from salome.kernel.Engines import ContainerParameters, ResourceParameters
+from salome.kernel import SALOME
+from salome.kernel import salome
+
+from time import sleep
+
+class TestResourceManager(unittest.TestCase):
+    def getContainer(self, name):
+        rp = ResourceParameters(name="localhost",
+                                hostname="localhost",
+                                can_launch_batch_jobs=False,
+                                can_run_containers=True,
+                                OS="Linux",
+                                componentList=[],
+                                nb_proc=1,
+                                mem_mb=1000,
+                                cpu_clock=1000,
+                                nb_node=1,
+                                nb_proc_per_node=1,
+                                policy="first",
+                                resList=[])
+        cp = ContainerParameters(container_name=name,
+                                 mode="start",
+                                 workingdir=getcwd(),
+                                 nb_proc=1,
+                                 isMPI=False,
+                                 parallelLib="",
+                                 resource_params=rp)
+        cm = salome.naming_service.Resolve("/ContainerManager")
+        return cm.GiveContainer(cp)
+
+    def checkLoads(self, cont, loads):
+        self.assertEqual(len(loads), cont.getNumberOfCPUCores())
+        for load in loads:
+            self.assertTrue(0.0 <= load <= 1.0)
+
+    def test1(self):
+        # Check custom script
+        cont = self.getContainer("test_container_2")
+        import multiprocessing as mp
+        ref_load = [min(0.1*(i+1),1.0) for i in range(mp.cpu_count())]
+        cont.setPyScriptForCPULoad('cpu_loads = {}'.format(ref_load))
+        loads1 = cont.loadOfCPUCores()
+        self.assertEqual(loads1, ref_load)
+        cont.resetScriptForCPULoad()
+        loads2 = cont.loadOfCPUCores()
+        self.checkLoads(cont, loads2)
+        cont.Shutdown()
+
+    def test2(self):
+        # Check bad script
+        cont = self.getContainer("test_container_3")
+        cont.setPyScriptForCPULoad("bla-bla-bla")
+        self.assertRaises(Exception, cont.loadOfCPUCores)
+        cont.Shutdown()
+
+    def test3(self):
+        # check memory sizes
+        cont = self.getContainer("test_container_4")
+        memory_total = cont.getTotalPhysicalMemory()
+        memory_in_use = cont.getTotalPhysicalMemoryInUse()
+        memory_by_me = cont.getTotalPhysicalMemoryInUseByMe()
+        self.assertGreater(memory_total, memory_in_use)
+        self.assertGreater(memory_in_use, memory_by_me)
+        cont.Shutdown()
+    
+    def test4(self):
+        """
+        Test checking memory consumption of container
+        """
+        cont = self.getContainer("test_container_5")
+        memory_by_me_start = cont.getTotalPhysicalMemoryInUseByMe()
+        import pickle
+        psn = cont.createPyScriptNode("n","""b = bytearray(10485760)""")# create 10MB byte array abroad
+        psn.execute([],pickle.dumps(((),{})))
+        memory_by_me_end = cont.getTotalPhysicalMemoryInUseByMe()
+        self.assertGreater(memory_by_me_end,memory_by_me_start)
+        self.assertIn(memory_by_me_end-memory_by_me_start,[9,10,11,12])# test elevation of memory
+        cont.Shutdown()
+
+if __name__ == '__main__':
+    salome.standalone()
+    salome.salome_init()
+    unittest.main()

salome/bin/salome/test/kernel/KernelHelpers/CTestTestfile.cmake

@@ -0,0 +1,31 @@
+# Copyright (C) 2015-2024  CEA, EDF
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+IF(NOT WIN32)
+  SET(TEST_NAME ${COMPONENT_NAME}_KernelHelpers)
+  ADD_TEST(${TEST_NAME} ${SALOME_TEST_DRIVER} ${TIMEOUT} TestKernelHelpers.py)
+  SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES
+                                    LABELS "${COMPONENT_NAME}"
+                                    ENVIRONMENT "LD_LIBRARY_PATH=${KERNEL_TEST_LIB}:$ENV{LD_LIBRARY_PATH}"
+  #                                 TIMEOUT 500
+                      )
+  # /!\ DO NOT SET TIMEOUT PROPERTY IF USING ${SALOME_TEST_DRIVER}
+  #     BUT PASS TIMEOUT VALUE TO THE DRIVER
+
+ENDIF()

salome/bin/salome/test/kernel/KernelHelpers/KernelHelpersUnitTests.hxx

@@ -0,0 +1,58 @@
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+//
+// Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License, or (at your option) any later version.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+
+#ifndef _SalomeAppTEST_HXX_
+#define _SalomeAppTEST_HXX_
+
+#include <cppunit/extensions/HelperMacros.h>
+
+#ifdef WIN32
+# if defined KERNELHELPERSTEST_EXPORTS || defined SalomeKernelHelpersTest_EXPORTS
+#  define KERNELHELPERSTEST_EXPORT __declspec( dllexport )
+# else
+#  define KERNELHELPERSTEST_EXPORT __declspec( dllimport )
+# endif
+#else
+# define KERNELHELPERSTEST_EXPORT
+#endif
+
+class KERNELHELPERSTEST_EXPORT KernelHelpersUnitTests : public CppUnit::TestFixture
+{
+  CPPUNIT_TEST_SUITE( KernelHelpersUnitTests );
+  CPPUNIT_TEST( TEST_corba );
+  CPPUNIT_TEST( TEST_getLifeCycleCORBA );
+  CPPUNIT_TEST( TEST_getStudy );
+  CPPUNIT_TEST( TEST_getSalomeLauncher );
+  CPPUNIT_TEST_SUITE_END();
+
+public:
+
+  void setUp();
+  void tearDown();
+
+  void TEST_corba();
+  void TEST_getLifeCycleCORBA();
+  void TEST_getStudy();
+  void TEST_getSalomeLauncher();
+};
+
+#endif

salome/bin/salome/test/kernel/KernelHelpers/TestKernelHelpers.py

@@ -0,0 +1,55 @@
+#  -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
+#
+# Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+# CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import sys, os,signal,string,subprocess
+import subprocess
+from salome.kernel import runSalomeOld_impl
+from salome.kernel import setenv_impl
+from salome.kernel import orbmodule
+from salome.kernel import TestKiller
+
+# get SALOME environment :
+
+args, modules_list, modules_root_dir = setenv_impl.get_config()
+setenv_impl.set_env(args, modules_list, modules_root_dir)
+
+# launch CORBA naming server
+
+clt=orbmodule.client()
+
+# launch CORBA logger server
+
+myServer=runSalomeOld_impl.LoggerServer(args)
+myServer.run()
+clt.waitLogger("Logger")
+
+# execute Unit Test
+
+command = ['./TestKernelHelpers']
+ret = subprocess.call(command)
+
+# kill Test process
+
+TestKiller.killProcess(runSalomeOld_impl.process_id)
+TestKiller.closeSalome()
+exit(ret)

salome/bin/salome/test/kernel/Launcher/CTestTestfile.cmake

@@ -0,0 +1,43 @@
+# Copyright (C) 2015-2024  CEA, EDF
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+IF(NOT WIN32)
+  SET(TEST_NAME ${COMPONENT_NAME}_Launcher)
+  ADD_TEST(${TEST_NAME} ${PYTHON_TEST_DRIVER} 2000 test_launcher.py)
+  SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
+    
+    SET(TEST_NAME ${COMPONENT_NAME}_AttachedLauncher)
+    ADD_TEST(${TEST_NAME} ${PYTHON_TEST_DRIVER} 2000 TestSSLAttached.py)
+    SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
+
+  SET(TEST_NAME ${COMPONENT_NAME}_StressLauncher)
+  ADD_TEST(${TEST_NAME} ${PYTHON_TEST_DRIVER} 2000 ./test_stress.sh)
+  SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
+
+  SET(TEST_NAME ${COMPONENT_NAME}_PerfLogManager1)
+  ADD_TEST(${TEST_NAME} ${PYTHON_TEST_DRIVER} 2000 testPerfLogManager1.py)
+  SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
+  
+  SET(TEST_NAME ${COMPONENT_NAME}_testCrashProofContainer)
+  ADD_TEST(${TEST_NAME} ${PYTHON_TEST_DRIVER} 2000 testCrashProofContainer.py)
+  SET_TESTS_PROPERTIES(${TEST_NAME} PROPERTIES LABELS "${COMPONENT_NAME}")
+  # /!\ DO NOT SET TIMEOUT PROPERTY IF USING ${SALOME_TEST_DRIVER}
+  #     BUT PASS TIMEOUT VALUE TO THE DRIVER
+
+ENDIF()