Added dummy message class for systems with python without tk

Make tempfile prefixed with fs-uae-wrapper string.
Also, included test requirements into tox file, and fixed docs.
2026-02-02 14:15:45 +01:00 · 2026-01-10 18:48:41 +01:00 · 2025-09-25 18:50:28 +02:00 · 2025-04-18 16:05:37 +02:00 · 2024-09-14 17:00:28 +02:00 · 2024-09-14 15:59:25 +02:00
29 changed files with 1370 additions and 518 deletions
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -0,0 +1,33 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Test
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v3
+      with:
+        python-version: "3.10"
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install flake8 pytest tox coverage pytest-cov pytest-pep8
+        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+    - name: Test with pytest
+      run: |
+        tox
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,8 +0,0 @@
-language: python
-env:
- TOXENV=py27
- TOXENV=py27-flake8
- TOXENV=py34
- TOXENV=py34-flake8
-install: pip install tox
-script: tox
--- a/README.rst
+++ b/README.rst
@@ -2,8 +2,8 @@
 FS-UAE Wrapper
 ==============

-.. image:: https://travis-ci.org/gryf/fs-uae-wrapper.svg?branch=master
-    :target: https://travis-ci.org/gryf/fs-uae-wrapper
+.. image:: https://github.com/gryf/fs-uae-wrapper/workflows/Test/badge.svg
+   :target: https://github.com/gryf/fs-uae-wrapper/actions?query=workflow%3ATest+event%3Apush+branch%3Amaster

 .. image:: https://img.shields.io/pypi/v/fs-uae-wrapper.svg
    :target: https://pypi.python.org/pypi/fs-uae-wrapper
@@ -12,7 +12,7 @@ This little utility is a wrapper on great FS-UAE_ emulator, to perform some
 actions, like uncompressing archived files (CD ROMs images, filesystems),
 launch the emulator and archive emulator save state.

-As an example, if there is a collection of CD³² game files and one want to
+As an example, if there is a collection of CD³² game files and you want to
 provide configuration for each game, but want to keep ISO images with
 corresponding files in archive (due to size of those images) than FS-UAE
 Wrapper is a way to achieve this.
@@ -25,11 +25,10 @@ preferably in a archive file vs a bunch of files.
 Requirements
 ============

- Python (2 or 3)
+- Python 3
 - `fs-uae`_ (obviously :)

-Also, there should be archivers programs available for compress/decompress
-archives. Fs-uae-wrapper supports several types of archives:
+Fs-uae-wrapper supports several types of archives:

 - `7z`_
 - `lha`_
@@ -43,25 +42,35 @@ archives. Fs-uae-wrapper supports several types of archives:

 - `zip`_

-There are several archive types which are supported, ranging from tar
-(compressed with gzip, bzip2 and xz), 7z, rar, zip. lha and lzx. All of those
-formats should have corresponding decompressors available in the system,
-otherwise archive extraction will fail.
+All of those formats should have corresponding software available in the
+system, otherwise archive extraction/compression will fail.

 Installation
 ============

-Just perform (preferably in ``virtualenv``) a command:
+FS-UAE Wrapper is available on `CheeseShop`_ (or python package index if you
+will). To install it, you can simply invoke (preferably in ``virtualenv``) a
+command:

 .. code:: shell-session

   $ pip install fs-uae-wrapper

+Note, that if ``virtualenv`` was used, there is no need for activating it every
+time, since if invoke wrapper like this:
+
+.. code:: shell-session
+
+   $ /path/to/virtualenv/bin/fs-uae-wrapper
+
+you should be able run the wrapper properly. *Tested only on Linux :)*.
+
 Usage
 =====

-After installation you should be able to access new command
-``fs-uae-wrapper``, and its invocation is identical like ``fs-uae`` binary:
+After installation you should be able to access new command ``fs-uae-wrapper``
+(or use the full path to the ``virtualenv`` like on the section above), and it's
+invocation is identical like ``fs-uae`` binary:

 .. code:: shell-session

@@ -73,9 +82,9 @@ directly in fs-uae configuration or passed as an option:
 .. code:: ini

   [config]
-   ...
+   # ...
   wrapper = cd32
-   ...
+   # ...

 or

@@ -89,24 +98,46 @@ specific module will be loaded and depending on the module, there would be
 performed specific tasks before ``fs-uae`` is launched and after it.

 Assumption is, that configuration file are written in portable way, so the are
-saved as `relative configuration file`_ (hence the name ``Config.fs-uae``, even
-if the are named differently. If certain wrapper is specified, it will create
-temporary directory and place the configuration file there as
+saved as `relative configuration file`_ (hence the name ``Config.fs-uae``),
+even if the are named differently. If certain wrapper is specified, it will
+create temporary directory and place the configuration file there as
 ``Config.fs-uae``.

 If no ``wrapper`` option would be passed either as an config option or
 command line argument, all command line options will be passed to the fs-uae
 executable as-is.

+Note, that you can also pass all *wrapper* options via commandline in the very
+same way as you can pass config options to `fs-uae`, so you don't have to
+modify original configuration if you don't want to.
+
+There is also new config variable introduced: ``$WRAPPER`` which have the same
+role as ``$CONFIG``, but apply for copied config. For instance - in module
+archive there are filesystem extracted to new location - to access this
+filesystem relatively to the copied configuration file it is enough to provide
+a config option:
+
+.. code:: ini
+
+   [config]
+   wrapper = archive
+   # ...
+
+   hard_drive_0 = $WRAPPER/my_hardrive
+
+which means, that we are expecting to have system files on ``my_hardrive`` in
+directory, where configuration will be copied.
+
 Modules
 =======

-Currently, three wrapper modules are available:
+Currently, couple of wrapper modules are available:

 - plain
 - cd32
 - archive
 - savestate
+- whdload

 plain
 -----
@@ -127,12 +158,12 @@ Options used:

 * ``wrapper`` (required) with ``cd32`` as an value
 * ``wrapper_archive`` (required) path to the archive with CD32 iso/cue/wav
-* ``wrapper_archiver`` (conditionally required) archiver to use for storage
-  save state
+* ``wrapper_archiver`` (optional) archiver to use for storage save state -
+  default ``7z``.
 * ``wrapper_gui_msg`` (optional) if set to "1", will display a graphical
  message during extracting files
 * ``wrapper_save_state`` (optional) if set to "1", will load/archive save state
-  directory, defined as ``$CONFIG/[save-state-dir-name]`` using provided
+  directory, defined as ``$WRAPPER/[save-state-dir-name]`` using provided
  ``wrapper_archiver`` archiver. If this option is enabled,
  ``wrapper_archiver`` will be required.

@@ -145,7 +176,7 @@ fragment of configuration file is saved as ``ChaosEngine.fs-uae``:
   [config]
   wrapper = cd32
   wrapper_archive = ChaosEngine.7z
-   wrapper_archiver = 7z
+   wrapper_archiver = zip
   wrapper_gui_msg = 1

   amiga_model = CD32
@@ -153,11 +184,11 @@ fragment of configuration file is saved as ``ChaosEngine.fs-uae``:

   cdrom_drive_0 = Chaos Engine, The (1994)(Renegade)(M4)[!][CDD3445].cue

-   save_states_dir = $CONFIG/fs-uae-save/
+   save_states_dir = $WRAPPER/fs-uae-save/

   joystick_port_1_mode = cd32 gamepad
   platform = cd32
-   ...
+   # ...

 Command line invocation of the wrapper would be as follows:

@@ -169,7 +200,7 @@ Now, there several thing will happen:

 - Config file will be read, and wrapper module will be found
 - New temporary directory will be created
- Archive with game assists will be extracted in that directory
+- Archive with game assets will be extracted in that directory
 - Configuration file will be copied into that directory, and renamed to
  ``Config.fs-uae``
 - If ``wrapper_save_state`` is set, and there is saved state archive, it also
@@ -189,16 +220,18 @@ archive
 Options used:

 * ``wrapper`` (required) with ``archive`` as an value
-* ``wrapper_archive`` (required) path to the archive with assets (usually means
-  whole system directories, floppies or hard disk images)
-* ``wrapper_archiver`` (conditionally required) archiver to use for storage
-  save state
+* ``wrapper_archive`` (optional) path to the archive with assets (usually means
+  whole system directories, floppies or hard disk images), defaults to same
+  name as configuration file with some detected archive extension. Note, that
+  name is case sensitive
+* ``wrapper_archiver`` (optional) archiver to use for storage save state -
+  default ``7z``.
 * ``wrapper_gui_msg`` (optional) if set to "1", will display a graphical
  message during extracting files
 * ``wrapper_persist_data`` (optional) if set to "1", will compress (possibly
  changed) data, replacing original archive
 * ``wrapper_save_state`` (optional) if set to "1", will archive save state
-  directory, defined as ``$CONFIG/[save-state-dir-name]`` using provided
+  directory, defined as ``$WRAPPER/[save-state-dir-name]`` using provided
  ``wrapper_archiver`` archiver. If this option is enabled,
  ``wrapper_archiver`` will be required.

@@ -220,7 +253,7 @@ Example configuration:
   wrapper_gui_msg = 1
   wrapper_persist_data = 1
   wrapper_save_state = 1
-   ...
+   # ...

 And execution is as usual:

@@ -247,7 +280,8 @@ savestate
 Options used:

 * ``wrapper`` (required) with ``archive`` as an value
-* ``wrapper_archiver`` (required) archiver to use for storage save state
+* ``wrapper_archiver`` (optional) archiver to use for storage save state -
+  default ``7z``.

 This module is primarily used to run emulator with read only media attached
 (like images of floppies or uncompressed CD-ROMs) and its purpose is to
@@ -259,12 +293,11 @@ set to value ``1`` in this module.
 Example configuration:

 .. code:: ini
-   :number-lines:

   [config]
   wrapper = savestate
   wrapper_archiver = 7z
-   ...
+   # ...

 And execution is as usual:

@@ -282,6 +315,212 @@ The steps would be as follows:
 - optionally create archive with save state (if save state directory place is
  *not* a global one)

+whdload
+-------
+
+Options used:
+
+* ``wrapper`` (required) with ``whdload`` as an value
+* ``wrapper_whdload_base`` (required) path to the whdload base system. Usually
+  it's minimal system containing at least whdload executables in C, and config
+  in S. Read on below for further details.
+* ``wrapper_whdload_options`` (optional) this option will replace the line in
+  ``s:whdload-startup`` with specific ``whdload`` options for certain slave.
+  For reference look at WHDLoad documentation and/or on ``s:WHDLoad.prefs``.
+  Note, that ``Slave=`` option must not be used.
+* ``wrapper_archive`` (optional) path to the whdload archive, defaults to same
+  name as configuration file with some detected archive extension. Note, that
+  name is case sensitive
+
+This module is solely used with whdload distributed games (not just whdload
+slave files, but whole games, which can be found on several places on the
+internet).
+
+Base image
+~~~~~~~~~~
+
+To make it work, first the absolute minimal image need to contain following
+structure:
+
+.. code::
+
+   .
+   ├── C
+   │   ├── DIC
+   │   ├── Execute
+   │   ├── Patcher
+   │   ├── RawDIC
+   │   ├── SetPatch
+   │   ├── WHDLoad
+   │   └── WHDLoadCD32
+   └── S
+       ├── startup-sequence
+       └── WHDLoad.prefs
+
+where the minimum dependences are:
+
+- ``Excecute`` from your copy of Workbench
+- `WHDLoad`_ 18.9
+- `SetPatch`_ 43.6
+
+and the ``S/startup-sequence`` should at least contain:
+
+.. code::
+
+   setpatch QUIET
+
+   IF EXISTS S:whdload-startup
+     Execute S:whdload-startup
+   EndIF
+
+To leverage more pleasant UX, additionally those bits should be installed (or -
+copied into base image filesystem):
+
+- ``Assign`` and whatever commands you'll be use in scripts from your copy of
+  Workbench
+- `uaequit`_ - this will allow to quit emulator, after quiting game
+- `kgiconload`_ - tool for reading icon and executing *default tool* with
+  optionally defined tool types as parameters (in this case: WHDLoad)
+- `SKick`_ optionally - for kickstart relocations. Also images of corresponding
+  kickstart ROM images will be needed.
+
+
+and then ``s/startup-sequence`` might looks a follows:
+
+.. code::
+
+   Assign >NIL: ENV: RAM:
+   Assign >NIL: T: RAM:
+
+   setpatch QUIET
+
+   IF EXISTS S:whdload-startup
+     Execute S:whdload-startup
+   EndIF
+
+   C:UAEquit
+
+Creating base image archive
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Now, the tree for the minimal image could look like that:
+
+.. code::
+
+   .
+   ├── C
+   │   ├── Assign
+   │   ├── DIC
+   │   ├── Execute
+   │   ├── kgiconload
+   │   ├── Patcher
+   │   ├── RawDIC
+   │   ├── SetPatch
+   │   ├── UAEquit
+   │   ├── WHDLoad
+   │   └── WHDLoadCD32
+   └── S
+       ├── startup-sequence
+       └── WHDLoad.prefs
+
+to use relocation tables you'll need to place ``Kickstarts`` drawer into Devs
+drawer. Also keep in mind, that corresponding kickstart rom images need to be
+placed there as well, otherwise it may or may not work. Structure looks like
+this:
+
+.. code::
+
+   .
+   ├── C
+   │   ├── Assign
+   │   ├── …
+   │   └── WHDLoadCD32
+   ├── Devs
+   │   └── Kickstarts
+   │       ├── 39115_ROMKick.PAT
+   │       ├── 39115_ROMKick.RTB
+   │       ├── …
+   │       ├── kick40068.A4000.PAT
+   │       └── kick40068.A4000.RTB
+   └── S
+       ├── startup-sequence
+       └── WHDLoad.prefs
+
+Important: You'll need to prepare archive with base OS without top directory,
+i.e. suppose you have prepared all the files in ``/tmp/baseos``:
+
+.. code:: shell-session
+
+   $ pwd
+   /tmp
+   $ cd baseos
+   $ pwd
+   /tmp/basos
+   $ ls
+   C    S
+   $ zip -r /tmp/base.zip .
+     adding: C/ (stored 0%)
+     adding: C/Assign (deflated 31%)
+     adding: C/WHDLoadCD32 (deflated 26%)
+     adding: C/RawDIC (deflated 46%)
+     adding: C/UAEquit (deflated 39%)
+     adding: C/Execute (deflated 42%)
+     adding: C/Patcher (deflated 56%)
+     adding: C/DIC (deflated 33%)
+     adding: C/kgiconload (deflated 49%)
+     adding: C/SetPatch (deflated 39%)
+     adding: C/WHDLoad (deflated 23%)
+     adding: S/ (stored 0%)
+     adding: S/startup-sequence (deflated 36%)
+     adding: S/WHDLoad.prefs (deflated 51%)
+
+You can do it with other archivers as well, like 7z: ``7z a /tmp/base.7z .`` or
+tar with different compressions: ``tar Jcf /tmp/base.tar.xz .``, ``tar zcf
+/tmp/base.tgz .``, ``tar jcf /tmp/base.tar.bz2 .``. It should work with all
+mentioned at the beginning of this document archivers.
+
+Starting point is in ``S/startup-sequence`` file, where eventually
+``S/whdload-startup`` is executed, which will be created by fs-uae-warpper
+before execution by fs-uae.
+
+
+Configuration
+~~~~~~~~~~~~~
+
+Now, to use whdload module with any of the WHDLoad game, you'll need to prepare
+configuration for the wrapper.
+
+Example configuration:
+
+.. code:: ini
+
+   [config]
+   wrapper = whdload
+   wrapper_whdload_base = $CONFIG/whdload_base.7z
+   # ...
+
+And execution is as usual:
+
+.. code:: shell-session
+
+   $ fs-uae-wrapper ChaosEngine_v1.2_0106.fs-uae
+
+Now, similar to the archive module, it will create temporary directory, unpack
+base image there, unpack WHDLoad game archive, search for slave file, and
+prepare ``s:whdload-startup``, and finally pass all the configuration to
+fs-uae.
+
+
+Limitations
+===========
+
+There is one limitation when using save ``wrapper_save_state`` option. In case
+of floppies it should work without any issues, although save state for running
+Workbench or WHDLoad games may or may not work. In the past there was an issue
+with `fs-uae`_ where saving state was causing data corruption on the emulated
+system. Use it with caution!
+
+
 License
 =======

@@ -295,3 +534,9 @@ This work is licensed on 3-clause BSD license. See LICENSE file for details.
 .. _lzx: http://aminet.net/package/misc/unix/unlzx.c.readme
 .. _tar: https://www.gnu.org/software/tar/
 .. _zip: http://www.info-zip.org
+.. _CheeseShop: https://pypi.python.org/pypi/fs-/fs-uae-wrapperuae-wrapper
+.. _WHDLoad: https://www.whdload.de
+.. _uaequit: https://aminet.net/package/misc/emu/UAEquit
+.. _SKick: https://aminet.net/package/util/boot/skick346
+.. _SetPatch: https://aminet.net/package/util/boot/SetPatch_43.6b
+.. _kgiconload: https://eab.abime.net/showpost.php?p=733614&postcount=92
--- a/fs_uae_wrapper/archive.py
+++ b/fs_uae_wrapper/archive.py
@@ -7,30 +7,28 @@ the temporary one.
 import os
 import shutil

-from fs_uae_wrapper import base
-from fs_uae_wrapper import utils
+from fs_uae_wrapper import base, utils


-class Archive(base.ArchiveBase):
+class Wrapper(base.ArchiveBase):
    """
    Class for performing extracting archive, copying emulator files, and
    cleaning it back again
    """
    def __init__(self, conf_file, fsuae_options, configuration):
-        super(Archive, self).__init__(conf_file, fsuae_options, configuration)
+        super(Wrapper, self).__init__(conf_file, fsuae_options, configuration)
        self.archive_type = None

    def run(self):
        """
        Main function which accepts configuration file for FS-UAE
        It will do as follows:
-            - set needed full path for asset files
            - extract archive file
            - copy configuration
            - run the emulation
            - optionally make archive save state
        """
-        if not super(Archive, self).run():
+        if not super(Wrapper, self).run():
            return False

        if not self._extract():
@@ -41,11 +39,7 @@ class Archive(base.ArchiveBase):
        if not self._copy_conf():
            return False

-        kick_opts = self._kickstart_option()
-        if kick_opts:
-            self.fsuae_options.update(kick_opts)
-
-        if not self._run_emulator(self.fsuae_options.list()):
+        if not self._run_emulator():
            return False

        if self._get_saves_dir():
@@ -78,13 +72,3 @@ class Archive(base.ArchiveBase):
        shutil.move(arch, self.arch_filepath)
        os.chdir(curdir)
        return True
-
-
-def run(config_file, fsuae_options, configuration):
-    """Run fs-uae with provided config file and options"""
-
-    runner = Archive(config_file, fsuae_options, configuration)
-    try:
-        return runner.run()
-    finally:
-        runner.clean()
--- a/fs_uae_wrapper/base.py
+++ b/fs_uae_wrapper/base.py
@@ -1,13 +1,12 @@
 """
 Base class for all wrapper modules
 """
+import logging
 import os
-import sys
 import shutil
 import tempfile

-from fs_uae_wrapper import utils
-from fs_uae_wrapper import path
+from fs_uae_wrapper import path, utils


 class Base(object):
@@ -41,10 +40,12 @@ class Base(object):
            - run the emulation
            - archive save state
        """
+        logging.debug("run")
        if not self._validate_options():
            return False

-        self.dir = tempfile.mkdtemp()
+        self.dir = tempfile.mkdtemp(prefix='fs-uae-wrapper-')
+        self._normalize_options()
        self._set_assets_paths()

        return True
@@ -55,33 +56,6 @@ class Base(object):
            shutil.rmtree(self.dir)
        return

-    def _kickstart_option(self):
-        """
-        This is kind of hack - since we potentially can have a relative path
-        to kickstart directory, there is a need for getting this option from
-        configuration files (which unfortunately can be spanned all over the
-        different places, see https://fs-uae.net/configuration-files) and
-        check whether or not one of 'kickstarts_dir', 'kickstart_file' or
-        'kickstart_ext_file' options are set. In either case if one of those
-        options are set and are relative, they should be set to absolute path,
-        so that kickstart files can be found by relocated configuration file.
-        """
-
-        conf = utils.get_config(self.conf_file)
-
-        kick = {}
-
-        for key in ('kickstart_file', 'kickstart_ext_file', 'kickstarts_dir'):
-            val = conf.get(key)
-            if val:
-                if not os.path.isabs(val):
-                    val = utils.interpolate_variables(val, self.conf_file)
-                    kick[key] = os.path.abspath(val)
-                else:
-                    kick[key] = val
-
-        return kick
-
    def _set_assets_paths(self):
        """
        Set full paths for archive file (without extension) and for save state
@@ -104,11 +78,11 @@ class Base(object):
                  os.path.join(self.dir, 'Config.fs-uae'))
        return True

-    def _run_emulator(self, fsuae_options):
-        """execute fs-uae in provided directory"""
+    def _run_emulator(self):
+        """execute fs-uae"""
        curdir = os.path.abspath('.')
        os.chdir(self.dir)
-        utils.run_command(['fs-uae'] + fsuae_options)
+        utils.run_command(['fs-uae', *self.fsuae_options.list()])
        os.chdir(curdir)
        return True

@@ -143,7 +117,7 @@ class Base(object):
        curdir = os.path.abspath('.')

        if not utils.create_archive(self.save_filename, '', [save_path]):
-            sys.stderr.write('Error: archiving save state failed\n')
+            logging.error('Error: archiving save state failed.')
            os.chdir(curdir)
            return False

@@ -169,7 +143,7 @@ class Base(object):
    def _get_saves_dir(self):
        """
        Return path to save state directory or None in cases:
-            - there is no save state dir set relative to config file
+            - there is no save state dir set relative to copied config file
            - save state dir is set globally
            - save state dir is set relative to the config file
            - save state dir doesn't exists
@@ -178,9 +152,9 @@ class Base(object):
        if not self.all_options.get('save_states_dir'):
            return None

-        if self.all_options['save_states_dir'].startswith('$CONFIG') and \
+        if self.all_options['save_states_dir'].startswith('$WRAPPER') and \
           '..' not in self.all_options['save_states_dir']:
-            save = self.all_options['save_states_dir'].replace('$CONFIG/', '')
+            save = self.all_options['save_states_dir'].replace('$WRAPPER/', '')
        else:
            return None

@@ -193,24 +167,84 @@ class Base(object):

        return save

+    def _normalize_options(self):
+        """
+        Search and replace values for options which starts with $CONFIG with
+        absolute path for all options.
+
+        Configuration file will be placed in new directory, therefore it is
+        needed to calculate new paths so that emulator can find assets.
+        """
+        logging.debug("_normalize_options")
+        options = ['wrapper_archive', 'wrapper_whdload_base',
+                   'accelerator_rom', 'base_dir', 'cdrom_drive_0',
+                   'cdroms_dir', 'controllers_dir', 'cpuboard_flash_ext_file',
+                   'cpuboard_flash_file', 'floppies_dir',
+                   'floppy_overlays_dir', 'fmv_rom', 'graphics_card_rom',
+                   'hard_drives_dir', 'kickstart_file', 'kickstarts_dir',
+                   'logs_dir', 'save_states_dir', 'screenshots_output_dir']
+
+        for num in range(20):
+            options.append('cdrom_image_%d' % num)
+            options.append('floppy_image_%d' % num)
+
+        for num in range(4):
+            options.append('floppy_drive_%d' % num)
+
+        for num in range(10):
+            options.append('hard_drive_%d' % num)
+
+        changed_options = {}
+
+        for key, val in utils.get_config(self.conf_file).items():
+
+            if key not in options:
+                continue
+
+            if val.startswith('/'):
+                continue
+
+            if val.startswith('~'):
+                continue
+
+            if val.startswith('$HOME'):
+                continue
+
+            if val.startswith('$WRAPPER'):
+                changed_options[key] = val.replace('$WRAPPER', self.dir)
+                continue
+
+            if val.startswith('$CONFIG'):
+                abspath = utils.interpolate_variables(val, self.conf_file)
+                changed_options[key] = abspath
+                logging.info("%s: %s => %s", key, val, abspath)
+                continue
+
+            _val = os.path.abspath(val)
+            if os.path.exists(_val):
+                changed_options[key] = _val
+            else:
+                changed_options[key] = val
+
+        self.fsuae_options.update(changed_options)
+
    def _validate_options(self):
        """Validate mandatory options"""
        if 'wrapper' not in self.all_options:
-            sys.stderr.write("Configuration lacks of required "
-                             "`wrapper' option.\n")
+            logging.error("Configuration lacks of required `wrapper' option.")
            return False

        if self.all_options.get('wrapper_save_state', '0') == '0':
            return True

        if 'wrapper_archiver' not in self.all_options:
-            sys.stderr.write("Configuration lacks of required "
-                             "`wrapper_archiver' option.\n")
-            return False
+            logging.warning("Configuration lacks of optional "
+                            "`wrapper_archiver' option, fall back to 7z")
+            self.all_options['wrapper_archiver'] = "7z"

        if not path.which(self.all_options['wrapper_archiver']):
-            sys.stderr.write("Cannot find archiver `%s'." %
-                             self.all_options['wrapper_archiver'])
+            logging.error("Cannot find archiver `%s'.",
+                          self.all_options['wrapper_archiver'])
            return False

        return True
@@ -249,6 +283,7 @@ class ArchiveBase(Base):

    def _extract(self):
        """Extract archive to temp dir"""
+        logging.debug("_extract")

        title = self._get_title()
        curdir = os.path.abspath('.')
@@ -258,12 +293,36 @@ class ArchiveBase(Base):
        return result

    def _validate_options(self):
+        logging.debug("_validate_options")

        validation_result = super(ArchiveBase, self)._validate_options()
+        if not validation_result:
+            return False

        if 'wrapper_archive' not in self.all_options:
-            sys.stderr.write("Configuration lacks of required "
-                             "`wrapper_archive' option.\n")
-            validation_result = False
+            logging.warning("Configuration lacks of optional `wrapper_archive'"
+                            " option.\n")
+            wrapper_archive = self._get_wrapper_archive_name()
+            if wrapper_archive is None:
+                logging.error("Configuration lacks of optional "
+                              "`wrapper_archive', cannot deduct the name by "
+                              "configuration file name.\n")
+                validation_result = False
+            self.all_options['wrapper_archive'] = wrapper_archive

        return validation_result
+
+    def _get_wrapper_archive_name(self):
+        """
+        Return full path to the archive name using configuration file
+        basename and appending one of the expected archive extensions.
+        """
+        basename = os.path.splitext(os.path.basename(self.conf_file))[0]
+        file_list = os.listdir(os.path.dirname(self.conf_file))
+        for fname in file_list:
+            for ext in ('.7z', '.lha', '.lzx', '.zip', '.rar', '.tar', '.tgz',
+                        '.tar.gz', '.tar.bz2', '.tar.xz'):
+                if ((basename + ext).lower() == fname.lower() and
+                   basename == os.path.splitext(fname)[0]):
+                    return fname
+        return None
--- a/fs_uae_wrapper/cd32.py
+++ b/fs_uae_wrapper/cd32.py
@@ -11,7 +11,7 @@ name.
 from fs_uae_wrapper import base


-class CD32(base.ArchiveBase):
+class Wrapper(base.ArchiveBase):
    """
    Class for performing extracting archive, copying emulator files, and
    cleaning it back again
@@ -28,7 +28,7 @@ class CD32(base.ArchiveBase):
            - run the emulation
            - archive save state
        """
-        super(CD32, self).run()
+        super(Wrapper, self).run()
        if not self._validate_options():
            return False

@@ -39,24 +39,10 @@ class CD32(base.ArchiveBase):
            if not method():
                return False

-        kick_opts = self._kickstart_option()
-        if kick_opts:
-            self.fsuae_options.update(kick_opts)
-
-        if not self._run_emulator(self.fsuae_options.list()):
+        if not self._run_emulator():
            return False

        if self._get_saves_dir():
            return self._save_save()

        return True
-
-
-def run(config_file, fsuae_options, configuration):
-    """Run fs-uae with provided config file and options"""
-
-    runner = CD32(config_file, fsuae_options, configuration)
-    try:
-        return runner.run()
-    finally:
-        runner.clean()
--- a/fs_uae_wrapper/file_archive.py
+++ b/fs_uae_wrapper/file_archive.py
@@ -1,34 +1,36 @@
 """
 File archive classes
 """
+import logging
 import os
-import subprocess
-import sys
 import re
+import subprocess

 from fs_uae_wrapper import path


 class Archive(object):
    """Base class for archive support"""
-    ADD = ['a']
-    EXTRACT = ['x']
+    ADD = ('a',)
+    EXTRACT = ('x',)
    ARCH = 'false'

    def __init__(self):
        self.archiver = path.which(self.ARCH)
-        self._compess = self.archiver
-        self._decompess = self.archiver
+        self._compress = self.archiver
+        self._decompress = self.archiver

    def create(self, arch_name, files=None):
        """
        Create archive. Return True on success, False otherwise.
        """
        files = files if files else ['.']
-        result = subprocess.call([self._compess] + self.ADD + [arch_name]
-                                 + files)
+        logging.debug("Calling `%s %s %s %s'.", self._compress,
+                      " ".join(self.ADD), arch_name, " ".join(files))
+        result = subprocess.call([self._compress, *self.ADD, arch_name,
+                                  *files])
        if result != 0:
-            sys.stderr.write("Unable to create archive `%s'\n" % arch_name)
+            logging.error("Unable to create archive `%s'.", arch_name)
            return False
        return True

@@ -37,42 +39,45 @@ class Archive(object):
        Extract archive. Return True on success, False otherwise.
        """
        if not os.path.exists(arch_name):
-            sys.stderr.write("Archive `%s' doesn't exists.\n" % arch_name)
+            logging.error("Archive `%s' doesn't exists.", arch_name)
            return False

-        result = subprocess.call([self._decompess] + self.EXTRACT +
-                                 [arch_name])
+        logging.debug("Calling `%s %s %s'.", self._compress,
+                      " ".join(self.ADD), arch_name)
+        result = subprocess.call([self._decompress, *self.EXTRACT, arch_name])
        if result != 0:
-            sys.stderr.write("Unable to extract archive `%s'\n" % arch_name)
+            logging.error("Unable to extract archive `%s'.", arch_name)
            return False
        return True


 class TarArchive(Archive):
-    ADD = ['cf']
-    EXTRACT = ['xf']
+    ADD = ('cf',)
+    EXTRACT = ('xf',)
    ARCH = 'tar'

    def create(self, arch_name, files=None):
        files = files if files else sorted(os.listdir('.'))
-        result = subprocess.call([self._compess] + self.ADD + [arch_name] +
-                                 files)
+        logging.debug("Calling `%s %s %s %s'.", self._compress,
+                      " ".join(self.ADD), arch_name, " ".join(files))
+        result = subprocess.call([self._compress, *self.ADD, arch_name,
+                                  *files])
        if result != 0:
-            sys.stderr.write("Unable to create archive `%s'\n" % arch_name)
+            logging.error("Unable to create archive `%s'.", arch_name)
            return False
        return True


 class TarGzipArchive(TarArchive):
-    ADD = ['zcf']
+    ADD = ('zcf',)


 class TarBzip2Archive(TarArchive):
-    ADD = ['jcf']
+    ADD = ('jcf',)


 class TarXzArchive(TarArchive):
-    ADD = ['Jcf']
+    ADD = ('Jcf',)


 class LhaArchive(Archive):
@@ -80,13 +85,13 @@ class LhaArchive(Archive):


 class ZipArchive(Archive):
-    ADD = ['a', '-tzip']
-    ARCH = ['7z', 'zip']
+    ADD = ('a', '-tzip')
+    ARCH = ('7z', 'zip')

    def __init__(self):
        super(ZipArchive, self).__init__()
        if self.archiver == 'zip':
-            self._decompess = path.which('unzip')
+            self._decompress = path.which('unzip')
            ZipArchive.ADD = ['-r']
            ZipArchive.EXTRACT = []

@@ -96,37 +101,39 @@ class SevenZArchive(Archive):


 class LzxArchive(Archive):
-    EXTRACT = ['-x']
+    EXTRACT = ('-x',)
    ARCH = 'unlzx'

    @classmethod
    def create(self, arch_name, files=None):
-        sys.stderr.write('Cannot create LZX archive. Only extracting is'
-                         'supported\n')
+        logging.error('Cannot create LZX archive. Only extracting is'
+                      'supported.')
        return False


 class RarArchive(Archive):
-    ARCH = ['rar', 'unrar']
+    ARCH = ('rar', 'unrar')

    def create(self, arch_name, files=None):
        files = files if files else sorted(os.listdir('.'))
        if self.archiver == 'unrar':
-            sys.stderr.write('Cannot create RAR archive. Only extracting is'
-                             'supported by unrar.\n')
+            logging.error('Cannot create RAR archive. Only extracting is'
+                          'supported by unrar.')
            return False

-        result = subprocess.call([self._compess] + self.ADD + [arch_name] +
-                                 files)
+        logging.debug("Calling `%s %s %s %s'.", self._compress,
+                      " ".join(self.ADD), arch_name, " ".join(files))
+        result = subprocess.call([self._compress, *self.ADD, arch_name,
+                                  *files])
        if result != 0:
-            sys.stderr.write("Unable to create archive `%s'\n" % arch_name)
+            logging.error("Unable to create archive `%s'.", arch_name)
            return False
        return True


 class Archivers(object):
    """Archivers class"""
-    archivers = [{'arch': TarArchive, 'name': 'tar', 'ext': ['tar']},
+    archivers = ({'arch': TarArchive, 'name': 'tar', 'ext': ['tar']},
                 {'arch': TarGzipArchive, 'name': 'tgz',
                  'ext': ['tar.gz', 'tgz']},
                 {'arch': TarBzip2Archive, 'name': 'tar.bz2',
@@ -136,7 +143,7 @@ class Archivers(object):
                 {'arch': SevenZArchive, 'name': '7z', 'ext': ['7z']},
                 {'arch': ZipArchive, 'name': 'zip', 'ext': ['zip']},
                 {'arch': LhaArchive, 'name': 'lha', 'ext': ['lha', 'lzh']},
-                 {'arch': LzxArchive, 'name': 'lzx', 'ext': ['lzx']}]
+                 {'arch': LzxArchive, 'name': 'lzx', 'ext': ['lzx']})

    @classmethod
    def get(cls, extension):
@@ -174,13 +181,13 @@ def get_archiver(arch_name):

    archiver = Archivers.get(ext)
    if not archiver:
-        sys.stderr.write("Unable find archive type for `%s'\n" % arch_name)
+        logging.error("Unable find archive type for `%s'.", arch_name)
        return None

    archobj = archiver()
    if archobj.archiver is None:
-        sys.stderr.write("Unable find executable for operating on files"
-                         " `*%s'\n" % ext)
+        logging.error("Unable find executable for operating on files `*%s'.",
+                      ext)
        return None

    return archobj
--- a/fs_uae_wrapper/message.py
+++ b/fs_uae_wrapper/message.py
@@ -3,19 +3,15 @@ Display message in separate process
 """
 import multiprocessing as mp
 import sys
-try:
-    import tkinter as tk
-    from tkinter import ttk
-except ImportError:
-    import Tkinter as tk
-    import ttk
+import tkinter
+import tkinter.ttk


-class MessageGui(tk.Tk):
+class MessageGui(tkinter.Tk):
    """Simple gui for displaying a message"""

    def __init__(self, parent=None, msg=""):
-        tk.Tk.__init__(self, parent)
+        tkinter.Tk.__init__(self, parent)

        self.grid()
        self.resizable(False, False)
@@ -24,12 +20,13 @@ class MessageGui(tk.Tk):
        # Display window without decorations
        self.wm_attributes('-type', 'splash')

-        self.frame = ttk.Frame(self, padding=5, borderwidth=0)
+        self.frame = tkinter.ttk.Frame(self, padding=5, borderwidth=0)
        self.frame.grid()
-        ttk.Label(self.frame, text=msg, relief="ridge", padding=10).grid()
+        tkinter.ttk.Label(self.frame, text=msg, relief="ridge",
+                          padding=10).grid()

        if 'linux' in sys.platform:
-            style = ttk.Style()
+            style = tkinter.ttk.Style()
            style.theme_use('clam')

    def __call__(self):
--- a/fs_uae_wrapper/nogui_message.py
+++ b/fs_uae_wrapper/nogui_message.py
@@ -0,0 +1,18 @@
+"""
+Display message as simple text on console
+"""
+import sys
+
+
+class Message:
+    """Just a fake message window for systems without TK"""
+
+    def __init__(self, msg):
+        self.msg = msg
+        self._process = None
+
+    def show(self):
+        sys.stdout.write(self.msg + "\n")
+
+    def close(self):
+        return None
--- a/fs_uae_wrapper/plain.py
+++ b/fs_uae_wrapper/plain.py
@@ -1,27 +1,24 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
 """
 Simple class for executing fs-uae with specified parameters. This is a
 failsafe class for running fs-uae.
 """
-import subprocess
-import sys
+from fs_uae_wrapper import base, utils


-def run_plain(conf_file, fs_uae_options):
-    """
-    Run the emulation.
-    conf_file is a path to the configuration,
-    fs_uae_options is an dict-like object which contains commandline options to
-                   be passed to fs-uae
-    """
-    try:
-        subprocess.call(['fs-uae'] + [conf_file] + fs_uae_options.list())
-    except subprocess.CalledProcessError:
-        sys.stderr.write('Warning: fs-uae returned non 0 exit code\n')
-    return True
+class Wrapper(base.Base):
+    """Simple class for running fs-uae"""

+    def run(self):
+        """
+        Main function which run FS-UAE
+        """
+        self._run_emulator()

-def run(config_file, fs_uae_options, _):
-    """Run fs-uae with provided config file and options"""
-    return run_plain(config_file, fs_uae_options)
+    def _run_emulator(self):
+        """execute fs-uae"""
+        utils.run_command(['fs-uae', self.conf_file,
+                           *self.fsuae_options.list()])
+
+    def clean(self):
+        """Do the cleanup. Here - just do nothing"""
+        return
--- a/fs_uae_wrapper/savestate.py
+++ b/fs_uae_wrapper/savestate.py
@@ -4,7 +4,7 @@ Wrapper module with preserved save state in archive file.
 from fs_uae_wrapper import base


-class SaveState(base.Base):
+class Wrapper(base.Base):
    """
    Preserve save state.
    """
@@ -16,8 +16,7 @@ class SaveState(base.Base):
                            parameters
            configuration:  is config dictionary created out of config file
        """
-        super(SaveState, self).__init__(conf_file, fsuae_options,
-                                        configuration)
+        super(Wrapper, self).__init__(conf_file, fsuae_options, configuration)
        self.arch_filepath = None
        self.all_options['wrapper_save_state'] = '1'

@@ -31,7 +30,7 @@ class SaveState(base.Base):
            - run the emulation
            - optionally make archive save state
        """
-        if not super(SaveState, self).run():
+        if not super(Wrapper, self).run():
            return False

        self._load_save()
@@ -39,11 +38,7 @@ class SaveState(base.Base):
        if not self._copy_conf():
            return False

-        kick_opts = self._kickstart_option()
-        if kick_opts:
-            self.fsuae_options.update(kick_opts)
-
-        if not self._run_emulator(self.fsuae_options.list()):
+        if not self._run_emulator():
            return False

        if self._get_saves_dir():
@@ -51,13 +46,3 @@ class SaveState(base.Base):
                return False

        return True
-
-
-def run(config_file, fsuae_options, configuration):
-    """Run fs-uae with provided config file and options"""
-
-    runner = SaveState(config_file, fsuae_options, configuration)
-    try:
-        return runner.run()
-    finally:
-        runner.clean()
--- a/fs_uae_wrapper/utils.py
+++ b/fs_uae_wrapper/utils.py
@@ -1,17 +1,18 @@
 """
 Misc utilities
 """
-from distutils import spawn
+import configparser
+import logging
 import os
+import pathlib
+import shutil
 import subprocess
-import sys
-try:
-    import configparser
-except ImportError:
-    import ConfigParser as configparser

-from fs_uae_wrapper import message
 from fs_uae_wrapper import file_archive
+try:
+    from fs_uae_wrapper.message import Message
+except ModuleNotFoundError:
+    from fs_uae_wrapper.nogui_message import Message


 class CmdOption(dict):
@@ -22,8 +23,8 @@ class CmdOption(dict):
    def add(self, option):
        """parse and add option to the dictionary"""
        if not option.startswith('--'):
-            raise AttributeError("Cannot add option `%s' to the dictionary" %
-                                 option)
+            raise AttributeError(f"Cannot add option {option} to the "
+                                 f"dictionary")
        if '=' in option:
            key, val = option.split('=', 1)
            key = key[2:].strip()
@@ -38,15 +39,15 @@ class CmdOption(dict):
        ret_list = []
        for key, val in self.items():
            if val != '1':
-                ret_list.append('--%(k)s=%(v)s' % {'k': key, 'v': val})
+                ret_list.append(f'--{key}={val}')
            else:
-                ret_list.append('--%(k)s' % {'k': key})
+                ret_list.append(f'--{key}')
        return ret_list


 def get_config_options(conf):
    """Read config file and return options as a dict"""
-    parser = configparser.SafeConfigParser()
+    parser = configparser.ConfigParser()
    try:
        parser.read(conf)
    except configparser.ParsingError:
@@ -67,7 +68,7 @@ def operate_archive(arch_name, operation, text, params):
    if archiver is None:
        return False

-    msg = message.Message(text)
+    msg = Message(text)
    if text:
        msg.show()

@@ -90,7 +91,7 @@ def create_archive(arch_name, title='', params=None):
    """
    msg = ''
    if title:
-        msg = "Creating archive for `%s'. Please be patient" % title
+        msg = f"Creating archive for `{title}'. Please be patient"
    return operate_archive(arch_name, 'create', msg, params)


@@ -100,7 +101,7 @@ def extract_archive(arch_name, title='', params=None):
    """
    msg = ''
    if title:
-        msg = "Extracting files for `%s'. Please be patient" % title
+        msg = f"Extracting files for `{title}'. Please be patient"
    return operate_archive(arch_name, 'extract', msg, params)


@@ -115,10 +116,10 @@ def run_command(cmd):
    if not isinstance(cmd, list):
        cmd = cmd.split()

+    logging.debug("Executing `%s'.", " ".join(cmd))
    code = subprocess.call(cmd)
    if code != 0:
-        sys.stderr.write('Command `{0}` returned non 0 exit '
-                         'code\n'.format(cmd[0]))
+        logging.error('Command `%s` returned non 0 exit code.', cmd[0])
        return False
    return True

@@ -144,17 +145,20 @@ def interpolate_variables(string, config_path, base=None):
        - $BASE
    """

+    _string = string
    if '$CONFIG' in string:
-        string = string.replace('$CONFIG',
-                                os.path.dirname(os.path.abspath(config_path)))
+        conf_path = pathlib.Path(config_path).resolve().parent
+        string = str(pathlib.Path(string.replace('$CONFIG', str(conf_path)))
+                     .resolve())
+
    if '$HOME' in string:
        string = string.replace('$HOME', os.path.expandvars('$HOME'))

    if '$EXE' in string:
-        string = string.replace('$EXE', spawn.find_executable('fs-uae'))
+        string = string.replace('$EXE', shutil.which('fs-uae'))

    if '$APP' in string:
-        string = string.replace('$APP', spawn.find_executable('fs-uae'))
+        string = string.replace('$APP', shutil.which('fs-uae'))

    if '$DOCUMENTS' in string:
        xdg_docs = os.getenv('XDG_DOCUMENTS_DIR',
@@ -165,7 +169,9 @@ def interpolate_variables(string, config_path, base=None):
        if '$BASE' in string:
            string = string.replace('$BASE', base)

-    return string
+    if os.path.exists(string):
+        return string
+    return _string


 def get_config(conf_file):
--- a/fs_uae_wrapper/whdload.py
+++ b/fs_uae_wrapper/whdload.py
@@ -0,0 +1,136 @@
+"""
+Run fs-uae with WHDLoad games
+
+It will use compressed base image and compressed directories.
+"""
+import logging
+import os
+
+from fs_uae_wrapper import base, utils
+
+
+class Wrapper(base.ArchiveBase):
+    """
+    Class for performing extracting archive, copying emulator files, and
+    cleaning it back again
+    """
+    def __init__(self, conf_file, fsuae_options, configuration):
+        super(Wrapper, self).__init__(conf_file, fsuae_options, configuration)
+        self.archive_type = None
+
+    def run(self):
+        """
+        Main function which accepts configuration file for FS-UAE
+        It will do as follows:
+            - extract base image and archive file
+            - copy configuration
+            - run the emulation
+        """
+        logging.debug("run")
+        if not super().run():
+            return False
+
+        if not self._extract():
+            return False
+
+        if not self._copy_conf():
+            return False
+
+        return self._run_emulator()
+
+    def _validate_options(self):
+        """
+        Do the validation for the options, additionally check if there is
+        mandatory WHDLoad base OS images set.
+        """
+        if not super()._validate_options():
+            return False
+
+        if not self.all_options.get('wrapper_whdload_base'):
+            logging.error("wrapper_whdload_base is not set in configuration, "
+                          "exiting.")
+            return False
+        return True
+
+    def _extract(self):
+        """Extract base image and then WHDLoad archive"""
+        base_image = self.fsuae_options['wrapper_whdload_base']
+        if not os.path.exists(base_image):
+            logging.error("Base image `%s` does't exists in provided "
+                          "location.", base_image)
+            return False
+
+        curdir = os.path.abspath('.')
+        os.chdir(self.dir)
+        result = utils.extract_archive(base_image)
+        os.chdir(curdir)
+        if not result:
+            return False
+
+        if not super()._extract():
+            return False
+
+        return self._find_slave()
+
+    def _find_slave(self):
+        """Find Slave file and create apropriate entry in S:whdload-startup"""
+        curdir = os.path.abspath('.')
+        os.chdir(self.dir)
+
+        # find slave name
+        slave_fname = None
+        slave_path = None
+        case_insensitvie_map = {}
+
+        # build case insensitive map of paths and find the slave file
+        for root, dirnames, fnames in os.walk('.'):
+            for dirname in dirnames:
+                full_path = os.path.normpath(os.path.join(root, dirname))
+                case_insensitvie_map[full_path.lower()] = full_path
+
+            for fname in fnames:
+                full_path = os.path.normpath(os.path.join(root, fname))
+                case_insensitvie_map[full_path.lower()] = full_path
+                if not slave_fname and fname.lower().endswith('.slave'):
+                    slave_path, slave_fname = os.path.normpath(root), fname
+
+        if slave_fname is None:
+            logging.error("Cannot find .slave file in archive.")
+            return False
+
+        # find corresponfing info (an icon) fname
+        icon_fname = None
+        for fname in os.listdir(slave_path):
+            if (fname.lower().endswith('.info') and
+               os.path.splitext(slave_fname)[0].lower() ==
+               os.path.splitext(fname)[0].lower()):
+                icon_fname = fname
+                break
+        if icon_fname is None:
+            logging.error("Cannot find .info file corresponding to %s in "
+                          "archive.", slave_fname)
+            return False
+
+        # find proper way to handle slave
+        # 1. check if there are user provided params
+        contents = f"cd {slave_path}\n"
+        if self.all_options.get('wrapper_whdload_options'):
+            contents = (f"{contents}"
+                        f"C:whdload "
+                        f"{self.all_options['wrapper_whdload_options']} "
+                        f"Slave={slave_fname}\n")
+        else:
+            # no params, find if kgiconload is available
+            if case_insensitvie_map.get('c/kgiconload'):
+                contents = f"{contents}C:kgiconload {icon_fname}\n"
+            else:
+                # if not, just add common defaults
+                contents = (f"{contents}C:whdload Preload "
+                            f"Slave={slave_fname}\n")
+
+        fname = os.path.join(case_insensitvie_map.get('s'), 'whdload-startup')
+        with open(fname, "w") as fobj:
+            fobj.write(contents)
+
+        os.chdir(curdir)
+        return True
--- a/fs_uae_wrapper/wrapper.py
+++ b/fs_uae_wrapper/wrapper.py
@@ -1,14 +1,33 @@
-#!/usr/bin/env python
 """
 Wrapper for FS-UAE to perform some actions before and or after running the
 emulator, if appropriate option is enabled.
 """
 import importlib
+import logging
 import os
 import sys

-from fs_uae_wrapper import utils
-from fs_uae_wrapper import WRAPPER_KEY
+from fs_uae_wrapper import WRAPPER_KEY, utils
+
+
+def setup_logger(options):
+    """Setup logger format and level"""
+
+    level = logging.WARNING
+
+    if options['wrapper_quiet']:
+        level = logging.ERROR
+        if options['wrapper_quiet'] > 1:
+            level = logging.CRITICAL
+
+    if options['wrapper_verbose']:
+        level = logging.INFO
+        if options['wrapper_verbose'] > 1:
+            level = logging.DEBUG
+
+    logging.basicConfig(level=level,
+                        format="%(asctime)s %(levelname)s\t%(filename)s:"
+                        "%(lineno)d:\t\t%(message)s")


 def parse_args():
@@ -18,7 +37,16 @@ def parse_args():
    """
    fs_conf = None
    options = utils.CmdOption()
+    options['wrapper_verbose'] = 0
+    options['wrapper_quiet'] = 0
+
    for parameter in sys.argv[1:]:
+        if parameter in ['-v', '-q']:
+            if parameter == '-v':
+                options['wrapper_verbose'] += 1
+            if parameter == '-q':
+                options['wrapper_quiet'] += 1
+            continue
        try:
            options.add(parameter)
        except AttributeError:
@@ -33,7 +61,7 @@ def parse_args():

 def usage():
    """Print help"""
-    sys.stdout.write("Usage: %s [conf-file] [fs-uae-option...]\n\n"
+    sys.stdout.write("Usage: %s [conf-file] [-v] [-q] [fs-uae-option...]\n\n"
                     % sys.argv[0])
    sys.stdout.write("Config file is not required, if `Config.fs-uae' "
                     "exists in the current\ndirectory, although it might "
@@ -46,24 +74,27 @@ def usage():

 def run():
    """run wrapper module"""
-    config_file, cmd_options = parse_args()
+    config_file, fsuae_options = parse_args()
+    setup_logger(fsuae_options)
+    del fsuae_options['wrapper_verbose']
+    del fsuae_options['wrapper_quiet']

-    if 'help' in cmd_options:
+    if 'help' in fsuae_options:
        usage()
        sys.exit(0)

    if not config_file:
-        sys.stderr.write('Error: Configuration file not found\nSee --help'
-                         ' for usage\n')
+        logging.error('Error: Configuration file not found. See --help'
+                      ' for usage')
        sys.exit(1)

    configuration = utils.get_config_options(config_file)

    if configuration is None:
-        sys.stderr.write('Error: Configuration file have syntax issues\n')
+        logging.error('Error: Configuration file have syntax issues')
        sys.exit(2)

-    wrapper_module = cmd_options.get(WRAPPER_KEY)
+    wrapper_module = fsuae_options.get(WRAPPER_KEY)
    if not wrapper_module:
        wrapper_module = configuration.get(WRAPPER_KEY)

@@ -74,13 +105,16 @@ def run():
            wrapper = importlib.import_module('fs_uae_wrapper.' +
                                              wrapper_module)
        except ImportError:
-            sys.stderr.write("Error: provided wrapper module: `%s' doesn't "
-                             "exists.\n" % wrapper_module)
+            logging.error("Error: provided wrapper module: `%s' doesn't "
+                          "exists.", wrapper_module)
            sys.exit(3)

-    if not wrapper.run(config_file, cmd_options, configuration):
+    runner = wrapper.Wrapper(config_file, fsuae_options, configuration)
+
+    try:
+        exit_code = runner.run()
+    finally:
+        runner.clean()
+
+    if not exit_code:
        sys.exit(4)
-
-
-if __name__ == "__main__":
-    run()
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools >= 77.0", "wheel", "setuptools-git-versioning"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "fs-uae-wrapper"
+authors = [{name = "Roman Dobosz", email = "gryf73@gmail.com"}]
+license = "BSD-3-Clause"
+description = "Automate archives support and state saves for fs-uae"
+readme = "README.rst"
+requires-python = ">=3.8"
+keywords = ["uae", "fs-uae", "amiga", "emulator", "wrapper"]
+dynamic = ["version"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: End Users/Desktop",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: System :: Emulators",
+    "Topic :: Games/Entertainment"
+]
+
+[project.urls]
+Homepage = "https://github.com/gryf/fs-uae-wrapper"
+
+[project.scripts]
+fs-uae-wrapper = "fs_uae_wrapper.wrapper:run"
+
+[tool.setuptools]
+packages = ["fs_uae_wrapper"]
+
+[tool.distutils.bdist_wheel]
+universal = true
+
+[tool.setuptools-git-versioning]
+enabled = true
+
+[tool.ruff.lint]
+select = [
+    "F",   # pyflakes
+    "E",   # pycodestyle
+    "I",   # isort
+    "RUF", # ruff-specific rules
+]
--- a/script/fs-uae-wrapper
+++ b/script/fs-uae-wrapper
@@ -1,16 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-Run CD32 games using fsuae
-"""
-
-from fs_uae_wrapper import wrapper
-
-
-def main():
-    """run wrapper"""
-    wrapper.run()
-
-
-if __name__ == "__main__":
-    main()
--- a/setup.py
+++ b/setup.py
@@ -1,31 +0,0 @@
-#!/usr/bin/env python
-"""
-Setup for the fs-uae-wrapper
-"""
-from setuptools import setup
-
-
-setup(name='fs-uae-wrapper',
-      packages=['fs_uae_wrapper'],
-      version='0.7.1',
-      description='Automate archives and state for fs-uae',
-      author='Roman Dobosz',
-      author_email='gryf73@gmail.com',
-      url='https://github.com/gryf/fs-uea-wrapper',
-      download_url='https://github.com/gryf/pygtktalog.git',
-      keywords=['uae', 'fs-uae', 'amiga', 'emulator', 'wrapper'],
-      scripts=['script/fs-uae-wrapper'],
-      classifiers=['Programming Language :: Python :: 2',
-                   'Programming Language :: Python :: 2.7',
-                   'Programming Language :: Python :: 3',
-                   'Programming Language :: Python :: 3.4',
-                   'Development Status :: 4 - Beta',
-                   'Environment :: Console',
-                   'Intended Audience :: End Users/Desktop',
-                   'License :: OSI Approved :: BSD License',
-                   'Operating System :: OS Independent',
-                   'Topic :: System :: Emulators',
-                   'Topic :: Games/Entertainment'],
-      long_description=open('README.rst').read(),
-      options={'test': {'verbose': False,
-                        'coverage': False}})
--- a/test-requirements.txt
+++ b/test-requirements.txt
@@ -1,5 +0,0 @@
-pytest
-pytest-cov
-pytest-pep8
-coverage
-flake8
--- a/tests/test_archive.py
+++ b/tests/test_archive.py
@@ -1,15 +1,9 @@
 import os
 import shutil
 from tempfile import mkdtemp
-from unittest import TestCase
+from unittest import TestCase, mock

-try:
-    from unittest import mock
-except ImportError:
-    import mock
-
-from fs_uae_wrapper import archive
-from fs_uae_wrapper import utils
+from fs_uae_wrapper import archive, utils


 class TestArchive(TestCase):
@@ -26,45 +20,47 @@ class TestArchive(TestCase):
        except OSError:
            pass

+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._get_wrapper_archive_name')
    @mock.patch('fs_uae_wrapper.path.which')
-    def test_validate_options(self, which):
+    def test_validate_options(self, which, get_wrapper_arch_name):
        which.return_value = 'unrar'

-        arch = archive.Archive('Config.fs-uae', utils.CmdOption(), {})
+        arch = archive.Wrapper('Config.fs-uae', utils.CmdOption(), {})
        self.assertFalse(arch._validate_options())
+
+        get_wrapper_arch_name.return_value = None
        arch.all_options = {'wrapper': 'archive'}
-
-        arch.all_options['wrapper'] = 'archive'
        self.assertFalse(arch._validate_options())

+        get_wrapper_arch_name.return_value = 'fake_arch_filename'
        arch.all_options['wrapper_archive'] = 'rar'
        self.assertTrue(arch._validate_options())

    @mock.patch('tempfile.mkdtemp')
    @mock.patch('fs_uae_wrapper.path.which')
-    @mock.patch('fs_uae_wrapper.archive.Archive._make_archive')
+    @mock.patch('fs_uae_wrapper.archive.Wrapper._make_archive')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._get_wrapper_archive_name')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._save_save')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._get_saves_dir')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._run_emulator')
-    @mock.patch('fs_uae_wrapper.base.ArchiveBase._kickstart_option')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._copy_conf')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._load_save')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._extract')
-    def test_run(self, extract, load_save, copy_conf, kick_option,
-                 run_emulator, get_save_dir, save_state, make_arch, which,
-                 mkdtemp):
+    def test_run(self, extract, load_save, copy_conf, run_emulator,
+                 get_save_dir, save_state, get_wrapper_arch_name, make_arch,
+                 which, mkdtemp):

        extract.return_value = False
        load_save.return_value = False
        copy_conf.return_value = False
-        kick_option.return_value = False
        run_emulator.return_value = False
        get_save_dir.return_value = False
        save_state.return_value = False
+        get_wrapper_arch_name.return_value = "fake_arch_filename"
        make_arch.return_value = False
        which.return_value = 'rar'

-        arch = archive.Archive('Config.fs-uae', utils.CmdOption(), {})
+        arch = archive.Wrapper('Config.fs-uae', utils.CmdOption(), {})
        self.assertFalse(arch.run())

        arch.all_options = {'wrapper': 'archive',
@@ -82,10 +78,6 @@ class TestArchive(TestCase):
        copy_conf.return_value = True
        self.assertFalse(arch.run())

-        kick_option.return_value = {'foo': 'bar'}
-        self.assertFalse(arch.run())
-        self.assertDictEqual(arch.fsuae_options, {'foo': 'bar'})
-
        run_emulator.return_value = True
        self.assertFalse(arch.run())

@@ -110,7 +102,7 @@ class TestArchive(TestCase):
        title.return_value = ''
        carch.return_value = False

-        arch = archive.Archive('Config.fs-uae', utils.CmdOption(), {})
+        arch = archive.Wrapper('Config.fs-uae', utils.CmdOption(), {})
        arch.dir = self.dirname
        arch.arch_filepath = os.path.join(self.dirname, 'foo.tgz')
        arch.all_options = {}
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -1,16 +1,10 @@
 import os
-import sys
 import shutil
-from tempfile import mkstemp, mkdtemp
-from unittest import TestCase
+import sys
+from tempfile import mkdtemp, mkstemp
+from unittest import TestCase, mock

-try:
-    from unittest import mock
-except ImportError:
-    import mock
-
-from fs_uae_wrapper import base
-from fs_uae_wrapper import utils
+from fs_uae_wrapper import base, utils


 class TestBase(TestCase):
@@ -47,28 +41,79 @@ class TestBase(TestCase):
        bobj.clean()
        self.assertFalse(os.path.exists(self.dirname))

+    @mock.patch('os.path.exists')
    @mock.patch('fs_uae_wrapper.utils.get_config')
-    def test_kickstart_option(self, get_config):
+    def test_normalize_options(self, get_config, os_exists):

+        os_exists.return_value = True
        bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
-        get_config.return_value = {'foo': 'bar'}
-        self.assertDictEqual(bobj._kickstart_option(), {})

        get_config.return_value = {'kickstarts_dir': '/some/path'}
-        self.assertDictEqual(bobj._kickstart_option(),
-                             {'kickstarts_dir': '/some/path'})
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options, {})

        os.chdir(self.dirname)
-        get_config.return_value = {'kickstarts_dir': '../some/path'}
+        get_config.return_value = {'fmv_rom': 'bar'}
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options,
+                             {'fmv_rom': os.path.join(self.dirname, 'bar')})
+
+        get_config.return_value = {'floppies_dir': '../some/path'}
+        bobj.fsuae_options = utils.CmdOption()
        result = os.path.abspath(os.path.join(self.dirname, '../some/path'))
-        self.assertDictEqual(bobj._kickstart_option(),
-                             {'kickstarts_dir': result})
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options, {'floppies_dir': result})

        bobj.conf_file = os.path.join(self.dirname, 'Config.fs-uae')
-        get_config.return_value = {'kickstarts_dir': '$CONFIG/../path'}
+        get_config.return_value = {'cdroms_dir': '$CONFIG/../path'}
+        bobj.fsuae_options = utils.CmdOption()
        result = os.path.abspath(os.path.join(self.dirname, '../path'))
-        self.assertDictEqual(bobj._kickstart_option(),
-                             {'kickstarts_dir': result})
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options, {'cdroms_dir': result})
+
+        get_config.return_value = {'cdroms_dir': '$HOME/path'}
+        bobj.fsuae_options = utils.CmdOption()
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options, {})
+
+        get_config.return_value = {'cdroms_dir': '$WRAPPER/path'}
+        bobj.fsuae_options = utils.CmdOption()
+        bobj.dir = self.dirname
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options,
+                             {'cdroms_dir': os.path.join(bobj.dir, 'path')})
+
+        get_config.return_value = {'cdroms_dir': '~/path'}
+        bobj.fsuae_options = utils.CmdOption()
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options, {})
+
+        get_config.return_value = {'random_item': 10}
+        bobj.fsuae_options = utils.CmdOption()
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options, {})
+
+    @mock.patch('os.path.exists')
+    @mock.patch('fs_uae_wrapper.utils.get_config')
+    def test_normalize_options_path_not_exists(self, get_config, os_exists):
+
+        os_exists.return_value = False
+        bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
+
+        get_config.return_value = {'kickstarts_dir': '/some/path'}
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options, {})
+
+        os.chdir(self.dirname)
+        get_config.return_value = {'fmv_rom': 'bar'}
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options, {'fmv_rom': 'bar'})
+
+        get_config.return_value = {'floppies_dir': '../some/path'}
+        bobj.fsuae_options = utils.CmdOption()
+        bobj._normalize_options()
+        self.assertDictEqual(bobj.fsuae_options,
+                             {'floppies_dir': '../some/path'})

    def test_set_assets_paths(self):

@@ -105,15 +150,22 @@ class TestBase(TestCase):
        bobj = base.Base('Config.fs-uae', utils.CmdOption(), {})
        bobj.dir = self.dirname

-        self.assertTrue(bobj._run_emulator([]))
+        self.assertTrue(bobj._run_emulator())
        run.assert_called_once_with(['fs-uae'])

        # Errors from emulator are not fatal to wrappers
        run.reset_mock()
        run.return_value = False
-        self.assertTrue(bobj._run_emulator([]))
+        self.assertTrue(bobj._run_emulator())
        run.assert_called_once_with(['fs-uae'])

+        # pass the options
+        bobj.fsuae_options = utils.CmdOption({'foo': '1'})
+        run.reset_mock()
+        run.return_value = False
+        self.assertTrue(bobj._run_emulator())
+        run.assert_called_once_with(['fs-uae', '--foo'])
+
    @mock.patch('fs_uae_wrapper.base.Base._get_saves_dir')
    @mock.patch('fs_uae_wrapper.utils.create_archive')
    def test_save_save(self, carch, saves_dir):
@@ -184,13 +236,13 @@ class TestBase(TestCase):
        bobj.all_options['save_states_dir'] = '/some/path'
        self.assertIsNone(bobj._get_saves_dir())

-        bobj.all_options['save_states_dir'] = '$CONFIG/../saves'
+        bobj.all_options['save_states_dir'] = '$WRAPPER/../saves'
        self.assertIsNone(bobj._get_saves_dir())

-        bobj.all_options['save_states_dir'] = '/foo/$CONFIG/saves'
+        bobj.all_options['save_states_dir'] = '/foo/$WRAPPER/saves'
        self.assertIsNone(bobj._get_saves_dir())

-        bobj.all_options['save_states_dir'] = '$CONFIG/saves'
+        bobj.all_options['save_states_dir'] = '$WRAPPER/saves'
        self.assertIsNone(bobj._get_saves_dir())

        path = os.path.join(self.dirname, 'saves')
@@ -202,7 +254,7 @@ class TestBase(TestCase):
        os.mkdir(path)
        self.assertEqual(bobj._get_saves_dir(), 'saves')

-        bobj.all_options['save_states_dir'] = '$CONFIG/saves/'
+        bobj.all_options['save_states_dir'] = '$WRAPPER/saves/'
        self.assertEqual(bobj._get_saves_dir(), 'saves')

    @mock.patch('fs_uae_wrapper.path.which')
@@ -233,13 +285,19 @@ class TestBase(TestCase):
        which.return_value = '7z'
        bobj.all_options = {'wrapper': 'dummy',
                            'wrapper_save_state': '1'}
-        self.assertFalse(bobj._validate_options())
+        self.assertTrue(bobj._validate_options())

        bobj.all_options = {'wrapper': 'dummy',
                            'wrapper_save_state': '1',
                            'wrapper_archiver': '7z'}
        self.assertTrue(bobj._validate_options())

+        which.return_value = None
+        bobj.all_options = {'wrapper': 'dummy',
+                            'wrapper_save_state': '1',
+                            'wrapper_archiver': '7z'}
+        self.assertFalse(bobj._validate_options())
+
    @mock.patch('fs_uae_wrapper.path.which')
    def test_run_clean(self, which):

@@ -331,16 +389,42 @@ class TestArchiveBase(TestCase):
        self.assertFalse(bobj._extract())
        utils_extract.assert_called_once_with(self.fname, '')

-    def test_validate_options(self):
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._get_wrapper_archive_name')
+    def test_validate_options(self, get_wrapper_arch_name):

        bobj = base.ArchiveBase('Config.fs-uae', utils.CmdOption(), {})
        bobj.all_options = {}

        self.assertFalse(bobj._validate_options())

+        get_wrapper_arch_name.return_value = None
        bobj.all_options = {'wrapper': 'dummy'}
        self.assertFalse(bobj._validate_options())

        bobj.all_options = {'wrapper': 'dummy',
                            'wrapper_archive': 'myarchive.7z'}
        self.assertTrue(bobj._validate_options())
+
+    @mock.patch('os.listdir')
+    def test_get_wrapper_archive_name(self, os_listdir):
+        os_listdir.return_value = 'no archive among other files'.split()
+        bobj = base.ArchiveBase('Config.fs-uae', utils.CmdOption(), {})
+        bobj.all_options = {'wrapper': 'dummy'}
+        self.assertIsNone(bobj._get_wrapper_archive_name())
+
+        os_listdir.return_value = 'no config.rar among other files'.split()
+        bobj = base.ArchiveBase('Config.fs-uae', utils.CmdOption(), {})
+        bobj.all_options = {'wrapper': 'dummy'}
+        self.assertIsNone(bobj._get_wrapper_archive_name())
+
+        os_listdir.return_value = 'file Config.TAR among other files'.split()
+        bobj = base.ArchiveBase('Config.fs-uae', utils.CmdOption(), {})
+        bobj.all_options = {'wrapper': 'dummy'}
+        self.assertEqual(bobj._get_wrapper_archive_name(), 'Config.TAR')
+
+        os_listdir.return_value = 'Config.lha FooBar_1.24b_20202.7z'.split()
+        bobj = base.ArchiveBase('FooBar_1.24b_20202.fs-uae',
+                                utils.CmdOption(), {})
+        bobj.all_options = {'wrapper': 'dummy'}
+        self.assertEqual(bobj._get_wrapper_archive_name(),
+                         'FooBar_1.24b_20202.7z')
--- a/tests/test_cd32.py
+++ b/tests/test_cd32.py
@@ -1,38 +1,33 @@
-from unittest import TestCase
+from unittest import TestCase, mock

-try:
-    from unittest import mock
-except ImportError:
-    import mock
-
-from fs_uae_wrapper import cd32
-from fs_uae_wrapper import utils
+from fs_uae_wrapper import cd32, utils


 class TestCD32(TestCase):

    @mock.patch('tempfile.mkdtemp')
    @mock.patch('fs_uae_wrapper.path.which')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._get_wrapper_archive_name')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._save_save')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._get_saves_dir')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._run_emulator')
-    @mock.patch('fs_uae_wrapper.base.ArchiveBase._kickstart_option')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._copy_conf')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._load_save')
    @mock.patch('fs_uae_wrapper.base.ArchiveBase._extract')
-    def test_run(self, extract, load_save, copy_conf, kick_option,
-                 run_emulator, get_save_dir, save_state, which, mkdtemp):
+    def test_run(self, extract, load_save, copy_conf, run_emulator,
+                 get_save_dir, save_state, get_wrapper_arch_name, which,
+                 mkdtemp):

        extract.return_value = False
        copy_conf.return_value = False
        load_save.return_value = False
-        kick_option.return_value = {}
        run_emulator.return_value = False
        get_save_dir.return_value = False
        save_state.return_value = False
+        get_wrapper_arch_name.return_value = "fake_arch_filename"
        which.return_value = 'unrar'

-        acd32 = cd32.CD32('Config.fs-uae', utils.CmdOption(), {})
+        acd32 = cd32.Wrapper('Config.fs-uae', utils.CmdOption(), {})
        self.assertFalse(acd32.run())

        acd32.all_options = {'wrapper': 'cd32',
@@ -50,10 +45,6 @@ class TestCD32(TestCase):
        load_save.return_value = True
        self.assertFalse(acd32.run())

-        kick_option.return_value = {'foo': 'bar'}
-        self.assertFalse(acd32.run())
-        self.assertDictEqual(acd32.fsuae_options, {'foo': 'bar'})
-
        run_emulator.return_value = True
        self.assertTrue(acd32.run())

--- a/tests/test_file_archive.py
+++ b/tests/test_file_archive.py
@@ -1,12 +1,7 @@
 import os
 import shutil
 from tempfile import mkdtemp
-from unittest import TestCase
-
-try:
-    from unittest import mock
-except ImportError:
-    import mock
+from unittest import TestCase, mock

 from fs_uae_wrapper import file_archive

@@ -54,9 +49,18 @@ class TestArchive(TestCase):
        call.assert_called_once_with(['false', 'a', 'foo', '.'])

        call.reset_mock()
-        call.return_value = 1
+        self.assertFalse(arch.extract('foo'))
        with open('foo', 'w') as fobj:
            fobj.write('\n')
+        self.assertTrue(arch.extract('foo'))
+
+        call.return_value = 1
+
+        call.reset_mock()
+        self.assertFalse(arch.create('foo'))
+        call.assert_called_once_with(['false', 'a', 'foo', '.'])
+
+        call.reset_mock()
        self.assertFalse(arch.extract('foo'))
        call.assert_called_once_with(['false', 'x', 'foo'])

@@ -128,6 +132,12 @@ class TestArchive(TestCase):
        self.assertTrue(arch.create('foo.tgz'))
        call.assert_called_once_with(['tar', 'zcf', 'foo.tgz', 'bar', 'foo'])

+        call.reset_mock()
+        call.return_value = 1
+        arch = file_archive.TarArchive()
+        self.assertFalse(arch.create('foo.tar'))
+        call.assert_called_once_with(['tar', 'cf', 'foo.tar', 'bar', 'foo'])
+
    @mock.patch('fs_uae_wrapper.path.which')
    @mock.patch('subprocess.call')
    def test_lha(self, call, which):
@@ -208,6 +218,11 @@ class TestArchive(TestCase):
        self.assertFalse(arch.extract('foo'))
        call.assert_called_once_with(['7z', 'x', 'foo'])

+        which.side_effect = ['zip', 'unzip']
+        arch = file_archive.ZipArchive()
+        self.assertEqual(arch._compress, 'zip')
+        self.assertEqual(arch._decompress, 'unzip')
+
    @mock.patch('fs_uae_wrapper.path.which')
    @mock.patch('subprocess.call')
    def test_rar(self, call, which):
@@ -231,17 +246,23 @@ class TestArchive(TestCase):
        self.assertTrue(arch.create('foo.rar'))
        call.assert_called_once_with(['rar', 'a', 'foo.rar', 'bar', 'baz',
                                      'directory', 'foo'])
+
+        call.return_value = 1
+        call.reset_mock()
+        self.assertFalse(arch.create('foo.rar'))
+        call.assert_called_once_with(['rar', 'a', 'foo.rar', 'bar', 'baz',
+                                      'directory', 'foo'])
+
        with open('foo', 'w') as fobj:
            fobj.write('\n')

        call.reset_mock()
-        call.return_value = 1
        self.assertFalse(arch.extract('foo'))
        call.assert_called_once_with(['rar', 'x', 'foo'])

        call.reset_mock()
        call.return_value = 0
-        arch._compess = arch._decompess = arch.archiver = 'unrar'
+        arch._compress = arch._decompress = arch.archiver = 'unrar'

        self.assertFalse(arch.create('foo'))
        call.assert_not_called()
@@ -250,3 +271,42 @@ class TestArchive(TestCase):
        call.return_value = 1
        self.assertFalse(arch.extract('foo'))
        call.assert_called_once_with(['unrar', 'x', 'foo'])
+
+
+class TestArchivers(TestCase):
+
+    def test_get(self):
+        self.assertEqual(file_archive.Archivers.get('tar'),
+                         file_archive.TarArchive)
+        self.assertEqual(file_archive.Archivers.get('tar.gz'),
+                         file_archive.TarGzipArchive)
+        self.assertEqual(file_archive.Archivers.get('tgz'),
+                         file_archive.TarGzipArchive)
+        self.assertEqual(file_archive.Archivers.get('tar.bz2'),
+                         file_archive.TarBzip2Archive)
+        self.assertEqual(file_archive.Archivers.get('tar.xz'),
+                         file_archive.TarXzArchive)
+        self.assertEqual(file_archive.Archivers.get('rar'),
+                         file_archive.RarArchive)
+        self.assertEqual(file_archive.Archivers.get('7z'),
+                         file_archive.SevenZArchive)
+        self.assertEqual(file_archive.Archivers.get('lha'),
+                         file_archive.LhaArchive)
+        self.assertEqual(file_archive.Archivers.get('lzh'),
+                         file_archive.LhaArchive)
+        self.assertEqual(file_archive.Archivers.get('lzx'),
+                         file_archive.LzxArchive)
+        self.assertIsNone(file_archive.Archivers.get('ace'))
+
+    def test_get_extension_by_name(self):
+        archivers = file_archive.Archivers
+        self.assertEqual(archivers.get_extension_by_name('tar'), '.tar')
+        self.assertEqual(archivers.get_extension_by_name('tgz'), '.tar.gz')
+        self.assertEqual(archivers.get_extension_by_name('tar.bz2'),
+                         '.tar.bz2')
+        self.assertEqual(archivers.get_extension_by_name('tar.xz'), '.tar.xz')
+        self.assertEqual(archivers.get_extension_by_name('rar'), '.rar')
+        self.assertEqual(archivers.get_extension_by_name('7z'), '.7z')
+        self.assertEqual(archivers.get_extension_by_name('lha'), '.lha')
+        self.assertEqual(archivers.get_extension_by_name('lzx'), '.lzx')
+        self.assertIsNone(archivers.get_extension_by_name('ace'))
--- a/tests/test_message.py
+++ b/tests/test_message.py
@@ -1,20 +1,12 @@
-from unittest import TestCase
 import os
-
-try:
-    from unittest import mock
-except ImportError:
-    import mock
+from unittest import TestCase, mock

 from fs_uae_wrapper import message
+from fs_uae_wrapper import nogui_message

 if os.environ.get('DISPLAY'):
-    try:
-        import tkinter as tk
-        from tkinter import ttk
-    except ImportError:
-        import Tkinter as tk
-        import ttk
+    import tkinter as tk
+    from tkinter import ttk


 class TestMessage(TestCase):
@@ -47,6 +39,19 @@ class TestMessage(TestCase):
        msg._process.join.assert_called_once()


+class TestNOPMessage(TestCase):
+
+    @mock.patch('sys.stdout.write')
+    def test_show(self, stdout_write):
+        msg = nogui_message.Message('display that')
+        msg.show()
+        stdout_write.assert_called_once()
+
+    def test_close(self):
+        msg = nogui_message.Message('display that')
+        self.assertIsNone(msg.close())
+
+
 if os.environ.get('DISPLAY'):
    # Tkinter needs graphic environment for the widgets
    class TestSpawn(TestCase):
--- a/tests/test_plain.py
+++ b/tests/test_plain.py
@@ -1,18 +1,16 @@
-from unittest import TestCase
+from unittest import TestCase, mock

-try:
-    from unittest import mock
-except ImportError:
-    import mock
-
-from fs_uae_wrapper import plain
-from fs_uae_wrapper import utils
+from fs_uae_wrapper import plain, utils


 class TestPlainModule(TestCase):

-    @mock.patch('subprocess.call')
-    def test_show(self, subprocess_call):
+    @mock.patch('fs_uae_wrapper.utils.run_command')
+    def test_run(self, run_command):
+        wrapper = plain.Wrapper('some.conf', utils.CmdOption(), {})
+        wrapper.run()
+        run_command.assert_called_once_with(['fs-uae', 'some.conf'])

-        plain.run('some.conf', utils.CmdOption(), None)
-        subprocess_call.assert_called_once()
+    def test_clean(self):
+        wrapper = plain.Wrapper('some.conf', utils.CmdOption(), {})
+        self.assertIsNone(wrapper.clean())
--- a/tests/test_savestate.py
+++ b/tests/test_savestate.py
@@ -1,18 +1,12 @@
 import os
 import shutil
 from tempfile import mkdtemp
-from unittest import TestCase
+from unittest import TestCase, mock

-try:
-    from unittest import mock
-except ImportError:
-    import mock
-
-from fs_uae_wrapper import savestate
-from fs_uae_wrapper import utils
+from fs_uae_wrapper import savestate, utils


-class TestArchive(TestCase):
+class TestSaveState(TestCase):

    def setUp(self):
        self.dirname = mkdtemp()
@@ -31,20 +25,18 @@ class TestArchive(TestCase):
    @mock.patch('fs_uae_wrapper.base.Base._save_save')
    @mock.patch('fs_uae_wrapper.base.Base._get_saves_dir')
    @mock.patch('fs_uae_wrapper.base.Base._run_emulator')
-    @mock.patch('fs_uae_wrapper.base.Base._kickstart_option')
    @mock.patch('fs_uae_wrapper.base.Base._copy_conf')
    @mock.patch('fs_uae_wrapper.base.Base._load_save')
-    def test_run(self, load_save, copy_conf, kick_option, run_emulator,
-                 get_save_dir, save_state, which, mkdtemp):
+    def test_run(self, load_save, copy_conf, run_emulator, get_save_dir,
+                 save_state, which, mkdtemp):

        copy_conf.return_value = False
-        kick_option.return_value = False
        run_emulator.return_value = False
        get_save_dir.return_value = False
        save_state.return_value = False
        which.return_value = 'rar'

-        arch = savestate.SaveState('Config.fs-uae', utils.CmdOption(), {})
+        arch = savestate.Wrapper('Config.fs-uae', utils.CmdOption(), {})
        self.assertFalse(arch.run())

        arch.all_options = {'wrapper': 'savestate',
@@ -58,10 +50,6 @@ class TestArchive(TestCase):
        copy_conf.return_value = True
        self.assertFalse(arch.run())

-        kick_option.return_value = {'foo': 'bar'}
-        self.assertFalse(arch.run())
-        self.assertDictEqual(arch.fsuae_options, {'foo': 'bar'})
-
        run_emulator.return_value = True
        self.assertTrue(arch.run())

@@ -75,11 +63,11 @@ class TestArchive(TestCase):
    def test_validate_options(self, which):
        which.return_value = 'unrar'

-        arch = savestate.SaveState('Config.fs-uae', utils.CmdOption(), {})
+        arch = savestate.Wrapper('Config.fs-uae', utils.CmdOption(), {})
        self.assertFalse(arch._validate_options())

        arch.all_options['wrapper'] = 'savestate'
-        self.assertFalse(arch._validate_options())
+        self.assertTrue(arch._validate_options())

        arch.all_options['wrapper_archiver'] = 'rar'
        self.assertTrue(arch._validate_options())
--- a/tests/test_utils.py
+++ b/tests/test_utils.py
@@ -1,13 +1,8 @@
 import os
-import sys
-from tempfile import mkstemp, mkdtemp
-from unittest import TestCase
 import shutil
-
-try:
-    from unittest import mock
-except ImportError:
-    import mock
+import sys
+from tempfile import mkdtemp, mkstemp
+from unittest import TestCase, mock

 from fs_uae_wrapper import utils

@@ -83,7 +78,7 @@ class TestUtils(TestCase):
        which.return_value = None

        # No config
-        self.assertFalse(utils.operate_archive('non-existend.7z', 'foo', '',
+        self.assertFalse(utils.operate_archive('non-existent.7z', 'foo', '',
                                               None))

        # Archive type not known
@@ -114,45 +109,36 @@ class TestUtils(TestCase):
        create.assert_called_once()
        show.assert_called_once()

-    def test_extract_archive(self):
+    @mock.patch('fs_uae_wrapper.utils.operate_archive')
+    def test_extract_archive(self, operate):

        os.chdir(self.dirname)

-        # No config
-        self.assertFalse(utils.extract_archive('non-existend.7z'))
+        operate.return_value = True
+        self.assertTrue(utils.extract_archive('arch.7z'))
+        operate.assert_called_once_with('arch.7z', 'extract', '', None)

-        # Archive type not known
-        with open('unsupported-archive.ace', 'w') as fobj:
-            fobj.write("\n")
-        self.assertFalse(utils.extract_archive('unsupported-archive.ace'))
+        operate.reset_mock()
+        operate.return_value = False
+        self.assertFalse(utils.extract_archive('arch.7z', 'MyFoo',
+                                               ['foo', 'bar']))
+        operate.assert_called_once_with('arch.7z', 'extract',
+                                        "Extracting files for `MyFoo'. Please"
+                                        " be patient", ['foo', 'bar'])

-        # archive is known, but extraction will fail - we have an empty
-        # archive and there is no guarantee, that 7z exists on system where
-        # test will run
-        with open('supported-archive.7z', 'w') as fobj:
-            fobj.write("\n")
-        self.assertFalse(utils.extract_archive('supported-archive.7z'))
+    @mock.patch('fs_uae_wrapper.utils.operate_archive')
+    def test_create_archive(self, operate):
+        operate.return_value = True
+        self.assertTrue(utils.create_archive('arch.7z'))
+        operate.assert_called_once_with('arch.7z', 'create', '', None)

-    @mock.patch('fs_uae_wrapper.file_archive.Archive.create')
-    def test_create_archive(self, arch_create):
-        arch_create.return_value = True
-
-        os.chdir(self.dirname)
-
-        # No config
-        self.assertFalse(utils.extract_archive('non-existend.7z'))
-
-        # Archive type not known
-        with open('unsupported-archive.ace', 'w') as fobj:
-            fobj.write("\n")
-        self.assertFalse(utils.extract_archive('unsupported-archive.ace'))
-
-        # archive is known, but extraction will fail - we have an empty
-        # archive and there is no guarantee, that 7z exists on system where
-        # test will run
-        with open('supported-archive.7z', 'w') as fobj:
-            fobj.write("\n")
-        self.assertFalse(utils.extract_archive('supported-archive.7z'))
+        operate.reset_mock()
+        operate.return_value = False
+        self.assertFalse(utils.create_archive('arch.7z', 'MyFoo',
+                                              ['foo', 'bar']))
+        operate.assert_called_once_with('arch.7z', 'create',
+                                        "Creating archive for `MyFoo'. Please"
+                                        " be patient", ['foo', 'bar'])

    @mock.patch('fs_uae_wrapper.path.which')
    @mock.patch('fs_uae_wrapper.file_archive.Archive.extract')
@@ -179,6 +165,37 @@ class TestUtils(TestCase):
        self.assertDictEqual(conf, {'foo': '1', 'bar': 'zip'})
        self.assertDictEqual(other, {'foo': '2', 'baz': '3'})

+    @mock.patch('subprocess.call')
+    def test_run_command(self, call):
+        call.return_value = 0
+        self.assertTrue(utils.run_command(['ls']))
+        call.assert_called_once_with(['ls'])
+
+        call.reset_mock()
+        self.assertTrue(utils.run_command('ls -l'))
+        call.assert_called_once_with(['ls', '-l'])
+
+        call.return_value = 1
+        call.reset_mock()
+        self.assertFalse(utils.run_command(['ls', '-l']))
+        call.assert_called_once_with(['ls', '-l'])
+
+        call.reset_mock()
+        self.assertFalse(utils.run_command('ls'))
+        call.assert_called_once_with(['ls'])
+
+    @mock.patch('os.path.exists')
+    def test_get_config(self, exists):
+        exists.return_value = False
+
+        os.chdir(self.dirname)
+        self.assertDictEqual(utils.get_config('foo'), {})
+
+        with open('conf.fs-uae', 'w') as fobj:
+            fobj.write("[conf]\nwrapper=foo\n")
+        self.assertDictEqual(utils.get_config('conf.fs-uae'),
+                             {'wrapper': 'foo'})
+

 class TestCmdOptions(TestCase):

@@ -212,33 +229,43 @@ class TestCmdOptions(TestCase):
        self.assertListEqual(sorted(cmd.list()),
                             ['--fast_memory=4096', '--fullscreen'])

+    @mock.patch('os.path.exists')
    @mock.patch('os.getenv')
    @mock.patch('os.path.expandvars')
-    @mock.patch('distutils.spawn.find_executable')
-    def test_interpolate_variables(self, find_exe, expandv, getenv):
+    @mock.patch('shutil.which')
+    def test_interpolate_variables(self, which, expandv, getenv, os_exists):

+        os_exists.return_value = True
        itrpl = utils.interpolate_variables

-        string = 'foo = $CONFIG/../path/to/smth'
+        string = '$CONFIG/../path/to/smth'
        self.assertEqual(itrpl(string, '/home/user/Config.fs-uae'),
-                         'foo = /home/user/../path/to/smth')
-        string = 'bar = $HOME'
+                         '/home/path/to/smth')
+        string = '$HOME'
        expandv.return_value = '/home/user'
        self.assertEqual(itrpl(string, '/home/user/Config.fs-uae'),
-                         'bar = /home/user')
+                         '/home/user')

-        string = 'foo = $APP/$EXE'
-        find_exe.return_value = '/usr/bin/fs-uae'
+        string = '$APP/$EXE'
+        which.return_value = '/usr/bin/fs-uae'
        self.assertEqual(itrpl(string, '/home/user/Config.fs-uae'),
-                         'foo = /usr/bin/fs-uae//usr/bin/fs-uae')
+                         '/usr/bin/fs-uae//usr/bin/fs-uae')

-        string = 'docs = $DOCUMENTS'
+        string = '$DOCUMENTS'
        getenv.return_value = '/home/user/Docs'
        self.assertEqual(itrpl(string, '/home/user/Config.fs-uae'),
-                         'docs = /home/user/Docs')
+                         '/home/user/Docs')

-        string = 'baz = $BASE'
+        string = '$BASE'
        self.assertEqual(itrpl(string, '/home/user/Config.fs-uae'),
-                         'baz = $BASE')
+                         '$BASE')
        self.assertEqual(itrpl(string, '/home/user/Config.fs-uae', 'base'),
-                         'baz = base')
+                         'base')
+
+    @mock.patch('os.getenv')
+    @mock.patch('os.path.expandvars')
+    def test_interpolate_variables_path_not_exists(self, expandv, getenv):
+        itrpl = utils.interpolate_variables
+
+        string = '$CONFIG/../path/to/smth'
+        self.assertEqual(itrpl(string, '/home/user/Config.fs-uae'), string)
--- a/tests/test_whdload.py
+++ b/tests/test_whdload.py
@@ -0,0 +1,233 @@
+import os
+import shutil
+from tempfile import mkdtemp
+from unittest import TestCase, mock
+
+from fs_uae_wrapper import utils, whdload
+
+
+class TestWHDLoad(TestCase):
+
+    def setUp(self):
+        self.dirname = mkdtemp()
+        self.curdir = os.path.abspath(os.curdir)
+        os.chdir(self.dirname)
+
+    def tearDown(self):
+        os.chdir(self.curdir)
+        try:
+            shutil.rmtree(self.dirname)
+        except OSError:
+            pass
+
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._validate_options')
+    def test_validate_options_arch_validation_fail(self, base_valid):
+
+        base_valid.return_value = False
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        self.assertFalse(wrapper._validate_options())
+
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._validate_options')
+    def test_validate_options_no_base_image(self, base_valid):
+
+        base_valid.return_value = True
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        self.assertFalse(wrapper._validate_options())
+
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._validate_options')
+    def test_validate_options_with_base_image_set(self, base_valid):
+
+        base_valid.return_value = True
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        wrapper.all_options['wrapper_whdload_base'] = 'fake_base_fname.7z'
+        self.assertTrue(wrapper._validate_options())
+
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase.run')
+    def test_run_base_run_fail(self, run):
+
+        run.return_value = False
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        self.assertFalse(wrapper.run())
+
+    @mock.patch('fs_uae_wrapper.whdload.Wrapper._extract')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase.run')
+    def test_run_extract_fail(self, run, extract):
+
+        run.return_value = True
+        extract.return_value = False
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        wrapper.all_options = {'wrapper': 'whdload',
+                               'wrapper_archive': 'fake.tgz',
+                               'wrapper_archiver': 'rar'}
+        self.assertFalse(wrapper.run())
+
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._copy_conf')
+    @mock.patch('fs_uae_wrapper.whdload.Wrapper._extract')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase.run')
+    def test_run_copy_conf_fail(self, run, extract, copy_conf):
+
+        run.return_value = True
+        extract.return_value = True
+        copy_conf.return_value = False
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        self.assertFalse(wrapper.run())
+
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._run_emulator')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._copy_conf')
+    @mock.patch('fs_uae_wrapper.whdload.Wrapper._extract')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase.run')
+    def test_run_emulator_fail(self, run, extract, copy_conf, run_emulator):
+
+        run.return_value = True
+        extract.return_value = True
+        copy_conf.return_value = True
+        run_emulator.return_value = False
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        self.assertFalse(wrapper.run())
+
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._run_emulator')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._copy_conf')
+    @mock.patch('fs_uae_wrapper.whdload.Wrapper._extract')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase.run')
+    def test_run_success(self, run, extract, copy_conf, run_emulator):
+
+        run.return_value = True
+        extract.return_value = True
+        copy_conf.return_value = True
+        run_emulator.return_value = True
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        self.assertTrue(wrapper.run())
+
+    @mock.patch('os.path.exists')
+    def test_extract_nonexistent_image(self, exists):
+        exists.return_value = False
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        wrapper.fsuae_options['wrapper_whdload_base'] = 'fakefilename'
+        self.assertFalse(wrapper._extract())
+
+    @mock.patch('os.chdir')
+    @mock.patch('os.path.exists')
+    def test_extract_extraction_failed(self, exists, chdir):
+        exists.return_value = True
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        wrapper.fsuae_options['wrapper_whdload_base'] = 'fakefilename.7z'
+        self.assertFalse(wrapper._extract())
+
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._extract')
+    @mock.patch('fs_uae_wrapper.utils.extract_archive')
+    @mock.patch('os.chdir')
+    @mock.patch('os.path.exists')
+    def test_extract_extraction_of_whdload_arch_failed(self, exists, chdir,
+                                                       image_extract,
+                                                       arch_extract):
+        exists.return_value = True
+        image_extract.return_value = True
+        arch_extract.return_value = False
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        wrapper.fsuae_options['wrapper_whdload_base'] = 'fakefilename'
+        self.assertFalse(wrapper._extract())
+
+    @mock.patch('fs_uae_wrapper.whdload.Wrapper._find_slave')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._extract')
+    @mock.patch('fs_uae_wrapper.utils.extract_archive')
+    @mock.patch('os.chdir')
+    @mock.patch('os.path.exists')
+    def test_extract_slave_not_found(self, exists, chdir, image_extract,
+                                     arch_extract, find_slave):
+        exists.return_value = True
+        image_extract.return_value = True
+        arch_extract.return_value = True
+        find_slave.return_value = False
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        wrapper.fsuae_options['wrapper_whdload_base'] = 'fakefilename'
+        self.assertFalse(wrapper._extract())
+
+    @mock.patch('fs_uae_wrapper.whdload.Wrapper._find_slave')
+    @mock.patch('fs_uae_wrapper.base.ArchiveBase._extract')
+    @mock.patch('fs_uae_wrapper.utils.extract_archive')
+    @mock.patch('os.chdir')
+    @mock.patch('os.path.exists')
+    def test_extract_success(self, exists, chdir, image_extract, arch_extract,
+                             find_slave):
+        exists.return_value = True
+        image_extract.return_value = True
+        arch_extract.return_value = True
+        find_slave.return_value = True
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        wrapper.fsuae_options['wrapper_whdload_base'] = 'fakefilename'
+        self.assertTrue(wrapper._extract())
+
+    @mock.patch('os.walk')
+    @mock.patch('os.chdir')
+    def test_find_slave_no_slave_file(self, chdir, walk):
+        walk.return_value = [(".", ('game'), ()),
+                             ('./game', (), ('foo', 'bar', 'baz'))]
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        self.assertFalse(wrapper._find_slave())
+
+    @mock.patch('os.listdir')
+    @mock.patch('os.walk')
+    @mock.patch('os.chdir')
+    def test_find_slave_no_corresponding_icon(self, chdir, walk, listdir):
+        contents = ('foo', 'bar', 'baz.slave')
+        walk.return_value = [(".", ('game'), ()),
+                             ('./game', (), contents)]
+        listdir.return_value = contents
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        self.assertFalse(wrapper._find_slave())
+
+    @mock.patch('os.listdir')
+    @mock.patch('os.walk')
+    @mock.patch('os.chdir')
+    def test_find_slave_success(self, chdir, walk, listdir):
+        contents = ('foo', 'bar', 'baz.slave', 'baz.info')
+        _open = mock.mock_open()
+        walk.return_value = [(".", ('C', 'S', 'game'), ()),
+                             ('./C', (), ('Assign', 'kgiconload')),
+                             ('./S', (), ()),
+                             ('./game', (), contents)]
+        listdir.return_value = contents
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        with mock.patch('builtins.open', _open):
+            self.assertTrue(wrapper._find_slave())
+        handle = _open()
+        handle.write.assert_called_once_with('cd game\n'
+                                             'C:kgiconload baz.info\n')
+
+    @mock.patch('os.listdir')
+    @mock.patch('os.walk')
+    @mock.patch('os.chdir')
+    def test_find_slave_minial(self, chdir, walk, listdir):
+        contents = ('foo', 'bar', 'baz.slave', 'baz.info')
+        _open = mock.mock_open()
+        walk.return_value = [(".", ('C', 'S', 'game'), ()),
+                             ('./C', (), ('Assign', 'WHDLoad')),
+                             ('./S', (), ()),
+                             ('./game', (), contents)]
+        listdir.return_value = contents
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        with mock.patch('builtins.open', _open):
+            self.assertTrue(wrapper._find_slave())
+        handle = _open()
+        handle.write.assert_called_once_with('cd game\nC:whdload Preload '
+                                             'Slave=baz.slave\n')
+
+    @mock.patch('os.listdir')
+    @mock.patch('os.walk')
+    @mock.patch('os.chdir')
+    def test_find_custom_options(self, chdir, walk, listdir):
+        contents = ('foo', 'bar', 'baz.slave', 'baz.info')
+        _open = mock.mock_open()
+        walk.return_value = [(".", ('C', 'S', 'game'), ()),
+                             ('./C', (), ('Assign', 'WHDLoad')),
+                             ('./S', (), ()),
+                             ('./game', (), contents)]
+        listdir.return_value = contents
+        wrapper = whdload.Wrapper('Config.fs-uae', utils.CmdOption(), {})
+        whdl_opts = 'Preload SplashDelay=0 MMU PAL'
+        wrapper.all_options['wrapper_whdload_options'] = whdl_opts
+        with mock.patch('builtins.open', _open):
+            self.assertTrue(wrapper._find_slave())
+        handle = _open()
+        handle.write.assert_called_once_with(f'cd game\nC:whdload {whdl_opts} '
+                                             'Slave=baz.slave\n')
--- a/tests/test_wrapper.py
+++ b/tests/test_wrapper.py
@@ -1,13 +1,8 @@
 import os
-import sys
-from tempfile import mkstemp, mkdtemp
-from unittest import TestCase
 import shutil
-
-try:
-    from unittest import mock
-except ImportError:
-    import mock
+import sys
+from tempfile import mkdtemp, mkstemp
+from unittest import TestCase, mock

 from fs_uae_wrapper import wrapper

@@ -28,7 +23,7 @@ class TestWrapper(TestCase):
        os.unlink(self.fname)
        sys.argv = self._argv[:]

-    @mock.patch('fs_uae_wrapper.plain.run')
+    @mock.patch('fs_uae_wrapper.plain.Wrapper.run')
    def test_run(self, mock_plain_run):

        sys.argv.append('--help')
@@ -47,10 +42,7 @@ class TestWrapper(TestCase):
            fobj.write('\n')

        wrapper.run()
-        mock_plain_run.called_once_with('Config.fs-uae',
-                                        ['--fullscreen',
-                                         '--fade_out_duration=0'],
-                                        [])
+        mock_plain_run.assert_called_once()

        # This will obviously fail for nonexistent module
        sys.argv.append('--wrapper=dummy_wrapper')
@@ -67,11 +59,13 @@ class TestWrapper(TestCase):
    def test_parse_args(self):

        # Looking for configuration file... first, we have nothing
-        self.assertEqual(wrapper.parse_args(), (None, {}))
+        self.assertEqual(wrapper.parse_args(),
+                         (None, {'wrapper_verbose': 0, 'wrapper_quiet': 0}))

        # still no luck - nonexistent file
        sys.argv.append('there-is-no-config.fs-uae')
-        self.assertEqual(wrapper.parse_args(), (None, {}))
+        self.assertEqual(wrapper.parse_args(),
+                         (None, {'wrapper_verbose': 0, 'wrapper_quiet': 0}))

        # lets make it
        os.chdir(self.dirname)
@@ -79,7 +73,8 @@ class TestWrapper(TestCase):
            fobj.write('\n')

        self.assertEqual(wrapper.parse_args(),
-                         ('there-is-no-config.fs-uae', {}))
+                         ('there-is-no-config.fs-uae',
+                          {'wrapper_verbose': 0, 'wrapper_quiet': 0}))

        # remove argument, try to find default one
        sys.argv.pop()
@@ -88,7 +83,9 @@ class TestWrapper(TestCase):
        with open('Config.fs-uae', 'w') as fobj:
            fobj.write('\n')

-        self.assertEqual(wrapper.parse_args(), ('Config.fs-uae', {}))
+        self.assertEqual(wrapper.parse_args(),
+                         ('Config.fs-uae',
+                          {'wrapper_verbose': 0, 'wrapper_quiet': 0}))

        # add --wrapper-foo and --wrapper-bar options
        sys.argv.extend(['--wrapper=plain', '--wrapper_foo=1',
@@ -104,7 +101,9 @@ class TestWrapper(TestCase):
        self.assertEqual(conf, 'Config.fs-uae')
        self.assertDictEqual(fsopts, {'wrapper': 'plain',
                                      'wrapper_foo': '1',
-                                      'wrapper_bar': 'false'})
+                                      'wrapper_bar': 'false',
+                                      'wrapper_verbose': 0,
+                                      'wrapper_quiet': 0})

        # mix wrapper* params in commandline and config
        sys.argv = ['fs-uae-wrapper',
@@ -120,4 +119,6 @@ class TestWrapper(TestCase):
        self.assertDictEqual(fsopts, {'wrapper': 'plain',
                                      'wrapper_bar': 'false',
                                      'fullscreen': '1',
-                                      'fast_memory': '4096'})
+                                      'fast_memory': '4096',
+                                      'wrapper_verbose': 0,
+                                      'wrapper_quiet': 0})
--- a/tox.ini
+++ b/tox.ini
@@ -1,5 +1,5 @@
 [tox]
-envlist = py27,py34,py27-flake8,py34-flake8
+envlist = py3,py3-flake8

 usedevelop = True

@@ -8,18 +8,14 @@ usedevelop=True
 setenv = COVERAGE_FILE = .coverage
 commands = py.test --cov=fs_uae_wrapper --cov-report=term-missing

-deps = -r{toxinidir}/test-requirements.txt
+deps =
+    pytest
+    pytest-cov
+    pytest-pep8
+    coverage
+    flake8

-[testenv:py27]
-deps = {[testenv]deps}
-       mock
-
-[testenv:py34-flake8]
-basepython = python3.4
-deps = flake8
-commands = flake8 {posargs}
-
-[testenv:py27-flake8]
-basepython = python2.7
+[testenv:py3-flake8]
+basepython = python3
 deps = flake8
 commands = flake8 {posargs}
Author	SHA1	Message	Date
gryf	7b0ef15eae	Added dummy message class for systems with python without tk	2026-01-10 18:48:41 +01:00
gryf	59bd1b6029	Make tempfile prefixed with fs-uae-wrapper string. Also, included test requirements into tox file, and fixed docs.	2025-09-25 18:50:28 +02:00
gryf	f5e6471555	Removed license classifier in favor of SPDX entry.	2025-04-18 16:05:37 +02:00
gryf	4c61c3d7ea	Fix user provided whdload options	2024-09-14 17:00:28 +02:00
gryf	7e3d68624f	Fixed packages find in pyproject	2024-09-14 15:59:25 +02:00
gryf	f311605019	Take version from git tag.	2024-09-14 11:49:44 +02:00
gryf	418e480fb5	Fixes for readme	2024-09-14 11:34:33 +02:00
gryf	118d758ec7	Trailing space	2024-09-14 10:57:50 +02:00
gryf	3b597e34ee	Fix some lint errors and warnings	2024-09-14 10:53:58 +02:00
gryf	7b40974779	Fixed imports order	2024-09-14 09:22:41 +02:00
gryf	b4ab8ac4f5	Change GH action icon location	2024-09-13 21:29:54 +02:00
gryf	8d8d38d5c0	Move from travis to gh actions	2024-09-13 21:27:40 +02:00
gryf	bd0aa3dee4	Changed name for the tests workflow	2024-09-13 21:25:00 +02:00
Roman Dobosz	d2a9f39fd9	Create python-app.yml	2024-09-13 21:02:58 +02:00
gryf	f1f64cf4d4	Added WHDLoad support	2024-09-13 18:18:35 +02:00
gryf	a5606272cd	Fix unit tests	2024-09-13 18:16:45 +02:00
gryf	463f6ed705	Fixed deduction of archive name. When in different directory, the archive name and config need to be treated differently. This commit unify behavior for both cases. Also, changing a bit logging format and added some more debugging messages.	2024-09-12 20:29:34 +02:00
gryf	148d28dac2	Make archive name and archiver for savestate optional.	2024-09-11 21:23:49 +02:00
gryf	60139d1728	Move to pyproject.	2024-09-11 19:53:52 +02:00
gryf	68b1f2a787	Correct homepage in setup.cfg	2022-10-02 14:57:38 +02:00
gryf	75d2cff96c	Drop Python2 support.	2022-09-02 19:01:56 +02:00
gryf	114984cbee	Go with setup.cfg instead of setup.py.	2022-09-02 18:47:17 +02:00
gryf	b015e443eb	Fix tests for file path calculations	2021-05-02 09:36:14 +02:00
gryf	874213aef9	Prevent from nonexistent paths in config. In case of defining paths in config, which wrapper is trying to normalize, sometimes it may happen, that paths can be either local or remote - depending on the intention, i.e. one can add: cdrom_drive_0: foo.iso where foo can be either an unpacked file or just some companion image, which exists within config file. In this patch calculated path is checked against file existence, and if it doesn't exists, original value is preserved.	2021-03-20 13:12:58 +01:00
gryf	1559591417	Changed python3 interpreter to default. Currently, as a python3 interpreter, specific version has been chosen. As fs-uae-wrapper doesn't use any special features from latest version of the python3, it doesn't make sense to have fixed version of it. Just let operating system pick right python 3 interpreter.	2019-10-06 18:09:32 +02:00
gryf	193e487bb9	Fix download link and typo in readme	2017-06-19 19:55:02 +02:00
gryf	eb9012f3fa	Readme update	2017-01-12 21:09:12 +01:00
gryf	efbb5f6f05	Readme update	2017-01-09 06:41:16 +01:00
gryf	00e3cf9801	Introduced new configuration variable $WRAPPER Calculation of file path may be performed in two different places - first is the original location of the config file, second is on copied one. Adding new option WRAPPER will take the same role as $CONFIG, except it will be only parsed on copied configuration file. An alternative would be to check existence in both places, but I'd like to have it explicit.	2017-01-08 19:40:27 +01:00
gryf	388a8cc835	Fix for interpolate_variables function	2017-01-08 15:38:59 +01:00
gryf	83185011aa	Fix for config options containing HOME variable	2017-01-08 15:37:29 +01:00
gryf	152446abbe	Use logging for displaying messages Also added debug logs	2017-01-08 13:58:47 +01:00
gryf	a918e4c9ff	Added logging module	2017-01-08 13:17:41 +01:00
gryf	7931022777	Additional tests for util module	2017-01-08 12:35:51 +01:00
gryf	1a67b355ae	Removed unused run function from savestate wrapper	2017-01-08 12:01:25 +01:00
gryf	6a026ecff1	Fix for typo in attribute name	2017-01-08 11:59:43 +01:00
gryf	bd0e3ea56a	Added more tests for file_archive module	2017-01-08 11:56:40 +01:00
gryf	8a6ddda7c8	Make plain wrapper module use base.Base class	2017-01-08 11:21:43 +01:00
gryf	a14871c52f	Get rid of run function for every wrapper module	2017-01-08 11:20:33 +01:00
gryf	8528d28a42	Get rid of unneeded _run_emulator parameter	2017-01-08 11:17:37 +01:00
gryf	ab4042f880	Refactor wrapper modules to have a main class with the same name	2017-01-07 13:13:18 +01:00
gryf	8892940339	Normalize paths for config options Removing _kickstart_option in favor of _normalize_options method to detect and replace relative paths with absolute ones. Dictionary with changed options lands as a commandline switches for fs-uae during execution.	2017-01-07 13:13:06 +01:00