rework combinators

bin/ffx/test/disposition_combinator_2.py

@@ -2,13 +2,15 @@ import os, sys, importlib, glob, inspect, itertools
 
 class DispositionCombinator2():
 
+    IDENTIFIER = 'disposition2'
+
     def __init__(self, context = None):
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
     def getIdentifier(self):
-        return self._identifier
+        return DispositionCombinator2.IDENTIFIER
     def getVariant(self):
         return self._variant
 
@@ -31,46 +33,3 @@ class DispositionCombinator2():
     @staticmethod
     def getAllClassReferences():
         return [DispositionCombinator2.getClassReference(i) for i in DispositionCombinator2.list()]
-
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-        yieldObj[self.getIdentifier()] = self.getPayload()
-
-        #assertFuncList = yieldObj.pop('asserts', [])
-        #variants = yieldObj.pop('variants', set())
-
-        sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-
-        #y = []
-        for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-            z = {}
-            for i in range(len(p)):
-                z[sc_list[i][0]] = p[i]
-
-            
-            #y.append(z)
-            for k,v in z.items():
-                yieldObj[k] = v
-
-                assertFunc = getattr(v, "assertFunc", None)
-                if callable(assertFunc):
-                    yieldObj['asserts'].append(assertFunc)
-
-                shouldFailFunc = getattr(v, "shouldFail", None)
-                if callable(shouldFailFunc):
-                    if shouldFailFunc():
-                        yieldObj['shouldFail'] = True
-
-                yieldObj['variants'].add(v.getVariant())
-
-        #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-        yield yieldObj

bin/ffx/test/disposition_combinator_2_0.py

@@ -6,16 +6,13 @@ from .disposition_combinator_2 import DispositionCombinator2
 
 class DispositionCombinator20(DispositionCombinator2):
 
-    IDENTIFIER = 'disposition2'
     VARIANT = 'D00'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator20.IDENTIFIER
         self._variant = DispositionCombinator20.VARIANT
         
-        
     def getPayload(self):
         return (set(),  # 0
                 set())  # 1

bin/ffx/test/disposition_combinator_2_1.py

@@ -6,16 +6,13 @@ from .disposition_combinator_2 import DispositionCombinator2
 
 class DispositionCombinator21(DispositionCombinator2):
 
-    IDENTIFIER = 'disposition2'
     VARIANT = 'D10'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator21.IDENTIFIER
         self._variant = DispositionCombinator21.VARIANT
 
-
     def getPayload(self):
         return (set([TrackDisposition.DEFAULT]),    # 0
                 set())                              # 1

bin/ffx/test/disposition_combinator_2_2.py

@@ -6,16 +6,13 @@ from .disposition_combinator_2 import DispositionCombinator2
 
 class DispositionCombinator22(DispositionCombinator2):
 
-    IDENTIFIER = 'disposition2'
     VARIANT = 'D01'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator22.IDENTIFIER
         self._variant = DispositionCombinator22.VARIANT
 
-
     def getPayload(self):
         return (set(),                              # 0
                 set([TrackDisposition.DEFAULT]))    # 1

bin/ffx/test/disposition_combinator_2_3 .py

@@ -6,22 +6,19 @@ from .disposition_combinator_2 import DispositionCombinator2
 
 class DispositionCombinator23(DispositionCombinator2):
 
-    IDENTIFIER = 'disposition2'
     VARIANT = 'D11'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator23.IDENTIFIER
         self._variant = DispositionCombinator23.VARIANT
 
-
     def getPayload(self):
         return (set([TrackDisposition.DEFAULT]),    # 0
                 set([TrackDisposition.DEFAULT]))    # 1
 
-    # def assertFunc(self, trackDescriptors):
+    def assertFunc(self, trackDescriptors):
-    #     pass
+        pass
 
     def shouldFail(self):
         return True

bin/ffx/test/disposition_combinator_3.py

@@ -2,13 +2,15 @@ import os, sys, importlib, glob, inspect, itertools
 
 class DispositionCombinator3():
 
+    IDENTIFIER = 'disposition3'
+
     def __init__(self, context = None):
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
     def getIdentifier(self):
-        return self._identifier
+        return DispositionCombinator3.IDENTIFIER
     def getVariant(self):
         return self._variant
 
@@ -31,46 +33,3 @@ class DispositionCombinator3():
     @staticmethod
     def getAllClassReferences():
         return [DispositionCombinator3.getClassReference(i) for i in DispositionCombinator3.list()]
-
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-        yieldObj[self.getIdentifier()] = self.getPayload()
-
-        #assertFuncList = yieldObj.pop('asserts', [])
-        #variants = yieldObj.pop('variants', set())
-
-        sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-
-        #y = []
-        for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-            z = {}
-            for i in range(len(p)):
-                z[sc_list[i][0]] = p[i]
-
-            
-            #y.append(z)
-            for k,v in z.items():
-                yieldObj[k] = v
-
-                assertFunc = getattr(v, "assertFunc", None)
-                if callable(assertFunc):
-                    yieldObj['asserts'].append(assertFunc)
-
-                shouldFailFunc = getattr(v, "shouldFail", None)
-                if callable(shouldFailFunc):
-                    if shouldFailFunc():
-                        yieldObj['shouldFail'] = True
-
-                yieldObj['variants'].add(v.getVariant())
-
-        #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-        yield yieldObj

bin/ffx/test/disposition_combinator_3_0.py

@@ -6,16 +6,13 @@ from .disposition_combinator_3 import DispositionCombinator3
 
 class DispositionCombinator30(DispositionCombinator3):
 
-    IDENTIFIER = 'disposition3'
     VARIANT = 'D000'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator30.IDENTIFIER
         self._variant = DispositionCombinator30.VARIANT
 
-
     def getPayload(self):
         return (set(),    # 0
                 set(),    # 1

bin/ffx/test/disposition_combinator_3_1.py

@@ -6,16 +6,13 @@ from .disposition_combinator_3 import DispositionCombinator3
 
 class DispositionCombinator31(DispositionCombinator3):
 
-    IDENTIFIER = 'disposition3'
     VARIANT = 'D100'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator31.IDENTIFIER
         self._variant = DispositionCombinator31.VARIANT
 
-
     def getPayload(self):
         return (set([TrackDisposition.DEFAULT]),    # 0
                 set(),                              # 1

bin/ffx/test/disposition_combinator_3_2.py

@@ -6,16 +6,13 @@ from .disposition_combinator_3 import DispositionCombinator3
 
 class DispositionCombinator32(DispositionCombinator3):
 
-    IDENTIFIER = 'disposition3'
     VARIANT = 'D010'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator32.IDENTIFIER
         self._variant = DispositionCombinator32.VARIANT
 
-
     def getPayload(self):
         return (set(),                              # 0
                 set([TrackDisposition.DEFAULT]),    # 1

bin/ffx/test/disposition_combinator_3_3.py

@@ -6,16 +6,13 @@ from .disposition_combinator_3 import DispositionCombinator3
 
 class DispositionCombinator33(DispositionCombinator3):
 
-    IDENTIFIER = 'disposition3'
     VARIANT = 'D001'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator33.IDENTIFIER
         self._variant = DispositionCombinator33.VARIANT
 
-
     def getPayload(self):
         return (set(),                              # 0
                 set(),                              # 1

bin/ffx/test/disposition_combinator_3_4.py

@@ -6,13 +6,11 @@ from .disposition_combinator_3 import DispositionCombinator3
 
 class DispositionCombinator34(DispositionCombinator3):
 
-    IDENTIFIER = 'disposition3'
     VARIANT = 'D101'
 
     def __init__(self, context):
         super().__init__(context)
 
-        self._identifier = DispositionCombinator34.IDENTIFIER
         self._variant = DispositionCombinator34.VARIANT
 
     def getPayload(self):
@@ -20,8 +18,8 @@ class DispositionCombinator34(DispositionCombinator3):
                 set(),                              # 1
                 set([TrackDisposition.DEFAULT]))    # 2
 
-    # def assertFunc(self, trackDescriptors):
+    def assertFunc(self, trackDescriptors):
-    #     pass
+        pass
 
     def shouldFail(self):
         return True

bin/ffx/test/media_combinator.py

@@ -1,6 +1,8 @@
 import os, sys, importlib, glob, inspect, itertools
 
-class TrackCombinator():
+class MediaCombinator():
+
+    IDENTIFIER = 'media'
 
     def __init__(self, context = None):
         self._context = context
@@ -17,17 +19,17 @@ class TrackCombinator():
         basePath = os.path.dirname(__file__)
         return [os.path.basename(p)[17:-3]
                 for p
-                in glob.glob(f"{ basePath }/track_combinator_*.py", recursive = True)
+                in glob.glob(f"{ basePath }/media_combinator_*.py", recursive = True)
                 if p != __file__]
 
     @staticmethod
     def getClassReference(identifier):
-        importlib.import_module(f"ffx.test.track_combinator_{ identifier }")
+        importlib.import_module(f"ffx.test.media_combinator_{ identifier }")
-        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.track_combinator_{ identifier }"]):
+        for name, obj in inspect.getmembers(sys.modules[f"ffx.test.media_combinator_{ identifier }"]):
-            #HINT: Excluding TrackCombinator as it seems to be included by import (?)
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
-            if inspect.isclass(obj) and name != 'TrackCombinator' and name.startswith('TrackCombinator'):
+            if inspect.isclass(obj) and name != 'MediaCombinator' and name.startswith('MediaCombinator'):
                 return obj
 
     @staticmethod
     def getAllClassReferences():
-        return [TrackCombinator.getClassReference(i) for i in TrackCombinator.list()]
+        return [MediaCombinator.getClassReference(i) for i in MediaCombinator.list()]

bin/ffx/test/media_combinator_0.py

@@ -0,0 +1,65 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+
+class MediaCombinator0(MediaCombinator):
+
+    VARIANT = 'VA'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinators
+
+        self._identifier = MediaCombinator0.IDENTIFIER
+        self._variant = MediaCombinator0.VARIANT
+
+
+    def getPayload(self):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor1,
+                                                                trackDescriptor2]
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+    def assertFunc(self, testObj):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        yieldObj = {}
+
+        yieldObj['identifier'] = MediaCombinator0.IDENTIFIER
+        yieldObj['variants'] = [MediaCombinator0.VARIANT]
+        yieldObj['payload'] = self.getPayload()
+
+        yieldObj['assertFuncs'] = [self.assertFunc]
+        yieldObj['shouldFail'] = self.shouldFail()
+
+        yield yieldObj

bin/ffx/test/media_combinator_1.py

@@ -0,0 +1,71 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+class MediaCombinator1(MediaCombinator):
+
+    VARIANT = 'VAS'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinations
+
+        self._identifier = MediaCombinator1.IDENTIFIER
+        self._variant = MediaCombinator1.VARIANT
+
+    def getPayload(self):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+    def assertFunc(self, testObj):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        yieldObj = {}
+
+        yieldObj['identifier'] = MediaCombinator1.IDENTIFIER
+        yieldObj['variants'] = [MediaCombinator1.VARIANT]
+
+        yieldObj['payload'] = self.getPayload()
+        yieldObj['assertFuncs'] = [self.assertFunc]
+        yieldObj['shouldFail'] = self.shouldFail()
+
+        yield yieldObj

bin/ffx/test/media_combinator_2.py

@@ -0,0 +1,85 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+
+class MediaCombinator2(MediaCombinator):
+
+    VARIANT = 'VASS'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinators
+
+        self._identifier = MediaCombinator2.IDENTIFIER
+        self._variant = MediaCombinator2.VARIANT
+
+    def getPayload(self, subtitleDispositionTuple = (set(), set())):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
+        trackDescriptor3 = TrackDescriptor(**kwargs)
+      
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] =  [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+    def assertFunc(self, testObj):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for DC2 in DispositionCombinator2.getAllClassReferences():
+
+            dc2 = DC2(self._context)
+
+            yieldObj = {}
+
+            yieldObj['identifier'] = MediaCombinator2.IDENTIFIER
+            yieldObj['variants'] = [MediaCombinator2.VARIANT, f"S:{dc2.getVariant()}"]
+
+            yieldObj['payload'] = self.getPayload(dc2.getPayload())
+            yieldObj['assertFuncs'] = [self.assertFunc, dc2.assertFunc]
+            yieldObj['shouldFail'] = self.shouldFail() | dc2.shouldFail()
+
+            yield yieldObj

bin/ffx/test/media_combinator_3.py

@@ -0,0 +1,95 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class MediaCombinator3(MediaCombinator):
+
+    VARIANT = 'VASSS'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinations
+
+        self._identifier = MediaCombinator3.IDENTIFIER
+        self._variant = MediaCombinator3.VARIANT
+
+
+    def getPayload(self, subtitleDispositionTuple = (set(), set(), set())):
+        
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
+        trackDescriptor3 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2]
+        trackDescriptor4 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] =  [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3,
+                trackDescriptor4]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for DC3 in DispositionCombinator3.getAllClassReferences():
+
+            dc3 = DC3(self._context)
+
+            yieldObj = {}
+
+            yieldObj['identifier'] = MediaCombinator3.IDENTIFIER
+            yieldObj['variants'] = [MediaCombinator3.VARIANT, f"S:{dc3.getVariant()}"]
+
+            yieldObj['payload'] = self.getPayload(dc3.getPayload())
+            yieldObj['assertFuncs'] = [self.assertFunc, dc3.assertFunc]
+            yieldObj['shouldFail'] = self.shouldFail() | dc3.shouldFail()
+
+            yield yieldObj

bin/ffx/test/media_combinator_4.py

@@ -0,0 +1,81 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class MediaCombinator4(MediaCombinator):
+
+    VARIANT = 'VAA'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinations
+
+        self._identifier = MediaCombinator4.IDENTIFIER
+        self._variant = MediaCombinator4.VARIANT
+
+    def getPayload(self, audioDispositionTuple = (set(), set())):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] =  [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for DC2 in DispositionCombinator2.getAllClassReferences():
+
+            dc2 = DC2(self._context)
+
+            yieldObj = {}
+
+            yieldObj['identifier'] = MediaCombinator4.IDENTIFIER
+            yieldObj['variants'] = [MediaCombinator4.VARIANT, f"A:{dc2.getVariant()}"]
+
+            yieldObj['payload'] = self.getPayload(dc2.getPayload())
+            yieldObj['assertFuncs'] = [self.assertFunc, dc2.assertFunc]
+            yieldObj['shouldFail'] = self.shouldFail() | dc2.shouldFail()
+
+            yield yieldObj

bin/ffx/test/media_combinator_5.py

@@ -0,0 +1,88 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class MediaCombinator5(MediaCombinator):
+
+    VARIANT = 'VAAS'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinations
+
+        self._identifier = MediaCombinator5.IDENTIFIER
+        self._variant = MediaCombinator5.VARIANT
+
+    def getPayload(self, audioDispositionTuple = (set(), set())):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        trackDescriptor3 = TrackDescriptor(**kwargs)
+
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for DC2 in DispositionCombinator2.getAllClassReferences():
+
+            dc2 = DC2(self._context)
+
+            yieldObj = {}
+
+            yieldObj['identifier'] = MediaCombinator5.IDENTIFIER
+            yieldObj['variants'] = [MediaCombinator5.VARIANT, f"A:{dc2.getVariant()}"]
+
+            yieldObj['payload'] = self.getPayload(dc2.getPayload())
+            yieldObj['assertFuncs'] = [self.assertFunc, dc2.assertFunc]
+            yieldObj['shouldFail'] = self.shouldFail() | dc2.shouldFail()
+
+            yield yieldObj

bin/ffx/test/media_combinator_6.py

@@ -0,0 +1,97 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class MediaCombinator6(MediaCombinator):
+
+    VARIANT = 'VAASS'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinations
+
+        self._identifier = MediaCombinator6.IDENTIFIER
+        self._variant = MediaCombinator6.VARIANT
+
+    def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set())):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
+        trackDescriptor3 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
+        trackDescriptor4 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3,
+                trackDescriptor4]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for DC2_A in DispositionCombinator2.getAllClassReferences():
+            for DC2_S in DispositionCombinator2.getAllClassReferences():
+
+                dc2a = DC2_A(self._context)
+                dc2s = DC2_S(self._context)
+
+                yieldObj = {}
+
+                yieldObj['identifier'] = MediaCombinator6.IDENTIFIER
+                yieldObj['variants'] = [MediaCombinator6.VARIANT, f"A:{dc2a.getVariant()}", f"S:{dc2s.getVariant()}"]
+
+                yieldObj['payload'] = self.getPayload(dc2a.getPayload(), dc2s.getPayload())
+                yieldObj['assertFuncs'] = [self.assertFunc, dc2a.assertFunc, dc2s.assertFunc]
+                yieldObj['shouldFail'] = self.shouldFail() | dc2a.shouldFail() | dc2s.shouldFail()
+
+                yield yieldObj

bin/ffx/test/media_combinator_7.py

@@ -0,0 +1,107 @@
+import os, sys, importlib, glob, inspect, itertools
+
+from ffx.track_type import TrackType
+
+from ffx.track_descriptor import TrackDescriptor
+from ffx.media_descriptor import MediaDescriptor
+
+from .media_combinator import MediaCombinator
+
+from .disposition_combinator_2 import DispositionCombinator2
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class MediaCombinator7(MediaCombinator):
+
+    VARIANT = 'VAASSS'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        # self._SubCombinators = SubCombinations
+
+        self._identifier = MediaCombinator7.IDENTIFIER
+        self._variant = MediaCombinator7.VARIANT
+
+    def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set(), set())):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
+        trackDescriptor3 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
+        trackDescriptor4 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2]
+        trackDescriptor5 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
+        kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor0,
+                trackDescriptor1,
+                trackDescriptor2,
+                trackDescriptor3,
+                trackDescriptor4,
+                trackDescriptor5]
+
+        mediaDescriptor = MediaDescriptor(**kwargs)
+        mediaDescriptor.reindexSubIndices()
+
+        return mediaDescriptor
+
+
+    def assertFunc(self, testObj):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for DC2_A in DispositionCombinator2.getAllClassReferences():
+            for DC3_S in DispositionCombinator3.getAllClassReferences():
+
+                dc2a = DC2_A(self._context)
+                dc3s = DC3_S(self._context)
+
+                yieldObj = {}
+
+                yieldObj['identifier'] = MediaCombinator7.IDENTIFIER
+                yieldObj['variants'] = [MediaCombinator7.VARIANT, f"A:{dc2a.getVariant()}", f"S:{dc3s.getVariant()}"]
+
+                yieldObj['payload'] = self.getPayload(dc2a.getPayload(), dc3s.getPayload())
+
+                yieldObj['assertFuncs'] = [self.assertFunc, dc2a.assertFunc, dc3s.assertFunc]
+
+                yieldObj['shouldFail'] = self.shouldFail() | dc2a.shouldFail() | dc3s.shouldFail()
+
+                yield yieldObj

bin/ffx/test/scenario_1.py

@@ -13,7 +13,7 @@ from ffx.track_descriptor import TrackDescriptor
 from ffx.track_type import TrackType
 from ffx.track_disposition import TrackDisposition
 
-from ffx.test.track_combinator import TrackCombinator
+from ffx.test.media_combinator import MediaCombinator
 
 
 class Scenario1(Scenario):
@@ -25,147 +25,17 @@ class Scenario1(Scenario):
         super().__init__(context)
 
 
-    def run(self):
+    def job(self, yieldObj: dict):
-
-        TC_list = TrackCombinator.getAllClassReferences()
-
-        for TC in TC_list:
-
-            self._logger.debug(f"TC={TC.__name__}")
-
-            tc = TC(context = self._context)
 
-            for y in tc.getYield():
+        identifier = yieldObj['identifier']
-                print(y)
+        variantList = yieldObj['variants']
+        variantIdentifier = '-'.join(variantList)
+        mediaDescriptor = yieldObj['payload']
+        assertFuncList = yieldObj['assertFuncs']
+        shouldFail = yieldObj['shouldFail']
 
+        self._logger.info(f"Running Scenario 1 Job {variantIdentifier}")
 
-#     def run(self):
-# 
-#         #   TrackCombinations -> asserts
-#         #   * Dispositions[2] -> asserts[2]
-#         #   * Tags[2] -> asserts[2]
-#         #   * MediaTags -> asserts
-# 
-#         for tci in TrackCombination.list():
-#             # combinationContext = self._context.copy()
-#             self._context['use_jellyfin'] = True
-#             self._context['use_tmdb'] = False
-#             self._context['use_pattern'] = False
-#             trackCombination = TrackCombination.getClassReference(tci)(self._context)
-#             
-#             subcombinations = trackCombination.getSubcombinations()
-#             if not subcombinations is None:
-#                 for trackDescriptors, evaluateFunc, shouldFail, combinationIdentifier in subcombinations:
-#                     
-#                     kwargs = {}
-#                     kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
-#                     kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = trackDescriptors
-#                     self._logger.debug(f"src track dispositions {[d.getDispositionSet() for d in trackDescriptors]}")
-#                     sourceMediaDescriptor = MediaDescriptor(**kwargs)
-#                     sourceMediaDescriptor.reindexSubIndices()
-#                     # sourceMediaDescriptor.reindexIndices()
-# 
-#                     # Phase 1: Setup source files
-#                     # TODO:
-#                     # src track dispositions [set(), set(), {<TrackDisposition.DEFAULT: {'name': 'default', 'index': 0}>}, set(), set()]
-#                     # vs
-#                     # Stream #0:4: Subtitle: ass (ssa) (default)
-#                     mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor, directory=self._testDirectory)
-# 
-#                     # Phase 2: Prepare database
-# 
-#                     # Phase 3: Run ffx
-#                     commandSequence = [sys.executable,
-#                                         self._ffxExecutablePath,
-#                                         'convert',
-#                                         mediaFilePath,
-#                                         '--no-prompt']
-#                     
-#                     if not self._context['use_jellyfin']:
-#                         commandSequence += ['--no-jellyfin']
-# 
-#                     self._logger.debug(f"Scenario1.run(): sub={trackCombination.getIdentifier()},{combinationIdentifier} test sequence: {commandSequence}")
-# 
-#                     out, err, rc = executeProcess(commandSequence, directory = self._testDirectory)
-# 
-#                     self._logger.debug(f"Scenario1.run(): sub={trackCombination.getIdentifier()},{combinationIdentifier} process returned: {rc}")
-# 
-#                     # if out:
-#                     #     self._logger.debug(f"Scenario1.run(): process output: {out}")
-#                     # if rc:
-#                     #     self._logger.error(f"Scenario1.run(): process resultet in error {rc}: {err}")
-# 
-#                     # Phase 4: Evaluate results
-# 
-#                     try:
-# 
-#                         if rc:
-#                             # Stuck with prompt: More than one default subtitle stream detected! Please select stream:
-#                             # TODO: Catch prompt is add option to fail at prompt
-#                             assert shouldFail, "ffmpeg run didn't fail" if shouldFail else "ffmpeg run failed"
-#                             self._reportLogger.info(f"Scenario 1 sub={trackCombination.getIdentifier()},{combinationIdentifier} test passed")
-#                         else:
-# 
-#                             resultFile = os.path.join(self._testDirectory, 'media.webm')
-# 
-#                             assert os.path.isfile(resultFile), f"Result file 'media.webm' in path '{self._testDirectory}' wasn't created"
-# 
-#                             resultFileProperties = FileProperties(self._context, resultFile)
-#                             resultMediaDescriptor = resultFileProperties.getMediaDescriptor()
-# 
-#                             resultMediaTracks = resultMediaDescriptor.getAllTrackDescriptors()
-# 
-#                             assert len(resultMediaTracks) == len(trackDescriptors), f"Result file contains unexpected number of streams"
-# 
-#                             # assert resultMediaTracks[0].getType() == TrackType.VIDEO, f"Stream #0 is not of type video"
-# 
-#                             # assert resultMediaTracks[1].getType() == TrackType.AUDIO, f"Stream #1 is not of type audio"
-# 
-#                             # assert resultMediaTracks[2].getType() == TrackType.AUDIO, f"Stream #2 is not of type audio"
-# 
-#                             self._logger.debug(f"tgt track dispositions {[d.getDispositionSet() for d in resultMediaDescriptor.getSubtitleTracks()]}")
-# 
-#                             # assert dispositions
-#                             evaluateFunc(resultMediaTracks)
-# 
-#                             self._reportLogger.info(f"Scenario 1 sub={trackCombination.getIdentifier()},{combinationIdentifier} test passed")
-# 
-#                     except AssertionError as ae:
-# 
-#                         self._reportLogger.error(f"Scenario 1 sub={trackCombination.getIdentifier()},{combinationIdentifier} test failed ({ae})")
-# 
-# 
-# 
-# 
-#     def job(self):
-# 
-#         self._logger.info(f"Running {self.__class__.__name__}")
-# 
-#         kwargs = {}
-#         kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-#         kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-#         kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = set([TrackDisposition.DEFAULT])
-#         trackDescriptor1 = TrackDescriptor(**kwargs)
-# 
-#         kwargs = {}
-#         kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-#         kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-#         kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = set([TrackDisposition.DEFAULT])
-#         trackDescriptor2 = TrackDescriptor(**kwargs)
-# 
-#         kwargs = {}
-#         kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-#         kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-#         trackDescriptor3 = TrackDescriptor(**kwargs)
-# 
-#         kwargs = {}
-#         kwargs[MediaDescriptor.CONTEXT_KEY] = self._context
-#         kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor1,
-#                                                                 trackDescriptor2,
-#                                                                 trackDescriptor3]
-#         sourceMediaDescriptor = MediaDescriptor(**kwargs)
-#         sourceMediaDescriptor.reindexSubIndices()
-# 
 #         # Phase 1: Setup source files
 #         mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor, directory=self._testDirectory)
 # 
@@ -214,3 +84,18 @@ class Scenario1(Scenario):
 #         except AssertionError as ae:
 # 
 #             self._reportLogger.error(f"Scenario 1 test failed ({ae})")
+
+
+    def run(self):
+
+        MC_list = MediaCombinator.getAllClassReferences()
+
+        for MC in MC_list:
+
+            self._logger.debug(f"MC={MC.__name__}")
+
+            mc = MC(context = self._context)
+
+            for y in mc.getYield():
+                self.job(y)
+

bin/ffx/test/track_combinator_0.py

@@ -1,87 +0,0 @@
-import os, sys, importlib, glob, inspect, itertools
-
-from ffx.track_type import TrackType
-from ffx.track_descriptor import TrackDescriptor
-from .track_combinator import TrackCombinator
-
-
-class TrackCombinator0(TrackCombinator):
-
-    IDENTIFIER = 'tracks'
-    VARIANT = 'VA'
-
-    def __init__(self, SubCombinators: dict = {}, context = None):
-        self._context = context
-        self._logger = context['logger']
-        self._reportLogger = context['report_logger']
-
-        self._SubCombinators = SubCombinators
-
-        self._identifier = TrackCombinator0.IDENTIFIER
-        self._variant = TrackCombinator0.VARIANT
-
-
-    def getPayload(self):
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-        trackDescriptor0 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        trackDescriptor1 = TrackDescriptor(**kwargs)
-
-        return [trackDescriptor0,
-                trackDescriptor1]
-
-
-    # def assertFunc(self, testObj):
-    #     pass
-
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-        yo = yieldObj.copy()
-
-        yo[self.getIdentifier()] = self.getPayload()
-
-        yo['variants'].add(self.getVariant())
-
-#         #assertFuncList = yo.pop('asserts', [])
-#         #variants = yo.pop('variants', set())
-# 
-#         sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-# 
-#         #y = []
-#         for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-#             z = {}
-#             for i in range(len(p)):
-#                 z[sc_list[i][0]] = p[i]
-# 
-#             
-#             #y.append(z)
-#             for k,v in z.items():
-#                 yo[k] = v
-# 
-#                 assertFunc = getattr(v, "assertFunc", None)
-#                 if callable(assertFunc):
-#                     yo['asserts'].append(assertFunc)
-# 
-#                 shouldFailFunc = getattr(v, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-#                 yo['variants'].add(v.getVariant())
-# 
-#         #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-        yield yo

bin/ffx/test/track_combinator_1.py

@@ -1,91 +0,0 @@
-import os, sys, importlib, glob, inspect, itertools
-
-from ffx.track_type import TrackType
-from ffx.track_descriptor import TrackDescriptor
-from .track_combinator import TrackCombinator
-
-class TrackCombinator1(TrackCombinator):
-
-    IDENTIFIER = 'tracks'
-    VARIANT = 'VAS'
-
-    def __init__(self, SubCombinations: dict = {}, context = None):
-        self._context = context
-        self._logger = context['logger']
-        self._reportLogger = context['report_logger']
-
-        self._SubCombinators = SubCombinations
-
-        self._identifier = TrackCombinator1.IDENTIFIER
-        self._variant = TrackCombinator1.VARIANT
-
-    def getPayload(self):
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-        trackDescriptor0 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        trackDescriptor1 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        trackDescriptor2 = TrackDescriptor(**kwargs)
-        
-        return [trackDescriptor0,
-                trackDescriptor1,
-                trackDescriptor2]
-
-
-    # def assertFunc(self, testObj):
-    #     pass
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-        yo = yieldObj.copy()
-
-        yo[self.getIdentifier()] = self.getPayload()
-
-        yo['variants'].add(self.getVariant())
-
-#         #assertFuncList = yo.pop('asserts', [])
-#         #variants = yo.pop('variants', set())
-# 
-#         sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-# 
-#         #y = []
-#         for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-#             z = {}
-#             for i in range(len(p)):
-#                 z[sc_list[i][0]] = p[i]
-# 
-#             
-#             #y.append(z)
-#             for k,v in z.items():
-#                 yo[k] = v
-# 
-#                 assertFunc = getattr(v, "assertFunc", None)
-#                 if callable(assertFunc):
-#                     yo['asserts'].append(assertFunc)
-# 
-#                 shouldFailFunc = getattr(v, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-#                 yo['variants'].add(v.getVariant())
-# 
-#         #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-        yield yo

bin/ffx/test/track_combinator_2.py

@@ -1,115 +0,0 @@
-import os, sys, importlib, glob, inspect, itertools
-
-from ffx.track_type import TrackType
-from ffx.track_descriptor import TrackDescriptor
-from .track_combinator import TrackCombinator
-
-from .disposition_combinator_2 import DispositionCombinator2
-
-class TrackCombinator2(TrackCombinator):
-
-    IDENTIFIER = 'tracks'
-    VARIANT = 'VASS'
-
-    def __init__(self, SubCombinators: dict = {}, context = None):
-        self._context = context
-        self._logger = context['logger']
-        self._reportLogger = context['report_logger']
-
-        self._SubCombinators = SubCombinators
-
-        self._identifier = TrackCombinator2.IDENTIFIER
-        self._variant = TrackCombinator2.VARIANT
-
-    def getPayload(self, subtitleDispositionTuple = (set(), set())):
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-        trackDescriptor0 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        trackDescriptor1 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
-        trackDescriptor2 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
-        trackDescriptor3 = TrackDescriptor(**kwargs)
-      
-        return [trackDescriptor0,
-                trackDescriptor1,
-                trackDescriptor2,
-                trackDescriptor3]
-
-
-    # def assertFunc(self, testObj):
-    #     pass
-
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-
-
-        for DC in DispositionCombinator2.getAllClassReferences():
-
-            yo = yieldObj.copy()
-
-            yo['variants'].add(self.getVariant())
-
-            dc = DC(context = self._context)
-            yo[self.getIdentifier()] = self.getPayload(dc.getPayload())
-
-            assertFunc = getattr(dc, "assertFunc", None)
-            if callable(assertFunc):
-                yo['asserts'].append(assertFunc)
-
-            shouldFailFunc = getattr(dc, "shouldFail", None)
-            if callable(shouldFailFunc):
-                if shouldFailFunc():
-                    yo['shouldFail'] = True
-
-            yo['variants'].add(dc.getVariant())
-
-#         sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-# 
-#         #y = []
-#         for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-#             z = {}
-#             for i in range(len(p)):
-#                 z[sc_list[i][0]] = p[i]
-# 
-#             
-#             #y.append(z)
-#             for k,v in z.items():
-#                 yo[k] = v
-# 
-#                 assertFunc = getattr(v, "assertFunc", None)
-#                 if callable(assertFunc):
-#                     yo['asserts'].append(assertFunc)
-# 
-#                 shouldFailFunc = getattr(v, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-#                 yo['variants'].add(v.getVariant())
-
-        #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-            yield yo

bin/ffx/test/track_combinator_3.py

@@ -1,123 +0,0 @@
-import os, sys, importlib, glob, inspect, itertools
-
-from ffx.track_type import TrackType
-from ffx.track_descriptor import TrackDescriptor
-from .track_combinator import TrackCombinator
-
-from .disposition_combinator_3 import DispositionCombinator3
-
-
-class TrackCombinator3(TrackCombinator):
-
-    IDENTIFIER = 'tracks'
-    VARIANT = 'VASSS'
-
-    def __init__(self, SubCombinations: dict = {}, context = None):
-        self._context = context
-        self._logger = context['logger']
-        self._reportLogger = context['report_logger']
-
-        self._SubCombinators = SubCombinations
-
-        self._identifier = TrackCombinator3.IDENTIFIER
-        self._variant = TrackCombinator3.VARIANT
-
-
-    def getPayload(self, subtitleDispositionTuple = (set(), set(), set())):
-        
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-        trackDescriptor0 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        trackDescriptor1 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
-        trackDescriptor2 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
-        trackDescriptor3 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2]
-        trackDescriptor4 = TrackDescriptor(**kwargs)
-
-        return [trackDescriptor0,
-                trackDescriptor1,
-                trackDescriptor2,
-                trackDescriptor3,
-                trackDescriptor4]
-
-
-    # def assertFunc(self, testObj):
-    #     pass
-
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-
-        for DC in DispositionCombinator3.getAllClassReferences():
-
-            yo = yieldObj.copy()
-
-            yo['variants'].add(self.getVariant())
-
-            dc = DC(context = self._context)
-            yo[self.getIdentifier()] = self.getPayload(dc.getPayload())
-
-            assertFunc = getattr(dc, "assertFunc", None)
-            if callable(assertFunc):
-                yo['asserts'].append(assertFunc)
-
-            shouldFailFunc = getattr(dc, "shouldFail", None)
-            if callable(shouldFailFunc):
-                if shouldFailFunc():
-                    yo['shouldFail'] = True
-
-            yo['variants'].add(dc.getVariant())
-
-#         sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-# 
-#         #y = []
-#         for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-#             z = {}
-#             for i in range(len(p)):
-#                 z[sc_list[i][0]] = p[i]
-# 
-#             
-#             #y.append(z)
-#             for k,v in z.items():
-#                 yo[k] = v
-# 
-#                 assertFunc = getattr(v, "assertFunc", None)
-#                 if callable(assertFunc):
-#                     yo['asserts'].append(assertFunc)
-# 
-#                 shouldFailFunc = getattr(v, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-#                 yo['variants'].add(v.getVariant())
-
-        #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-            yield yo

bin/ffx/test/track_combinator_4.py

@@ -1,108 +0,0 @@
-import os, sys, importlib, glob, inspect, itertools
-
-from ffx.track_type import TrackType
-from ffx.track_descriptor import TrackDescriptor
-from .track_combinator import TrackCombinator
-
-from .disposition_combinator_2 import DispositionCombinator2
-
-
-class TrackCombinator4(TrackCombinator):
-
-    IDENTIFIER = 'tracks'
-    VARIANT = 'VAA'
-
-    def __init__(self, SubCombinations: dict = {}, context = None):
-        self._context = context
-        self._logger = context['logger']
-        self._reportLogger = context['report_logger']
-
-        self._SubCombinators = SubCombinations
-
-        self._identifier = TrackCombinator4.IDENTIFIER
-        self._variant = TrackCombinator4.VARIANT
-
-    def getPayload(self, audioDispositionTuple = (set(), set())):
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-        trackDescriptor0 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
-        trackDescriptor1 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
-        trackDescriptor2 = TrackDescriptor(**kwargs)
-        
-        return [trackDescriptor0,
-                trackDescriptor1,
-                trackDescriptor2]
-
-    # def assertFunc(self, testObj):
-    #     pass
-
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-
-        for DC in DispositionCombinator2.getAllClassReferences():
-
-            yo = yieldObj.copy()
-
-            yo['variants'].add(self.getVariant())
-
-            dc = DC(context = self._context)
-            yo[self.getIdentifier()] = self.getPayload(dc.getPayload())
-
-            assertFunc = getattr(dc, "assertFunc", None)
-            if callable(assertFunc):
-                yo['asserts'].append(assertFunc)
-
-            shouldFailFunc = getattr(dc, "shouldFail", None)
-            if callable(shouldFailFunc):
-                if shouldFailFunc():
-                    yo['shouldFail'] = True
-
-            yo['variants'].add(dc.getVariant())
-
-#         sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-# 
-#         #y = []
-#         for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-#             z = {}
-#             for i in range(len(p)):
-#                 z[sc_list[i][0]] = p[i]
-# 
-#             
-#             #y.append(z)
-#             for k,v in z.items():
-#                 yo[k] = v
-# 
-#                 assertFunc = getattr(v, "assertFunc", None)
-#                 if callable(assertFunc):
-#                     yo['asserts'].append(assertFunc)
-# 
-#                 shouldFailFunc = getattr(v, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-#                 yo['variants'].add(v.getVariant())
-
-        #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-            yield yo

bin/ffx/test/track_combinator_5.py

@@ -1,114 +0,0 @@
-import os, sys, importlib, glob, inspect, itertools
-
-from ffx.track_type import TrackType
-from ffx.track_descriptor import TrackDescriptor
-from .track_combinator import TrackCombinator
-
-from .disposition_combinator_2 import DispositionCombinator2
-
-
-class TrackCombinator5(TrackCombinator):
-
-    IDENTIFIER = 'tracks'
-    VARIANT = 'VAAS'
-
-    def __init__(self, SubCombinations: dict = {}, context = None):
-        self._context = context
-        self._logger = context['logger']
-        self._reportLogger = context['report_logger']
-
-        self._SubCombinators = SubCombinations
-
-        self._identifier = TrackCombinator5.IDENTIFIER
-        self._variant = TrackCombinator5.VARIANT
-
-    def getPayload(self, audioDispositionTuple = (set(), set())):
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-        trackDescriptor0 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
-        trackDescriptor1 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
-        trackDescriptor2 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        trackDescriptor3 = TrackDescriptor(**kwargs)
-      
-        return [trackDescriptor0,
-                trackDescriptor1,
-                trackDescriptor2,
-                trackDescriptor3]
-
-    # def assertFunc(self, testObj):
-    #     pass
-
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-
-        for DC in DispositionCombinator2.getAllClassReferences():
-
-            yo = yieldObj.copy()
-
-            yo['variants'].add(self.getVariant())
-
-            dc = DC(context = self._context)
-            yo[self.getIdentifier()] = self.getPayload(dc.getPayload())
-
-            assertFunc = getattr(dc, "assertFunc", None)
-            if callable(assertFunc):
-                yo['asserts'].append(assertFunc)
-
-            shouldFailFunc = getattr(dc, "shouldFail", None)
-            if callable(shouldFailFunc):
-                if shouldFailFunc():
-                    yo['shouldFail'] = True
-
-            yo['variants'].add(dc.getVariant())
-
-#         sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-# 
-#         #y = []
-#         for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-#             z = {}
-#             for i in range(len(p)):
-#                 z[sc_list[i][0]] = p[i]
-# 
-#             
-#             #y.append(z)
-#             for k,v in z.items():
-#                 yo[k] = v
-# 
-#                 assertFunc = getattr(v, "assertFunc", None)
-#                 if callable(assertFunc):
-#                     yo['asserts'].append(assertFunc)
-# 
-#                 shouldFailFunc = getattr(v, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-#                 yo['variants'].add(v.getVariant())
-
-        #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-            yield yo

bin/ffx/test/track_combinator_6.py

@@ -1,138 +0,0 @@
-import os, sys, importlib, glob, inspect, itertools
-
-from ffx.track_type import TrackType
-from ffx.track_descriptor import TrackDescriptor
-from .track_combinator import TrackCombinator
-
-from .disposition_combinator_2 import DispositionCombinator2
-
-
-class TrackCombinator6(TrackCombinator):
-
-    IDENTIFIER = 'tracks'
-    VARIANT = 'VAASS'
-
-    def __init__(self, SubCombinations: dict = {}, context = None):
-        self._context = context
-        self._logger = context['logger']
-        self._reportLogger = context['report_logger']
-
-        self._SubCombinators = SubCombinations
-
-        self._identifier = TrackCombinator6.IDENTIFIER
-        self._variant = TrackCombinator6.VARIANT
-
-    def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set())):
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-        trackDescriptor0 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
-        trackDescriptor1 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
-        trackDescriptor2 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
-        trackDescriptor3 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
-        trackDescriptor4 = TrackDescriptor(**kwargs)
-
-        return [trackDescriptor0,
-                trackDescriptor1,
-                trackDescriptor2,
-                trackDescriptor3,
-                trackDescriptor4]
-
-    # def assertFunc(self, testObj):
-    #     pass
-
-
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-
-
-        for DC_A in DispositionCombinator2.getAllClassReferences():
-            for DC_S in DispositionCombinator2.getAllClassReferences():
-
-                yo = yieldObj.copy()
-
-                yo['variants'].add(self.getVariant())
-
-                dc_a = DC_A(context = self._context)
-                dc_s = DC_S(context = self._context)
-
-                yo[self.getIdentifier()] = self.getPayload(dc_a.getPayload(), dc_s.getPayload())
-
-                assertFunc = getattr(dc_a, "assertFunc", None)
-                if callable(assertFunc):
-                    yo['asserts'].append(assertFunc)
-
-                shouldFailFunc = getattr(dc_a, "shouldFail", None)
-                if callable(shouldFailFunc):
-                    if shouldFailFunc():
-                        yo['shouldFail'] = True
-
-                yo['variants'].add(dc_a.getVariant())
-
-                assertFunc = getattr(dc_s, "assertFunc", None)
-                if callable(assertFunc):
-                    yo['asserts'].append(assertFunc)
-
-                shouldFailFunc = getattr(dc_s, "shouldFail", None)
-                if callable(shouldFailFunc):
-                    if shouldFailFunc():
-                        yo['shouldFail'] = True
-
-                yo['variants'].add(dc_s.getVariant())
-
-
-#         sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-# 
-#         #y = []
-#         for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-#             z = {}
-#             for i in range(len(p)):
-#                 z[sc_list[i][0]] = p[i]
-# 
-#             
-#             #y.append(z)
-#             for k,v in z.items():
-#                 yieldObj[k] = v
-# 
-#                 assertFunc = getattr(v, "assertFunc", None)
-#                 if callable(assertFunc):
-#                     yieldObj['asserts'].append(assertFunc)
-# 
-#                 shouldFailFunc = getattr(v, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yieldObj['shouldFail'] = True
-# 
-#                 yieldObj['variants'].add(v.getVariant())
-
-        #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-                yield yo

bin/ffx/test/track_combinator_7.py

@@ -1,155 +0,0 @@
-import os, sys, importlib, glob, inspect, itertools
-
-from ffx.track_type import TrackType
-from ffx.track_descriptor import TrackDescriptor
-from .track_combinator import TrackCombinator
-
-from .disposition_combinator_2 import DispositionCombinator2
-from .disposition_combinator_3 import DispositionCombinator3
-
-
-class TrackCombinator7(TrackCombinator):
-
-    IDENTIFIER = 'tracks'
-    VARIANT = 'VAASSS'
-
-    def __init__(self, SubCombinations: dict = {}, context = None):
-        self._context = context
-        self._logger = context['logger']
-        self._reportLogger = context['report_logger']
-
-        self._SubCombinators = SubCombinations
-
-        self._identifier = TrackCombinator7.IDENTIFIER
-        self._variant = TrackCombinator7.VARIANT
-
-    def getPayload(self, audioDispositionTuple = (set(), set()), subtitleDispositionTuple = (set(), set(), set())):
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
-        trackDescriptor0 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
-        trackDescriptor1 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
-        trackDescriptor2 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
-        trackDescriptor3 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
-        trackDescriptor4 = TrackDescriptor(**kwargs)
-
-        kwargs = {}
-        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
-        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
-        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2]
-        trackDescriptor5 = TrackDescriptor(**kwargs)
-
-        return [trackDescriptor0,
-                trackDescriptor1,
-                trackDescriptor2,
-                trackDescriptor3,
-                trackDescriptor4,
-                trackDescriptor5]
-
-    # def assertFunc(self, testObj):
-    #     pass
-
-    #1 yieldObj leer, kommt aus Schleife in Scenario1
-    def getYield(self, yieldObj: dict = {}):
-
-        if not 'asserts' in yieldObj.keys():
-            yieldObj['asserts'] = []
-        if not 'variants' in yieldObj.keys():
-            yieldObj['variants'] = set()
-        if not 'shouldFail' in yieldObj.keys():
-            yieldObj['shouldFail'] = False
-
-        yieldObj['variants'].add(self.getVariant())
-
-
-        for DC_A in DispositionCombinator2.getAllClassReferences():
-            for DC_S in DispositionCombinator3.getAllClassReferences():
-
-                yo = {}
-                yo['asserts'] = yieldObj['asserts']
-                yo['variants'] = yieldObj['variants']
-                yo['shouldFail'] = yieldObj['shouldFail']
-
-                self._logger.debug(f"Iterating DC_A={DC_A.__name__} DC_S={DC_S.__name__}")
-                self._logger.debug(f"><))))^> yieldObj id={id(yieldObj)}")
-                self._logger.debug(f"><))))^> yo id={id(yo)}")
-
-                dc_a = DC_A(context = self._context)
-                dc_s = DC_S(context = self._context)
-
-
-                yo[self.getIdentifier()] = self.getPayload(dc_a.getPayload(), dc_s.getPayload())
-
-                assertFunc = getattr(dc_a, "assertFunc", None)
-                if callable(assertFunc):
-                    yo['asserts'].append(assertFunc)
-
-#                 shouldFailFunc = getattr(dc_a, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-                yo['variants'].add(f"{dc_a.getVariant()}A")
-# 
-
-                assertFunc = getattr(dc_s, "assertFunc", None)
-                if callable(assertFunc):
-                    yo['asserts'].append(assertFunc)
-
-#                 shouldFailFunc = getattr(dc_s, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-                yo['variants'].add(f"{dc_s.getVariant()}S")
-
-
-#         sc_list = [(k,v) for k,v in self._SubCombinators.items()]
-# 
-#         #y = []
-#         for p in itertools.product(*[v.getYield() for k,v in sc_list]):
-#             z = {}
-#             for i in range(len(p)):
-#                 z[sc_list[i][0]] = p[i]
-# 
-#             
-#             #y.append(z)
-#             for k,v in z.items():
-#                 yo[k] = v
-# 
-#                 assertFunc = getattr(v, "assertFunc", None)
-#                 if callable(assertFunc):
-#                     yo['asserts'].append(assertFunc)
-# 
-#                 shouldFailFunc = getattr(v, "shouldFail", None)
-#                 if callable(shouldFailFunc):
-#                     if shouldFailFunc():
-#                         yo['shouldFail'] = True
-# 
-#                 yo['variants'].add(v.getVariant())
-
-        #HINT: y should now contain a list of dicts with labels as keys and the SubCombinator classes as keys
-
-                yield yo
-                # yield yo | yieldObj