diff --git a/test/test_compat_alt.py b/test/test_compat_alt.py
deleted file mode 100644
index da7a8cf..0000000
--- a/test/test_compat_alt.py
+++ /dev/null
@@ -1,453 +0,0 @@
-"""Test alt"""
-
-import os
-import string
-import py
-import pytest
-import utils
-
-# These tests are for the alternate processing in YADM_COMPATIBILITY=1 mode
-pytestmark = pytest.mark.deprecated
-
-# These test IDs are broken. During the writing of these tests, problems have
-# been discovered in the way yadm orders matching files.
-BROKEN_TEST_IDS = [
-    'test_wild[tracked-##C.S.H.U-C-S%-H%-U]',
-    'test_wild[tracked-##C.S.H.U-C-S-H%-U]',
-    'test_wild[encrypted-##C.S.H.U-C-S%-H%-U]',
-    'test_wild[encrypted-##C.S.H.U-C-S-H%-U]',
-    ]
-
-PRECEDENCE = [
-    '##',
-    '##$tst_sys',
-    '##$tst_sys.$tst_host',
-    '##$tst_sys.$tst_host.$tst_user',
-    '##$tst_class',
-    '##$tst_class.$tst_sys',
-    '##$tst_class.$tst_sys.$tst_host',
-    '##$tst_class.$tst_sys.$tst_host.$tst_user',
-    ]
-
-WILD_TEMPLATES = [
-    '##$tst_class',
-    '##$tst_class.$tst_sys',
-    '##$tst_class.$tst_sys.$tst_host',
-    '##$tst_class.$tst_sys.$tst_host.$tst_user',
-    ]
-
-TEST_PATHS = [utils.ALT_FILE1, utils.ALT_FILE2, utils.ALT_DIR]
-
-WILD_TESTED = set()
-
-
-@pytest.mark.parametrize('precedence_index', range(len(PRECEDENCE)))
-@pytest.mark.parametrize(
-    'tracked, encrypt, exclude', [
-        (False, False, False),
-        (True, False, False),
-        (False, True, False),
-        (False, True, True),
-    ], ids=[
-        'untracked',
-        'tracked',
-        'encrypted',
-        'excluded',
-    ])
-@pytest.mark.usefixtures('ds1_copy')
-def test_alt(runner, yadm_y, paths,
-             tst_sys, tst_host, tst_user,
-             tracked, encrypt, exclude,
-             precedence_index):
-    """Test alternate linking
-
-    This test is done by iterating for the number of templates in PRECEDENCE.
-    With each iteration, another file is left off the list. So with each
-    iteration, the template with the "highest precedence" is left out. The file
-    using the highest precedence should be the one linked.
-    """
-
-    # set the class
-    tst_class = 'testclass'
-    utils.set_local(paths, 'class', tst_class)
-
-    # process the templates in PRECEDENCE
-    precedence = list()
-    for template in PRECEDENCE:
-        precedence.append(
-            string.Template(template).substitute(
-                tst_class=tst_class,
-                tst_host=tst_host,
-                tst_sys=tst_sys,
-                tst_user=tst_user,
-            )
-        )
-
-    # create files using a subset of files
-    for suffix in precedence[0:precedence_index+1]:
-        utils.create_alt_files(paths, suffix, tracked=tracked,
-                               encrypt=encrypt, exclude=exclude)
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the proper linking has occurred
-    for file_path in TEST_PATHS:
-        source_file = file_path + precedence[precedence_index]
-        if tracked or (encrypt and not exclude):
-            assert paths.work.join(file_path).islink()
-            target = py.path.local(
-                os.path.realpath(paths.work.join(file_path)))
-            if target.isfile():
-                assert paths.work.join(file_path).read() == source_file
-                assert str(paths.work.join(source_file)) in linked
-            else:
-                assert paths.work.join(file_path).join(
-                    utils.CONTAINED).read() == source_file
-                assert str(paths.work.join(source_file)) in linked
-        else:
-            assert not paths.work.join(file_path).exists()
-            assert str(paths.work.join(source_file)) not in linked
-
-
-def short_template(template):
-    """Translate template into something short for test IDs"""
-    return string.Template(template).substitute(
-        tst_class='C',
-        tst_host='H',
-        tst_sys='S',
-        tst_user='U',
-    )
-
-
-@pytest.mark.parametrize('wild_user', [True, False], ids=['U%', 'U'])
-@pytest.mark.parametrize('wild_host', [True, False], ids=['H%', 'H'])
-@pytest.mark.parametrize('wild_sys', [True, False], ids=['S%', 'S'])
-@pytest.mark.parametrize('wild_class', [True, False], ids=['C%', 'C'])
-@pytest.mark.parametrize('template', WILD_TEMPLATES, ids=short_template)
-@pytest.mark.parametrize(
-    'tracked, encrypt', [
-        (True, False),
-        (False, True),
-    ], ids=[
-        'tracked',
-        'encrypted',
-    ])
-@pytest.mark.usefixtures('ds1_copy')
-def test_wild(request, runner, yadm_y, paths,
-              tst_sys, tst_host, tst_user,
-              tracked, encrypt,
-              wild_class, wild_host, wild_sys, wild_user,
-              template):
-    """Test wild linking
-
-    These tests are done by creating permutations of the possible files using
-    WILD_TEMPLATES. Each case is then tested (while skipping the already tested
-    permutations for efficiency).
-    """
-
-    if request.node.name in BROKEN_TEST_IDS:
-        pytest.xfail(
-            'This test is known to be broken. '
-            'This bug only affects deprecated features.')
-
-    tst_class = 'testclass'
-
-    # determine the "wild" version of the suffix
-    str_class = '%' if wild_class else tst_class
-    str_host = '%' if wild_host else tst_host
-    str_sys = '%' if wild_sys else tst_sys
-    str_user = '%' if wild_user else tst_user
-    wild_suffix = string.Template(template).substitute(
-        tst_class=str_class,
-        tst_host=str_host,
-        tst_sys=str_sys,
-        tst_user=str_user,
-    )
-
-    # determine the "standard" version of the suffix
-    std_suffix = string.Template(template).substitute(
-        tst_class=tst_class,
-        tst_host=tst_host,
-        tst_sys=tst_sys,
-        tst_user=tst_user,
-    )
-
-    # skip over duplicate tests (this seems to be the simplest way to cover the
-    # permutations of tests, while skipping duplicates.)
-    test_key = f'{tracked}{encrypt}{wild_suffix}{std_suffix}'
-    if test_key in WILD_TESTED:
-        return
-    WILD_TESTED.add(test_key)
-
-    # set the class
-    utils.set_local(paths, 'class', tst_class)
-
-    # create files using the wild suffix
-    utils.create_alt_files(paths, wild_suffix, tracked=tracked,
-                           encrypt=encrypt, exclude=False)
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the proper linking has occurred
-    for file_path in TEST_PATHS:
-        source_file = file_path + wild_suffix
-        assert paths.work.join(file_path).islink()
-        target = py.path.local(os.path.realpath(paths.work.join(file_path)))
-        if target.isfile():
-            assert paths.work.join(file_path).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-        else:
-            assert paths.work.join(file_path).join(
-                utils.CONTAINED).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-
-    # create files using the standard suffix
-    utils.create_alt_files(paths, std_suffix, tracked=tracked,
-                           encrypt=encrypt, exclude=False)
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the proper linking has occurred
-    for file_path in TEST_PATHS:
-        source_file = file_path + std_suffix
-        assert paths.work.join(file_path).islink()
-        target = py.path.local(os.path.realpath(paths.work.join(file_path)))
-        if target.isfile():
-            assert paths.work.join(file_path).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-        else:
-            assert paths.work.join(file_path).join(
-                utils.CONTAINED).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-
-
-@pytest.mark.usefixtures('ds1_copy')
-def test_local_override(runner, yadm_y, paths,
-                        tst_sys, tst_host, tst_user):
-    """Test local overrides"""
-
-    # define local overrides
-    utils.set_local(paths, 'class', 'or-class')
-    utils.set_local(paths, 'hostname', 'or-hostname')
-    utils.set_local(paths, 'os', 'or-os')
-    utils.set_local(paths, 'user', 'or-user')
-
-    # create files, the first would normally be the most specific version
-    # however, the second is the overridden version which should be preferred.
-    utils.create_alt_files(
-        paths, f'##or-class.{tst_sys}.{tst_host}.{tst_user}')
-    utils.create_alt_files(
-        paths, '##or-class.or-os.or-hostname.or-user')
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the proper linking has occurred
-    for file_path in TEST_PATHS:
-        source_file = file_path + '##or-class.or-os.or-hostname.or-user'
-        assert paths.work.join(file_path).islink()
-        target = py.path.local(os.path.realpath(paths.work.join(file_path)))
-        if target.isfile():
-            assert paths.work.join(file_path).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-        else:
-            assert paths.work.join(file_path).join(
-                utils.CONTAINED).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-
-
-@pytest.mark.parametrize('suffix', ['AAA', 'ZZZ', 'aaa', 'zzz'])
-@pytest.mark.usefixtures('ds1_copy')
-def test_class_case(runner, yadm_y, paths, tst_sys, suffix):
-    """Test range of class cases"""
-
-    # set the class
-    utils.set_local(paths, 'class', suffix)
-
-    # create files
-    endings = [suffix]
-    if tst_sys == 'Linux':
-        # Only create all of these side-by-side on Linux, which is
-        # unquestionably case-sensitive. This would break tests on
-        # case-insensitive systems.
-        endings = ['AAA', 'ZZZ', 'aaa', 'zzz']
-    for ending in endings:
-        utils.create_alt_files(paths, f'##{ending}')
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the proper linking has occurred
-    for file_path in TEST_PATHS:
-        source_file = file_path + f'##{suffix}'
-        assert paths.work.join(file_path).islink()
-        target = py.path.local(os.path.realpath(paths.work.join(file_path)))
-        if target.isfile():
-            assert paths.work.join(file_path).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-        else:
-            assert paths.work.join(file_path).join(
-                utils.CONTAINED).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-
-
-@pytest.mark.parametrize('autoalt', [None, 'true', 'false'])
-@pytest.mark.usefixtures('ds1_copy')
-def test_auto_alt(runner, yadm_y, paths, autoalt):
-    """Test setting auto-alt"""
-
-    # set the value of auto-alt
-    if autoalt:
-        os.system(' '.join(yadm_y('config', 'yadm.auto-alt', autoalt)))
-
-    # create file
-    suffix = '##'
-    utils.create_alt_files(paths, suffix)
-
-    # run status to possibly trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('status'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the proper linking has occurred
-    for file_path in TEST_PATHS:
-        source_file = file_path + suffix
-        if autoalt == 'false':
-            assert not paths.work.join(file_path).exists()
-        else:
-            assert paths.work.join(file_path).islink()
-            target = py.path.local(
-                os.path.realpath(paths.work.join(file_path)))
-            if target.isfile():
-                assert paths.work.join(file_path).read() == source_file
-                # no linking output when run via auto-alt
-                assert str(paths.work.join(source_file)) not in linked
-            else:
-                assert paths.work.join(file_path).join(
-                    utils.CONTAINED).read() == source_file
-                # no linking output when run via auto-alt
-                assert str(paths.work.join(source_file)) not in linked
-
-
-@pytest.mark.parametrize('delimiter', ['.', '_'])
-@pytest.mark.usefixtures('ds1_copy')
-def test_delimiter(runner, yadm_y, paths,
-                   tst_sys, tst_host, tst_user, delimiter):
-    """Test delimiters used"""
-
-    suffix = '##' + delimiter.join([tst_sys, tst_host, tst_user])
-
-    # create file
-    utils.create_alt_files(paths, suffix)
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the proper linking has occurred
-    # only a delimiter of '.' is valid
-    for file_path in TEST_PATHS:
-        source_file = file_path + suffix
-        if delimiter == '.':
-            assert paths.work.join(file_path).islink()
-            target = py.path.local(
-                os.path.realpath(paths.work.join(file_path)))
-            if target.isfile():
-                assert paths.work.join(file_path).read() == source_file
-                assert str(paths.work.join(source_file)) in linked
-            else:
-                assert paths.work.join(file_path).join(
-                    utils.CONTAINED).read() == source_file
-                assert str(paths.work.join(source_file)) in linked
-        else:
-            assert not paths.work.join(file_path).exists()
-            assert str(paths.work.join(source_file)) not in linked
-
-
-@pytest.mark.usefixtures('ds1_copy')
-def test_invalid_links_removed(runner, yadm_y, paths):
-    """Links to invalid alternative files are removed
-
-    This test ensures that when an already linked alternative becomes invalid
-    due to a change in class, the alternate link is removed.
-    """
-
-    # set the class
-    tst_class = 'testclass'
-    utils.set_local(paths, 'class', tst_class)
-
-    # create files which match the test class
-    utils.create_alt_files(paths, f'##{tst_class}')
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the proper linking has occurred
-    for file_path in TEST_PATHS:
-        source_file = file_path + '##' + tst_class
-        assert paths.work.join(file_path).islink()
-        target = py.path.local(os.path.realpath(paths.work.join(file_path)))
-        if target.isfile():
-            assert paths.work.join(file_path).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-        else:
-            assert paths.work.join(file_path).join(
-                utils.CONTAINED).read() == source_file
-            assert str(paths.work.join(source_file)) in linked
-
-    # change the class so there are no valid alternates
-    utils.set_local(paths, 'class', 'changedclass')
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    linked = utils.parse_alt_output(run.out)
-
-    # assert the linking is removed
-    for file_path in TEST_PATHS:
-        source_file = file_path + '##' + tst_class
-        assert not paths.work.join(file_path).exists()
-        assert str(paths.work.join(source_file)) not in linked
diff --git a/test/test_compat_jinja.py b/test/test_compat_jinja.py
deleted file mode 100644
index 7e2b766..0000000
--- a/test/test_compat_jinja.py
+++ /dev/null
@@ -1,198 +0,0 @@
-"""Test jinja"""
-
-import os
-import pytest
-import utils
-
-# These tests are for the template processing in YADM_COMPATIBILITY=1 mode
-pytestmark = pytest.mark.deprecated
-
-
-@pytest.fixture(scope='module')
-def envtpl_present(runner):
-    """Is envtpl present and working?"""
-    try:
-        run = runner(command=['envtpl', '-h'])
-        if run.success:
-            return True
-    except OSError:
-        pass
-    return False
-
-
-@pytest.mark.usefixtures('ds1_copy')
-def test_local_override(runner, yadm_y, paths,
-                        tst_distro, envtpl_present):
-    """Test local overrides"""
-    if not envtpl_present:
-        pytest.skip('Unable to test without envtpl.')
-
-    # define local overrides
-    utils.set_local(paths, 'class', 'or-class')
-    utils.set_local(paths, 'hostname', 'or-hostname')
-    utils.set_local(paths, 'os', 'or-os')
-    utils.set_local(paths, 'user', 'or-user')
-
-    template = (
-        'j2-{{ YADM_CLASS }}-'
-        '{{ YADM_OS }}-{{ YADM_HOSTNAME }}-'
-        '{{ YADM_USER }}-{{ YADM_DISTRO }}'
-        '-{%- '
-        f"include '{utils.INCLUDE_FILE}'"
-        ' -%}'
-    )
-    expected = (
-        f'j2-or-class-or-os-or-hostname-or-user-{tst_distro}'
-        f'-{utils.INCLUDE_CONTENT}'
-    )
-
-    utils.create_alt_files(paths, '##yadm.j2', content=template,
-                           includefile=True)
-
-    # os.system(f'find {paths.work}' + ' -name *j2 -ls -exec cat \'{}\' ";"')
-    # os.system(f'find {paths.work}')
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    created = utils.parse_alt_output(run.out, linked=False)
-
-    # assert the proper creation has occurred
-    for file_path in (utils.ALT_FILE1, utils.ALT_FILE2):
-        source_file = file_path + '##yadm.j2'
-        assert paths.work.join(file_path).isfile()
-        lines = paths.work.join(file_path).readlines(cr=False)
-        assert lines[0] == source_file
-        assert lines[1] == expected
-        assert str(paths.work.join(source_file)) in created
-
-
-@pytest.mark.parametrize('autoalt', [None, 'true', 'false'])
-@pytest.mark.usefixtures('ds1_copy')
-def test_auto_alt(runner, yadm_y, paths, autoalt, tst_sys,
-                  envtpl_present):
-    """Test setting auto-alt"""
-
-    if not envtpl_present:
-        pytest.skip('Unable to test without envtpl.')
-
-    # set the value of auto-alt
-    if autoalt:
-        os.system(' '.join(yadm_y('config', 'yadm.auto-alt', autoalt)))
-
-    # create file
-    jinja_suffix = '##yadm.j2'
-    utils.create_alt_files(paths, jinja_suffix, content='{{ YADM_OS }}')
-
-    # run status to possibly trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('status'), env=env)
-    assert run.success
-    assert run.err == ''
-    created = utils.parse_alt_output(run.out, linked=False)
-
-    # assert the proper creation has occurred
-    for file_path in (utils.ALT_FILE1, utils.ALT_FILE2):
-        source_file = file_path + jinja_suffix
-        if autoalt == 'false':
-            assert not paths.work.join(file_path).exists()
-        else:
-            assert paths.work.join(file_path).isfile()
-            lines = paths.work.join(file_path).readlines(cr=False)
-            assert lines[0] == source_file
-            assert lines[1] == tst_sys
-            # no created output when run via auto-alt
-            assert str(paths.work.join(source_file)) not in created
-
-
-@pytest.mark.usefixtures('ds1_copy')
-def test_jinja_envtpl_missing(runner, paths):
-    """Test operation when envtpl is missing"""
-
-    script = f"""
-        YADM_TEST=1 source {paths.pgm}
-        process_global_args -Y "{paths.yadm}"
-        set_operating_system
-        configure_paths
-        YADM_COMPATIBILITY=1
-        ENVTPL_PROGRAM='envtpl_missing' main alt
-    """
-
-    utils.create_alt_files(paths, '##yadm.j2')
-
-    run = runner(command=['bash'], inp=script)
-    assert run.success
-    assert run.err == ''
-    assert f'envtpl not available, not creating' in run.out
-
-
-@pytest.mark.parametrize(
-    'tracked, encrypt, exclude', [
-        (False, False, False),
-        (True, False, False),
-        (False, True, False),
-        (False, True, True),
-    ], ids=[
-        'untracked',
-        'tracked',
-        'encrypted',
-        'excluded',
-    ])
-@pytest.mark.usefixtures('ds1_copy')
-def test_jinja(runner, yadm_y, paths,
-               tst_sys, tst_host, tst_user, tst_distro,
-               tracked, encrypt, exclude,
-               envtpl_present):
-    """Test jinja processing"""
-
-    if not envtpl_present:
-        pytest.skip('Unable to test without envtpl.')
-
-    jinja_suffix = '##yadm.j2'
-
-    # set the class
-    tst_class = 'testclass'
-    utils.set_local(paths, 'class', tst_class)
-
-    template = (
-        'j2-{{ YADM_CLASS }}-'
-        '{{ YADM_OS }}-{{ YADM_HOSTNAME }}-'
-        '{{ YADM_USER }}-{{ YADM_DISTRO }}'
-        '-{%- '
-        f"include '{utils.INCLUDE_FILE}'"
-        ' -%}'
-    )
-    expected = (
-        f'j2-{tst_class}-'
-        f'{tst_sys}-{tst_host}-'
-        f'{tst_user}-{tst_distro}'
-        f'-{utils.INCLUDE_CONTENT}'
-    )
-
-    utils.create_alt_files(paths, jinja_suffix, content=template,
-                           tracked=tracked, encrypt=encrypt, exclude=exclude,
-                           includefile=True)
-
-    # run alt to trigger linking
-    env = os.environ.copy()
-    env['YADM_COMPATIBILITY'] = '1'
-    run = runner(yadm_y('alt'), env=env)
-    assert run.success
-    assert run.err == ''
-    created = utils.parse_alt_output(run.out, linked=False)
-
-    # assert the proper creation has occurred
-    for file_path in (utils.ALT_FILE1, utils.ALT_FILE2):
-        source_file = file_path + jinja_suffix
-        if tracked or (encrypt and not exclude):
-            assert paths.work.join(file_path).isfile()
-            lines = paths.work.join(file_path).readlines(cr=False)
-            assert lines[0] == source_file
-            assert lines[1] == expected
-            assert str(paths.work.join(source_file)) in created
-        else:
-            assert not paths.work.join(file_path).exists()
-            assert str(paths.work.join(source_file)) not in created