inc

bin/ffx/test/basename_combinator_2.py

@@ -63,7 +63,7 @@ class BasenameCombinator2(BasenameCombinator):
                 'expectedBasename': expectedBasename}
 
 
-    def assertFunc(self,
+    def createAssertFunc(self,
                     indicator = '',
                     label = '',
                     show = '',
@@ -141,7 +141,7 @@ class BasenameCombinator2(BasenameCombinator):
 
                         yieldObj['assertSelectors'] = ['B', 'L', 'I', 'S', 'R']
 
-                        yieldObj['assertFuncs'] = [self.assertFunc(indicator,
+                        yieldObj['assertFuncs'] = [self.createAssertFunc(indicator,
                                                                     l.getPayload(),
                                                                     show = show,
                                                                     release = release),

bin/ffx/test/disposition_combinator_2_0.py

@@ -6,20 +6,68 @@ from .disposition_combinator_2 import DispositionCombinator2
 
 class DispositionCombinator20(DispositionCombinator2):
 
+    # COMMENT
+    # DESCRIPTIONS
+
     VARIANT = 'D00'
 
-    def __init__(self, context):
-        super().__init__(context)
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator20.VARIANT
 
-        self._variant = DispositionCombinator20.VARIANT
 
     def getPayload(self):
-        return (set(),  # 0
-                set())  # 1
 
-    def assertFunc(self, trackDescriptors):
-        assert not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has set default disposition"
-        assert not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has set default disposition"
+        subtrack0 = set()
+        subtrack1 = set()
+
+        if self.__createPreset:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+
+        return (subtrack0,
+                subtrack1)
+
+    def getAssertFunc(self):
+
+        if self.__createPreset:
+
+            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.DESCRIPTIONS),
+                            f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved 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

bin/ffx/test/disposition_combinator_2_1.py

@@ -8,22 +8,99 @@ class DispositionCombinator21(DispositionCombinator2):
 
     VARIANT = 'D10'
 
-    def __init__(self, context):
-        super().__init__(context)
 
-        self._variant = DispositionCombinator21.VARIANT
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator21.VARIANT
+
 
     def getPayload(self):
-        return (set([TrackDisposition.DEFAULT]),    # 0
-                set())                              # 1
 
-    def assertFunc(self, trackDescriptors):
-        if self._context['use_jellyfin']:
-            assert not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has set default disposition"
-            assert     trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has not set default disposition"
+        subtrack0 = set([TrackDisposition.DEFAULT])
+        subtrack1 = set()
+
+        if self.__preserves:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+
+        return (subtrack0,
+                subtrack1)
+
+    def getAssertFunc(self):
+
+        if self.__createPreset:
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 1
+                        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 0
+                        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.HEARING_IMPAIRED),
+                                f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].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")
+                        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.DESCRIPTIONS),
+                                f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved descriptions disposition")
+
         else:
-            assert     trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has not set default disposition"
-            assert not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has set default disposition"
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 1
+                        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 0
+                        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")
+
+            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

bin/ffx/test/disposition_combinator_2_2.py

@@ -8,18 +8,65 @@ class DispositionCombinator22(DispositionCombinator2):
 
     VARIANT = 'D01'
 
-    def __init__(self, context):
-        super().__init__(context)
 
-        self._variant = DispositionCombinator22.VARIANT
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator22.VARIANT
+
 
     def getPayload(self):
-        return (set(),                              # 0
-                set([TrackDisposition.DEFAULT]))    # 1
 
-    def assertFunc(self, trackDescriptors):
-        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[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not set default disposition"
+        subtrack0 = set()
+        subtrack1 = set([TrackDisposition.DEFAULT])
+
+        if self.__createPreset:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+
+        return (subtrack0,
+                subtrack1)
+
+
+    def getAssertFunc(self):
+
+        if self.__createPreset:
+
+            def f(assertObj: dict):                        
+                    if not 'tracks' in assertObj.keys():
+                        raise KeyError("assertObj does not contain key 'tracks'")
+                    trackDescriptors = assertObj['tracks']
+
+                    # source subIndex 1
+                    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 0
+                    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.HEARING_IMPAIRED),
+                            f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].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 1
+                    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 0
+                    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

bin/ffx/test/disposition_combinator_2_3 .py

@@ -8,17 +8,33 @@ class DispositionCombinator23(DispositionCombinator2):
 
     VARIANT = 'D11'
 
-    def __init__(self, context):
-        super().__init__(context)
 
-        self._variant = DispositionCombinator23.VARIANT
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator23.VARIANT
+
 
     def getPayload(self):
-        return (set([TrackDisposition.DEFAULT]),    # 0
-                set([TrackDisposition.DEFAULT]))    # 1
 
-    def assertFunc(self, trackDescriptors):
-        pass
+        subtrack0 = set([TrackDisposition.DEFAULT])
+        subtrack1 = set([TrackDisposition.DEFAULT])
+
+        if self.__createPreset:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+
+        return (subtrack0,
+                subtrack1)
+
+    #TODO: tmdb cases
+    def getAssertFunc(self):
+        def f(assertObj: dict = {}):
+            pass
+        return f
 
     def shouldFail(self):
         return True

bin/ffx/test/disposition_combinator_3.py

@@ -11,8 +11,7 @@ class DispositionCombinator3():
 
     def getIdentifier(self):
         return DispositionCombinator3.IDENTIFIER
-    def getVariant(self):
-        return self._variant
+
 
     @staticmethod    
     def list():

bin/ffx/test/disposition_combinator_3_0.py

@@ -8,20 +8,65 @@ class DispositionCombinator30(DispositionCombinator3):
 
     VARIANT = 'D000'
 
-    def __init__(self, context):
-        super().__init__(context)
 
-        self._variant = DispositionCombinator30.VARIANT
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator30.VARIANT
+
 
     def getPayload(self):
-        return (set(),    # 0
-                set(),    # 1
-                set())    # 2
+
+        subtrack0 = set()
+        subtrack1 = set()
+        subtrack2 = set()
+
+        if self.__createPreset:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+            subtrack2.add(TrackDisposition.HEARING_IMPAIRED)
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
 
     def assertFunc(self, trackDescriptors):
-        assert not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has set default disposition"
-        assert not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has set default disposition"
-        assert not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #2 has set default disposition"
+
+        if self.__createPreset:
+
+            # 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 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.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:
+
+            # source subIndex 0
+            assert not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has set default disposition"
+
+            # source subIndex 1
+            assert not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has set default disposition"
+
+            # source subIndex 2
+            assert not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #2 has set default disposition"
+
 
     def shouldFail(self):
         return False

bin/ffx/test/disposition_combinator_3_1.py

@@ -8,25 +8,132 @@ class DispositionCombinator31(DispositionCombinator3):
 
     VARIANT = 'D100'
 
-    def __init__(self, context):
-        super().__init__(context)
 
-        self._variant = DispositionCombinator31.VARIANT
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator31.VARIANT
+
 
     def getPayload(self):
-        return (set([TrackDisposition.DEFAULT]),    # 0
-                set(),                              # 1
-                set())                              # 2
 
-    def assertFunc(self, trackDescriptors):
-        if self._context['use_jellyfin']:
-            assert not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has set default disposition"
-            assert not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has set default disposition"
-            assert     trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #2 has not set default disposition"
+        subtrack0 = set([TrackDisposition.DEFAULT])
+        subtrack1 = set()
+        subtrack2 = set()
+
+        if self.__createPreset:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+            subtrack2.add(TrackDisposition.HEARING_IMPAIRED)
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+    def getAssertFunc(self):
+        
+        if self.__createPreset:
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):
+                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 1
+                        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.DESCRIPTIONS),
+                                f"Stream #0 index={trackDescriptors[0].getIndex()} [{trackDescriptors[0].getType().label()}:{trackDescriptors[0].getSubIndex()}] has not preserved descriptions disposition")
+
+                        # source subIndex 2
+                        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.HEARING_IMPAIRED),
+                                f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition")
+
+                        # source subIndex 0
+                        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.COMMENT),
+                                f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved set 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")
+                        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.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:
-            assert     trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has not set default disposition"
-            assert not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has set default disposition"
-            assert not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #2 has set default disposition"
+
+            if self._context['use_jellyfin']:
+
+                def f(assertObj: dict):
+                        
+                        if not 'tracks' in assertObj.keys():
+                            raise KeyError("assertObj does not contain key 'tracks'")
+
+                        trackDescriptors = assertObj['tracks']
+
+                        # source subIndex 1
+                        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 2
+                        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 0
+                        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")
+
+            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

bin/ffx/test/disposition_combinator_3_2.py

@@ -8,25 +8,117 @@ class DispositionCombinator32(DispositionCombinator3):
 
     VARIANT = 'D010'
 
-    def __init__(self, context):
-        super().__init__(context)
 
-        self._variant = DispositionCombinator32.VARIANT
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator32.VARIANT
+
 
     def getPayload(self):
-        return (set(),                              # 0
-                set([TrackDisposition.DEFAULT]),    # 1
-                set())                              # 2
 
-    def assertFunc(self, trackDescriptors):
-        if self._context['use_jellyfin']:
-            assert not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has set default disposition"
-            assert not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has set default disposition"
-            assert     trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #2 has not set default disposition"
+        subtrack0 = set()
+        subtrack1 = set([TrackDisposition.DEFAULT])
+        subtrack2 = set()
+
+        if self.__createPreset:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+            subtrack2.add(TrackDisposition.HEARING_IMPAIRED)
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def getAssertFunc(self):
+
+        if self.__createPreset:
+            if self._context['use_jellyfin']:
+
+                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 2
+                        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.HEARING_IMPAIRED),
+                                f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition")
+                        # source subIndex 1
+                        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.DESCRIPTIONS),
+                                f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved 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")
+                        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.HEARING_IMPAIRED),
+                                f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved default disposition")
+
         else:
-            assert not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has set default disposition"
-            assert     trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has not set default disposition"
-            assert not trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #2 has set default disposition"
+
+            if self._context['use_jellyfin']:
+
+                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 2
+                        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 1
+                        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")
+
+            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

bin/ffx/test/disposition_combinator_3_3.py

@@ -8,21 +8,121 @@ class DispositionCombinator33(DispositionCombinator3):
 
     VARIANT = 'D001'
 
-    def __init__(self, context):
-        super().__init__(context)
 
-        self._variant = DispositionCombinator33.VARIANT
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator33.VARIANT
+
 
     def getPayload(self):
-        return (set(),                              # 0
-                set(),                              # 1
-                set([TrackDisposition.DEFAULT]))    # 2
 
-    def assertFunc(self, trackDescriptors):
-        if self._context['use_jellyfin']:
-            assert not trackDescriptors[0].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #0 has set default disposition"
-            assert not trackDescriptors[1].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #1 has set default disposition"
-            assert     trackDescriptors[2].getDispositionFlag(TrackDisposition.DEFAULT), f"Stream #2 has not set default disposition"
+        subtrack0 = set()
+        subtrack1 = set()
+        subtrack2 = set([TrackDisposition.DEFAULT])
+
+        if self.__createPreset:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+            subtrack2.add(TrackDisposition.HEARING_IMPAIRED)
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+
+    def getAssertFunc(self):
+
+        if self.__createPreset:
+            if self._context['use_jellyfin']:
+
+                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 2
+                        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.HEARING_IMPAIRED),
+                                f"Stream #1 index={trackDescriptors[1].getIndex()} [{trackDescriptors[1].getType().label()}:{trackDescriptors[1].getSubIndex()}] has not preserved default disposition")
+                        # source subIndex 1
+                        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.DESCRIPTIONS),
+                                f"Stream #2 index={trackDescriptors[2].getIndex()} [{trackDescriptors[2].getType().label()}:{trackDescriptors[2].getSubIndex()}] has not preserved 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")
+                        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.DESCRIPTIONS),
+                                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:
+
+            if self._context['use_jellyfin']:
+
+                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 2
+                        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 1
+                        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")
+
+            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

bin/ffx/test/disposition_combinator_3_4.py

@@ -8,18 +8,36 @@ class DispositionCombinator34(DispositionCombinator3):
 
     VARIANT = 'D101'
 
-    def __init__(self, context):
-        super().__init__(context)
 
-        self._variant = DispositionCombinator34.VARIANT
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
+    def getVariant(self):
+        return DispositionCombinator34.VARIANT
+
 
     def getPayload(self):
-        return (set([TrackDisposition.DEFAULT]),    # 0
-                set(),                              # 1
-                set([TrackDisposition.DEFAULT]))    # 2
 
-    def assertFunc(self, trackDescriptors):
-        pass
+        subtrack0 = set([TrackDisposition.DEFAULT])
+        subtrack1 = set()
+        subtrack2 = set([TrackDisposition.DEFAULT])
+
+        if self.__createPreset:
+            subtrack0.add(TrackDisposition.COMMENT)
+            subtrack1.add(TrackDisposition.DESCRIPTIONS)
+            subtrack2.add(TrackDisposition.HEARING_IMPAIRED)
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
+
+    #TODO: tmpdb cases
+    def getAssertFunc(self):
+        def f(assertObj: dict = {}):
+            pass
+        return f
 
     def shouldFail(self):
         return True

bin/ffx/test/media_combinator_0.py

@@ -14,13 +14,17 @@ class MediaCombinator0(MediaCombinator):
 
     VARIANT = 'VA'
 
-    # def __init__(self, SubCombinators: dict = {}, context = None):
-    def __init__(self, context = None):
+    def __init__(self, context = None,
+                    overwrites: bool = False,
+                    preserves: bool = False):
+
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
-        # self._SubCombinators = SubCombinators
+        self.__overwrites = overwrites
+        self.__preserves = preserves
+
 
     def getVariant(self):
         return MediaCombinator0.VARIANT
@@ -50,9 +54,14 @@ class MediaCombinator0(MediaCombinator):
         kwargs[MediaDescriptor.TRACK_DESCRIPTOR_LIST_KEY] = [trackDescriptor1,
                                                                 trackDescriptor2]
         mediaDescriptor = MediaDescriptor(**kwargs)
-        mediaDescriptor.reindexSubIndices()
+        # mediaDescriptor.reindexSubIndices()
+
+        presetMediaDescriptor = MediaDescriptor(**kwargs)
+
+        payloadObj = {'target': mediaDescriptor,
+                      'preset': presetMediaDescriptor}
+        return payloadObj
 
-        return mediaDescriptor
 
     def assertFunc(self, testObj = {}):
         pass

bin/ffx/test/media_combinator_1.py

@@ -14,14 +14,17 @@ class MediaCombinator1(MediaCombinator):
 
     VARIANT = 'VAS'
 
-    # def __init__(self, SubCombinators: dict = {}, context = None):
-    def __init__(self, context = None):
+    def __init__(self, context = None,
+                    overwrites: bool = False,
+                    preserves: bool = False):
 
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
-        # self._SubCombinators = SubCombinations
+        self.__overwrites = overwrites
+        self.__preserves = preserves
+
 
     def getVariant(self):
         return MediaCombinator1.VARIANT
@@ -60,9 +63,14 @@ class MediaCombinator1(MediaCombinator):
                 trackDescriptor2]
 
         mediaDescriptor = MediaDescriptor(**kwargs)
-        mediaDescriptor.reindexSubIndices()
+        # mediaDescriptor.reindexSubIndices()
+
+        presetMediaDescriptor = MediaDescriptor(**kwargs)
+
+        payloadObj = {'target': mediaDescriptor,
+                      'preset': presetMediaDescriptor}
+        return payloadObj
 
-        return mediaDescriptor
 
     def assertFunc(self, testObj = {}):
         pass

bin/ffx/test/media_combinator_2.py

@@ -17,14 +17,17 @@ class MediaCombinator2(MediaCombinator):
 
     VARIANT = 'VASS'
 
-    # def __init__(self, SubCombinators: dict = {}, context = None):
-    def __init__(self, context = None):
+    def __init__(self, context = None,
+                    overwrites: bool = False,
+                    preserves: bool = False):
 
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
-        # self._SubCombinators = SubCombinators
+        self.__overwrites = overwrites
+        self.__preserves = preserves
+
 
     def getVariant(self):
         return MediaCombinator2.VARIANT
@@ -78,9 +81,14 @@ class MediaCombinator2(MediaCombinator):
                 trackDescriptor3]
 
         mediaDescriptor = MediaDescriptor(**kwargs)
-        mediaDescriptor.reindexSubIndices()
+        # mediaDescriptor.reindexSubIndices()
+
+        presetMediaDescriptor = MediaDescriptor(**kwargs)
+
+        payloadObj = {'target': mediaDescriptor,
+                      'preset': presetMediaDescriptor}
+        return payloadObj
 
-        return mediaDescriptor
 
     def assertFunc(self, testObj = {}):
         pass
@@ -98,9 +106,9 @@ class MediaCombinator2(MediaCombinator):
                         j = J(self._context)
                         self._context['use_jellyfin'] = j.getPayload()
 
-                        dc2 = DC2(self._context)
-                        tc2 = TC2(self._context)
-                        mtc = MTC(self._context)
+                        dc2 = DC2(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                        tc2 = TC2(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                        mtc = MTC(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
 
                         yieldObj = {}
 

bin/ffx/test/media_combinator_3.py

@@ -17,14 +17,17 @@ class MediaCombinator3(MediaCombinator):
 
     VARIANT = 'VASSS'
 
-    # def __init__(self, SubCombinators: dict = {}, context = None):
-    def __init__(self, context = None):
+    def __init__(self, context = None,
+                    overwrites: bool = False,
+                    preserves: bool = False):
 
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
-        # self._SubCombinators = SubCombinations
+        self.__overwrites = overwrites
+        self.__preserves = preserves
+
 
     def getVariant(self):
         return MediaCombinator3.VARIANT
@@ -89,9 +92,13 @@ class MediaCombinator3(MediaCombinator):
                 trackDescriptor4]
 
         mediaDescriptor = MediaDescriptor(**kwargs)
-        mediaDescriptor.reindexSubIndices()
+        # mediaDescriptor.reindexSubIndices()
 
-        return mediaDescriptor
+        presetMediaDescriptor = MediaDescriptor(**kwargs)
+
+        payloadObj = {'target': mediaDescriptor,
+                      'preset': presetMediaDescriptor}
+        return payloadObj
 
 
     def assertFunc(self, testObj = {}):
@@ -110,9 +117,9 @@ class MediaCombinator3(MediaCombinator):
                         j = J(self._context)
                         self._context['use_jellyfin'] = j.getPayload()
 
-                        dc3 = DC3(self._context)
-                        tc3 = TC3(self._context)
-                        mtc = MTC(self._context)
+                        dc3 = DC3(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                        tc3 = TC3(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                        mtc = MTC(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
 
                         yieldObj = {}
 

bin/ffx/test/media_combinator_4.py

@@ -17,14 +17,17 @@ class MediaCombinator4(MediaCombinator):
 
     VARIANT = 'VAA'
 
-    # def __init__(self, SubCombinators: dict = {}, context = None):
-    def __init__(self, context = None):
+    def __init__(self, context = None,
+                    overwrites: bool = False,
+                    preserves: bool = False):
 
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
-        # self._SubCombinators = SubCombinations
+        self.__overwrites = overwrites
+        self.__preserves = preserves
+
 
     def getVariant(self):
         return MediaCombinator4.VARIANT
@@ -69,9 +72,13 @@ class MediaCombinator4(MediaCombinator):
                 trackDescriptor2]
 
         mediaDescriptor = MediaDescriptor(**kwargs)
-        mediaDescriptor.reindexSubIndices()
+        # mediaDescriptor.reindexSubIndices()
 
-        return mediaDescriptor
+        presetMediaDescriptor = MediaDescriptor(**kwargs)
+
+        payloadObj = {'target': mediaDescriptor,
+                      'preset': presetMediaDescriptor}
+        return payloadObj
 
 
     def assertFunc(self, testObj = {}):
@@ -90,9 +97,9 @@ class MediaCombinator4(MediaCombinator):
                         j = J(self._context)
                         self._context['use_jellyfin'] = j.getPayload()
 
-                        dc2 = DC2(self._context)
-                        tc2 = TC2(self._context)
-                        mtc = MTC(self._context)
+                        dc2 = DC2(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                        tc2 = TC2(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                        mtc = MTC(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
 
                         yieldObj = {}
 

bin/ffx/test/media_combinator_5.py

@@ -17,14 +17,17 @@ class MediaCombinator5(MediaCombinator):
 
     VARIANT = 'VAAS'
 
-    # def __init__(self, SubCombinators: dict = {}, context = None):
-    def __init__(self, context = None):
+    def __init__(self, context = None,
+                    overwrites: bool = False,
+                    preserves: bool = False):
 
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
-        # self._SubCombinators = SubCombinations
+        self.__overwrites = overwrites
+        self.__preserves = preserves
+
 
     def getVariant(self):
         return MediaCombinator5.VARIANT
@@ -79,9 +82,13 @@ class MediaCombinator5(MediaCombinator):
                 trackDescriptor3]
 
         mediaDescriptor = MediaDescriptor(**kwargs)
-        mediaDescriptor.reindexSubIndices()
+        # mediaDescriptor.reindexSubIndices()
 
-        return mediaDescriptor
+        presetMediaDescriptor = MediaDescriptor(**kwargs)
+
+        payloadObj = {'target': mediaDescriptor,
+                      'preset': presetMediaDescriptor}
+        return payloadObj
 
 
     def assertFunc(self, testObj = {}):
@@ -100,9 +107,9 @@ class MediaCombinator5(MediaCombinator):
                         j = J(self._context)
                         self._context['use_jellyfin'] = j.getPayload()
 
-                        dc2 = DC2(self._context)
-                        tc2 = TC2(self._context)
-                        mtc = MTC(self._context)
+                        dc2 = DC2(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                        tc2 = TC2(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                        mtc = MTC(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
 
                         yieldObj = {}
 

bin/ffx/test/media_combinator_6.py

@@ -17,14 +17,17 @@ class MediaCombinator6(MediaCombinator):
 
     VARIANT = 'VAASS'
 
-    # def __init__(self, SubCombinators: dict = {}, context = None):
-    def __init__(self, context = None):
+    def __init__(self, context = None,
+                    overwrites: bool = False,
+                    preserves: bool = False):
 
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
-        # self._SubCombinators = SubCombinations
+        self.__overwrites = overwrites
+        self.__preserves = preserves
+
 
     def getVariant(self):
         return MediaCombinator6.VARIANT
@@ -93,9 +96,13 @@ class MediaCombinator6(MediaCombinator):
                 trackDescriptor4]
 
         mediaDescriptor = MediaDescriptor(**kwargs)
-        mediaDescriptor.reindexSubIndices()
+        # mediaDescriptor.reindexSubIndices()
 
-        return mediaDescriptor
+        presetMediaDescriptor = MediaDescriptor(**kwargs)
+
+        payloadObj = {'target': mediaDescriptor,
+                      'preset': presetMediaDescriptor}
+        return payloadObj
 
 
     def assertFunc(self, testObj = {}):
@@ -116,10 +123,11 @@ class MediaCombinator6(MediaCombinator):
                                 j = J(self._context)
                                 self._context['use_jellyfin'] = j.getPayload()
                                 
-                                dc2a = DC2_A(self._context)
-                                tc2a = TC2_A(self._context)
-                                dc2s = DC2_S(self._context)
-                                tc2s = TC2_S(self._context)
+                                dc2a = DC2_A(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                                tc2a = TC2_A(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                                dc2s = DC2_S(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                                tc2s = TC2_S(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+
                                 mtc = MTC(self._context)
 
                                 yieldObj = {}

bin/ffx/test/media_combinator_7.py

@@ -18,14 +18,17 @@ class MediaCombinator7(MediaCombinator):
 
     VARIANT = 'VAASSS'
 
-    # def __init__(self, SubCombinators: dict = {}, context = None):
-    def __init__(self, context = None):
+    def __init__(self, context = None,
+                    overwrites: bool = False,
+                    preserves: bool = False):
 
         self._context = context
         self._logger = context['logger']
         self._reportLogger = context['report_logger']
 
-        # self._SubCombinators = SubCombinations
+        self.__overwrites = overwrites
+        self.__preserves = preserves
+
 
     def getVariant(self):
         return MediaCombinator7.VARIANT
@@ -105,9 +108,13 @@ class MediaCombinator7(MediaCombinator):
                 trackDescriptor5]
 
         mediaDescriptor = MediaDescriptor(**kwargs)
-        mediaDescriptor.reindexSubIndices()
+        # mediaDescriptor.reindexSubIndices()
 
-        return mediaDescriptor
+        presetMediaDescriptor = MediaDescriptor(**kwargs)
+
+        payloadObj = {'target': mediaDescriptor,
+                      'preset': presetMediaDescriptor}
+        return payloadObj
 
 
     def assertFunc(self, testObj = {}):
@@ -128,10 +135,11 @@ class MediaCombinator7(MediaCombinator):
                                 j = J(self._context)
                                 self._context['use_jellyfin'] = j.getPayload()
                                 
-                                dc2a = DC2_A(self._context)
-                                tc2a = TC2_A(self._context)
-                                dc3s = DC3_S(self._context)
-                                tc3s = TC3_S(self._context)
+                                dc2a = DC2_A(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                                tc2a = TC2_A(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                                dc3s = DC3_S(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+                                tc3s = TC3_S(self._context, overwrites = self.__overwrites, preserves = self.__preserves)
+
                                 mtc = MTC(self._context)
 
                                 yieldObj = {}

bin/ffx/test/scenario_2.py

@@ -44,7 +44,8 @@ class Scenario2(Scenario):
         variantIdentifier = '-'.join(variantList)
         variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}"
 
-        sourceMediaDescriptor: MediaDescriptor = yieldObj['payload']
+        sourceMediaDescriptor: MediaDescriptor = yieldObj['payload']['target']
+
         assertSelectorList: list = yieldObj['assertSelectors']
         assertFuncList = yieldObj['assertFuncs']
         shouldFail = yieldObj['shouldFail']

bin/ffx/test/scenario_4.py

@@ -37,7 +37,9 @@ class Scenario4(Scenario):
         variantIdentifier = '-'.join(variantList)
         variantLabel = f"{self.__class__.__name__} Variant {variantIdentifier}"
 
-        sourceMediaDescriptor: MediaDescriptor = yieldObj['payload']
+        sourceMediaDescriptor: MediaDescriptor = yieldObj['payload']['target']
+        presetMediaDescriptor: MediaDescriptor = yieldObj['payload']['preset']
+
         assertSelectorList: list = yieldObj['assertSelectors']
         assertFuncList = yieldObj['assertFuncs']
         shouldFail = yieldObj['shouldFail']

bin/ffx/test/track_tag_combinator_2_0.py

@@ -8,25 +8,40 @@ class TrackTagCombinator20(TrackTagCombinator2):
 
     VARIANT = 'T00'
 
-    def __init__(self, context):
-        super().__init__(context)
+
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
 
     def getVariant(self):
         return TrackTagCombinator20.VARIANT
 
+
     def getPayload(self):
-        return ({},  # 0
-                {})  # 1
+
+        subTrack0 = {}
+        subTrack1 = {}
+
+        if self.__createPreset:
+            pass
+
+        return (subTrack0,
+                subTrack1)
 
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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 (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 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 (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")
 
     def shouldFail(self):
         return False

bin/ffx/test/track_tag_combinator_2_1.py

@@ -8,27 +8,44 @@ class TrackTagCombinator21(TrackTagCombinator2):
 
     VARIANT = 'T10'
 
-    def __init__(self, context):
-        super().__init__(context)
+
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
 
     def getVariant(self):
         return TrackTagCombinator21.VARIANT
 
+
     def getPayload(self):
-        return ({'language': 'fra', 'title': 'Französisch'},  # 0
-                {})  # 1
+
+        subTrack0 = {'language': 'fra', 'title': 'Französisch'}
+        subTrack1 = {}
+
+        if self.__createPreset:
+            pass
+
+        return (subTrack0,
+                subTrack1)
 
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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 ('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 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 (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")
 
     def shouldFail(self):
         return False

bin/ffx/test/track_tag_combinator_2_2.py

@@ -8,27 +8,44 @@ class TrackTagCombinator21(TrackTagCombinator2):
 
     VARIANT = 'T01'
 
-    def __init__(self, context):
-        super().__init__(context)
+
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
 
     def getVariant(self):
         return TrackTagCombinator21.VARIANT
 
+
     def getPayload(self):
-        return ({},  # 0
-                {'language': 'bas', 'title': 'Baskisch'})  # 1
+
+        subTrack0 = {}
+        subTrack1 = {'language': 'bas', 'title': 'Baskisch'}
+
+        if self.__createPreset:
+            pass
+
+        return (subTrack0,
+                subTrack1)
     
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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 (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 '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 ('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'")
 
     def shouldFail(self):
         return False

bin/ffx/test/track_tag_combinator_2_3.py

@@ -8,29 +8,53 @@ class TrackTagCombinator23(TrackTagCombinator2):
 
     VARIANT = 'T11'
 
-    def __init__(self, context):
-        super().__init__(context)
+
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
+
 
     def getVariant(self):
         return TrackTagCombinator23.VARIANT
 
+
     def getPayload(self):
         return ({'language': 'deu', 'title': 'Deutsch'},  # 0
                 {'language': 'jpn', 'title': 'Japanisch'})  # 1
 
+    def getPayload(self):
+
+        subTrack0 = {}
+        subTrack1 = {}
+
+        if self.__createPreset:
+            pass
+
+        return (subTrack0,
+                subTrack1)
+
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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 ('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 '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 ('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'")
 
 
     def shouldFail(self):

bin/ffx/test/track_tag_combinator_3_0.py

@@ -8,29 +8,47 @@ class TrackTagCombinator30(TrackTagCombinator3):
 
     VARIANT = 'T000'
 
-    def __init__(self, context):
-        super().__init__(context)
+
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
 
     def getVariant(self):
         return TrackTagCombinator30.VARIANT
 
+
     def getPayload(self):
-        return ({},    # 0
-                {},    # 1
-                {})    # 2
+
+        subtrack0 = {}
+        subtrack1 = {}
+        subtrack2 = {}
+
+        if self.__createPreset:
+            pass
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
 
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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 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 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 ('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 '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 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")
 
     def shouldFail(self):
         return False

bin/ffx/test/track_tag_combinator_3_1.py

@@ -8,31 +8,51 @@ class TrackTagCombinator31(TrackTagCombinator3):
 
     VARIANT = 'T100'
 
-    def __init__(self, context):
-        super().__init__(context)
+
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
 
     def getVariant(self):
         return TrackTagCombinator31.VARIANT
 
+
     def getPayload(self):
-        return ({'language': 'fra', 'title': 'Französisch'},    # 0
-                {},    # 1
-                {})    # 2
+
+        subtrack0 = {'language': 'fra', 'title': 'Französisch'}
+        subtrack1 = {}
+        subtrack2 = {}
+
+        if self.__createPreset:
+            pass
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
 
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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 ('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 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 '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 '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 (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")
 
     def shouldFail(self):
         return False

bin/ffx/test/track_tag_combinator_3_2.py

@@ -8,32 +8,51 @@ class TrackTagCombinator32(TrackTagCombinator3):
 
     VARIANT = 'T010'
 
-    def __init__(self, context):
-        super().__init__(context)
 
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
 
     def getVariant(self):
         return TrackTagCombinator32.VARIANT
 
+
     def getPayload(self):
-        return ({},    # 0
-                {'language': 'bas', 'title': 'Baskisch'},    # 1
-                {})    # 2
+
+        subtrack0 = {}
+        subtrack1 = {'language': 'bas', 'title': 'Baskisch'}
+        subtrack2 = {}
+
+        if self.__createPreset:
+            pass
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
     
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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 (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 '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 ('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 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 (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")
 
     def shouldFail(self):
         return False

bin/ffx/test/track_tag_combinator_3_3.py

@@ -8,31 +8,51 @@ class TrackTagCombinator33(TrackTagCombinator3):
 
     VARIANT = 'T001'
 
-    def __init__(self, context):
-        super().__init__(context)
+
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
 
     def getVariant(self):
         return TrackTagCombinator33.VARIANT
 
+
     def getPayload(self):
-        return ({},    # 0
-                {},    # 1
-                {'language': 'eng', 'title': 'English'})    # 2
+
+        subtrack0 = {}
+        subtrack1 = {}
+        subtrack2 = {'language': 'eng', 'title': 'English'}
+
+        if self.__createPreset:
+            pass
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
 
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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 (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 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 '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 '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 ('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'")
 
     def shouldFail(self):
         return False

bin/ffx/test/track_tag_combinator_3_4.py

@@ -8,35 +8,59 @@ class TrackTagCombinator34(TrackTagCombinator3):
 
     VARIANT = 'T111'
 
-    def __init__(self, context):
-        super().__init__(context)
+
+    def __init__(self, context = None,
+                    createPreset: bool = False):
+
+        self.__createPreset = createPreset
 
     def getVariant(self):
         return TrackTagCombinator34.VARIANT
 
+
     def getPayload(self):
-        return ({'language': 'jpn', 'title': 'Japanisch'},    # 0
-                {'language': 'deu', 'title': 'Deutsch'},    # 1
-                {'language': 'eng', 'title': 'English'})    # 2
+
+        subtrack0 = {'language': 'jpn', 'title': 'Japanisch'}
+        subtrack1 = {'language': 'deu', 'title': 'Deutsch'}
+        subtrack2 = {'language': 'eng', 'title': 'English'}
+
+        if self.__createPreset:
+            pass
+
+        return (subtrack0,
+                subtrack1,
+                subtrack2)
 
     def assertFunc(self, trackDescriptors):
 
         resortedTrackDescriptors = sorted(trackDescriptors, key=lambda d: d.getSourceIndex())
 
-        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'] == 'jpn', f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'"
-        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'] == 'Japanisch', f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'"
+        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'] == 'jpn',
+                f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'jpn'")
+        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'] == 'Japanisch',
+                f"Stream src_index={resortedTrackDescriptors[0].getSourceIndex()} index={resortedTrackDescriptors[0].getIndex()} [{resortedTrackDescriptors[0].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Japanisch'")
 
-        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'] == 'deu', f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'deu'"
-        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'] == 'Deutsch', f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Deutsch'"
+        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'] == 'deu',
+                f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set language tag 'deu'")
+        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'] == 'Deutsch',
+                f"Stream src_index={resortedTrackDescriptors[1].getSourceIndex()} index={resortedTrackDescriptors[1].getIndex()} [{resortedTrackDescriptors[1].getType().label()}:{resortedTrackDescriptors[0].getSubIndex()}] has not set title 'Deutsch'")
 
-        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 ('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'")
 
     def shouldFail(self):
         return False