Tidy up logging and rework tests from scratch

tests/legacy/__init__.py

@@ -0,0 +1 @@
+# Legacy custom FFX test harness modules.

tests/legacy/_basename_combinator_1.py

@@ -0,0 +1,64 @@
+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 .basename_combinator import BasenameCombinator
+
+from .indicator_combinator import IndicatorCombinator
+from .label_combinator import LabelCombinator
+
+class BasenameCombinator2(BasenameCombinator):
+    """documentation_site"""
+
+    VARIANT = 'B2'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return BasenameCombinator2.VARIANT
+
+    def getPayload(self):
+        return ''
+
+    def assertFunc(self, mediaDescriptor: MediaDescriptor):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        for L in LabelCombinator.getAllClassReferences():
+#            for I in IndicatorCombinator.getAllClassReferences():
+#                for S in SiteCombinator.getAllClassReferences():
+#                    for T in TitleCombinator.getAllClassReferences():
+#
+
+            l = L(self._context)
+
+            yieldObj = {}
+
+            yieldObj['identifier'] = self.getIdentifier()
+
+            yieldObj['variants'] = [self.getVariant(),
+                                    l.getVariant()]
+
+            yieldObj['payload'] = {'label': l.getPayload()}
+
+            yieldObj['assertSelectors'] = ['B', 'L']
+
+            yieldObj['assertFuncs'] = [self.assertFunc,
+                                        l.assertFunc]
+
+            yieldObj['shouldFail'] = (self.shouldFail()
+                                        | l.shouldFail())
+
+            yield yieldObj

tests/legacy/basename_combinator.py

@@ -0,0 +1,36 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class BasenameCombinator():
+
+    IDENTIFIER = 'basename'
+
+    BASENAME = 'media'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return BasenameCombinator.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[20:-3]
+                for p
+                in glob.glob(f"{ basePath }/basename_combinator_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        module_name = f"tests.legacy.basename_combinator_{ identifier }"
+        importlib.import_module(module_name)
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'BasenameCombinator' and name.startswith('BasenameCombinator'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [BasenameCombinator.getClassReference(i) for i in BasenameCombinator.list()]

tests/legacy/basename_combinator_0.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 .basename_combinator import BasenameCombinator
+
+from .indicator_combinator import IndicatorCombinator
+from .label_combinator import LabelCombinator
+
+
+class BasenameCombinator0(BasenameCombinator):
+    """base[_indicator]"""
+
+    VARIANT = 'B0'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return BasenameCombinator0.VARIANT
+
+    def getPayload(self, indicator = '', label = ''):
+
+        basename = BasenameCombinator.BASENAME
+        expectedBasename = label if label else BasenameCombinator.BASENAME
+
+        if indicator:
+            basename += f"_{indicator}"
+            expectedBasename += f"_{indicator}"
+
+        return {'basename': basename,
+                'label': label,
+                'expectedBasename': expectedBasename}
+
+
+    def assertFunc(self, indicator = '', label = ''):
+
+        def f(testObj: dict = {}):
+
+            if not 'filenames' in testObj.keys():
+                raise KeyError("testObj does not contain key 'filenames'")
+
+            fNames = testObj['filenames']
+
+            assert len(fNames) == 1, "More than one result file was created"
+
+            resultFilename = fNames[0]
+
+            fTokens = resultFilename.split('.')
+
+            resultBasename = '.'.join(fTokens[:-1])
+            resultExtension = fTokens[-1]
+
+            if not indicator and not label:
+                
+                assert resultBasename == BasenameCombinator.BASENAME, f"Result basename is not {BasenameCombinator.BASENAME}"
+            if not indicator and     label:
+                assert resultBasename == label, f"Result basename is not {label}"
+            if     indicator and not label:
+                assert resultBasename == f"{BasenameCombinator.BASENAME}_{indicator}", f"Result basename is not {BasenameCombinator.BASENAME}_{indicator}"
+            if     indicator and     label:
+                assert resultBasename == f"{label}_{indicator}", f"Result basename is not {label}_{indicator}"
+
+        return f
+
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        ic = IndicatorCombinator(self._context)
+
+        for L in LabelCombinator.getAllClassReferences():
+            for i in ic.getYield():
+
+                l = L(self._context)
+
+                indicator = i['indicator']
+                indicatorVariant = i['variant']
+
+                yieldObj = {}
+
+                yieldObj['identifier'] = self.getIdentifier()
+
+                yieldObj['variants'] = [self.getVariant(),
+                                        l.getVariant(),
+                                        indicatorVariant]
+
+                yieldObj['payload'] = self.getPayload(indicator = indicator,
+                                                        label = l.getPayload())
+
+                yieldObj['assertSelectors'] = ['B', 'L', 'I']
+
+                yieldObj['assertFuncs'] = [self.assertFunc(indicator, l.getPayload()), l.assertFunc, ic.assertFunc]
+
+                yieldObj['shouldFail'] = (self.shouldFail()
+                                            | l.shouldFail()
+                                            | ic.shouldFail())
+
+                yield yieldObj

tests/legacy/basename_combinator_2.py

@@ -0,0 +1,159 @@
+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 .basename_combinator import BasenameCombinator
+
+from .indicator_combinator import IndicatorCombinator
+from .label_combinator import LabelCombinator
+from .title_combinator import TitleCombinator
+from .release_combinator import ReleaseCombinator
+from .show_combinator import ShowCombinator
+
+
+class BasenameCombinator2(BasenameCombinator):
+    """show[_indicator]_group"""
+
+    VARIANT = 'B2'
+
+    # def __init__(self, SubCombinators: dict = {}, context = None):
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return BasenameCombinator2.VARIANT
+
+#
+#    SHOW_LIST = [
+#        'Boruto: Naruto Next Generations (2017)',
+#        'The Rising of the Shield Hero (2019)',
+#        'Scrubs - Die Anfänger (2001)'
+#    ]
+#
+#    RELEASE_LIST = [
+#        ".GerEngSub.AAC.1080pINDICATOR.WebDL.x264-Tanuki",
+#        ".German.AC3.DL.1080pINDICATOR.BluRay.x264-AST4u",
+#        "-720pINDICATOR"
+#    ]
+
+
+    def getPayload(self,
+                    indicator = '',
+                    label = '',
+                    show = '',
+                    release = ''):
+
+        if label:
+            basename = label
+            expectedBasename = label
+            if indicator:
+                basename += f"_{indicator}"
+                expectedBasename += f"_{indicator}"
+        else:
+            basename = show+release
+            expectedBasename = basename
+
+        return {'basename': basename,
+                'label': label,
+                'expectedBasename': expectedBasename}
+
+
+    def createAssertFunc(self,
+                    indicator = '',
+                    label = '',
+                    show = '',
+                    release = ''):
+
+        def f(testObj: dict = {}):
+
+            if not 'filenames' in testObj.keys():
+                raise KeyError("testObj does not contain key 'filenames'")
+
+            fNames = testObj['filenames']
+
+            assert len(fNames) == 1, "More than one result file was created"
+
+            resultFilename = fNames[0]
+
+            fTokens = resultFilename.split('.')
+
+            resultBasename = '.'.join(fTokens[:-1])
+            resultExtension = fTokens[-1]
+
+            if not indicator and not label:
+                assert resultBasename == show+release, f"Result basename is not {show+release}"
+            elif not indicator and     label:
+                assert resultBasename == label, f"Result basename is not {label}"
+            elif     indicator and not label:
+                assert resultBasename == show+release, f"Result basename is not {show+release}"
+            elif     indicator and     label:
+                assert resultBasename == f"{label}_{indicator}", f"Result basename is not {label}_{indicator}"
+
+        return f
+
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        ic = IndicatorCombinator(self._context)
+        sc = ShowCombinator(self._context)
+
+        for L in LabelCombinator.getAllClassReferences():
+            for iy in ic.getYield():
+
+                indicator = iy['indicator']
+                indicatorVariant = iy['variant']
+
+                rc = ReleaseCombinator(self._context, indicator=indicator)
+
+                for sy in sc.getYield():
+                    for ry in rc.getYield():
+
+                        l = L(self._context)
+
+                        show = sy['show']
+                        showVariant = sy['variant']
+
+                        release = ry['release']
+                        releaseVariant = ry['variant']
+
+                        yieldObj = {}
+
+                        yieldObj['identifier'] = self.getIdentifier()
+
+                        yieldObj['variants'] = [self.getVariant(),
+                                                l.getVariant(),
+                                                indicatorVariant,
+                                                showVariant,
+                                                releaseVariant]
+
+                        yieldObj['payload'] = self.getPayload(indicator = indicator,
+                                                                label = l.getPayload(),
+                                                                show = show,
+                                                                release = release)
+
+                        yieldObj['assertSelectors'] = ['B', 'L', 'I', 'S', 'R']
+
+                        yieldObj['assertFuncs'] = [self.createAssertFunc(indicator,
+                                                                    l.getPayload(),
+                                                                    show = show,
+                                                                    release = release),
+                                                    l.assertFunc,
+                                                    ic.assertFunc,
+                                                    sc.assertFunc,
+                                                    rc.assertFunc]
+
+                        yieldObj['shouldFail'] = (self.shouldFail()
+                                                    | l.shouldFail()
+                                                    | ic.shouldFail()
+                                                    | sc.shouldFail()
+                                                    | rc.shouldFail())
+
+                        yield yieldObj

tests/legacy/combinator.py

@@ -0,0 +1,13 @@
+class Combinator():
+
+    def __init__(self, SubCombinations: dict):
+        self._SubCombinators = SubCombinations
+
+    def getPayload(self):
+        pass
+
+    def assertFunc(self, testObj):
+        pass
+
+    def getYield(yieldObj: dict):
+        pass

tests/legacy/disposition_combinator_2.py

@@ -0,0 +1,36 @@
+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 DispositionCombinator2.IDENTIFIER
+    def getVariant(self):
+        return self._variant
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[25:-3]
+                for p
+                in glob.glob(f"{ basePath }/disposition_combinator_2_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        module_name = f"tests.legacy.disposition_combinator_2_{ identifier }"
+        importlib.import_module(module_name)
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            #HINT: Excluding DispositionCombination as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'DispositionCombinator2' and name.startswith('DispositionCombinator2'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [DispositionCombinator2.getClassReference(i) for i in DispositionCombinator2.list()]

tests/legacy/disposition_combinator_2_0.py

@@ -0,0 +1,76 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class DispositionCombinator20(DispositionCombinator2):
+
+    # COMMENT
+    # DESCRIPTIONS
+
+    VARIANT = 'D00'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator20.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = set()
+        subtrack1 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            subtrack0.add(TrackDisposition.FORCED) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+
+        return (subtrack0,
+                subtrack1)
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict):
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.FORCED)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set 'forced' disposition"
+                    # source subIndex 1
+                    assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                    # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                    # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved set 'descriptions' disposition"
+
+        else:
+
+            def f(assertObj: dict):
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    # source subIndex 1
+                    assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/disposition_combinator_2_1.py

@@ -0,0 +1,79 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class DispositionCombinator21(DispositionCombinator2):
+
+    VARIANT = 'D10'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator21.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set()
+            subtrack1 = set([TrackDisposition.DEFAULT])
+        else:
+            subtrack0 = set([TrackDisposition.DEFAULT])
+            subtrack1 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            subtrack1.add(TrackDisposition.FORCED) # DESCRIPTIONS
+
+        return (subtrack0,
+                subtrack1)
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+
+            def f(assertObj: dict):
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not set default disposition"
+                    # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                    # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set 'comment' disposition"
+                    # source subIndex 1
+                    assert not (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                    assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.FORCED)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved set 'forced' disposition"
+
+        else:
+
+            def f(assertObj: dict):
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not set default disposition"
+                    # source subIndex 1
+                    assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/disposition_combinator_2_2.py

@@ -0,0 +1,79 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class DispositionCombinator22(DispositionCombinator2):
+
+    VARIANT = 'D01'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator22.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set([TrackDisposition.DEFAULT])
+            subtrack1 = set()
+        else:
+            subtrack0 = set()
+            subtrack1 = set([TrackDisposition.DEFAULT])
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            subtrack0.add(TrackDisposition.FORCED) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+
+        return (subtrack0,
+                subtrack1)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict):                        
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.FORCED)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set 'descriptions' disposition"
+                    # source subIndex 1
+                    assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+                    # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                    # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved 'forced' disposition"
+
+        else:
+
+            def f(assertObj: dict):                        
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    # source subIndex 1
+                    assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/disposition_combinator_2_3 .py

@@ -0,0 +1,43 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_2 import DispositionCombinator2
+
+
+class DispositionCombinator23(DispositionCombinator2):
+
+    VARIANT = 'D11'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator23.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = set([TrackDisposition.DEFAULT])
+        subtrack1 = set([TrackDisposition.DEFAULT])
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            subtrack1.add(TrackDisposition.FORCED) # DESCRIPTIONS
+
+        return (subtrack0,
+                subtrack1)
+
+    #TODO: tmdb cases
+    def createAssertFunc(self):
+        def f(assertObj: dict = {}):
+            pass
+        return f
+
+    def shouldFail(self):
+        return True

tests/legacy/disposition_combinator_3.py

@@ -0,0 +1,35 @@
+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 DispositionCombinator3.IDENTIFIER
+
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[25:-3]
+                for p
+                in glob.glob(f"{ basePath }/disposition_combinator_3_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        module_name = f"tests.legacy.disposition_combinator_3_{ identifier }"
+        importlib.import_module(module_name)
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            #HINT: Excluding DispositionCombination as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'DispositionCombinator3' and name.startswith('DispositionCombinator3'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [DispositionCombinator3.getClassReference(i) for i in DispositionCombinator3.list()]

tests/legacy/disposition_combinator_3_0.py

@@ -0,0 +1,92 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator30(DispositionCombinator3):
+
+    VARIANT = 'D000'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator30.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = set()
+        subtrack1 = set()
+        subtrack2 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            subtrack0.add(TrackDisposition.FORCED) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+            # subtrack2.add(TrackDisposition.HEARING_IMPAIRED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict):
+                    
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+
+                trackDescriptors = assertObj['tracks']
+
+                # source subIndex 0
+                assert not (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.FORCED)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved default disposition"
+
+                # source subIndex 1
+                assert not (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition"
+
+                # source subIndex 2
+                assert not (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+                # assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.HEARING_IMPAIRED)
+                # ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition"
+
+        else:
+
+            def f(assertObj: dict):
+                    
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+
+                trackDescriptors = assertObj['tracks']
+
+                # source subIndex 0
+                assert not (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+
+                # source subIndex 1
+                assert not (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+                # source subIndex 2
+                assert not (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+        return f
+
+    def shouldFail(self):
+        return False

tests/legacy/disposition_combinator_3_1.py

@@ -0,0 +1,97 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator31(DispositionCombinator3):
+
+    VARIANT = 'D100'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator31.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set()
+            subtrack1 = set()
+            subtrack2 = set([TrackDisposition.DEFAULT])
+        else:
+            subtrack0 = set([TrackDisposition.DEFAULT])
+            subtrack1 = set()
+            subtrack2 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            subtrack1.add(TrackDisposition.FORCED) # DESCRIPTIONS
+            # subtrack2.add(TrackDisposition.HEARING_IMPAIRED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+    def createAssertFunc(self):
+        
+        if self.__createPresets:
+
+            def f(assertObj: dict):
+
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not set default disposition"
+                    # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                    # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved default disposition"
+
+                    # source subIndex 1
+                    assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                    assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.FORCED)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition"
+
+                    # source subIndex 2
+                    assert (not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+                    # assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.HEARING_IMPAIRED)
+                    # ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition"
+
+        else:
+
+            def f(assertObj: dict):
+
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not set default disposition"
+
+                    # source subIndex 1
+                    assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+
+                    # source subIndex 2
+                    assert (not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/disposition_combinator_3_2.py

@@ -0,0 +1,89 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator32(DispositionCombinator3):
+
+    VARIANT = 'D010'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator32.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set([TrackDisposition.DEFAULT])
+            subtrack1 = set()
+            subtrack2 = set()
+        else:
+            subtrack0 = set()
+            subtrack1 = set([TrackDisposition.DEFAULT])
+            subtrack2 = set()
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+            subtrack2.add(TrackDisposition.FORCED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict):
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                    # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set default disposition"
+                    # source subIndex 1
+                    assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+                    # assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DESCRIPTIONS)
+                    # ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved descriptions disposition"
+                    # source subIndex 2
+                    assert (not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+                    assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.FORCED)
+                    ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition"
+
+        else:
+
+            def f(assertObj: dict):
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 0
+                    assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                    # source subIndex 1
+                    assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+                    # source subIndex 2
+                    assert (not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                    ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has set default disposition"
+        return f
+
+    def shouldFail(self):
+        return False

tests/legacy/disposition_combinator_3_3.py

@@ -0,0 +1,89 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator33(DispositionCombinator3):
+
+    VARIANT = 'D001'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator33.VARIANT
+
+
+    def getPayload(self):
+
+        if self.__createPresets:
+            subtrack0 = set()
+            subtrack1 = set([TrackDisposition.DEFAULT])
+            subtrack2 = set()
+        else:
+            subtrack0 = set()
+            subtrack1 = set()
+            subtrack2 = set([TrackDisposition.DEFAULT])
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            # subtrack0.add(TrackDisposition.COMMENT) # COMMENT
+            subtrack1.add(TrackDisposition.FORCED) # DESCRIPTIONS
+            # subtrack2.add(TrackDisposition.HEARING_IMPAIRED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict):
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                trackDescriptors = assertObj['tracks']
+
+                # source subIndex 0
+                assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                # assert (trackDescriptors[0].getDispositionFlag(TrackDisposition.COMMENT)
+                # ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved set default disposition"
+                # source subIndex 1
+                assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                assert (trackDescriptors[1].getDispositionFlag(TrackDisposition.FORCED)
+                ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved descriptions disposition"
+                # source subIndex 2
+                assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+                # assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.HEARING_IMPAIRED)
+                # ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition"
+
+        else:
+
+            def f(assertObj: dict):
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                trackDescriptors = assertObj['tracks']
+
+                # source subIndex 0
+                assert (not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has set default disposition"
+                # source subIndex 1
+                assert (not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has set default disposition"
+                # source subIndex 2
+                assert (trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT)
+                ), f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not set default disposition"
+        return f
+
+    def shouldFail(self):
+        return False

tests/legacy/disposition_combinator_3_4.py

@@ -0,0 +1,46 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .disposition_combinator_3 import DispositionCombinator3
+
+
+class DispositionCombinator34(DispositionCombinator3):
+
+    VARIANT = 'D101'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return DispositionCombinator34.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = set([TrackDisposition.DEFAULT])
+        subtrack1 = set()
+        subtrack2 = set([TrackDisposition.DEFAULT])
+
+        #NOTE: Current ffmpeg version will not set most of the dispositions on arbitrary tracks
+        # so some checks for preserved dispositions are omitted for now
+        if self.__createPresets:
+            subtrack0.add(TrackDisposition.FORCED) # COMMENT
+            # subtrack1.add(TrackDisposition.DESCRIPTIONS) # DESCRIPTIONS
+            # subtrack2.add(TrackDisposition.HEARING_IMPAIRED) # HEARING_IMPAIRED
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+    #TODO: tmpdb cases
+    def createAssertFunc(self):
+        def f(assertObj: dict = {}):
+            pass
+        return f
+
+    def shouldFail(self):
+        return True

tests/legacy/helper.py

@@ -0,0 +1,275 @@
+import os, math, tempfile, click
+
+from ffx.process import executeProcess
+
+from ffx.media_descriptor import MediaDescriptor
+from ffx.media_descriptor_change_set import MediaDescriptorChangeSet
+from ffx.track_type import TrackType
+
+from ffx.helper import dictCache
+from ffx.configuration_controller import ConfigurationController
+
+
+SHORT_SUBTITLE_SEQUENCE = [{'start': 1, 'end': 2, 'text': 'yolo'},
+                           {'start': 3, 'end': 4, 'text': 'zolo'},
+                           {'start': 5, 'end': 6, 'text': 'golo'}]
+
+def getTimeString(hours: float = 0.0,
+                    minutes: float = 0.0,
+                    seconds: float = 0.0,
+                    millis: float = 0.0,
+                    format: str = ''):
+
+    duration = (hours * 3600.0
+                + minutes * 60.0
+                + seconds
+                + millis / 1000.0)
+
+    hours = math.floor(duration / 3600.0)
+    remaining = duration - 3600.0 * hours
+
+    minutes = math.floor(remaining / 60.0)
+    remaining = remaining - 60.0 * minutes
+
+    seconds = math.floor(remaining)
+    remaining = remaining - seconds
+
+    millis = math.floor(remaining * 1000)
+
+    if format == 'ass':
+        return f"{hours:01d}:{minutes:02d}:{seconds:02d}.{millis:02d}"
+
+    # srt & vtt
+    return f"{hours:02d}:{minutes:02d}:{seconds:02d}.{millis:03d}"
+
+
+def createAssFile(entries: dict, directory = None):
+
+    # [Script Info]
+    # ; Script generated by FFmpeg/Lavc61.3.100
+    # ScriptType: v4.00+
+    # PlayResX: 384
+    # PlayResY: 288
+    # ScaledBorderAndShadow: yes
+    # YCbCr Matrix: None
+    # 
+    # [V4+ Styles]
+    # Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding
+    # Style: Default,Arial,16,&Hffffff,&Hffffff,&H0,&H0,0,0,0,0,100,100,0,0,1,1,0,2,10,10,10,1
+    # 
+    # [Events]
+    # Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text
+    # Dialogue: 0,0:00:01.00,0:00:02.00,Default,,0,0,0,,yolo
+    # Dialogue: 0,0:00:03.00,0:00:04.00,Default,,0,0,0,,zolo
+    # Dialogue: 0,0:00:05.00,0:00:06.00,Default,,0,0,0,,golo
+    tmpFileName = tempfile.mktemp(suffix=".ass", dir = directory)
+
+    with open(tmpFileName, 'w') as tmpFile:
+
+        tmpFile.write("[Script Info]\n")
+        tmpFile.write("; Script generated by Ffx\n")
+        tmpFile.write("ScriptType: v4.00+\n")
+        tmpFile.write("PlayResX: 384\n")
+        tmpFile.write("PlayResY: 288\n")
+        tmpFile.write("ScaledBorderAndShadow: yes\n")
+        tmpFile.write("YCbCr Matrix: None\n")
+        tmpFile.write("\n")
+        tmpFile.write("[V4+ Styles]\n")
+        tmpFile.write("Format: Name, Fontname, Fontsize, PrimaryColour, SecondaryColour, OutlineColour, BackColour, Bold, Italic, Underline, StrikeOut, ScaleX, ScaleY, Spacing, Angle, BorderStyle, Outline, Shadow, Alignment, MarginL, MarginR, MarginV, Encoding\n")
+        tmpFile.write("Style: Default,Arial,16,&Hffffff,&Hffffff,&H0,&H0,0,0,0,0,100,100,0,0,1,1,0,2,10,10,10,1\n")
+        tmpFile.write("\n")
+        tmpFile.write("[Events]\n")
+        tmpFile.write("Format: Layer, Start, End, Style, Name, MarginL, MarginR, MarginV, Effect, Text\n")
+
+        for entryIndex in range(len(entries)):
+            tmpFile.write(f"Dialogue: 0,{getTimeString(seconds=entries[entryIndex]['start'], format='ass')},{getTimeString(seconds=entries[entryIndex]['end'], format='ass')},Default,,0,0,0,,{entries[entryIndex]['text']}\n")
+
+    return tmpFileName
+
+def createSrtFile(entries: dict, directory = None):
+    # 1
+    # 00:00:00,000 --> 00:00:02,500
+    # Welcome to the Example Subtitle File!
+    # 
+    # 2
+    # 00:00:03,000 --> 00:00:06,000
+    # This is a demonstration of SRT subtitles.
+    # 
+    # 3
+    # 00:00:07,000 --> 00:00:10,500
+    # You can use SRT files to add subtitles to your videos.
+
+    tmpFileName = tempfile.mktemp(suffix=".srt", dir = directory)
+
+    with open(tmpFileName, 'w') as tmpFile:
+
+        for entryIndex in range(len(entries)):
+
+            tmpFile.write(f"{entryIndex}\n")
+            tmpFile.write(f"{getTimeString(seconds=entries[entryIndex]['start'])} --> {getTimeString(seconds=entries[entryIndex]['end'])}\n")
+            tmpFile.write(f"{entries[entryIndex]['text']}\n\n")
+
+    return tmpFileName
+
+
+def createVttFile(entries: dict, directory = None):
+    # WEBVTT
+    # 
+    # 01:20:33.050 --> 01:20:35.050
+    # Yolo
+
+    tmpFileName = tempfile.mktemp(suffix=".vtt", dir = directory)
+
+    with open(tmpFileName, 'w') as tmpFile:
+
+        tmpFile.write("WEBVTT\n")
+
+        for entryIndex in range(len(entries)):
+
+            tmpFile.write("\n")
+            tmpFile.write(f"{getTimeString(seconds=entries[entryIndex]['start'])} --> {getTimeString(seconds=entries[entryIndex]['end'])}\n")
+            tmpFile.write(f"{entries[entryIndex]['text']}\n")
+
+
+    return tmpFileName
+
+
+def createMediaTestFile(mediaDescriptor: MediaDescriptor,
+                    directory: str = '',
+                    baseName: str = 'media',
+                    format: str = '',
+                    extension: str = 'mkv',
+                    sizeX: int = 1280,
+                    sizeY: int = 720,
+                    rate: int = 25,
+                    length: int = 10,
+                    logger = None):
+
+    # subtitleFilePath = createVttFile(SHORT_SUBTITLE_SEQUENCE)
+
+    commandTokens = ['ffmpeg', '-y']
+
+    generatorCache = []
+    generatorTokens = []
+    mappingTokens = []
+    importTokens = []
+    metadataTokens = []
+
+
+    for mediaTagKey, mediaTagValue in mediaDescriptor.getTags().items():
+        metadataTokens += ['-metadata:g', f"{mediaTagKey}={mediaTagValue}"]
+
+    subIndexCounter = {}
+
+    # for trackDescriptor in mediaDescriptor.getAllTrackDescriptors():
+    for trackDescriptor in mediaDescriptor.getTrackDescriptors():
+
+        trackType = trackDescriptor.getType()
+
+        if trackType == TrackType.VIDEO:
+
+            cacheIndex, generatorCache = dictCache({'type': TrackType.VIDEO}, generatorCache)
+            # click.echo(f"createMediaTestFile() cache index={cacheIndex} size={len(generatorCache)}")
+
+            if cacheIndex == -1:
+                generatorTokens += ['-f',
+                                    'lavfi',
+                                    '-i',
+                                    f"color=size={sizeX}x{sizeY}:rate={rate}:color=black"]
+
+            sourceIndex = len(generatorCache) - 1 if cacheIndex == -1 else cacheIndex
+            mappingTokens += ['-map', f"{sourceIndex}:v:0"]
+
+            if not trackType in subIndexCounter.keys():
+                subIndexCounter[trackType] = 0
+            for mediaTagKey, mediaTagValue in trackDescriptor.getTags().items():
+                metadataTokens += [f"-metadata:s:{trackType.indicator()}:{subIndexCounter[trackType]}",
+                                    f"{mediaTagKey}={mediaTagValue}"]
+            subIndexCounter[trackType] += 1
+
+        if trackType == TrackType.AUDIO:
+
+            audioLayout = 'stereo'
+
+            cacheIndex, generatorCache = dictCache({'type': TrackType.AUDIO, 'layout': audioLayout}, generatorCache)
+            # click.echo(f"createMediaTestFile() cache index={cacheIndex} size={len(generatorCache)}")
+
+            # click.echo(f"generartorCache index={cacheIndex} len={len(generatorCache)}")
+            if cacheIndex == -1:
+                generatorTokens += ['-f',
+                                    'lavfi',
+                                    '-i',
+                                    f"anullsrc=channel_layout={audioLayout}:sample_rate=44100"]
+
+            sourceIndex = len(generatorCache) - 1 if cacheIndex == -1 else cacheIndex
+            mappingTokens += ['-map', f"{sourceIndex}:a:0"]
+
+            if not trackType in subIndexCounter.keys():
+                subIndexCounter[trackType] = 0
+            for mediaTagKey, mediaTagValue in trackDescriptor.getTags().items():
+                metadataTokens += [f"-metadata:s:{trackType.indicator()}:{subIndexCounter[trackType]}",
+                                    f"{mediaTagKey}={mediaTagValue}"]
+            subIndexCounter[trackType] += 1
+
+        if trackType == TrackType.SUBTITLE:
+
+            cacheIndex, generatorCache = dictCache({'type': TrackType.SUBTITLE}, generatorCache)
+            # click.echo(f"createMediaTestFile() cache index={cacheIndex} size={len(generatorCache)}")
+
+            if cacheIndex == -1:
+                importTokens = ['-i', createVttFile(SHORT_SUBTITLE_SEQUENCE, directory=directory if directory else None)]
+
+            sourceIndex = len(generatorCache) - 1 if cacheIndex == -1 else cacheIndex
+            mappingTokens += ['-map', f"{sourceIndex}:s:0"]
+
+            if not trackType in subIndexCounter.keys():
+                subIndexCounter[trackType] = 0
+            for mediaTagKey, mediaTagValue in trackDescriptor.getTags().items():
+                metadataTokens += [f"-metadata:s:{trackType.indicator()}:{subIndexCounter[trackType]}",
+                                    f"{mediaTagKey}={mediaTagValue}"]
+            subIndexCounter[trackType] += 1
+
+    ffxContext = {'config': ConfigurationController(), 'logger': logger}
+    mdcs = MediaDescriptorChangeSet(ffxContext, mediaDescriptor)
+
+    commandTokens += (generatorTokens
+                        + importTokens
+                        + mappingTokens
+                        + metadataTokens
+                        + mdcs.generateDispositionTokens())
+
+
+    commandTokens += ['-t', str(length)]
+
+    if format:
+        commandTokens += ['-f', format]
+
+    fileName = f"{baseName}.{extension}"
+
+    if directory:
+        outputPath = os.path.join(directory, fileName)
+    else:
+        outputPath = fileName
+
+    commandTokens += [outputPath]
+
+
+    ctx = {'logger': logger}
+
+    out, err, rc = executeProcess(commandTokens, context = ctx)
+
+    if not logger is None:
+        if out:
+            logger.debug(f"createMediaTestFile(): Process output: {out}")
+        if rc:
+            logger.debug(f"createMediaTestFile(): Process returned ERROR {rc} ({err})")
+
+
+    return outputPath
+
+
+def createEmptyDirectory():
+    return tempfile.mkdtemp()
+
+def createEmptyFile(suffix=None):
+    return tempfile.mkstemp(suffix=suffix)

tests/legacy/indicator_combinator.py

@@ -0,0 +1,43 @@
+class IndicatorCombinator():
+
+    IDENTIFIER = 'indicator'
+
+    MAX_SEASON = 2
+    MAX_EPISODE = 3
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return IndicatorCombinator.IDENTIFIER
+        
+    def getPayload(self, season: int = -1, episode: int = -1):
+        if season == -1 and episode == -1:
+            return {
+                'variant': 'S00E00',
+                'indicator': '',
+                'season': season,
+                'episode': episode
+            }
+        else:
+            return {
+                'variant': f"S{season:02d}E{episode:02d}",
+                'indicator': f"S{season:02d}E{episode:02d}",
+                'season': season,
+                'episode': episode
+            }
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+
+        yield self.getPayload()
+        for season in range(IndicatorCombinator.MAX_SEASON):
+            for episode in range(IndicatorCombinator.MAX_EPISODE):
+                yield self.getPayload(season+1, episode+1)

tests/legacy/label_combinator.py

@@ -0,0 +1,37 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class LabelCombinator():
+
+    IDENTIFIER = 'label'
+    PREFIX = 'label_combinator_'
+
+    LABEL = 'ffx'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return LabelCombinator.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[len(LabelCombinator.PREFIX):-3]
+                for p
+                in glob.glob(f"{ basePath }/{LabelCombinator.PREFIX}*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        module_name = f"tests.legacy.{LabelCombinator.PREFIX}{ identifier }"
+        importlib.import_module(module_name)
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'LabelCombinator' and name.startswith('LabelCombinator'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [LabelCombinator.getClassReference(i) for i in LabelCombinator.list()]

tests/legacy/label_combinator_0.py

@@ -0,0 +1,30 @@
+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 .label_combinator import LabelCombinator
+
+
+class LabelCombinator0(LabelCombinator):
+
+    VARIANT = 'L0'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return LabelCombinator0.VARIANT
+
+    def getPayload(self):
+        return ''
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False

tests/legacy/label_combinator_1.py

@@ -0,0 +1,30 @@
+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 .label_combinator import LabelCombinator
+
+class LabelCombinator1(LabelCombinator):
+
+    VARIANT = 'L1'
+
+    def __init__(self, context = None):
+
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getVariant(self):
+        return LabelCombinator1.VARIANT
+
+    def getPayload(self):
+        return LabelCombinator.LABEL
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False

tests/legacy/media_combinator.py

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

tests/legacy/media_combinator_0.py

@@ -0,0 +1,103 @@
+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 .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator0(MediaCombinator):
+
+    VARIANT = 'VA'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator0.VARIANT
+
+
+
+    def getPayload(self):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 0
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 1
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        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):
+
+        for MTC in MediaTagCombinator.getAllClassReferences():
+
+            mtc = MTC(self._context)
+
+            yObj = {}
+
+            yObj['identifier'] = self.getIdentifier()
+            yObj['variants'] = [self.getVariant(),
+                                    mtc.getVariant()]
+            yObj['payload'] = self.getPayload()
+
+            yObj['assertSelectors'] = ['M', 'MT']
+            yObj['assertFuncs'] = [self.assertFunc, 
+                                        mtc.createAssertFunc()]
+            yObj['shouldFail'] = (self.shouldFail()
+                                        | mtc.shouldFail())
+
+            yieldObj = {'target': yObj}
+
+            if self.__createPresets:
+
+                mtc_p = MTC(self._context, createPresets = True)
+
+                yObj_p = {}
+
+                yObj_p['identifier'] = self.getIdentifier()
+                yObj_p['variants'] = [self.getVariant(),
+                                        mtc_p.getVariant()]
+
+                yObj_p['payload'] = self.getPayload()
+
+                yObj_p['assertSelectors'] = ['M', 'MT']
+                yObj_p['assertFuncs'] = [self.assertFunc, 
+                                            mtc_p.createAssertFunc()]
+                yObj_p['shouldFail'] = (self.shouldFail()
+                                            | mtc_p.shouldFail())
+
+                yieldObj['preset'] = yObj_p
+
+            yield yieldObj

tests/legacy/media_combinator_1.py

@@ -0,0 +1,114 @@
+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 .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator1(MediaCombinator):
+
+    VARIANT = 'VAS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator1.VARIANT
+
+
+    def getPayload(self):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 0
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 1
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 2
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        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 MTC in MediaTagCombinator.getAllClassReferences():
+
+            mtc = MTC(self._context)
+
+            yObj = {}
+
+            yObj['identifier'] = self.getIdentifier()
+            yObj['variants'] = [self.getVariant(),
+                                    mtc.getVariant()]
+
+            yObj['payload'] = self.getPayload()
+
+            yObj['assertSelectors'] = ['M', 'MT']
+            yObj['assertFuncs'] = [self.assertFunc,
+                                        mtc.createAssertFunc()]
+
+            yObj['shouldFail'] = (self.shouldFail()
+                                        | mtc.shouldFail())
+
+            yieldObj = {'target': yObj}
+
+            if self.__createPresets:
+
+                mtc_p = MTC(self._context, createPresets = True)
+
+                yObj_p = {}
+
+                yObj_p['identifier'] = self.getIdentifier()
+                yObj_p['variants'] = [self.getVariant(),
+                                        mtc_p.getVariant()]
+
+                yObj_p['payload'] = self.getPayload()
+
+                yObj_p['assertSelectors'] = ['M', 'MT']
+                yObj_p['assertFuncs'] = [self.assertFunc,
+                                            mtc_p.createAssertFunc()]
+
+                yObj_p['shouldFail'] = (self.shouldFail()
+                                            | mtc_p.shouldFail())
+                yieldObj['preset'] = yObj_p
+
+            yield yieldObj

tests/legacy/media_combinator_2.py

@@ -0,0 +1,156 @@
+import os, sys, importlib, glob, inspect, itertools, click
+
+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 .track_tag_combinator_2 import TrackTagCombinator2
+from .permutation_combinator_2 import PermutationCombinator2
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator2(MediaCombinator):
+
+    VARIANT = 'VASS'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return MediaCombinator2.VARIANT
+
+
+    def getPayload(self,
+                    subtitleDispositionTuple = (set(), set()),
+                    subtitleTagTuple = ({}, {})):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 0
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 1
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 2
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[0]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 3
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[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 MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2 in DispositionCombinator2.getAllClassReferences():
+                for TC2 in TrackTagCombinator2.getAllClassReferences():
+
+                    dc2 = DC2(self._context)
+                    tc2 = TC2(self._context)
+
+                    mtc = MTC(self._context)
+
+                    yObj = {}
+
+                    yObj['identifier'] = self.getIdentifier()
+                    yObj['variants'] = [self.getVariant(),
+                                            f"S:{dc2.getVariant()}",
+                                            f"S:{tc2.getVariant()}",
+                                            mtc.getVariant()]
+
+                    yObj['payload'] = self.getPayload(dc2.getPayload(),
+                                                        tc2.getPayload())
+
+                    yObj['assertSelectors'] = ['M', 'SD', 'ST', 'MT']
+                    yObj['assertFuncs'] = [self.assertFunc,
+                                                dc2.createAssertFunc(),
+                                                tc2.createAssertFunc(),
+                                                mtc.createAssertFunc()]
+
+                    yObj['shouldFail'] = (self.shouldFail()
+                                                | dc2.shouldFail()
+                                                | tc2.shouldFail()
+                                                | mtc.shouldFail())
+
+                    yieldObj = {'target': yObj}
+
+                    if self.__createPresets:
+
+                        dc2_p = DC2(self._context, createPresets = True)
+                        tc2_p = TC2(self._context, createPresets = True)
+
+                        mtc_p = MTC(self._context, createPresets = True)
+
+                        yObj_p = {}
+
+                        yObj_p['identifier'] = self.getIdentifier()
+                        yObj_p['variants'] = [self.getVariant(),
+                                                f"S:{dc2_p.getVariant()}",
+                                                f"S:{tc2_p.getVariant()}",
+                                                mtc_p.getVariant()]
+
+                        yObj_p['payload'] = self.getPayload(dc2_p.getPayload(),
+                                                            tc2_p.getPayload())
+
+                        yObj_p['assertSelectors'] = ['M', 'SD', 'ST', 'MT']
+                        yObj_p['assertFuncs'] = [self.assertFunc,
+                                                    dc2_p.createAssertFunc(),
+                                                    tc2_p.createAssertFunc(),
+                                                    mtc_p.createAssertFunc()]
+
+                        yObj_p['shouldFail'] = (self.shouldFail()
+                                                    | dc2_p.shouldFail()
+                                                    | tc2_p.shouldFail()
+                                                    | mtc_p.shouldFail())
+
+                        yieldObj['preset'] = yObj_p
+
+                    yield yieldObj

tests/legacy/media_combinator_3.py

@@ -0,0 +1,165 @@
+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
+from .track_tag_combinator_3 import TrackTagCombinator3
+from .permutation_combinator_3 import PermutationCombinator3
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator3(MediaCombinator):
+
+    VARIANT = 'VASSS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator3.VARIANT
+
+
+    def getPayload(self,
+                    subtitleDispositionTuple = (set(), set(), set()),
+                    subtitleTagTuple = ({}, {}, {})):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 0
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 1
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 2
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[0]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 3
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[1]
+        trackDescriptor3 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 4
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 4
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[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 MTC in MediaTagCombinator.getAllClassReferences():
+            for DC3 in DispositionCombinator3.getAllClassReferences():
+                for TC3 in TrackTagCombinator3.getAllClassReferences():
+
+                        dc3 = DC3(self._context)
+                        tc3 = TC3(self._context)
+
+                        mtc = MTC(self._context)
+
+                        yObj = {}
+
+                        yObj['identifier'] = self.getIdentifier()
+                        yObj['variants'] = [self.getVariant(),
+                                                f"S:{dc3.getVariant()}",
+                                                f"S:{tc3.getVariant()}",
+                                                mtc.getVariant()]
+
+                        yObj['payload'] = self.getPayload(dc3.getPayload(),
+                                                            tc3.getPayload())
+
+                        yObj['assertSelectors'] = ['M', 'SD', 'ST', 'MT']
+                        yObj['assertFuncs'] = [self.assertFunc,
+                                                    dc3.createAssertFunc(),
+                                                    tc3.createAssertFunc(),
+                                                    mtc.createAssertFunc()]
+
+                        yObj['shouldFail'] = (self.shouldFail()
+                                                    | dc3.shouldFail()
+                                                    | tc3.shouldFail()
+                                                    | mtc.shouldFail())
+                        yieldObj = {'target': yObj}
+
+                        if self.__createPresets:
+
+                            dc3_p = DC3(self._context, createPresets = True)
+                            tc3_p = TC3(self._context, createPresets = True)
+
+                            mtc_p = MTC(self._context, createPresets = True)
+
+                            yObj_p = {}
+
+                            yObj_p['identifier'] = self.getIdentifier()
+                            yObj_p['variants'] = [self.getVariant(),
+                                                    f"S:{dc3_p.getVariant()}",
+                                                    f"S:{tc3_p.getVariant()}",
+                                                    mtc_p.getVariant()]
+
+                            yObj_p['payload'] = self.getPayload(dc3_p.getPayload(),
+                                                                tc3_p.getPayload())
+
+                            yObj_p['assertSelectors'] = ['M', 'SD', 'ST', 'MT']
+                            yObj_p['assertFuncs'] = [self.assertFunc,
+                                                        dc3_p.createAssertFunc(),
+                                                        tc3_p.createAssertFunc(),
+                                                        mtc_p.createAssertFunc()]
+
+                            yObj_p['shouldFail'] = (self.shouldFail()
+                                                        | dc3_p.shouldFail()
+                                                        | tc3_p.shouldFail()
+                                                        | mtc_p.shouldFail())
+                            yieldObj['preset'] = yObj_p
+
+                        yield yieldObj

tests/legacy/media_combinator_4.py

@@ -0,0 +1,145 @@
+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 .track_tag_combinator_2 import TrackTagCombinator2
+from .permutation_combinator_2 import PermutationCombinator2
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator4(MediaCombinator):
+
+    VARIANT = 'VAA'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator4.VARIANT
+
+
+    def getPayload(self,
+                    audioDispositionTuple = (set(), set()),
+                    audioTagTuple = ({}, {})):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 0
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 1
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
+        kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[0]
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 2
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
+        kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[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 MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2 in DispositionCombinator2.getAllClassReferences():
+                for TC2 in TrackTagCombinator2.getAllClassReferences():
+
+                        dc2 = DC2(self._context)
+                        tc2 = TC2(self._context)
+
+                        mtc = MTC(self._context)
+
+                        yObj = {}
+
+                        yObj['identifier'] = self.getIdentifier()
+                        yObj['variants'] = [self.getVariant(),
+                                                f"A:{dc2.getVariant()}",
+                                                f"A:{tc2.getVariant()}",
+                                                mtc.getVariant()]
+
+                        yObj['payload'] = self.getPayload(dc2.getPayload(),
+                                                            tc2.getPayload())
+
+                        yObj['assertSelectors'] = ['M', 'AD', 'AT', 'MT']
+                        yObj['assertFuncs'] = [self.assertFunc,
+                                                    dc2.createAssertFunc(),
+                                                    tc2.createAssertFunc(),
+                                                    mtc.createAssertFunc()]
+
+                        yObj['shouldFail'] = (self.shouldFail()
+                                                | dc2.shouldFail()
+                                                | tc2.shouldFail()
+                                                | mtc.shouldFail())
+                        yieldObj = {'target': yObj}
+
+                        if self.__createPresets:
+
+                            dc2_p = DC2(self._context, createPresets = True)
+                            tc2_p = TC2(self._context, createPresets = True)
+
+                            mtc_p = MTC(self._context, createPresets = True)
+
+                            yObj_p = {}
+
+                            yObj_p['identifier'] = self.getIdentifier()
+                            yObj_p['variants'] = [self.getVariant(),
+                                                    f"A:{dc2_p.getVariant()}",
+                                                    f"A:{tc2_p.getVariant()}",
+                                                    mtc_p.getVariant()]
+
+                            yObj_p['payload'] = self.getPayload(dc2_p.getPayload(),
+                                                                tc2_p.getPayload())
+
+                            yObj_p['assertSelectors'] = ['M', 'AD', 'AT', 'MT']
+                            yObj_p['assertFuncs'] = [self.assertFunc,
+                                                        dc2_p.createAssertFunc(),
+                                                        tc2_p.createAssertFunc(),
+                                                        mtc_p.createAssertFunc()]
+
+                            yObj_p['shouldFail'] = (self.shouldFail()
+                                                    | dc2_p.shouldFail()
+                                                    | tc2_p.shouldFail()
+                                                    | mtc_p.shouldFail())
+                            yieldObj['preset'] = yObj_p
+
+                        yield yieldObj

tests/legacy/media_combinator_5.py

@@ -0,0 +1,155 @@
+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 .track_tag_combinator_2 import TrackTagCombinator2
+from .permutation_combinator_2 import PermutationCombinator2
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator5(MediaCombinator):
+
+    VARIANT = 'VAAS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator5.VARIANT
+
+
+    def getPayload(self,
+                    audioDispositionTuple = (set(), set()),
+                    audioTagTuple = ({}, {})):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 0
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 1
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
+        kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[0]
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 2
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
+        kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[1]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 3
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        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 MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2 in DispositionCombinator2.getAllClassReferences():
+                for TC2 in TrackTagCombinator2.getAllClassReferences():
+
+                        dc2 = DC2(self._context)
+                        tc2 = TC2(self._context)
+
+                        mtc = MTC(self._context)
+
+                        yObj = {}
+
+                        yObj['identifier'] = self.getIdentifier()
+                        yObj['variants'] = [self.getVariant(),
+                                                f"A:{dc2.getVariant()}",
+                                                f"A:{tc2.getVariant()}",
+                                                mtc.getVariant()]
+
+                        yObj['payload'] = self.getPayload(dc2.getPayload(),
+                                                          tc2.getPayload())
+
+                        yObj['assertSelectors'] = ['M', 'AD', 'AT', 'MT']
+                        yObj['assertFuncs'] = [self.assertFunc,
+                                                    dc2.createAssertFunc(),
+                                                    tc2.createAssertFunc(),
+                                                    mtc.createAssertFunc()]
+
+                        yObj['shouldFail'] = (self.shouldFail()
+                                                    | dc2.shouldFail()
+                                                    | tc2.shouldFail()
+                                                    | mtc.shouldFail())
+                        yieldObj = {'target': yObj}
+
+                        if self.__createPresets:
+
+                            dc2_p = DC2(self._context, createPresets = True)
+                            tc2_p = TC2(self._context, createPresets = True)
+
+                            mtc_p = MTC(self._context, createPresets = True)
+
+                            yObj_p = {}
+
+                            yObj_p['identifier'] = self.getIdentifier()
+                            yObj_p['variants'] = [self.getVariant(),
+                                                    f"A:{dc2_p.getVariant()}",
+                                                    f"A:{tc2_p.getVariant()}",
+                                                    mtc_p.getVariant()]
+
+                            yObj_p['payload'] = self.getPayload(dc2_p.getPayload(),
+                                                                tc2_p.getPayload())
+
+                            yObj_p['assertSelectors'] = ['M', 'AD', 'AT', 'MT']
+                            yObj_p['assertFuncs'] = [self.assertFunc,
+                                                        dc2_p.createAssertFunc(),
+                                                        tc2_p.createAssertFunc(),
+                                                        mtc_p.createAssertFunc()]
+
+                            yObj_p['shouldFail'] = (self.shouldFail()
+                                                        | dc2_p.shouldFail()
+                                                        | tc2_p.shouldFail()
+                                                        | mtc_p.shouldFail())
+                            yieldObj['preset'] = yObj_p
+
+                        yield yieldObj

tests/legacy/media_combinator_6.py

@@ -0,0 +1,191 @@
+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 .track_tag_combinator_2 import TrackTagCombinator2
+from .permutation_combinator_2 import PermutationCombinator2
+from .media_tag_combinator import MediaTagCombinator
+
+
+class MediaCombinator6(MediaCombinator):
+
+    VARIANT = 'VAASS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator6.VARIANT
+
+
+    def getPayload(self,
+                    audioDispositionTuple = (set(), set()),
+                    audioTagTuple = ({}, {}),
+                    subtitleDispositionTuple = (set(), set()),
+                    subtitleTagTuple = ({}, {})):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 0
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 1
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
+        kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[0]
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 2
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
+        kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[1]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 3
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[0]
+        trackDescriptor3 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 4
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 4
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[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 MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2_A in DispositionCombinator2.getAllClassReferences():
+                for TC2_A in TrackTagCombinator2.getAllClassReferences():
+                    for DC2_S in DispositionCombinator2.getAllClassReferences():
+                        for TC2_S in TrackTagCombinator2.getAllClassReferences():
+
+                                dc2a = DC2_A(self._context)
+                                tc2a = TC2_A(self._context)
+                                dc2s = DC2_S(self._context)
+                                tc2s = TC2_S(self._context)
+
+                                mtc = MTC(self._context)
+
+                                yObj = {}
+
+                                yObj['identifier'] = self.getIdentifier()
+                                yObj['variants'] = [self.getVariant(),
+                                                        f"A:{dc2a.getVariant()}",
+                                                        f"A:{tc2a.getVariant()}",
+                                                        f"S:{dc2s.getVariant()}",
+                                                        f"S:{tc2s.getVariant()}",
+                                                        mtc.getVariant()]
+
+                                yObj['payload'] = self.getPayload(dc2a.getPayload(),
+                                                                    tc2a.getPayload(),
+                                                                    dc2s.getPayload(),
+                                                                    tc2s.getPayload())
+
+                                yObj['assertSelectors'] = ['M', 'AD', 'AT', 'SD', 'ST', 'MT']
+                                yObj['assertFuncs'] = [self.assertFunc,
+                                                            dc2a.createAssertFunc(),
+                                                            tc2a.createAssertFunc(),
+                                                            dc2s.createAssertFunc(),
+                                                            tc2s.createAssertFunc(),
+                                                            mtc.createAssertFunc()]
+
+                                yObj['shouldFail'] = (self.shouldFail()
+                                                            | dc2a.shouldFail()
+                                                            | tc2a.shouldFail()
+                                                            | dc2s.shouldFail()
+                                                            | tc2s.shouldFail()
+                                                            | mtc.shouldFail())
+                                yieldObj = {'target': yObj}
+
+                                if self.__createPresets:
+
+                                    dc2a_p = DC2_A(self._context, createPresets = True)
+                                    tc2a_p = TC2_A(self._context, createPresets = True)
+                                    dc2s_p = DC2_S(self._context, createPresets = True)
+                                    tc2s_p = TC2_S(self._context, createPresets = True)
+
+                                    mtc_p = MTC(self._context, createPresets = True)
+
+                                    yObj_p = {}
+
+                                    yObj_p['identifier'] = self.getIdentifier()
+                                    yObj_p['variants'] = [self.getVariant(),
+                                                            f"A:{dc2a_p.getVariant()}",
+                                                            f"A:{tc2a_p.getVariant()}",
+                                                            f"S:{dc2s_p.getVariant()}",
+                                                            f"S:{tc2s_p.getVariant()}",
+                                                            mtc_p.getVariant()]
+
+                                    yObj_p['payload'] = self.getPayload(dc2a_p.getPayload(),
+                                                                        tc2a_p.getPayload(),
+                                                                        dc2s_p.getPayload(),
+                                                                        tc2s_p.getPayload())
+
+                                    yObj_p['assertSelectors'] = ['M', 'AD', 'AT', 'SD', 'ST', 'MT']
+                                    yObj_p['assertFuncs'] = [self.assertFunc,
+                                                                dc2a_p.createAssertFunc(),
+                                                                tc2a_p.createAssertFunc(),
+                                                                dc2s_p.createAssertFunc(),
+                                                                tc2s_p.createAssertFunc(),
+                                                                mtc_p.createAssertFunc()]
+
+                                    yObj_p['shouldFail'] = (self.shouldFail()
+                                                                | dc2a_p.shouldFail()
+                                                                | tc2a_p.shouldFail()
+                                                                | dc2s_p.shouldFail()
+                                                                | tc2s_p.shouldFail()
+                                                                | mtc_p.shouldFail())
+                                    yieldObj['preset'] = yObj_p
+
+                                yield yieldObj

tests/legacy/media_combinator_7.py

@@ -0,0 +1,230 @@
+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
+from .track_tag_combinator_2 import TrackTagCombinator2
+from .track_tag_combinator_3 import TrackTagCombinator3
+from .permutation_combinator_2 import PermutationCombinator2
+from .permutation_combinator_3 import PermutationCombinator3
+from .media_tag_combinator import MediaTagCombinator
+
+class MediaCombinator7(MediaCombinator):
+
+    VARIANT = 'VAASSS'
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return MediaCombinator7.VARIANT
+
+
+    def getPayload(self,
+                    audioPermutation,
+                    subtitlePermutation,
+                    audioDispositionTuple = (set(), set()),
+                    audioTagTuple = ({}, {}),
+                    subtitleDispositionTuple = (set(), set(), set()),
+                    subtitleTagTuple = ({}, {}, {})):
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 0
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.VIDEO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        trackDescriptor0 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 1
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[0]
+        kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[0]
+        trackDescriptor1 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 2
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.AUDIO
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = audioDispositionTuple[1]
+        kwargs[TrackDescriptor.TAGS_KEY] = audioTagTuple[1]
+        trackDescriptor2 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 3
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 3
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 0
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[0]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[0]
+        trackDescriptor3 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 4
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 4
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 1
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[1]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[1]
+        trackDescriptor4 = TrackDescriptor(**kwargs)
+
+        kwargs = {}
+        kwargs[TrackDescriptor.CONTEXT_KEY] = self._context
+        kwargs[TrackDescriptor.INDEX_KEY] = 5
+        kwargs[TrackDescriptor.SOURCE_INDEX_KEY] = 5
+        kwargs[TrackDescriptor.TRACK_TYPE_KEY] = TrackType.SUBTITLE
+        kwargs[TrackDescriptor.SUB_INDEX_KEY] = 2
+        kwargs[TrackDescriptor.DISPOSITION_SET_KEY] = subtitleDispositionTuple[2]
+        kwargs[TrackDescriptor.TAGS_KEY] = subtitleTagTuple[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):
+
+
+        pc2 = PermutationCombinator2(self._context)
+        pc3 = PermutationCombinator3(self._context)
+
+        for MTC in MediaTagCombinator.getAllClassReferences():
+            for DC2_A in DispositionCombinator2.getAllClassReferences():
+                for TC2_A in TrackTagCombinator2.getAllClassReferences():
+                    for DC3_S in DispositionCombinator3.getAllClassReferences():
+                        for TC3_S in TrackTagCombinator3.getAllClassReferences():
+                            for p2y in pc2.getYield():
+                                for p3y in pc3.getYield():
+
+                                    dc2a = DC2_A(self._context)
+                                    tc2a = TC2_A(self._context)
+                                    dc3s = DC3_S(self._context)
+                                    tc3s = TC3_S(self._context)
+
+                                    mtc = MTC(self._context)
+
+                                    yObj = {}
+
+                                    yObj['identifier'] = self.getIdentifier()
+                                    yObj['variants'] = [self.getVariant(),
+                                                            f"A:{p2y['variant']}",
+                                                            f"S:{p3y['variant']}",
+                                                            f"A:{dc2a.getVariant()}",
+                                                            f"A:{tc2a.getVariant()}",
+                                                            f"S:{dc3s.getVariant()}",
+                                                            f"S:{tc3s.getVariant()}",
+                                                            mtc.getVariant()]
+
+                                    yObj['payload'] = self.getPayload(p2y['permutation'],
+                                                                      p3y['permutation'],
+                                                                      dc2a.getPayload(),
+                                                                        tc2a.getPayload(),
+                                                                        dc3s.getPayload(),
+                                                                        tc3s.getPayload())
+
+                                    yObj['assertSelectors'] = ['M', 'AP', 'SP', 'AD', 'AT', 'SD', 'ST', 'MT']
+
+                                    yObj['assertFuncs'] = [self.assertFunc,
+                                                                p2y['assertFunc'],
+                                                                p3y['assertFunc'],
+                                                                dc2a.createAssertFunc(),
+                                                                tc2a.createAssertFunc(),
+                                                                dc3s.createAssertFunc(),
+                                                                tc3s.createAssertFunc(),
+                                                                mtc.createAssertFunc()]
+
+                                    yObj['shouldFail'] = (self.shouldFail()
+                                                                | p2y['shouldFail']
+                                                                | p3y['shouldFail']
+                                                                | dc2a.shouldFail()
+                                                                | tc2a.shouldFail()
+                                                                | dc3s.shouldFail()
+                                                                | tc3s.shouldFail()
+                                                                | mtc.shouldFail())
+                                    yieldObj = {'target': yObj}
+
+                                    if self.__createPresets:
+
+                                        dc2a_p = DC2_A(self._context, createPresets = True)
+                                        tc2a_p = TC2_A(self._context, createPresets = True)
+                                        dc3s_p = DC3_S(self._context, createPresets = True)
+                                        tc3s_p = TC3_S(self._context, createPresets = True)
+
+                                        mtc_p = MTC(self._context, createPresets = True)
+
+                                        yObj_p = {}
+
+                                        yObj_p['identifier'] = self.getIdentifier()
+                                        yObj_p['variants'] = [self.getVariant(),
+                                                                f"A:{p2y['variant']}",
+                                                                f"S:{p3y['variant']}",
+                                                                f"A:{dc2a_p.getVariant()}",
+                                                                f"A:{tc2a_p.getVariant()}",
+                                                                f"S:{dc3s_p.getVariant()}",
+                                                                f"S:{tc3s_p.getVariant()}",
+                                                                mtc_p.getVariant()]
+
+                                        yObj_p['payload'] = self.getPayload(p2y['permutation'],
+                                                                            p3y['permutation'],
+                                                                            dc2a_p.getPayload(),
+                                                                            tc2a_p.getPayload(),
+                                                                            dc3s_p.getPayload(),
+                                                                            tc3s_p.getPayload())
+
+                                        yObj_p['assertSelectors'] = ['M', 'AP', 'SP', 'AD', 'AT', 'SD', 'ST', 'MT']
+
+                                        yObj_p['assertFuncs'] = [self.assertFunc,
+                                                                    p2y['assertFunc'],
+                                                                    p3y['assertFunc'],
+                                                                    dc2a_p.createAssertFunc(),
+                                                                    tc2a_p.createAssertFunc(),
+                                                                    dc3s_p.createAssertFunc(),
+                                                                    tc3s_p.createAssertFunc(),
+                                                                    mtc_p.createAssertFunc()]
+
+                                        yObj_p['shouldFail'] = (self.shouldFail()
+                                                                    | p2y['shouldFail']
+                                                                    | p3y['shouldFail']
+                                                                    | dc2a_p.shouldFail()
+                                                                    | tc2a_p.shouldFail()
+                                                                    | dc3s_p.shouldFail()
+                                                                    | tc3s_p.shouldFail()
+                                                                    | mtc_p.shouldFail())
+                                        yieldObj['preset'] = yObj_p
+
+                                    yield yieldObj

tests/legacy/media_tag_combinator.py

@@ -0,0 +1,34 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class MediaTagCombinator():
+
+    IDENTIFIER = 'mediaTag'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return MediaTagCombinator.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[21:-3]
+                for p
+                in glob.glob(f"{ basePath }/media_tag_combinator_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        module_name = f"tests.legacy.media_tag_combinator_{ identifier }"
+        importlib.import_module(module_name)
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            #HINT: Excluding MediaCombinator as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'MediaTagCombinator' and name.startswith('MediaTagCombinator'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [MediaTagCombinator.getClassReference(i) for i in MediaTagCombinator.list()]

tests/legacy/media_tag_combinator_0.py

@@ -0,0 +1,55 @@
+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_tag_combinator import MediaTagCombinator
+
+
+class MediaTagCombinator0(MediaTagCombinator):
+
+    VARIANT = 'MT0'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return MediaTagCombinator0.VARIANT
+
+
+    def getPayload(self):
+        mediaTags = {}
+        if self.__createPresets:
+            mediaTags['THIS_IS'] = 'FFX'
+        return mediaTags
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tags'")
+                mediaTags = assertObj['tags']
+
+                assert ('THIS_IS' in mediaTags.keys() and mediaTags.keys()['THIS_IS'] == 'FFX'
+                ), "Media tag 'THIS_IS' was not preserved"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                pass
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/media_tag_combinator_1.py

@@ -0,0 +1,59 @@
+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_tag_combinator import MediaTagCombinator
+
+class MediaTagCombinator1(MediaTagCombinator):
+
+    VARIANT = 'MT1'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return MediaTagCombinator1.VARIANT
+
+
+    def getPayload(self):
+        mediaTags = {'From': 'Encoders'}
+        if self.__createPresets:
+            mediaTags['THIS_IS'] = 'FFX'
+        return mediaTags
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tags'")
+                mediaTags = assertObj['tags']
+
+                assert ('From' in mediaTags.keys()
+                ), "'From' not in media tag keys"
+                assert (mediaTags.keys()['From'] == 'Encoders'
+                ), "Media tag value not 'Encoders' for key 'To'"
+
+                assert ('THIS_IS' in mediaTags.keys() and mediaTags.keys()['THIS_IS'] == 'FFX'
+                ), "Media tag 'THIS_IS' was not preserved"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                pass
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/media_tag_combinator_2.py

@@ -0,0 +1,64 @@
+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_tag_combinator import MediaTagCombinator
+
+class MediaTagCombinator2(MediaTagCombinator):
+
+    VARIANT = 'MT2'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return MediaTagCombinator2.VARIANT
+
+
+    def getPayload(self):
+        mediaTags = {'To': 'Fanz',
+                        'Yolo': 'Holo'}
+        if self.__createPresets:
+            mediaTags['THIS_IS'] = 'FFX'
+        return mediaTags
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tags'")
+                mediaTags = assertObj['tags']
+
+                assert ('To' in mediaTags.keys()
+                ), "'To' not in media tag keys"
+                assert (mediaTags.keys()['To'] == 'Fanz'
+                ), "Media tag value not 'Fanz' for key 'To'"
+                assert ('Yolo' in mediaTags.keys()
+                ), "'Yolo' not in media tag keys"
+                assert (mediaTags.keys()['Yolo'] == 'Holo'
+                ), "Media tag value not 'Holo' for key 'Yolo'"
+
+                assert ('THIS_IS' in mediaTags.keys() and mediaTags.keys()['THIS_IS'] == 'FFX'
+                ), "Media tag 'THIS_IS' was not preserved"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                pass
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/permutation_combinator_2.py

@@ -0,0 +1,38 @@
+class PermutationCombinator2():
+
+    IDENTIFIER = 'permutation2'
+
+    PERMUTATION_LIST = [
+        [0,1],
+        [1,0]
+    ]
+
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return PermutationCombinator2.IDENTIFIER
+
+
+    def getPayload(self, permutationIndex):
+        return {
+            'variant': f"P{permutationIndex}",
+            'permutation': PermutationCombinator2.PERMUTATION_LIST[permutationIndex],
+            'assertFunc': self.createAssertFunc(),
+            'shouldFail': self.shouldFail()
+        }
+
+    def createAssertFunc(self):
+        def f(testObj = {}):
+            pass
+        return f
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        for permutationIndex in range(len(PermutationCombinator2.PERMUTATION_LIST)):
+            yield self.getPayload(permutationIndex)

tests/legacy/permutation_combinator_3.py

@@ -0,0 +1,39 @@
+class PermutationCombinator3():
+
+    IDENTIFIER = 'permutation3'
+
+    PERMUTATION_LIST = [
+        [0,1,2],
+        [0,2,1],
+        [1,2,0]
+    ]
+
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return PermutationCombinator3.IDENTIFIER
+
+
+    def getPayload(self, permutationIndex):
+        return {
+            'variant': f"P{permutationIndex}",
+            'permutation': PermutationCombinator3.PERMUTATION_LIST[permutationIndex],
+            'assertFunc': self.createAssertFunc(),
+            'shouldFail': self.shouldFail()
+        }
+
+    def createAssertFunc(self):
+        def f(testObj = {}):
+            pass
+        return f
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        for permutationIndex in range(len(PermutationCombinator3.PERMUTATION_LIST)):
+            yield self.getPayload(permutationIndex)

tests/legacy/release_combinator.py

@@ -0,0 +1,37 @@
+class ReleaseCombinator():
+
+    IDENTIFIER = 'release'
+
+    RELEASE_LIST = [
+        ".GerEngSub.AAC.1080pINDICATOR.WebDL.x264-Tanuki",
+        ".German.AC3.DL.1080pINDICATOR.BluRay.x264-AST4u",
+        "-720pINDICATOR"
+    ]
+
+    def __init__(self, context = None, indicator = ''):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        self.__indicator = indicator
+
+    def getIdentifier(self):
+        return ReleaseCombinator.IDENTIFIER
+
+    def getPayload(self, releaseIndex):
+        releaseStr: str = ReleaseCombinator.RELEASE_LIST[releaseIndex]
+        return {
+            'variant': f"R{releaseIndex}",
+            'release': releaseStr.replace('INDICATOR', f".{self.__indicator}")
+                    if self.__indicator else releaseStr.replace('INDICATOR', '')
+        }
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        for releaseIndex in range(len(ReleaseCombinator.RELEASE_LIST)):
+            yield self.getPayload(releaseIndex)

tests/legacy/scenario.py

@@ -0,0 +1,150 @@
+import os, glob, sys, importlib, glob, inspect
+
+from ffx.show_controller import ShowController
+from ffx.pattern_controller import PatternController
+from ffx.media_controller import MediaController
+
+from .helper import createEmptyDirectory
+from ffx.database import databaseContext
+
+class Scenario():
+    """Scenarios
+    
+    Scenario1: MediaTags, Stream-Kombinationen, Dispositions und StreamTags per Kombinatoren
+
+    Scenario2: <pattern> mit 3 Files x Scenario1
+
+    Scenario3: <tmdb+pattern> mit 3 Files (wenn TMDB API Key verfügbar)
+
+    Naming:
+
+    1: test.mkv             no tmdb, no pattern
+    2: test_s01e02.mkv
+    
+    Operationen:
+    
+    tmdb lookup: Set Showname as prefix, append episode name
+    pattern lookup: Set/update tags/dispositions; Filter/Reorder Tracks
+
+    MediaTag-Kombinationen (2)
+    
+    0: nichs
+    1: Yolo=Holo
+
+    Stream-Kombinationen (8)
+    
+    VA      D=1     T=1     =1
+    VAS     D=1     T=1     =1
+    VASS    D=4     T=4     =16
+    VASSS   D=5     T=5     =25
+    VAA     D=4     T=4     =16
+    VAAS    D=4     T=4     =16
+    VAASS   D=16    T=16    =256
+    VAASSS  D=20    T=20    =400
+                            =731
+
+    Dispositions-Kombinationen (per TrackType)
+    
+    0 = keine
+    1 = DEFAULT
+
+    2 Streams (4):
+    
+    D1: 00
+    D2: 01
+    D3: 10
+    D4: 11
+
+    3 Streams (5):
+    
+    D5: 000
+    D6: 001
+    D7: 010
+    D8: 100
+    D9: 101
+
+    Stream-Tag-Kombinationen (per TrackType)
+    
+    0 = keine
+    1 = lang+title
+
+    2 Streams:
+    
+    00
+    01
+    10
+    11
+
+    3 Streams:
+    
+    000
+    001
+    010
+    100
+    101
+    
+    
+    
+    """
+
+    def __init__(self, context = None):
+        self._context = context
+        self._testDirectory = createEmptyDirectory()
+        self._ffxModuleName = 'ffx'
+
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+        self._testDbFilePath = os.path.join(self._testDirectory, 'test.db')
+        self.createEmptyTestDatabase()
+
+        # Convenience
+        self._niceness = self._context['resource_limits']['niceness'] if 'resource_limits' in self._context.keys() and 'niceness' in self._context['resource_limits'].keys() else 99
+        self._cpuPercent = self._context['resource_limits']['cpu_percent'] if 'resource_limits' in self._context.keys() and 'cpu_percent' in self._context['resource_limits'].keys() else 99
+
+
+    def createEmptyTestDatabase(self):
+
+        if not self._context['database'] is None:
+            self._context['database']['engine'].dispose()
+
+        if os.path.isfile(self._testDbFilePath):
+            os.unlink(self._testDbFilePath)
+        self._context['database'] = None
+
+        self._logger.debug(f"Creating test db with path {self._testDbFilePath}")
+        self._context['database'] = databaseContext(databasePath=self._testDbFilePath)
+
+        self._sc = ShowController(context = self._context)
+        self._pc = PatternController(context = self._context)
+        self._mc = MediaController(context = self._context)
+    
+
+    def clearTestDirectory(self):
+        testFiles = glob.glob(f"{self._testDirectory}/*")
+        for f in testFiles:
+            os.remove(f)
+
+    def getFilePathsInTestDirectory(self):
+        return [f for f in glob.glob(f"{self._testDirectory}/*")]
+
+    def getFilenamesInTestDirectory(self):
+        return [os.path.basename(f) for f in self.getFilePathsInTestDirectory()]
+
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[9:-3]
+                for p
+                in glob.glob(f"{ basePath }/scenario_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        module_name = f"tests.legacy.scenario_{ identifier }"
+        importlib.import_module(module_name)
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            #HINT: Excluding Scenario as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'Scenario' and name.startswith('Scenario'):
+                return obj

tests/legacy/scenario_1.py

@@ -0,0 +1,172 @@
+import os, sys, click, glob
+
+from .scenario import Scenario
+
+from .helper import createMediaTestFile
+from ffx.process import executeProcess
+
+from ffx.file_properties import FileProperties
+
+from ffx.media_descriptor import MediaDescriptor
+from ffx.track_descriptor import TrackDescriptor
+
+from ffx.track_type import TrackType
+from ffx.track_disposition import TrackDisposition
+
+from .media_combinator_0 import MediaCombinator0
+
+from .basename_combinator import BasenameCombinator
+
+
+class Scenario1(Scenario):
+    """Creating file VAa, h264/aac/aac
+    Converting to VaA, vp9/opus/opus
+    No tmdb, default parameters"""
+
+    TEST_FILE_EXTENSION = 'mkv'
+    EXPECTED_FILE_EXTENSION = 'webm'
+
+
+    def __init__(self, context):
+
+        context['use_tmdb'] = False
+        context['use_pattern'] = False
+
+        super().__init__(context)
+
+    def getScenario(self):
+        return self.__class__.__name__[8:]
+
+
+    def job(self, yieldObj: dict):
+
+        testContext = self._context.copy()
+
+        identifier = yieldObj['identifier']
+        variantList = yieldObj['variants']
+
+        variantIdentifier = '-'.join(variantList)
+        variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}"
+
+        mc0 = MediaCombinator0(context = testContext)
+        sourceMediaDescriptor: MediaDescriptor = mc0.getPayload()
+
+        assertSelectorList: list = yieldObj['assertSelectors']
+        assertFuncList = yieldObj['assertFuncs']
+        shouldFail = yieldObj['shouldFail']
+
+        variantPayload = yieldObj['payload']
+        variantBasename = variantPayload['basename']
+        variantFilenameLabel = variantPayload['label']
+        expectedBasename = variantPayload['expectedBasename']
+
+        variantFilename = f"{variantBasename}.{Scenario1.TEST_FILE_EXTENSION}"
+        expectedFilename = f"{expectedBasename}.{Scenario1.EXPECTED_FILE_EXTENSION}"
+
+
+        if self._context['test_variant'] and not variantIdentifier.startswith(self._context['test_variant']):
+            return
+
+        if (self._context['test_limit'] and (self._context['test_passed_counter'] + self._context['test_failed_counter'])
+                    >= self._context['test_limit']):
+            return
+
+        self._logger.debug(f"Running Job: {variantLabel}")
+
+
+        # Phase 1: Setup source files
+
+        if not variantBasename:
+            raise ValueError(f"{variantLabel}: Testfile basename is falsy")
+
+
+        self.clearTestDirectory()
+
+        self._logger.debug(f"Creating test file: {variantFilename}")
+        mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor,
+                                            baseName=variantBasename,
+                                            directory=self._testDirectory,
+                                            logger=self._logger,
+                                            length = 2)
+
+
+        # Phase 2: Run ffx
+
+        commandSequence = [sys.executable, '-m', self._ffxModuleName]
+        
+        if self._context['verbosity']:
+            commandSequence += ['--verbose',
+                                str(self._context['verbosity'])]
+
+        commandSequence += ['convert',
+                            mediaFilePath,
+                            '--no-prompt',
+                            '--no-signature']
+        
+        if variantFilenameLabel:
+            commandSequence += ['--label', variantFilenameLabel]
+
+
+        commandSequence += ['--no-pattern']
+        commandSequence += ['--no-tmdb']
+
+        out, err, rc = executeProcess(commandSequence, directory = self._testDirectory, context = self._context)
+
+        if out and self._context['verbosity'] >= 9:
+            self._logger.debug(f"{variantLabel}: Process output: {out}")
+        if rc:
+            self._logger.debug(f"{variantLabel}: Process returned ERROR {rc} ({err})")
+
+
+        # Phase 3: Evaluate results
+            
+        resultFilenames = [rf for rf in self.getFilenamesInTestDirectory() if rf != 'ffmpeg2pass-0.log' and rf != variantFilename]
+        self._logger.debug(f"{variantLabel}: Result filenames: {resultFilenames}")
+
+
+        try:
+
+            jobFailed = bool(rc)
+
+            self._logger.debug(f"{variantLabel}: Should fail: {shouldFail} / actually failed: {jobFailed}")
+
+            assert (jobFailed == shouldFail
+            ), f"Process {'failed' if jobFailed else 'did not fail'}"
+
+            if not jobFailed:
+
+                expectedResultFilePath = os.path.join(self._testDirectory, f"{expectedFilename}")
+
+                assert (os.path.isfile(expectedResultFilePath)
+                ), f"Result file {expectedFilename} in path '{self._testDirectory}' wasn't created"
+
+                for assertIndex in range(len(assertSelectorList)):
+
+                    assertSelector = assertSelectorList[assertIndex]
+                    assertFunc = assertFuncList[assertIndex]
+                    assertVariant = variantList[assertIndex]
+
+                    if assertSelector == 'B':
+                        #TODO: per file find
+                        testObj = {'filenames': resultFilenames}
+                        assertFunc(testObj=testObj)
+                    if assertSelector == 'L':
+                        assertFunc()
+                    if assertSelector == 'I':
+                        assertFunc()
+
+            self._context['test_passed_counter'] += 1
+            self._reportLogger.info(f"{variantLabel}: Test passed")
+
+        except AssertionError as ae:
+
+            self._context['test_failed_counter'] += 1
+            self._reportLogger.error(f"{variantLabel}: Test FAILED ({ae})")
+
+
+    def run(self):
+        for BC in BasenameCombinator.getAllClassReferences():
+            self._logger.debug(f"BC={BC.__name__}")
+            bc = BC(context = self._context)
+            for y in bc.getYield():
+                self.job(y)

tests/legacy/scenario_2.py

@@ -0,0 +1,165 @@
+import os, sys, click
+
+from .scenario import Scenario
+
+from .helper import createMediaTestFile
+from ffx.process import executeProcess
+
+from ffx.file_properties import FileProperties
+
+from ffx.media_descriptor import MediaDescriptor
+from ffx.track_descriptor import TrackDescriptor
+
+from ffx.track_type import TrackType
+from ffx.track_disposition import TrackDisposition
+
+from .media_combinator import MediaCombinator
+
+
+class Scenario2(Scenario):
+    """Creating file VAa, h264/aac/aac
+    Converting to VaA, vp9/opus/opus
+    No tmdb, default parameters"""
+
+    TEST_FILE_EXTENSION = 'mkv'
+    EXPECTED_FILE_EXTENSION = 'webm'
+
+
+    def __init__(self, context):
+
+        context['use_tmdb'] = False
+        context['use_pattern'] = False
+
+        super().__init__(context)
+        
+    def getScenario(self):
+        return self.__class__.__name__[8:]
+
+
+    def job(self, yieldObj: dict):
+
+        testContext = self._context.copy()
+
+        targetYieldObj = yieldObj['target']
+        # presetYieldObj = yieldObj['preset'] # not used here
+
+        identifier = targetYieldObj['identifier']
+        variantList = targetYieldObj['variants']
+
+        variantIdentifier = '-'.join(variantList)
+        variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}"
+
+        sourceMediaDescriptor: MediaDescriptor = targetYieldObj['payload']
+
+        assertSelectorList: list = targetYieldObj['assertSelectors']
+        assertFuncList = targetYieldObj['assertFuncs']
+        shouldFail = targetYieldObj['shouldFail']
+
+
+        if self._context['test_variant'] and not variantIdentifier.startswith(self._context['test_variant']):
+            return
+
+        if (self._context['test_limit'] and (self._context['test_passed_counter'] + self._context['test_failed_counter'])
+                    >= self._context['test_limit']):
+            return
+
+        self._logger.debug(f"Running Job: {variantLabel}")
+
+
+        # Phase 1: Setup source files
+
+        self.clearTestDirectory()
+        mediaFilePath = createMediaTestFile(mediaDescriptor=sourceMediaDescriptor,
+                                            directory=self._testDirectory,
+                                            logger=self._logger,
+                                            length = 2)
+
+
+        # Phase 2: Run ffx
+
+        commandSequence = [sys.executable, '-m', self._ffxModuleName]
+        
+        if self._context['verbosity']:
+            commandSequence += ['--verbose',
+                                str(self._context['verbosity'])]
+
+        commandSequence += ['convert',
+                            mediaFilePath,
+                            '--no-prompt',
+                            '--no-signature']
+
+        out, err, rc = executeProcess(commandSequence, directory = self._testDirectory, context = self._context)
+
+        if out and self._context['verbosity'] >= 9:
+            self._logger.debug(f"{variantLabel}: Process output: {out}")
+        if rc:
+            self._logger.debug(f"{variantLabel}: Process returned ERROR {rc} ({err})")
+
+
+        # Phase 3: Evaluate results
+
+        resultFilenames = [rf for rf in self.getFilenamesInTestDirectory() if rf.endswith(f".{Scenario2.EXPECTED_FILE_EXTENSION}")]
+
+        self._logger.debug(f"{variantLabel}: Result filenames: {resultFilenames}")
+
+        try:
+
+            jobFailed = bool(rc)
+            self._logger.debug(f"{variantLabel}: Should fail: {shouldFail} / actually failed: {jobFailed}")
+
+            assert (jobFailed == shouldFail
+            ), f"Process {'failed' if jobFailed else 'did not fail'}"
+
+
+            if not jobFailed:
+
+                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(testContext, resultFile)
+                resultMediaDescriptor = resultFileProperties.getMediaDescriptor()
+
+                # resultMediaTracks = resultMediaDescriptor.getAllTrackDescriptors()
+                resultMediaTracks = resultMediaDescriptor.getTrackDescriptors()
+
+                for assertIndex in range(len(assertSelectorList)):
+
+                    assertSelector = assertSelectorList[assertIndex]
+                    assertFunc = assertFuncList[assertIndex]
+                    assertVariant = variantList[assertIndex]
+
+                    if assertSelector == 'M':
+                        assertFunc()
+                        for variantIndex in range(len(assertVariant)):
+                            assert (assertVariant[variantIndex].lower() == resultMediaTracks[variantIndex].getType().indicator()
+                            ), f"Stream #{variantIndex} is not of type {resultMediaTracks[variantIndex].getType().label()}"
+
+                    elif assertSelector == 'AD' or assertSelector == 'AT':
+                        assertFunc({'tracks': resultMediaDescriptor.getAudioTracks()})
+
+                    elif assertSelector == 'SD' or assertSelector == 'ST':
+                        assertFunc({'tracks': resultMediaDescriptor.getSubtitleTracks()})
+
+                    elif type(assertSelector) is str:
+                        if assertSelector == 'J':
+                            assertFunc()
+
+
+            self._context['test_passed_counter'] += 1
+            self._reportLogger.info(f"{variantLabel}: Test passed")
+
+        except AssertionError as ae:
+
+            self._context['test_failed_counter'] += 1
+            self._reportLogger.error(f"{variantLabel}: 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)

tests/legacy/scenario_4.py

@@ -0,0 +1,274 @@
+import os, sys, click
+
+from .scenario import Scenario
+
+from .helper import createMediaTestFile
+from ffx.process import executeProcess
+from ffx.database import databaseContext
+
+from .helper import createEmptyDirectory
+from ffx.helper import getEpisodeFileBasename
+
+from ffx.file_properties import FileProperties
+
+from ffx.media_descriptor import MediaDescriptor
+from ffx.track_descriptor import TrackDescriptor
+
+from ffx.track_type import TrackType
+from ffx.track_disposition import TrackDisposition
+
+from .media_combinator import MediaCombinator
+from .indicator_combinator import IndicatorCombinator
+
+from ffx.show_descriptor import ShowDescriptor
+
+
+from ffx.tmdb_controller import TmdbController
+from ffx.tmdb_controller import TMDB_API_KEY_NOT_PRESENT_EXCEPTION
+
+class Scenario4(Scenario):
+
+    TEST_SHOW_IDENTIFIER = 83095
+    TEST_SHOW_NAME = 'The Rising of the Shield Hero'
+    TEST_SHOW_YEAR = 2019
+
+    TEST_FILE_LABEL = 'rotsh'
+    TEST_FILE_EXTENSION = 'mkv'
+
+    TEST_PATTERN = f"{TEST_FILE_LABEL}_{FileProperties.SE_INDICATOR_PATTERN}.{TEST_FILE_EXTENSION}"
+
+    EXPECTED_FILE_EXTENSION = 'webm'
+
+
+    def __init__(self, context):
+        super().__init__(context)
+
+        self.__tmdbApiKey = os.environ.get('TMDB_API_KEY', None)
+        if self.__tmdbApiKey is None:
+            raise TMDB_API_KEY_NOT_PRESENT_EXCEPTION
+
+        self.__ic = IndicatorCombinator(context = context)
+        self.__tc = TmdbController()
+
+
+        kwargs = {}
+        kwargs[ShowDescriptor.ID_KEY] = Scenario4.TEST_SHOW_IDENTIFIER
+        kwargs[ShowDescriptor.NAME_KEY] = Scenario4.TEST_SHOW_NAME
+        kwargs[ShowDescriptor.YEAR_KEY] = Scenario4.TEST_SHOW_YEAR
+
+        self.__testShowDescriptor = ShowDescriptor(**kwargs)
+
+    def getScenario(self):
+        return self.__class__.__name__[8:]
+
+
+    def prepareTestDatabase(self, sourceMediaDescriptor: MediaDescriptor):
+
+        if not self._context['database'] is None:
+            self._context['database']['engine'].dispose()
+
+        if os.path.isfile(self._testDbFilePath):
+            os.unlink(self._testDbFilePath)
+        self._context['database'] = None
+
+        self._logger.debug(f"Creating test db with path {self._testDbFilePath}")
+        self._context['database'] = databaseContext(databasePath=self._testDbFilePath)
+
+
+        self._logger.debug(f"Adding test show '{self.__testShowDescriptor.getFilenamePrefix()}' to test db")
+        if not self._sc.updateShow(self.__testShowDescriptor):
+            raise click.ClickException('Could not create test show in db')
+
+        testPatternDescriptor = {
+             'show_id': Scenario4.TEST_SHOW_IDENTIFIER,
+             'pattern': Scenario4.TEST_PATTERN
+        }
+        patternId = self._pc.addPattern(testPatternDescriptor)
+
+        if patternId:
+            self._mc.setPatternMediaDescriptor(sourceMediaDescriptor, patternId)
+
+
+    def job(self, yieldObj: dict):
+
+        testContext = self._context.copy()
+
+        if 'preset' not in yieldObj.keys():
+            raise KeyError('yieldObj did not contain presets')
+
+        targetYieldObj = yieldObj['target']
+        presetYieldObj = yieldObj['preset']
+
+        identifier = targetYieldObj['identifier']
+        variantList = targetYieldObj['variants']
+
+        variantIdentifier = '-'.join(variantList)
+        variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}"
+
+        sourceMediaDescriptor: MediaDescriptor = targetYieldObj['payload']
+        presetMediaDescriptor: MediaDescriptor = presetYieldObj['payload']
+
+        assertSelectorList: list = presetYieldObj['assertSelectors']
+        assertFuncList = presetYieldObj['assertFuncs']
+        shouldFail = presetYieldObj['shouldFail']
+
+
+        if self._context['test_variant'] and not variantIdentifier.startswith(self._context['test_variant']):
+            return
+
+        if (self._context['test_limit'] and (self._context['test_passed_counter'] + self._context['test_failed_counter'])
+                    >= self._context['test_limit']):
+            return
+
+        self._logger.debug(f"Running Job: {variantLabel}")
+
+
+        for l in presetMediaDescriptor.getConfiguration(label = 'presetMediaDescriptor'):
+            self._logger.debug(l)
+
+        for l in sourceMediaDescriptor.getConfiguration(label = 'sourceMediaDescriptor'):
+            self._logger.debug(l)
+
+
+        # Phase 1: Setup source files
+
+        self.clearTestDirectory()
+
+        testFileList = []
+        for indicatorObj in [y for y in self.__ic.getYield() if y['indicator']]:
+
+            indicator = indicatorObj['indicator']
+
+            testFileObj = {}
+            testFileObj['season'] = indicatorObj['season']
+            testFileObj['episode'] = indicatorObj['episode']
+
+            testFileObj['basename'] = f"{Scenario4.TEST_FILE_LABEL}_{indicator}"
+
+            testFileObj['path'] = createMediaTestFile(mediaDescriptor = presetMediaDescriptor,
+                                                directory = self._testDirectory,
+                                                baseName = testFileObj['basename'],
+                                                logger=self._logger,
+                                                length = 2)
+            testFileObj['filename'] = f"{testFileObj['basename']}.{Scenario4.TEST_FILE_EXTENSION}"
+
+            testFileList.append(testFileObj)
+
+
+        # Phase 2: Prepare database
+
+        self.createEmptyTestDatabase()
+        self.prepareTestDatabase(sourceMediaDescriptor)
+
+
+        # Phase 3: Run ffx
+
+        commandSequence = [sys.executable, '-m', self._ffxModuleName]
+        
+        if self._context['verbosity']:
+            commandSequence += ['--verbose',
+                                str(self._context['verbosity'])]
+
+        commandSequence += ['--database-file',
+                            self._testDbFilePath,
+                            'convert']
+        commandSequence += [tfo['filename'] for tfo in testFileList]
+
+        commandSequence += ['--no-prompt', '--no-signature']
+
+        out, err, rc = executeProcess(commandSequence, directory = self._testDirectory, context = self._context)
+
+        if out and self._context['verbosity'] >= 9:
+            self._logger.debug(f"{variantLabel}: Process output: {out}")
+        if rc:
+            self._logger.debug(f"{variantLabel}: Process returned ERROR {rc} ({err})")
+
+
+        # Phase 4: Evaluate results
+
+        resultFilenames = [rf for rf in self.getFilenamesInTestDirectory() if rf.endswith(f".{Scenario4.EXPECTED_FILE_EXTENSION}")]
+
+        self._logger.debug(f"{variantLabel}: Result filenames: {resultFilenames}")
+        
+
+        try:
+
+            jobFailed = bool(rc)
+            self._logger.debug(f"{variantLabel}: Should fail: {shouldFail} / actually failed: {jobFailed}")
+
+            assert (jobFailed == shouldFail
+            ), f"Process {'failed' if jobFailed else 'did not fail'}"
+
+            if not jobFailed:
+
+                for tfo in testFileList:
+
+                    tmdbEpisodeResult = self.__tc.queryEpisode(Scenario4.TEST_SHOW_IDENTIFIER,
+                                                                tfo['season'], tfo['episode']) 
+
+                    expectedFileBasename = getEpisodeFileBasename(self.__testShowDescriptor.getFilenamePrefix(),
+                                                                    tmdbEpisodeResult['name'],
+                                                                    tfo['season'], tfo['episode'],
+                                                                    context=testContext) 
+
+                    expectedFilename = f"{expectedFileBasename}.{Scenario4.EXPECTED_FILE_EXTENSION}"
+                    expectedFilePath = os.path.join(self._testDirectory, expectedFilename)
+
+                    assert (os.path.isfile(expectedFilePath)
+                    ), f"Result file '{expectedFilename}' in path '{self._testDirectory}' wasn't created"
+
+
+                    rfp = FileProperties(testContext, expectedFilePath)
+                    self._logger.debug(f"{variantLabel}: Result file properties: {rfp.getFilename()} season={rfp.getSeason()} episode={rfp.getEpisode()}")
+
+                    rmd = rfp.getMediaDescriptor()
+                    # rmt = rmd.getAllTrackDescriptors()
+                    rmt = rmd.getTrackDescriptors()
+
+                    for l in rmd.getConfiguration(label = 'resultMediaDescriptor'):
+                        self._logger.debug(l)
+
+                    # num tracks differ
+                    rmd.applySourceIndices(sourceMediaDescriptor)
+
+
+                    for assertIndex in range(len(assertSelectorList)):
+
+                        assertSelector = assertSelectorList[assertIndex]
+                        assertFunc = assertFuncList[assertIndex]
+                        assertVariant = variantList[assertIndex]
+
+                        if assertSelector == 'M':
+                            assertFunc()
+                            for variantIndex in range(len(assertVariant)):
+                                assert (assertVariant[variantIndex].lower() == rmt[variantIndex].getType().indicator()
+                                ), f"Stream #{variantIndex} is not of type {rmt[variantIndex].getType().label()}"
+
+                        if assertSelector == 'AD' or assertSelector == 'AT':
+                            assertFunc({'tracks': rmd.getAudioTracks()})
+
+                        elif assertSelector == 'SD' or assertSelector == 'ST':
+                            assertFunc({'tracks': rmd.getSubtitleTracks()})
+
+                        elif type(assertSelector) is str:
+                            if assertSelector == 'J':
+                                assertFunc()
+
+
+            self._context['test_passed_counter'] += 1
+            self._reportLogger.info(f"\n{variantLabel}: Test passed\n")
+
+        except AssertionError as ae:
+
+            self._context['test_failed_counter'] += 1
+            self._reportLogger.error(f"\n{variantLabel}: Test FAILED ({ae})\n")
+
+
+    def run(self):
+
+        MC_list = [MediaCombinator.getClassReference(6)]
+        for MC in MC_list:
+            self._logger.debug(f"MC={MC.__name__}")
+            mc = MC(context = self._context, createPresets = True)
+            for y in mc.getYield():
+                self.job(y)

tests/legacy/show_combinator.py

@@ -0,0 +1,33 @@
+class ShowCombinator():
+
+    IDENTIFIER = 'show'
+
+    SHOW_LIST = [
+        'Boruto; Naruto Next Generations (2017)',
+        'The Rising of the Shield Hero (2019)',
+        'Scrubs - Die Anfänger (2001)'
+    ]
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return ShowCombinator.IDENTIFIER
+
+    def getPayload(self, showIndex):
+        return {
+            'variant': f"S{showIndex}",
+            'show': ShowCombinator.SHOW_LIST[showIndex]
+        }
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        for showIndex in range(len(ShowCombinator.SHOW_LIST)):
+            yield self.getPayload(showIndex)

tests/legacy/title_combinator.py

@@ -0,0 +1,33 @@
+class TitleCombinator():
+
+    IDENTIFIER = 'title'
+
+    TITLE_LIST = [
+        'The Sound of Space',
+        '2001; Odyssee im Weltraum (1968)',
+        'Ansible 101'
+    ]
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return TitleCombinator.IDENTIFIER
+        
+    def getPayload(self, titleIndex):
+        return {
+            'variant': f"S{titleIndex}",
+            'show': TitleCombinator.TITLE_LIST[titleIndex]
+        }
+
+    def assertFunc(self, testObj = {}):
+        pass
+
+    def shouldFail(self):
+        return False
+
+    def getYield(self):
+        for titleIndex in range(len(TitleCombinator.TITLE_LIST)):
+            yield self.getPayload(titleIndex)

tests/legacy/track_tag_combinator_2.py

@@ -0,0 +1,34 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class TrackTagCombinator2():
+
+    IDENTIFIER = 'trackTag2'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return TrackTagCombinator2.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[23:-3]
+                for p
+                in glob.glob(f"{ basePath }/track_tag_combinator_2_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        module_name = f"tests.legacy.track_tag_combinator_2_{ identifier }"
+        importlib.import_module(module_name)
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            #HINT: Excluding DispositionCombination as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'TrackTagCombinator2' and name.startswith('TrackTagCombinator2'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [TrackTagCombinator2.getClassReference(i) for i in TrackTagCombinator2.list()]

tests/legacy/track_tag_combinator_2_0.py

@@ -0,0 +1,89 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_2 import TrackTagCombinator2
+
+
+class TrackTagCombinator20(TrackTagCombinator2):
+
+    VARIANT = 'T00'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator20.VARIANT
+
+
+    def getPayload(self):
+
+        subTrack0 = {}
+        subTrack1 = {}
+
+        if self.__createPresets:
+            subTrack0['THIS_IS'] = 'track0'
+            subTrack1['THIS_IS'] = 'track1'
+
+        return (subTrack0,
+                subTrack1)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert (not 'language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert (not 'language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert (not 'language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+                
+                # source subIndex 1
+                assert (not 'language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/track_tag_combinator_2_1.py

@@ -0,0 +1,96 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_2 import TrackTagCombinator2
+
+
+class TrackTagCombinator21(TrackTagCombinator2):
+
+    VARIANT = 'T10'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator21.VARIANT
+
+
+    def getPayload(self):
+
+        subTrack0 = ({'language': 'rus', 'title': 'Russisch'}
+                        if self.__createPresets else {'language': 'fra', 'title': 'Französisch'})
+        subTrack1 = {}
+
+        if self.__createPresets:
+            subTrack0['THIS_IS'] = 'track0'
+            subTrack1['THIS_IS'] = 'track1'
+
+        return (subTrack0,
+                subTrack1)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'fra'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'fra'"
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Französisch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Französisch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert (not 'language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'fra'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'fra'"
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Französisch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Französisch'"
+
+                # source subIndex 1
+                assert (not 'language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/track_tag_combinator_2_2.py

@@ -0,0 +1,97 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_2 import TrackTagCombinator2
+
+
+class TrackTagCombinator21(TrackTagCombinator2):
+
+    VARIANT = 'T01'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator21.VARIANT
+
+
+    def getPayload(self):
+
+        subTrack0 = {}
+        subTrack1 = ({'language': 'chn', 'title': 'China'}
+                        if self.__createPresets else {'language': 'bas', 'title': 'Baskisch'})
+
+        if self.__createPresets:
+            subTrack0['THIS_IS'] = 'track0'
+            subTrack1['THIS_IS'] = 'track1'
+
+        return (subTrack0,
+                subTrack1)
+    
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert (not 'language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'bas'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag 'bas'"
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Baskisch'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set title 'Baskisch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert (not 'language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'bas'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag 'bas'"
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Baskisch'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not set title 'Baskisch'"
+
+        return f
+
+
+    def shouldFail(self):
+        return False
+    

tests/legacy/track_tag_combinator_2_3.py

@@ -0,0 +1,106 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_2 import TrackTagCombinator2
+
+
+class TrackTagCombinator23(TrackTagCombinator2):
+
+    VARIANT = 'T11'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+
+    def getVariant(self):
+        return TrackTagCombinator23.VARIANT
+
+
+    def getPayload(self):
+
+        subTrack0 = ({'language': 'chn', 'title': 'China'}
+                        if self.__createPresets else {'language': 'deu', 'title': 'Deutsch'})
+        subTrack1 = {'language': 'jpn', 'title': 'Japanisch'}
+
+        if self.__createPresets:
+            subTrack0['THIS_IS'] = 'track0'
+            subTrack1['THIS_IS'] = 'track1'
+
+        return (subTrack0,
+                subTrack1)
+
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'deu'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'deu'"
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Deutsch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Deutsch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'jpn'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'"
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Japanisch'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'deu'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'deu'"
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Deutsch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Deutsch'"
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'jpn'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'"
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Japanisch'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/track_tag_combinator_3.py

@@ -0,0 +1,34 @@
+import os, sys, importlib, glob, inspect, itertools
+
+class TrackTagCombinator3():
+
+    IDENTIFIER = 'trackTag3'
+
+    def __init__(self, context = None):
+        self._context = context
+        self._logger = context['logger']
+        self._reportLogger = context['report_logger']
+
+    def getIdentifier(self):
+        return TrackTagCombinator3.IDENTIFIER
+
+    @staticmethod    
+    def list():
+        basePath = os.path.dirname(__file__)
+        return [os.path.basename(p)[23:-3]
+                for p
+                in glob.glob(f"{ basePath }/track_tag_combinator_3_*.py", recursive = True)
+                if p != __file__]
+
+    @staticmethod
+    def getClassReference(identifier):
+        module_name = f"tests.legacy.track_tag_combinator_3_{ identifier }"
+        importlib.import_module(module_name)
+        for name, obj in inspect.getmembers(sys.modules[module_name]):
+            #HINT: Excluding DispositionCombination as it seems to be included by import (?)
+            if inspect.isclass(obj) and name != 'TrackTagCombinator3' and name.startswith('TrackTagCombinator3'):
+                return obj
+
+    @staticmethod
+    def getAllClassReferences():
+        return [TrackTagCombinator3.getClassReference(i) for i in TrackTagCombinator3.list()]

tests/legacy/track_tag_combinator_3_0.py

@@ -0,0 +1,105 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator30(TrackTagCombinator3):
+
+    VARIANT = 'T000'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator30.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = {}
+        subtrack1 = {}
+        subtrack2 = {}
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert not ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert not ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert not ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set language tag"
+                assert not ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 2
+                assert not ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert not ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys() and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert not ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert not ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                # source subIndex 1
+                assert not ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set language tag"
+                assert not ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+
+                # source subIndex 2
+                assert not ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert not ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/track_tag_combinator_3_1.py

@@ -0,0 +1,114 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator31(TrackTagCombinator3):
+
+    VARIANT = 'T100'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator31.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = ({'language': 'rus', 'title': 'Russisch'}
+                        if self.__createPresets else {'language': 'fra', 'title': 'Französisch'})
+        subtrack1 = {}
+        subtrack2 = {}
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'fra'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'fra'"
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Französisch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Französisch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert (not 'language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 2
+                assert (not 'language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys() and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'fra'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'fra'"
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Französisch'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Französisch'"
+
+                # source subIndex 1
+                assert (not 'language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+
+                # source subIndex 2
+                assert (not 'language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/track_tag_combinator_3_2.py

@@ -0,0 +1,114 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator32(TrackTagCombinator3):
+
+    VARIANT = 'T010'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator32.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = {}
+        subtrack1 = ({'language': 'chn', 'title': 'China'}
+                        if self.__createPresets else {'language': 'bas', 'title': 'Baskisch'})
+        subtrack2 = {}
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+ 
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert (not 'language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'bas'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'bas'"
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Baskisch'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Baskisch'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 2
+                assert (not 'language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys() and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert (not 'language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'bas'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'bas'"
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Baskisch'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Baskisch'"
+
+                # source subIndex 2
+                assert (not 'language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has set title tag"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/track_tag_combinator_3_3.py

@@ -0,0 +1,114 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator33(TrackTagCombinator3):
+
+    VARIANT = 'T001'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator33.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = {}
+        subtrack1 = {}
+        subtrack2 = ({'language': 'tkm', 'title': 'Turkmenistan'}
+                        if self.__createPresets else {'language': 'eng', 'title': 'English'})
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert (not 'language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys() and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 1
+                assert (not 'language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys() and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS"
+
+                # source subIndex 2
+                assert ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[2].getTags()['language'] == 'eng'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'eng'"
+                assert ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[2].getTags()['title'] == 'English'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'English'"
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys() and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS"
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert (not 'language' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[0].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has set title tag"
+
+                # source subIndex 1
+                assert (not 'language' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set language tag"
+                assert (not 'title' in resortedTrackDescriptors[1].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[1].getSubIndex()}] has set title tag"
+
+                # source subIndex 2
+                assert ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag"
+                assert (resortedTrackDescriptors[2].getTags()['language'] == 'eng'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'eng'"
+                assert ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag"
+                assert (resortedTrackDescriptors[2].getTags()['title'] == 'English'
+                ), f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} index={resortedTrackDescriptors[2].getIndex()} [{resortedTrackDescriptors[2].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'English'"
+
+        return f
+
+
+    def shouldFail(self):
+        return False

tests/legacy/track_tag_combinator_3_4.py

@@ -0,0 +1,214 @@
+import os, sys, importlib, glob, inspect
+
+from ffx.track_disposition import TrackDisposition
+from .track_tag_combinator_3 import TrackTagCombinator3
+
+
+class TrackTagCombinator34(TrackTagCombinator3):
+
+    VARIANT = 'T111'
+
+
+    def __init__(self, context = None,
+                    createPresets: bool = False):
+        super().__init__(context)
+
+        self.__createPresets = createPresets
+
+    def getVariant(self):
+        return TrackTagCombinator34.VARIANT
+
+
+    def getPayload(self):
+
+        subtrack0 = {'language': 'jpn', 'title': 'Japanisch'}
+        subtrack1 = {'language': 'deu', 'title': 'Deutsch'}
+        subtrack2 = ({'language': 'tkm', 'title': 'Turkmenistan'}
+                        if self.__createPresets else {'language': 'eng', 'title': 'English'})
+
+        if self.__createPresets:
+            subtrack0['THIS_IS'] = 'track0'
+            subtrack1['THIS_IS'] = 'track1'
+            subtrack2['THIS_IS'] = 'track2'
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def createAssertFunc(self):
+
+        if self.__createPresets:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'jpn'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'")
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Japanisch'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'")
+
+                assert ('THIS_IS' in resortedTrackDescriptors[0].getTags().keys()
+                and resortedTrackDescriptors[0].getTags()['THIS_IS'] == 'track0'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[0].getIndex()}"
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not preserved tag THIS_IS")
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'deu'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'deu'")
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Deutsch'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Deutsch'")
+
+                assert ('THIS_IS' in resortedTrackDescriptors[1].getTags().keys()
+                and resortedTrackDescriptors[1].getTags()['THIS_IS'] == 'track1'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[1].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not preserved tag THIS_IS")
+
+                # source subIndex 2
+                assert ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[2].getTags()['language'] == 'eng'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'eng'")
+                assert ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[2].getTags()['title'] == 'English'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'English'")
+
+                assert ('THIS_IS' in resortedTrackDescriptors[2].getTags().keys()
+                and resortedTrackDescriptors[2].getTags()['THIS_IS'] == 'track2'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()}"
+                + f"index={resortedTrackDescriptors[2].getIndex()}"
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not preserved tag THIS_IS")
+
+        else:
+
+            def f(assertObj: dict = {}):
+                
+                if not 'tracks' in assertObj.keys():
+                    raise KeyError("assertObj does not contain key 'tracks'")
+                resortedTrackDescriptors = sorted(assertObj['tracks'], key=lambda d: d.getSourceIndex())
+
+                # source subIndex 0
+                assert ('language' in resortedTrackDescriptors[0].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[0].getIndex()} "
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[0].getTags()['language'] == 'jpn'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[0].getIndex()} "
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'")
+                assert ('title' in resortedTrackDescriptors[0].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[0].getIndex()} "
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[0].getTags()['title'] == 'Japanisch'
+                ), (f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[0].getIndex()} "
+                + f"[{resortedTrackDescriptors[0].getType().label()}:"
+                + f"{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'")
+
+                # source subIndex 1
+                assert ('language' in resortedTrackDescriptors[1].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[1].getIndex()} "
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[1].getTags()['language'] == 'deu'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[1].getIndex()} "
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not set language tag 'deu'")
+                assert ('title' in resortedTrackDescriptors[1].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[1].getIndex()} "
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[1].getTags()['title'] == 'Deutsch'
+                ), (f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[1].getIndex()} "
+                + f"[{resortedTrackDescriptors[1].getType().label()}:"
+                + f"{resortedTrackDescriptors[1].getSubIndex()}] has not set title 'Deutsch'")
+
+                # source subIndex 2
+                assert ('language' in resortedTrackDescriptors[2].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[2].getIndex()} "
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not set language tag")
+                assert (resortedTrackDescriptors[2].getTags()['language'] == 'eng'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[2].getIndex()} "
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not set language tag 'eng'")
+                assert ('title' in resortedTrackDescriptors[2].getTags().keys()
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[2].getIndex()} "
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not set title tag")
+                assert (resortedTrackDescriptors[2].getTags()['title'] == 'English'
+                ), (f"Stream src_index={resortedTrackDescriptors[2].getSourceIndex()} "
+                + f"index={resortedTrackDescriptors[2].getIndex()} "
+                + f"[{resortedTrackDescriptors[2].getType().label()}:"
+                + f"{resortedTrackDescriptors[2].getSubIndex()}] has not set title 'English'")
+
+        return f
+
+
+    def shouldFail(self):
+        return False