Tidy up logging and rework tests from scratch

tests/__init__.py

@@ -0,0 +1 @@
+# Repo-root tests package for legacy and future test code.

tests/integration/__init__.py

@@ -0,0 +1 @@
+

tests/integration/subtrack_mapping/__init__.py

@@ -0,0 +1 @@
+

tests/integration/subtrack_mapping/test_cli_bundle.py

@@ -0,0 +1,283 @@
+from __future__ import annotations
+
+from pathlib import Path
+import tempfile
+import unittest
+
+from tests.support.ffx_bundle import (
+    PatternTrackSpec,
+    SourceTrackSpec,
+    create_source_fixture,
+    expected_output_path,
+    extract_first_subtitle_text,
+    ffprobe_json,
+    get_tag,
+    prepare_pattern_database,
+    run_ffx_convert,
+    write_vtt,
+)
+
+from ffx.track_type import TrackType
+
+try:
+    import pytest
+except ImportError:  # pragma: no cover - unittest-only environments
+    pytest = None
+
+if pytest is not None:
+    pytestmark = [pytest.mark.integration, pytest.mark.subtrack_mapping]
+
+
+class SubtrackMappingBundleTests(unittest.TestCase):
+    def setUp(self):
+        self.tempdir = tempfile.TemporaryDirectory()
+        self.workdir = Path(self.tempdir.name)
+        self.home_dir = self.workdir / "home"
+        self.home_dir.mkdir()
+        self.database_path = self.workdir / "test.db"
+
+    def tearDown(self):
+        self.tempdir.cleanup()
+
+    def assertCompleted(self, completed):
+        if completed.returncode != 0:
+            self.fail(
+                "FFX convert failed\n"
+                f"STDOUT:\n{completed.stdout}\n"
+                f"STDERR:\n{completed.stderr}"
+            )
+
+    def test_pattern_reorders_and_omits_tracks_preserving_metadata_and_group_order(self):
+        source_filename = "reorder_s01e01.mkv"
+        source_path = create_source_fixture(
+            self.workdir,
+            source_filename,
+            [
+                SourceTrackSpec(TrackType.VIDEO, identity="video-0", title="Video Zero"),
+                SourceTrackSpec(
+                    TrackType.SUBTITLE,
+                    identity="subtitle-1",
+                    language="eng",
+                    title="First Subtitle",
+                    subtitle_lines=("first embedded subtitle",),
+                ),
+                SourceTrackSpec(
+                    TrackType.AUDIO,
+                    identity="audio-2",
+                    language="deu",
+                    title="German Audio",
+                ),
+                SourceTrackSpec(
+                    TrackType.SUBTITLE,
+                    identity="subtitle-3",
+                    language="fra",
+                    title="Second Subtitle",
+                    subtitle_lines=("second embedded subtitle",),
+                ),
+                SourceTrackSpec(TrackType.ATTACHMENT, attachment_name="ordered.ttf"),
+            ],
+        )
+
+        prepare_pattern_database(
+            self.database_path,
+            r"^reorder_(s[0-9]+e[0-9]+)\.mkv$",
+            [
+                PatternTrackSpec(
+                    index=0,
+                    source_index=0,
+                    track_type=TrackType.VIDEO,
+                    tags={"THIS_IS": "video-0", "title": "Video Zero"},
+                ),
+                PatternTrackSpec(
+                    index=1,
+                    source_index=2,
+                    track_type=TrackType.AUDIO,
+                    tags={"THIS_IS": "audio-2", "language": "deu", "title": "German Audio"},
+                ),
+                PatternTrackSpec(
+                    index=2,
+                    source_index=1,
+                    track_type=TrackType.SUBTITLE,
+                    tags={"THIS_IS": "subtitle-1", "language": "eng", "title": "First Subtitle"},
+                ),
+            ],
+        )
+
+        completed = run_ffx_convert(
+            self.workdir,
+            self.home_dir,
+            self.database_path,
+            "--video-encoder",
+            "copy",
+            "--no-tmdb",
+            "--no-prompt",
+            "--no-signature",
+            str(source_path),
+        )
+        self.assertCompleted(completed)
+
+        output_path = expected_output_path(self.workdir, source_filename)
+        self.assertTrue(output_path.is_file(), output_path)
+
+        streams = ffprobe_json(output_path)["streams"]
+        self.assertEqual(
+            [stream["codec_type"] for stream in streams],
+            ["video", "audio", "subtitle", "attachment"],
+        )
+        self.assertEqual(
+            [get_tag(streams[index], "THIS_IS") for index in range(3)],
+            ["video-0", "audio-2", "subtitle-1"],
+        )
+        self.assertNotIn(
+            "subtitle-3",
+            [get_tag(stream, "THIS_IS") for stream in streams if stream["codec_type"] != "attachment"],
+        )
+        self.assertEqual(streams[-1]["codec_name"], "ttf")
+        extracted_subtitle = extract_first_subtitle_text(self.workdir, output_path)
+        self.assertIn("first embedded subtitle", extracted_subtitle)
+        self.assertNotIn("second embedded subtitle", extracted_subtitle)
+
+    def test_cli_rearrange_streams_reorders_tracks_without_database_pattern(self):
+        source_filename = "cli_s01e01.mkv"
+        source_path = create_source_fixture(
+            self.workdir,
+            source_filename,
+            [
+                SourceTrackSpec(TrackType.VIDEO, identity="video-0"),
+                SourceTrackSpec(TrackType.AUDIO, identity="audio-1", language="eng", title="First Audio"),
+                SourceTrackSpec(TrackType.AUDIO, identity="audio-2", language="deu", title="Second Audio"),
+                SourceTrackSpec(TrackType.SUBTITLE, identity="subtitle-3", language="eng", title="Subtitle"),
+            ],
+        )
+
+        completed = run_ffx_convert(
+            self.workdir,
+            self.home_dir,
+            self.database_path,
+            "--video-encoder",
+            "copy",
+            "--no-pattern",
+            "--no-tmdb",
+            "--no-prompt",
+            "--no-signature",
+            "--rearrange-streams",
+            "0,2,1,3",
+            str(source_path),
+        )
+        self.assertCompleted(completed)
+
+        output_path = expected_output_path(self.workdir, source_filename)
+        streams = ffprobe_json(output_path)["streams"]
+
+        self.assertEqual(
+            [stream["codec_type"] for stream in streams],
+            ["video", "audio", "audio", "subtitle"],
+        )
+        self.assertEqual(
+            [get_tag(stream, "THIS_IS") for stream in streams],
+            ["video-0", "audio-2", "audio-1", "subtitle-3"],
+        )
+
+    def test_pattern_validation_fails_for_nonexistent_source_track_reference(self):
+        source_filename = "invalid_s01e01.mkv"
+        source_path = create_source_fixture(
+            self.workdir,
+            source_filename,
+            [
+                SourceTrackSpec(TrackType.VIDEO, identity="video-0"),
+                SourceTrackSpec(TrackType.AUDIO, identity="audio-1"),
+                SourceTrackSpec(TrackType.SUBTITLE, identity="subtitle-2"),
+            ],
+        )
+
+        prepare_pattern_database(
+            self.database_path,
+            r"^invalid_(s[0-9]+e[0-9]+)\.mkv$",
+            [
+                PatternTrackSpec(index=0, source_index=0, track_type=TrackType.VIDEO),
+                PatternTrackSpec(index=1, source_index=99, track_type=TrackType.SUBTITLE),
+            ],
+        )
+
+        completed = run_ffx_convert(
+            self.workdir,
+            self.home_dir,
+            self.database_path,
+            "--video-encoder",
+            "copy",
+            "--no-tmdb",
+            "--no-prompt",
+            "--no-signature",
+            str(source_path),
+        )
+
+        self.assertNotEqual(completed.returncode, 0)
+        error_output = f"{completed.stdout}\n{completed.stderr}"
+        self.assertIn("non-existent source track #99", error_output)
+        self.assertFalse(expected_output_path(self.workdir, source_filename).exists())
+
+    def test_external_subtitle_file_replaces_payload_and_overrides_metadata(self):
+        source_filename = "substitute_s01e01.mkv"
+        source_path = create_source_fixture(
+            self.workdir,
+            source_filename,
+            [
+                SourceTrackSpec(TrackType.VIDEO, identity="video-0"),
+                SourceTrackSpec(TrackType.AUDIO, identity="audio-1", language="eng", title="Main Audio"),
+                SourceTrackSpec(
+                    TrackType.SUBTITLE,
+                    identity="embedded-subtitle",
+                    language="eng",
+                    title="Embedded Title",
+                    subtitle_lines=("embedded subtitle payload",),
+                ),
+            ],
+        )
+
+        write_vtt(
+            self.workdir / "substitute_s01e01_2_deu.vtt",
+            ("external subtitle payload",),
+        )
+
+        prepare_pattern_database(
+            self.database_path,
+            r"^substitute_(s[0-9]+e[0-9]+)\.mkv$",
+            [
+                PatternTrackSpec(index=0, source_index=0, track_type=TrackType.VIDEO),
+                PatternTrackSpec(index=1, source_index=1, track_type=TrackType.AUDIO),
+                PatternTrackSpec(index=2, source_index=2, track_type=TrackType.SUBTITLE),
+            ],
+        )
+
+        completed = run_ffx_convert(
+            self.workdir,
+            self.home_dir,
+            self.database_path,
+            "--video-encoder",
+            "copy",
+            "--no-tmdb",
+            "--no-prompt",
+            "--no-signature",
+            "--subtitle-directory",
+            str(self.workdir),
+            "--subtitle-prefix",
+            "substitute",
+            str(source_path),
+        )
+        self.assertCompleted(completed)
+
+        output_path = expected_output_path(self.workdir, source_filename)
+        streams = ffprobe_json(output_path)["streams"]
+        subtitle_stream = [stream for stream in streams if stream["codec_type"] == "subtitle"][0]
+
+        self.assertEqual(get_tag(subtitle_stream, "language"), "deu")
+        self.assertEqual(get_tag(subtitle_stream, "title"), "Embedded Title")
+        self.assertEqual(get_tag(subtitle_stream, "THIS_IS"), "embedded-subtitle")
+
+        extracted_subtitle = extract_first_subtitle_text(self.workdir, output_path)
+        self.assertIn("external subtitle payload", extracted_subtitle)
+        self.assertNotIn("embedded subtitle payload", extracted_subtitle)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

tests/legacy_runner.py

@@ -0,0 +1,142 @@
+#! /usr/bin/python3
+
+import os, sys, logging, click
+
+# Allow direct execution from the source tree by exposing both the repository
+# root for `tests.*` imports and `src/` for `ffx.*` imports.
+script_dir = os.path.dirname(os.path.abspath(__file__))
+repo_root = os.path.dirname(script_dir)
+src_root = os.path.join(repo_root, 'src')
+
+sys.path = [p for p in sys.path if os.path.abspath(p) != script_dir]
+for path in [repo_root, src_root]:
+    if path not in sys.path:
+        sys.path.insert(0, path)
+
+existing_pythonpath = [p for p in os.environ.get('PYTHONPATH', '').split(os.pathsep) if p]
+pythonpath_entries = []
+for path in [src_root, repo_root] + existing_pythonpath:
+    if path not in pythonpath_entries:
+        pythonpath_entries.append(path)
+os.environ['PYTHONPATH'] = os.pathsep.join(pythonpath_entries)
+
+from ffx.configuration_controller import ConfigurationController
+
+from ffx.file_properties import FileProperties
+from ffx.ffx_controller import FfxController
+
+from tests.legacy.helper import createMediaTestFile
+
+from tests.legacy.scenario import Scenario
+from ffx.tmdb_controller import TMDB_API_KEY_NOT_PRESENT_EXCEPTION
+
+
+@click.group()
+@click.pass_context
+@click.option('-v', '--verbose', type=int, default=0, help='Set verbosity of output')
+@click.option("--dry-run", is_flag=True, default=False)
+def ffx(ctx, verbose, dry_run):
+    """FFX"""
+
+    ctx.obj = {}
+
+    ctx.obj['config'] = ConfigurationController()
+
+    ctx.obj['database'] = None
+    ctx.obj['dry_run'] = dry_run
+
+    ctx.obj['verbosity'] = verbose
+
+    # Critical 50
+    # Error 40
+    # Warning 30
+    # Info 20
+    # Debug 10
+    fileLogVerbosity = max(40 - verbose * 10, 10)
+    consoleLogVerbosity = max(20 - verbose * 10, 10)
+
+    ctx.obj['logger'] = logging.getLogger('FFX Tests')
+    ctx.obj['logger'].setLevel(logging.DEBUG)
+
+    ctx.obj['report_logger'] = logging.getLogger('FFX Test Result')
+    ctx.obj['report_logger'].setLevel(logging.INFO)
+
+    ffxFileHandler = logging.FileHandler(ctx.obj['config'].getLogFilePath())
+    ffxFileHandler.setLevel(fileLogVerbosity)
+    ffxConsoleHandler = logging.StreamHandler()
+    ffxConsoleHandler.setLevel(consoleLogVerbosity)
+
+    if os.path.isfile('ffx_test_report.log'):
+        os.unlink('ffx_test_report.log')
+    ffxTestReportFileHandler = logging.FileHandler('ffx_test_report.log')
+
+    fileFormatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+    ffxFileHandler.setFormatter(fileFormatter)
+    consoleFormatter = logging.Formatter(
+        '%(message)s')
+    ffxConsoleHandler.setFormatter(consoleFormatter)
+    reportFormatter = logging.Formatter(
+        '%(message)s')
+    ffxTestReportFileHandler.setFormatter(reportFormatter)
+
+    ctx.obj['logger'].addHandler(ffxConsoleHandler)
+    ctx.obj['logger'].addHandler(ffxFileHandler)
+
+    ctx.obj['report_logger'].addHandler(ffxConsoleHandler)
+    ctx.obj['report_logger'].addHandler(ffxTestReportFileHandler)
+    
+
+# Another subcommand
+@ffx.command()
+@click.pass_context
+@click.option('--scenario', type=str, default='', help='Only run tests from this scenario')
+@click.option('--variant', type=str, default='', help='Only run variants beginning like this')
+@click.option('--limit', type=int, default=0, help='Only run this number of tests')
+def run(ctx, scenario, variant, limit):
+    """Run ffx test sequences"""
+
+    ctx.obj['logger'].info('Starting FFX test runs')
+    ctx.obj['test_passed_counter'] = 0
+    ctx.obj['test_failed_counter'] = 0
+
+    ctx.obj['test_variant'] = variant
+    ctx.obj['test_limit'] = limit
+
+    for si in Scenario.list():
+
+        try:
+            SCEN = Scenario.getClassReference(si)
+            scen = SCEN(ctx.obj)
+
+            if scenario and scenario != scen.getScenario():
+                continue
+
+            ctx.obj['logger'].debug(f"Running scenario {si}")
+
+            scen.run()
+
+        except TMDB_API_KEY_NOT_PRESENT_EXCEPTION:
+            ctx.obj['logger'].info(f"TMDB_API_KEY not set: Skipping {SCEN.__class__.__name__}")    
+
+    ctx.obj['logger'].info(f"\n{ctx.obj['test_passed_counter']} tests passed")
+    ctx.obj['logger'].info(f"{ctx.obj['test_failed_counter']} test failed")
+    ctx.obj['logger'].info('\nDone.')
+
+
+@ffx.command()
+@click.pass_context
+@click.argument('paths', nargs=-1)
+def dupe(ctx, paths):
+
+    existingSourcePaths = [p for p in paths if os.path.isfile(p) and p.split('.')[-1] in FfxController.INPUT_FILE_EXTENSIONS]
+
+    for sourcePath in existingSourcePaths:
+
+        sourceFileProperties = FileProperties(ctx.obj, sourcePath)
+        sourceMediaDescriptor = sourceFileProperties.getMediaDescriptor()
+
+        createMediaTestFile(sourceMediaDescriptor, baseName='dupe')
+
+if __name__ == '__main__':
+    ffx()

tests/support/__init__.py

@@ -0,0 +1 @@
+

tests/support/ffx_bundle.py

@@ -0,0 +1,337 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import json
+import logging
+import os
+from pathlib import Path
+import subprocess
+import sys
+from typing import Mapping
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SRC_ROOT = REPO_ROOT / "src"
+
+if str(SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(SRC_ROOT))
+
+
+from ffx.audio_layout import AudioLayout
+from ffx.database import databaseContext
+from ffx.pattern_controller import PatternController
+from ffx.show_controller import ShowController
+from ffx.show_descriptor import ShowDescriptor
+from ffx.track_controller import TrackController
+from ffx.track_descriptor import TrackDescriptor
+from ffx.track_disposition import TrackDisposition
+from ffx.track_type import TrackType
+
+
+class StaticConfig:
+    def __init__(self, data: dict | None = None):
+        self._data = data or {}
+
+    def getData(self):
+        return self._data
+
+
+@dataclass(frozen=True)
+class SourceTrackSpec:
+    track_type: TrackType
+    identity: str | None = None
+    language: str | None = None
+    title: str | None = None
+    extra_tags: Mapping[str, str] = field(default_factory=dict)
+    dispositions: tuple[TrackDisposition, ...] = ()
+    subtitle_lines: tuple[str, ...] = ("subtitle line",)
+    attachment_name: str = "fixture.ttf"
+
+
+@dataclass(frozen=True)
+class PatternTrackSpec:
+    index: int
+    source_index: int
+    track_type: TrackType
+    tags: Mapping[str, str] = field(default_factory=dict)
+    dispositions: tuple[TrackDisposition, ...] = ()
+    audio_layout: AudioLayout = AudioLayout.LAYOUT_STEREO
+
+
+def make_logger(name: str) -> logging.Logger:
+    logger = logging.getLogger(name)
+    logger.handlers = []
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+    logger.addHandler(logging.NullHandler())
+    return logger
+
+
+def build_controller_context(database_path: Path) -> dict:
+    return {
+        "logger": make_logger(f"ffx-test-db-{database_path.stem}"),
+        "config": StaticConfig(),
+        "database": databaseContext(str(database_path)),
+    }
+
+
+def dispose_controller_context(context: dict) -> None:
+    context["database"]["engine"].dispose()
+
+
+def write_vtt(path: Path, lines: tuple[str, ...]) -> Path:
+    body = ["WEBVTT", ""]
+    for index, line in enumerate(lines):
+        start_ms = index * 600
+        end_ms = start_ms + 500
+        body.extend(
+            [
+                f"{start_ms // 3600000:02d}:{(start_ms // 60000) % 60:02d}:{(start_ms // 1000) % 60:02d}.{start_ms % 1000:03d} --> "
+                + f"{end_ms // 3600000:02d}:{(end_ms // 60000) % 60:02d}:{(end_ms // 1000) % 60:02d}.{end_ms % 1000:03d}",
+                line,
+                "",
+            ]
+        )
+    path.write_text("\n".join(body), encoding="utf-8")
+    return path
+
+
+def create_source_fixture(workdir: Path, filename: str, tracks: list[SourceTrackSpec], duration_seconds: int = 1) -> Path:
+    output_path = workdir / filename
+
+    has_video = any(track.track_type == TrackType.VIDEO for track in tracks)
+    has_audio = any(track.track_type == TrackType.AUDIO for track in tracks)
+
+    command = ["ffmpeg", "-y"]
+
+    input_indices: dict[str, int] = {}
+    next_input_index = 0
+
+    if has_video:
+        command += ["-f", "lavfi", "-i", "color=size=96x54:rate=2:color=black"]
+        input_indices["video"] = next_input_index
+        next_input_index += 1
+
+    if has_audio:
+        command += ["-f", "lavfi", "-i", "anullsrc=channel_layout=stereo:sample_rate=48000"]
+        input_indices["audio"] = next_input_index
+        next_input_index += 1
+
+    subtitle_input_indices: list[int] = []
+    subtitle_counter = 0
+    for track in tracks:
+        if track.track_type == TrackType.SUBTITLE:
+            subtitle_path = write_vtt(
+                workdir / f"{output_path.stem}_subtitle_{subtitle_counter}.vtt",
+                track.subtitle_lines,
+            )
+            command += ["-i", str(subtitle_path)]
+            subtitle_input_indices.append(next_input_index)
+            next_input_index += 1
+            subtitle_counter += 1
+
+    map_tokens: list[str] = []
+    metadata_tokens: list[str] = []
+    disposition_tokens: list[str] = []
+    attachment_tokens: list[str] = []
+
+    per_type_subindex: dict[TrackType, int] = {}
+    subtitle_input_cursor = 0
+    attachment_subindex = 0
+
+    for track in tracks:
+        if track.track_type == TrackType.VIDEO:
+            map_tokens += ["-map", f"{input_indices['video']}:v:0"]
+            stream_group = "v"
+        elif track.track_type == TrackType.AUDIO:
+            map_tokens += ["-map", f"{input_indices['audio']}:a:0"]
+            stream_group = "a"
+        elif track.track_type == TrackType.SUBTITLE:
+            map_tokens += ["-map", f"{subtitle_input_indices[subtitle_input_cursor]}:s:0"]
+            subtitle_input_cursor += 1
+            stream_group = "s"
+        elif track.track_type == TrackType.ATTACHMENT:
+            attachment_path = workdir / track.attachment_name
+            attachment_path.write_bytes(b"dummy font bytes")
+            attachment_tokens += [
+                "-attach",
+                str(attachment_path),
+                f"-metadata:s:t:{attachment_subindex}",
+                "mimetype=application/x-truetype-font",
+                f"-metadata:s:t:{attachment_subindex}",
+                f"filename={attachment_path.name}",
+            ]
+            attachment_subindex += 1
+            continue
+        else:
+            raise ValueError(f"Unsupported track type {track.track_type}")
+
+        subindex = per_type_subindex.get(track.track_type, 0)
+        per_type_subindex[track.track_type] = subindex + 1
+
+        tags = {}
+        if track.identity is not None:
+            tags["THIS_IS"] = track.identity
+        if track.language is not None:
+            tags["language"] = track.language
+        if track.title is not None:
+            tags["title"] = track.title
+        tags.update(track.extra_tags)
+
+        for key, value in tags.items():
+            metadata_tokens += [f"-metadata:s:{stream_group}:{subindex}", f"{key}={value}"]
+
+        if track.dispositions:
+            disposition_tokens += [
+                f"-disposition:{stream_group}:{subindex}",
+                "+".join(disposition.label() for disposition in track.dispositions),
+            ]
+
+    command += map_tokens
+    command += metadata_tokens
+    command += disposition_tokens
+    command += [
+        "-c:v",
+        "libx264",
+        "-preset",
+        "ultrafast",
+        "-crf",
+        "35",
+        "-pix_fmt",
+        "yuv420p",
+        "-c:a",
+        "aac",
+        "-b:a",
+        "48k",
+        "-c:s",
+        "webvtt",
+        "-t",
+        str(duration_seconds),
+        "-shortest",
+    ]
+    command += attachment_tokens
+    command += [str(output_path)]
+
+    completed = subprocess.run(command, cwd=workdir, capture_output=True, text=True)
+    if completed.returncode != 0:
+        raise AssertionError(f"ffmpeg fixture creation failed\nSTDOUT:\n{completed.stdout}\nSTDERR:\n{completed.stderr}")
+
+    return output_path
+
+
+def add_show_and_pattern(context: dict, filename_pattern: str, show_id: int = 1) -> int:
+    show_descriptor = ShowDescriptor(
+        id=show_id,
+        name="Bundle Test Show",
+        year=2000,
+    )
+    ShowController(context).updateShow(show_descriptor)
+    pattern_id = PatternController(context).addPattern(
+        {
+            "show_id": show_id,
+            "pattern": filename_pattern,
+        }
+    )
+    if not pattern_id:
+        raise AssertionError("Failed to create pattern in test database")
+    return pattern_id
+
+
+def add_pattern_tracks(context: dict, pattern_id: int, track_specs: list[PatternTrackSpec]) -> None:
+    track_controller = TrackController(context)
+    for track in track_specs:
+        kwargs = {
+            TrackDescriptor.INDEX_KEY: track.index,
+            TrackDescriptor.SOURCE_INDEX_KEY: track.source_index,
+            TrackDescriptor.TRACK_TYPE_KEY: track.track_type,
+            TrackDescriptor.TAGS_KEY: dict(track.tags),
+            TrackDescriptor.DISPOSITION_SET_KEY: set(track.dispositions),
+        }
+        if track.track_type == TrackType.AUDIO:
+            kwargs[TrackDescriptor.AUDIO_LAYOUT_KEY] = track.audio_layout
+        track_controller.addTrack(TrackDescriptor(**kwargs), pattern_id)
+
+
+def prepare_pattern_database(database_path: Path, filename_pattern: str, track_specs: list[PatternTrackSpec], show_id: int = 1) -> None:
+    context = build_controller_context(database_path)
+    try:
+        pattern_id = add_show_and_pattern(context, filename_pattern, show_id=show_id)
+        add_pattern_tracks(context, pattern_id, track_specs)
+    finally:
+        dispose_controller_context(context)
+
+
+def run_ffx_convert(workdir: Path, home_dir: Path, database_path: Path, *args: str) -> subprocess.CompletedProcess[str]:
+    env = os.environ.copy()
+    env["HOME"] = str(home_dir)
+    existing_pythonpath = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = str(SRC_ROOT) if not existing_pythonpath else f"{SRC_ROOT}{os.pathsep}{existing_pythonpath}"
+
+    command = [
+        sys.executable,
+        "-m",
+        "ffx",
+        "--database-file",
+        str(database_path),
+        "convert",
+        *args,
+    ]
+    return subprocess.run(command, cwd=workdir, env=env, capture_output=True, text=True)
+
+
+def ffprobe_json(path: Path) -> dict:
+    completed = subprocess.run(
+        [
+            "ffprobe",
+            "-hide_banner",
+            "-show_streams",
+            "-show_format",
+            "-of",
+            "json",
+            str(path),
+        ],
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise AssertionError(f"ffprobe failed for {path}\nSTDERR:\n{completed.stderr}")
+    return json.loads(completed.stdout)
+
+
+def stream_tags(stream: dict) -> dict[str, str]:
+    return {str(key): str(value) for key, value in stream.get("tags", {}).items()}
+
+
+def get_tag(stream: dict, key: str) -> str | None:
+    tags = stream_tags(stream)
+    for candidate in (key, key.lower(), key.upper()):
+        if candidate in tags:
+            return tags[candidate]
+    return None
+
+
+def extract_first_subtitle_text(workdir: Path, media_path: Path) -> str:
+    extracted_path = workdir / f"{media_path.stem}.subtitle.vtt"
+    completed = subprocess.run(
+        [
+            "ffmpeg",
+            "-y",
+            "-i",
+            str(media_path),
+            "-map",
+            "0:s:0",
+            "-c",
+            "copy",
+            str(extracted_path),
+        ],
+        cwd=workdir,
+        capture_output=True,
+        text=True,
+    )
+    if completed.returncode != 0:
+        raise AssertionError(f"Subtitle extraction failed\nSTDERR:\n{completed.stderr}")
+    return extracted_path.read_text(encoding="utf-8")
+
+
+def expected_output_path(workdir: Path, source_filename: str) -> Path:
+    return workdir / f"out_{source_filename}"

tests/unit/__init__.py

@@ -0,0 +1 @@
+

tests/unit/test_logging.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+
+
+SRC_ROOT = Path(__file__).resolve().parents[2] / "src"
+
+if str(SRC_ROOT) not in sys.path:
+    sys.path.insert(0, str(SRC_ROOT))
+
+
+from ffx.logging_utils import (  # noqa: E402
+    CONSOLE_HANDLER_NAME,
+    FILE_HANDLER_NAME,
+    configure_ffx_logger,
+    get_ffx_logger,
+)
+
+
+class LoggingUtilsTests(unittest.TestCase):
+    def cleanup_logger(self, logger_name: str) -> None:
+        logger = logging.getLogger(logger_name)
+        for handler in list(logger.handlers):
+            logger.removeHandler(handler)
+            handler.close()
+
+    def test_get_ffx_logger_adds_only_one_null_handler(self):
+        logger_name = "ffx-test-null-handler"
+        self.cleanup_logger(logger_name)
+
+        logger = get_ffx_logger(logger_name)
+        logger = get_ffx_logger(logger_name)
+
+        null_handlers = [
+            handler for handler in logger.handlers if isinstance(handler, logging.NullHandler)
+        ]
+        self.assertEqual(1, len(null_handlers))
+
+        self.cleanup_logger(logger_name)
+
+    def test_configure_ffx_logger_reuses_named_handlers(self):
+        logger_name = "ffx-test-configure-handler"
+        self.cleanup_logger(logger_name)
+
+        with tempfile.TemporaryDirectory() as tempdir:
+            first_log_path = Path(tempdir) / "first.log"
+            second_log_path = Path(tempdir) / "second.log"
+
+            logger = configure_ffx_logger(
+                str(first_log_path),
+                logging.ERROR,
+                logging.INFO,
+                name=logger_name,
+            )
+            logger = configure_ffx_logger(
+                str(second_log_path),
+                logging.DEBUG,
+                logging.WARNING,
+                name=logger_name,
+            )
+
+            console_handlers = [
+                handler for handler in logger.handlers if handler.get_name() == CONSOLE_HANDLER_NAME
+            ]
+            file_handlers = [
+                handler for handler in logger.handlers if handler.get_name() == FILE_HANDLER_NAME
+            ]
+
+            self.assertEqual(1, len(console_handlers))
+            self.assertEqual(1, len(file_handlers))
+            self.assertFalse(
+                any(isinstance(handler, logging.NullHandler) for handler in logger.handlers)
+            )
+            self.assertEqual(logging.WARNING, console_handlers[0].level)
+            self.assertEqual(logging.DEBUG, file_handlers[0].level)
+            self.assertEqual(str(second_log_path.resolve()), file_handlers[0].baseFilename)
+
+        self.cleanup_logger(logger_name)
+
+
+if __name__ == "__main__":
+    unittest.main()