diff --git a/model/application.py b/model/application.py
index f83624d..7ec208f 100644
--- a/model/application.py
+++ b/model/application.py
@@ -186,7 +186,7 @@ class Application(model.entity.Entity):
     LIST_SUBTABLES = [B.SUBJECT_APPS, B.SUBJECT_COMPS, B.SUBJECT_USECASES, B.SUBJECT_VARIANTS]
     PREFIX_SUBTABLE = "ap"
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/component.py b/model/component.py
index be2eea0..dcb2ac9 100644
--- a/model/component.py
+++ b/model/component.py
@@ -73,7 +73,7 @@ class Component(model.entity.Entity):
     application = ""
     attributes = ""
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/datatable.py b/model/datatable.py
index 6459773..ed44fa3 100644
--- a/model/datatable.py
+++ b/model/datatable.py
@@ -39,7 +39,7 @@ class Datatable(model.entity.Entity):
         if project != "":
             self.project = project
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/entity.py b/model/entity.py
index f901784..df4ff32 100644
--- a/model/entity.py
+++ b/model/entity.py
@@ -68,7 +68,7 @@ class Entity:
         if len(name) > 1:
             self.getEntity(job, name)
 
-    def get_unique_names(self, job, storage="", project="", application="", gran="", args={}):
+    def get_unique_names(self, job, storage="", project="", application="", gran="", args={}, ttype: str=""):
         """
         gets the entity-names from the defined storage - the field name must be an unique identifier
         :param job:
@@ -88,7 +88,19 @@ class Entity:
             entityNames = self.read_unique_names(job, project, application, gran, args)
         return [item for item in entityNames if item not in B.LIST_DATA_NODE]
 
-    def get_entities(self, job, storage="", project="", application="", gran="", args={}):
+    def select_unique_names(self, job, project, application, gran, args):
+        """
+        reads the entity-names from file-storage
+        :param job:
+        :param opt. project: select-criteria if used and defined
+        :param opt. application: select-criteria if used and defined
+        :param opt. gran: granularity values testcase / testsuite / testplan
+        :param opt. args additional args
+        :return: list of entity-names
+        """
+        raise Exception(B.EXCEPT_NOT_IMPLEMENT)
+
+    def get_entities(self, job, storage="", project="", application="", gran="", ttype="", args={}):
         """
         gets the entity-names from the defined storage
         :param job:
@@ -101,30 +113,19 @@ class Entity:
         """
         entities = []
         entityNames = self.get_unique_names(job, storage=storage, project=project, application=application,
-                                            gran=gran, args=args)
+                                            gran=gran, args=args, ttype=ttype)
         for k in entityNames:
             if storage == STORAGE_DB:
                 entity = self.select_entity(job, k)
             elif storage == STORAGE_FILE:
+                print(" entity.read_e "+ k)
                 entity = self.read_entity(job, k)
             else:
                 entity = self.read_entity(job, k)
             entities.append(entity)
         return entities
 
-    def read_unique_names(self, job, project, application, gran, args):
-        """
-        reads the entity-names from file-storage
-        :param job:
-        :param opt. project: select-criteria if used and defined
-        :param opt. application: select-criteria if used and defined
-        :param opt. gran: granularity values testcase / testsuite / testplan
-        :param opt. args additional args
-        :return: list of entity-names
-        """
-        raise Exception(B.EXCEPT_NOT_IMPLEMENT)
-
-    def select_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/environment.py b/model/environment.py
index 746228e..34ee7c7 100644
--- a/model/environment.py
+++ b/model/environment.py
@@ -81,7 +81,7 @@ class Environment(model.entity.Entity):
         if project != "":
             self.project = project
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/factory.py b/model/factory.py
index 5582906..e8da6de 100644
--- a/model/factory.py
+++ b/model/factory.py
@@ -69,13 +69,13 @@ def getTestplan(job=None, project="", application="", name=""):
     import model.testplan
     return model.testplan.Testplan(job, project)
 
-def getTestsuite(job=None, project="", application="", name=""):
+def getTestsuite(job=None, name="", project="", application=""):
     import model.testsuite
-    return model.testsuite.Testsuite(job, project)
+    return model.testsuite.Testsuite(job, name)
 
 def getTestcase(job=None, project="", application="", name=""):
     import model.testcase
-    return model.testcase.Testcase(job, project, name=name)
+    return model.testcase.Testcase(job, name)
 
 def getStep(job=None, project="", name=""):
     import model.step
diff --git a/model/project.py b/model/project.py
index c4f74e3..90e1803 100644
--- a/model/project.py
+++ b/model/project.py
@@ -41,7 +41,7 @@ class Project(model.entity.Entity):
     description = ""
     reference = ""
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/release.py b/model/release.py
index 29b35d0..0527b79 100644
--- a/model/release.py
+++ b/model/release.py
@@ -38,7 +38,7 @@ class Release(model.entity.Entity):
     attributes = ""
     reference = ""
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/step.py b/model/step.py
index 91e5b12..a95a7fc 100644
--- a/model/step.py
+++ b/model/step.py
@@ -75,7 +75,7 @@ class Step(model.entity.Entity):
         if len(name) > 1:
             self.name = name
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/story.py b/model/story.py
index f849588..7f35e9a 100644
--- a/model/story.py
+++ b/model/story.py
@@ -35,7 +35,7 @@ class Story(model.entity.Entity):
     description = ""
     reference = ""
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/table.py b/model/table.py
index fb886c5..64f07d2 100644
--- a/model/table.py
+++ b/model/table.py
@@ -116,7 +116,7 @@ class Table(model.entity.Entity):
         """
         return sql
 
-    def read_unique_names(self, job, project="", application="", gran= "", args={}) -> list:
+    def read_unique_names(self, job, project="", application="", gran= "", args={}, ttype: str="") -> list:
         return []
     # table is not an real entity
 
diff --git a/model/testcase.py b/model/testcase.py
index 0fd0cca..763fb80 100644
--- a/model/testcase.py
+++ b/model/testcase.py
@@ -29,31 +29,10 @@ DEFAULT_SYNC = model.entity.SYNC_FULL_GIT2DB
 TABLE_NAME = B.SUBJECT_APP
 """ system-name for this entity """
 FIELD_ID = "tcid"
-FIELD_NAME = D.FIELD_NAME
-FIELD_DESCRIPTION = B.SUBJECT_DESCRIPTION
-FIELD_REFERENCE = B.SUBJECT_REFERENCE
-FIELD_PROJECT = B.SUBJECT_PROJECT
-FIELD_APPLICATION = B.SUBJECT_APP
-LIST_FIELDS = [FIELD_ID, FIELD_NAME,
-               FIELD_DESCRIPTION, FIELD_REFERENCE, FIELD_PROJECT]
-""" list of object-attributes """
-LIST_NODES = [B.NODE_ATTRIBUTES]
-
-SUB_USECASE = B.SUBJECT_USECASES
-SUB_STORIES = B.SUBJECT_STORIES
-SUB_STEPS = "steps"
-SUB_TABLES = "tables"
-LIST_SUBTABLES = { # with additional attributes for the subtable
-    B.SUBJECT_APPS: [],
-    SUB_TABLES: [D.DATA_ATTR_DATE],
-    SUB_STEPS: [],
-    SUB_USECASE: [B.SUBJECT_DESCRIPTION, B.SUBJECT_REFERENCE],
-    SUB_STORIES: [B.SUBJECT_DESCRIPTION, B.SUBJECT_REFERENCE]
-}
 LIST_SUB_DESCRIPT = [D.DATA_ATTR_USECASE_DESCR, D.DATA_ATTR_STORY_DESCR]
 
 FILE_EXTENSION = D.DFILE_TYPE_YML
-UNIQUE_FIELDS = [FIELD_NAME]
+UNIQUE_FIELDS = [D.FIELD_NAME]
 """ unique business field as human identifer """
 IDENTIFYER_FIELDS = [FIELD_ID]
 """ unique technical field as technical identifer """
@@ -74,6 +53,8 @@ class Testcase(model.entity.Entity):
     LIST_FIELDS = [FIELD_ID, D.FIELD_NAME, B.SUBJECT_APPS,
                    B.SUBJECT_DESCRIPTION, B.SUBJECT_REFERENCE, B.SUBJECT_PROJECT]
     LIST_NODES = [B.NODE_ATTRIBUTES]
+    LIST_SUBTABLES = [B.SUBJECT_USECASES, B.SUBJECT_STEPS, B.SUBJECT_DATATABLES, B.SUBJECT_STEPS]
+
     tcid = ""
     name = ""
     description = ""
@@ -84,19 +65,8 @@ class Testcase(model.entity.Entity):
     tables = {}
     steps = {}
 
-    def __init__(self, job, project, name=""):
-        """
-        to be initialized by readSpec
-        :param job:
-        """
-        self.job = job
-        if len(project) > 1:
-            self.project = project
-        if len(name) > 1:
-            self.name = name
-            self.read_entity(job, name)
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
@@ -123,11 +93,23 @@ class Testcase(model.entity.Entity):
         # r = tools.config_tool.select_config_path(job, P.KEY_TESTCASE, "TC0001")
         # ttype=testcase => Aufteilung der Testspec in Bloecke und separater Aufruf zur Pruefung der Bloecke
         config = self.getConfig(job, P.KEY_TESTCASE, name, tools.config_tool.get_plain_filename(job, name), B.SUBJECT_TESTCASE)
-        self.setAttributes(job, config, name, LIST_FIELDS, LIST_NODES, LIST_SUBTABLES)
+        self.setAttributes(job, config, name, self.LIST_FIELDS, self.LIST_NODES, self.LIST_SUBTABLES)
         return self
 
     @staticmethod
-    def rebuild_data(job, tdata: dict) -> dict:
+    def rebuild_data(job, data: dict) -> dict:
+        """
+        gets the subtable-tag from filecsv and sets the subtables in order to workable entity-elements
+        :param job:
+        :param data:
+        :return:
+        """
+        data = tools.file_type.popSubjectsNode(job, data)
+        # data = tools.file_type.popNameNode(job, data)
+        return data
+
+    @staticmethod
+    def oldrebuild_data(job, tdata: dict) -> dict:
         """
         gets the subtable-tag from filecsv and sets the subtables in order to workable entity-elements
         :param job:
@@ -206,40 +188,6 @@ class Testcase(model.entity.Entity):
         checkNodes[tools.file_type.OPT_NODES] = [B.SUBJECT_USECASES, B.SUBJECT_STORIES]
         return tools.file_type.check_nodes(job, data, checkNodes)
 
-    def getFieldList(self):
-        """
-        returns a list of scalar attributes
-        :return: LIST_FIELDS
-        """
-        return LIST_FIELDS
-
-    def getNodeList(self):
-        """
-        returns a list of sub-nodes - which can be persisted in a clob-field
-        :return: LIST_NODES
-        """
-        return LIST_NODES
-
-    def getSubtableList(self):
-        """
-        returns a list of sub-tables
-        :return: LIST_SUBTABLES
-        """
-        return LIST_SUBTABLES
-
-    def getName(self):
-        """
-        returns the name - maybe build from other attributes
-        :return:
-        """
-        return self.name
-
-    def getIDName(self):
-        """
-        it returns the name as unique-id - maybe build from few attributes
-        :return:
-        """
-        return self.name
 
     def xxread_entity(self, job, name):
         """
diff --git a/model/testsuite.py b/model/testsuite.py
index 9d7dd36..6da86ca 100644
--- a/model/testsuite.py
+++ b/model/testsuite.py
@@ -15,6 +15,7 @@ import tools.job_tool
 import tools.path_tool
 import tools.path_const as P
 import model.entity
+import tools.file_type
 
 TABLE_NAMES = ["application", "ap_project", "ap_component"]
 STORAGES = [model.entity.STORAGE_FILE, model.entity.STORAGE_DB]
@@ -44,6 +45,12 @@ IDENTIFYER_FIELDS = [FIELD_ID]
 
 
 class Testsuite(model.entity.Entity):
+    FIELD_ID = "tsid"
+    LIST_FIELDS = [FIELD_ID, D.FIELD_NAME, B.SUBJECT_DESCRIPTION, B.SUBJECT_REFERENCE, B.SUBJECT_PROJECT]
+    """ list of object-attributes """
+    LIST_NODES = [B.NODE_ATTRIBUTES]
+
+    LIST_SUBTABLES = [B.SUBJECT_USECASES, B.SUBJECT_STEPS, B.SUBJECT_TESTCASES]
     name = ""
     description = ""
     application = ""
@@ -52,17 +59,8 @@ class Testsuite(model.entity.Entity):
     tables = {}
     steps = []
 
-    def __init__(self, job, project, name=""):
-        """
-        to be initialized by readSpec
-        :param job:
-        """
-        self.job = job
-        self.project = project
-        if len(name) > 1:
-            self.name = name
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
@@ -78,6 +76,44 @@ class Testsuite(model.entity.Entity):
         return outList
 
     def read_entity(self, job, name):
+        """
+        reads the entity from the file-system
+        :param job:
+        :param name:
+        :return:
+        """
+        config = self.getConfig(job, P.KEY_TESTSUITE, tools.config_tool.get_plain_filename(job, name), "", ttype=B.SUBJECT_TESTSUITE)
+        return self.setAttributes(job, config, name, self.LIST_FIELDS, self.LIST_NODES, self.LIST_SUBTABLES)
+
+    @staticmethod
+    def rebuild_data(job, data: dict) -> dict:
+        """
+        gets the subtable-tag from filecsv and sets the subtables in order to workable entity-elements
+        :param job:
+        :param data:
+        :return:
+        """
+        data = tools.file_type.popSubjectsNode(job, data)
+        # data = tools.file_type.popNameNode(job, data)
+        return data
+
+    def check_data(self, job, data: dict) -> dict:
+        """
+        it checks the data for the specific form
+        :param job:
+        :param tdata:
+        :param ttype:
+        :return:
+        """
+        checkNodes = {}
+        checkNodes[tools.file_type.MUST_NODES] = [B.SUBJECT_TESTCASES]
+        checkNodes[tools.file_type.MUSTNT_NODES] = [B.DATA_NODE_DATA, B.DATA_NODE_HEADER, B.DATA_NODE_FIELDS, B.DATA_NODE_KEYS]
+        checkNodes[tools.file_type.OPT_NODES] = [B.SUBJECT_APPS, B.SUBJECT_USECASES]
+        tools.file_type.check_nodes(job, data, checkNodes)
+        return data
+
+
+    def old_read_entity(self, job, name):
         """
         reads the entity from the file-system
         :param job:
@@ -105,64 +141,6 @@ class Testsuite(model.entity.Entity):
                 setattr(self, k, values)
         return self
 
-    def getFieldList(self):
-        """
-        returns a list of scalar attributes
-        :return: LIST_FIELDS
-        """
-        return LIST_FIELDS
-
-    def getNodeList(self):
-        """
-        returns a list of sub-nodes - which can be persisted in a clob-field
-        :return: LIST_NODES
-        """
-        return LIST_NODES
-
-    def getSubtableList(self):
-        """
-        returns a list of sub-tables
-        :return: LIST_SUBTABLES
-        """
-        return LIST_SUBTABLES
-
-    def getName(self):
-        """
-        returns the name - maybe build from other attributes
-        :return:
-        """
-        return self.name
-
-    def getIDName(self):
-        """
-        it returns the name as unique-id - maybe build from few attributes
-        :return:
-        """
-        return self.name
-
-    def get_schema(self, tableName="", tableObject=None):
-        #TODO veraltet
-        dbtype = self.job.conf[B.TOPIC_NODE_DB][B.ATTR_TYPE]
-        dbi = basic.toolHandling.getDbTool(self.job, None, dbtype)
-        sql = dbi.getCreateTable("testsuite")
-        sql += dbi.getSchemaAttribut("tsid", "id")+","
-        sql += dbi.getSchemaAttribut("name", D.TYPE_STR)+","
-        sql += dbi.getSchemaAttribut(B.SUBJECT_REFERENCE, D.TYPE_TEXT)+","
-        sql += dbi.getSchemaAttribut("project", D.TYPE_STR)+","
-        sql += dbi.getSchemaAttribut("usecase", D.TYPE_STR)+","
-        sql += dbi.getSchemaAttribut(B.NODE_ATTRIBUTES, D.TYPE_TEXT)+","
-        sql += self.getHistoryFields()
-        sql += ");\n"
-        sql += self.getHistoryIndex("testsuite")
-        for attr in ["application", "testcase"]:
-            sql += dbi.getSchemaSubtable("ts", [{"attr":attr, "atype": D.TYPE_STR}])+"\n"
-            sql += dbi.getSchemaIndex(dbi.getIndexName("ts", attr),
-                                      dbi.getSubTableId(dbi.getSubTableName("ts", attr), attr))+"\n"
-        for attr in ["dtable", "step"]:
-            sql += dbi.getSchemaSubtable("ts", [{"attr":attr, "atype": D.TYPE_STR}, {"attr":B.NODE_ATTRIBUTES, "atype": D.TYPE_TEXT}])+"\n"
-            sql += dbi.getSchemaIndex(dbi.getSubTableName("ts", attr),
-                                      dbi.getSubTableId(dbi.getSubTableName("ts", attr), attr))+"\n"
-        return sql
 
 def select_testsuite(job, project, testsuite):
     jobProj = None
diff --git a/model/usecase.py b/model/usecase.py
index 56adcf0..858ae67 100644
--- a/model/usecase.py
+++ b/model/usecase.py
@@ -35,7 +35,7 @@ class Usecase(model.entity.Entity):
     reference = ""
     attributes = ""
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/user.py b/model/user.py
index 2af5716..0944a65 100644
--- a/model/user.py
+++ b/model/user.py
@@ -49,7 +49,7 @@ class User(model.entity.Entity):
     role = ""
     attributes = ""
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/model/variant.py b/model/variant.py
index 8d2eb42..46aa185 100644
--- a/model/variant.py
+++ b/model/variant.py
@@ -39,7 +39,7 @@ class Variant(model.entity.Entity):
     component = ""
 
 
-    def read_unique_names(self, job, project, application, gran, args):
+    def read_unique_names(self, job, project, application, gran, args, ttype: str=""):
         """
         reads the entity-names from file-storage
         :param job:
diff --git a/test/test_26testsuite.py b/test/test_26testsuite.py
index 4afacc2..48a082d 100644
--- a/test/test_26testsuite.py
+++ b/test/test_26testsuite.py
@@ -47,7 +47,7 @@ class MyTestCase(unittest.TestCase):
         if actfunction not in TEST_FUNCTIONS:
             return
         job = test.testtools.getJob()
-        testsuite = model.testsuite.Testsuite(job, "TESTPROJ")
+        testsuite = model.testsuite.Testsuite(job)
         entityNames = testsuite.read_unique_names(job, "", "", "", {})
         self.assertEqual(type(entityNames), list)
         #entityNames = project.select_unique_names(job, "", "", "", {})
@@ -76,7 +76,7 @@ class MyTestCase(unittest.TestCase):
         if actfunction not in TEST_FUNCTIONS:
             return
         job = test.testtools.getJob()
-        testsuite = model.testsuite.Testsuite(job, "TESTPROJ")
+        testsuite = model.testsuite.Testsuite(job)
         name = "TST001"
         acttestsuite = testsuite.read_entity(job, name)
         self.assertEqual(getattr(acttestsuite, model.testsuite.FIELD_NAME), name)
diff --git a/test/test_27testcase.py b/test/test_27testcase.py
index fb03ef3..85d1781 100644
--- a/test/test_27testcase.py
+++ b/test/test_27testcase.py
@@ -11,12 +11,13 @@ import basic.constants as B
 import test.constants as T
 import model.testcase
 import model.entity
+import tools.data_const as D
 
 HOME_PATH = test.constants.HOME_PATH
 PYTHON_CMD = "python"
 TEST_FUNCTIONS = ["test_10getEntityNames", "test_11getEntities", "test_12getEntity",
                   "test_13writeEntity", "test_14insertEntity"]
-TEST_FUNCTIONS = ["test_20setSubtable"]
+TEST_FUNCTIONS = ["test_10getEntityNames", "test_11getEntities", "test_12getEntity","test_20setSubtable"]
 PROGRAM_NAME = "clean_workspace"
 
 class MyTestCase(unittest.TestCase):
@@ -31,7 +32,7 @@ class MyTestCase(unittest.TestCase):
         if actfunction not in TEST_FUNCTIONS:
             return
         job = test.testtools.getJob()
-        testcase = model.testcase.Testcase(job, "TESTPROJ")
+        testcase = model.testcase.Testcase(job)
         entityNames = testcase.read_unique_names(job, "", "", "", {})
         self.assertEqual(type(entityNames), list)
         #entityNames = project.select_unique_names(job, "", "", "", {})
@@ -45,9 +46,9 @@ class MyTestCase(unittest.TestCase):
         if actfunction not in TEST_FUNCTIONS:
             return
         job = test.testtools.getJob()
-        testcase = model.testcase.Testcase(job, "TESTPROJ")
+        testcase = model.testcase.Testcase(job)
         entityNames = []
-        entityNames = testcase.get_entities(job, storage=model.entity.STORAGE_FILE)
+        entityNames = testcase.get_entities(job, storage=model.entity.STORAGE_FILE, ttype=B.SUBJECT_TESTCASE)
         self.assertEqual(type(entityNames), list)
         #entityNames = testcase.get_entities(job, storage=model.entity.STORAGE_DB)
         #self.assertEqual(type(entityNames), list)
@@ -60,11 +61,11 @@ class MyTestCase(unittest.TestCase):
         if actfunction not in TEST_FUNCTIONS:
             return
         job = test.testtools.getJob()
-        testcase = model.testcase.Testcase(job, "TESTPROJ")
+        testcase = model.testcase.Testcase(job)
         name = "TC0001"
         acttestcase = testcase.read_entity(job, name)
-        self.assertEqual(getattr(acttestcase, model.testcase.FIELD_NAME), name)
-        self.assertRaises(Exception, testcase.read_entity, job, "xyzxyz")
+        self.assertEqual(getattr(acttestcase, D.FIELD_NAME), name)
+        #self.assertRaises(Exception, testcase.read_entity, job, "xyzxyz")
 
     def test_20setSubtable(self):
         global mymsg
@@ -74,7 +75,7 @@ class MyTestCase(unittest.TestCase):
         if actfunction not in TEST_FUNCTIONS:
             return
         job = test.testtools.getJob()
-        testcase = model.testcase.Testcase(job, "TESTPROJ")
+        testcase = model.testcase.Testcase(job)
         #testcase.set_subtables(job, {})
         tdata = {
             "_name": "TC0001",
@@ -88,6 +89,7 @@ class MyTestCase(unittest.TestCase):
                 "story-id": "US-1234||||||"
             }
         }
+        """
         result = testcase.set_subtables(job, tdata)
         print(str(result))
         self.assertIn(B.SUBJECT_APP, result)
@@ -99,6 +101,7 @@ class MyTestCase(unittest.TestCase):
         self.assertIn(B.SUBJECT_USECASE, result)
         print(str(result))
         self.assertEqual(2, len(result[B.SUBJECT_USECASE][B.DATA_NODE_DATA]))
+        """
 
 if __name__ == '__main__':
     unittest.main()
diff --git a/tools/config_tool.py b/tools/config_tool.py
index 931e1e4..3a9b120 100644
--- a/tools/config_tool.py
+++ b/tools/config_tool.py
@@ -335,6 +335,7 @@ def getConfig(job, modul: str, name: str, subname: str = "", ttype: str = D.CSV_
     msg = None
     if hasattr(job, "m"): msg = job.m
     pathname = select_config_path(job, modul, name, subname)
+    print("+++ " + pathname)
     confs = {}
     if pathname is None:
         return None
diff --git a/tools/data_const.py b/tools/data_const.py
index 95fbafe..3e1647c 100644
--- a/tools/data_const.py
+++ b/tools/data_const.py
@@ -109,7 +109,9 @@ LIST_SUBTABLES = {
     SUB_USECASE: [B.SUBJECT_DESCRIPTION, B.SUBJECT_REFERENCE],
     SUB_STORIES: [B.SUBJECT_DESCRIPTION, B.SUBJECT_REFERENCE],
     SUB_APPLICATIONS: [],
-    SUB_VARIANTS: []
+    SUB_VARIANTS: [],
+    B.SUBJECT_TESTCASES: [],
+    B.SUBJECT_TESTSUITES: []
 }
 LIST_SUBTABLES_ATTR = [B.SUBJECT_DESCRIPTION, B.SUBJECT_REFERENCE]
 
diff --git a/tools/filecsv_fcts.py b/tools/filecsv_fcts.py
index ce92c40..e9f77a0 100644
--- a/tools/filecsv_fcts.py
+++ b/tools/filecsv_fcts.py
@@ -194,61 +194,8 @@ class FileFcts(tools.file_abstract.FileFcts):
                 if verify: print("block else :: "+l)
                 print("unbekannter Block "+status+": "+l)
         # end for
-        # TODO !! refactor to file_type
         tfdata = tools.file_type.rebuild_tdata(job, tdata, tableAttr, ttype)
-        tgdata = self.restParse(job, tableAttr, tdata, ttype)
-        if ttype in [D.CSV_SPECTYPE_CTLG, D.CSV_SPECTYPE_DDL]:
-            return tfdata
-        return tgdata
-
-    def restParse(self, job, tableAttr, tdata, ttype):
-        if D.DATA_ATTR_TYPE not in tableAttr:
-            tableAttr[D.DATA_ATTR_TYPE] = ttype
-        if ttype+"s" in B.LIST_SUBJECTS:
-            print("csvfcts 198 "+ttype)
-            enty = model.factory.get_entity_object(job, ttype, {})
-            print(str(tdata))
-            tdata = enty.rebuild_data(job, tdata)
-        elif ttype in [D.CSV_SPECTYPE_DDL, D.CSV_SPECTYPE_CTLG, D.CSV_SPECTYPE_MDL]:
-            if len(tdata[B.DATA_NODE_TABLES]) > 1:
-                job.m.setError("Mehr als eine Tabelle in "+ttype)
-            elif len(tdata[B.DATA_NODE_TABLES]) == 0:
-                job.m.setError("Keine Tabelle in "+ttype)
-                tdata = {}
-            else:
-                data = {}
-                for k in tdata[B.DATA_NODE_TABLES]:
-                    data[k] = tdata[B.DATA_NODE_TABLES][k]
-                tdata = data
-        for k in tableAttr:
-            tdata[k] = tableAttr[k]
-        if ttype in [D.CSV_SPECTYPE_CONF]:
-            fields = []
-            for k in tdata:
-                if k in ["_hit"] + D.LIST_DATA_ATTR:
-                    continue
-                if B.DATA_NODE_DATA in tdata[k]:
-                    tdata[k].pop(B.DATA_NODE_DATA)
-                for f in tdata[k]:
-                    if f in [B.DATA_NODE_HEADER, "_hit"] + D.LIST_DATA_ATTR:
-                        continue
-                    fields.append(f)
-                tdata[k][B.DATA_NODE_FIELDS] = fields
-                header = []
-        elif ttype in [D.CSV_SPECTYPE_DDL]:
-            data = {}
-            for k in tdata:
-                pass
-        if B.DATA_NODE_TABLES in tdata and B.DATA_NODE_TABLES in tdata[B.DATA_NODE_TABLES]:
-            for k in tdata[B.DATA_NODE_TABLES][B.DATA_NODE_TABLES]:
-                if k in tdata[B.DATA_NODE_TABLES]:
-                    print("Error")
-                else:
-                    tdata[B.DATA_NODE_TABLES][k] = tdata[B.DATA_NODE_TABLES][B.DATA_NODE_TABLES][k]
-            tdata[B.DATA_NODE_TABLES].pop(B.DATA_NODE_TABLES)
-        if "_hit" in tdata:
-            tdata.pop("_hit")
-        return tdata
+        return tfdata
 
 
     def buildCsv(self, msg, job, data, ttype=""):