diff --git a/src/scancode/cli.py b/src/scancode/cli.py
index ede8d89844b..fffc882d289 100644
--- a/src/scancode/cli.py
+++ b/src/scancode/cli.py
@@ -28,22 +28,28 @@
 from functools import partial
 import json
 import os
+from types import GeneratorType
 
 import click
+from click.termui import style
 
-from commoncode import ignore, fileutils
+from commoncode import ignore
 from commoncode.fileutils import resource_iter
+from commoncode import fileutils
 
 from scancode import __version__ as version
-from scancode.api import as_html
-from scancode.api import as_html_app
-from scancode.api import create_html_app_assets
-from scancode.api import extract_archives
+from scancode import utils
+
+from scancode.format import as_html
+from scancode.format import as_html_app
+from scancode.format import create_html_app_assets
+from scancode.format import HtmlAppAssetCopyWarning
+from scancode.format import HtmlAppAssetCopyError
+
 from scancode.api import get_copyrights
 from scancode.api import get_licenses
-from scancode.api import HtmlAppAssetCopyWarning
-from scancode.api import HtmlAppAssetCopyError
 from scancode.api import get_file_infos
+from scancode.api import get_package_infos
 
 
 info_text = '''
@@ -156,20 +162,7 @@ def print_about(ctx, param, value):
 
     scancode -f json -l -c samples/zlib/ > scan.json
 
-Extract all archives found in the 'samples' directory tree:
-
-    scancode --extract samples
-
-Note: If an archive contains other archives, all contained archives will be
-extracted recursively. Extraction is done directly in the 'samples' directory,
-side-by-side with each archive. Files are extracted in a directory named after
-the archive with an '-extract' suffix added to its name, created side-by-side
-with the corresponding archive file.
-
-Extract a single archive. Files are extracted in the directory
-'samples/arch/zlib.tar.gz-extract/':
-
-    scancode --extract samples/arch/zlib.tar.gz
+To extract archives, see the 'extractcode' command instead.
 '''
 
 
@@ -207,179 +200,146 @@ def print_version(ctx, param, value):
 '''
 
 
-short_help = '''
+class ScanCommand(utils.BaseCommand):
+    short_usage_help = '''
 Try 'scancode --help' for help on options and arguments.'''
 
 
 formats = ['json', 'html', 'html-app']
 
 
-class ScanCommand(click.Command):
-    def get_usage(self, ctx):
-        """
-        Ensure that usage points to the --help option explicitly.
-        Workaround click issue https://github.com/mitsuhiko/click/issues/393
-        """
-        return click.Command.get_usage(self, ctx) + short_help
-
-    def main(self, args=None, prog_name=None, complete_var=None,
-             standalone_mode=True, **extra):
-        """
-        Workaround click 4.0 bug https://github.com/mitsuhiko/click/issues/365
-        """
-        return click.Command.main(self, args=args, prog_name=self.name,
-                                  complete_var=complete_var,
-                                  standalone_mode=standalone_mode, **extra)
-
-
 @click.command(name='scancode', epilog=epilog_text, cls=ScanCommand)
 @click.pass_context
+
 @click.argument('input', metavar='<input>', type=click.Path(exists=True, readable=True))
 @click.argument('output_file', default='-', metavar='<output_file>', type=click.File('wb'))
+
 @click.option('-c', '--copyright', is_flag=True, default=False, help='Scan <input> for copyrights. [default]')
 @click.option('-l', '--license', is_flag=True, default=False, help='Scan <input> for licenses. [default]')
-@click.option('-i', '--info', is_flag=True, default=False, help='Collect files information from  <input>.')
-@click.option('-f', '--format', metavar='<style>', type=click.Choice(formats),
-              default='json', show_default=True,
-              help='Set <output_file> format <style> to one of: %s' % ' or '.join(formats),
-              )
-@click.option('-e', '--extract', is_flag=True, default=False, is_eager=True,
-              help=('Extract any archives and compressed files found in <input> recursively, in-place, ignoring other scan options. Use this before scanning proper, as an <input> preparation step.'))
+@click.option('-p', '--package', is_flag=True, default=False, help='Scan <input> for packages. [default]')
+@click.option('-i', '--info', is_flag=True, default=False, help='Scan <input> for files information.')
+
+@click.option('-f', '--format', is_flag=False, default='json', show_default=True, metavar='<style>', type=click.Choice(formats),
+              help='Set <output_file> format <style> to one of: %s' % ' or '.join(formats),)
 @click.option('--verbose', is_flag=True, default=False, help='Print verbose file-by-file progress messages.')
+
 @click.help_option('-h', '--help')
-@click.option('--examples', is_flag=True, is_eager=True, callback=print_examples,
-              help=('Show command examples and exit.'))
-@click.option('--about', is_flag=True, is_eager=True, callback=print_about,
-              help=('Show information about ScanCode and licensing and exit.'))
-@click.option('--version', is_flag=True, is_eager=True, callback=print_version,
-              help=('Show the version and exit.'))
-def scancode(ctx, input, output_file, extract, copyright, license, info, format, verbose, *args, **kwargs):  # @ReservedAssignment
+@click.option('--examples', is_flag=True, is_eager=True, callback=print_examples, help=('Show command examples and exit.'))
+@click.option('--about', is_flag=True, is_eager=True, callback=print_about, help='Show information about ScanCode and licensing and exit.')
+@click.option('--version', is_flag=True, is_eager=True, callback=print_version, help='Show the version and exit.')
+
+def scancode(ctx, input, output_file, copyright, license, package,  # @ReservedAssignment
+             info, format, verbose, *args, **kwargs):  # @ReservedAssignment
     """scan the <input> file or directory for origin and license and save results to the <output_file>.
 
     The scan results are printed on terminal if <output_file> is not provided.
     """
+
     abs_input = os.path.abspath(os.path.expanduser(input))
-    scans = [copyright, license, info]
-    if extract:
-        if any(scans):
-            # exclusive, ignoring other options.
-            # FIXME: this should turned into  a sub-command
-            ctx.fail('''The '--extract' option cannot be combined with other scanning options.
-Use the '--extract' option alone to extract archives found in  <input>.
-then run scancode again to scan the extracted files.''')
-            ctx.exit(1)
-
-        click.secho('Extracting archives...', fg='green')
-        extract_with_progress(abs_input, verbose)
-        click.secho('Extracting done.', fg='green')
-        return
+    scans = [copyright, license, package, info]
 
     # Default scan when no options is provided
     if not any(scans):
         copyright = True  # @ReservedAssignment
         license = True  # @ReservedAssignment
+        package = True
+
+    # note: "flag and function" expressions return the function if flag is True
+    scans = {
+        'copyrights': copyright and get_copyrights,
+        'licenses': license and get_licenses,
+        'packages': package and get_package_infos,
+        'infos': info and get_file_infos,
+    }
+
+    results = []
+
+    # note: we inline progress display functions to close on some args
+
+    def scan_start():
+        """Progress event displayed at start of scan"""
+        return style('Scanning files...', fg='green')
+
+
+    def scan_event(item):
+        """Progress event displayed each time a file is scanned"""
+        if item:
+            line = verbose and item or fileutils.file_name(item) or ''
+            return 'Scanning: %(line)s' % locals()
+
+
+    def scan_end():
+        """Progress event displayed at end of scan"""
+        has_warnings = False
+        has_errors = False
+        summary = []
+        summary_color = 'green'
+        summary_color = has_warnings and 'yellow' or summary_color
+        summary_color = has_errors and 'red' or summary_color
+        summary.append(style('Scanning done.', fg=summary_color, reset=True))
+        return '\n'.join(summary)
+
+
+    ignored = partial(ignore.is_ignored, ignores=ignore.ignores_VCS, unignores={})
+    resources = resource_iter(abs_input, ignored=ignored)
+
+    with utils.progressmanager(resources,
+                               item_show_func=scan_event,
+                               start_show_func=scan_start,
+                               finish_show_func=scan_end,
+                               verbose=verbose,
+                               show_pos=True,
+                               ) as progressive_resources:
+
+        for resource in progressive_resources:
+            res = fileutils.as_posixpath(resource)
+            results.append(scan_one(res, scans))
+
+    # TODO: eventually merge scans for the same resource location...
+    # TODO: fix absolute paths as relative to original input argument...
+
+    save_results(results, format, input, output_file)
+
 
-    if copyright or license or info:
-        click.secho('Scanning files...', fg='green')
-        results = []
-
-        ignored = partial(ignore.is_ignored, ignores=ignore.ignores_VCS, unignores={})
-        files = resource_iter(abs_input, ignored=ignored)
-
-        if not verbose:
-            # only display a progress bar
-            with click.progressbar(files, show_pos=True) as files:
-                for input_file in files:
-                    input_file = fileutils.as_posixpath(input_file)
-                    results.append(scan_one(input_file, copyright, license, info, verbose))
-        else:
-            for input_file in files:
-                input_file = fileutils.as_posixpath(input_file)
-                results.append(scan_one(input_file, copyright, license, info, verbose))
-
-        if format == 'html':
-            output_file.write(as_html(results))
-
-        elif format == 'html-app':
-            output_file.write(as_html_app(results, input, output_file))
-            try:
-                create_html_app_assets(output_file)
-            except HtmlAppAssetCopyWarning:
-                click.secho('\nHTML app creation skipped when printing to terminal.',
-                            fg='yellow')
-            except HtmlAppAssetCopyError:
-                click.secho('\nFailed to create HTML app.', fg='red')
-
-        elif format == 'json':
-            meta = OrderedDict()
-            meta['scancode_notice'] = acknowledgment_text_json
-            meta['scancode_version'] = version
-            meta['resource_count'] = len(results)
-            meta['results'] = results
-            output_file.write(json.dumps(meta, indent=2))
-        else:
-            # This should never happen by construction
-            raise Exception('Unknown format: ' + repr(format))
-        click.secho('Scanning done.', fg='green')
-
-
-def scan_one(input_file, copyright, license, info, verbose=False):  # @ReservedAssignment
+def scan_one(input_file, scans):
     """
-    Scan one file and return scanned data.
+    Scan one file or directory and return scanned data, calling every scan in
+    the scans mapping of (scan name -> scan function).
     """
-    if verbose:
-        click.secho('Scanning: %(input_file)s: ' % locals(), nl=False, fg='blue')
     data = OrderedDict()
     data['location'] = input_file
-    if copyright:
-        if verbose:
-            click.secho('copyrights. ', nl=False, fg='green')
-        data['copyrights'] = list(get_copyrights(input_file))
-    if license:
-        if verbose:
-            click.secho('licenses. ', nl=False, fg='green')
-        data['licenses'] = list(get_licenses(input_file))
-    if info:
-        if verbose:
-            click.secho('infos. ', nl=False, fg='green')
-        data['infos'] = get_file_infos(input_file)
-
-    if verbose:
-        click.secho('', nl=True)
+    for scan_name, scan_func in scans.items():
+        if scan_func:
+            scan = scan_func(input_file)
+            if isinstance(scan, GeneratorType):
+                scan = list(scan)
+            data[scan_name] = scan
     return data
 
 
-def extract_with_progress(input, verbose=False):  # @ReservedAssignment
+def save_results(results, format, input, output_file):  # @ReservedAssignment
     """
-    Extract archives and display progress.
+    Save results to file or screen.
     """
-    if verbose:
-        for xev in extract_archives(input, verbose=verbose):
-            if not xev.done:
-                click.secho('Extracting: ' + xev.source + ': ', nl=False, fg='green')
-            else:
-                if xev.warnings or xev.errors:
-                    click.secho('done.', fg='red' if xev.errors else 'yellow')
-                    display_extract_event(xev)
-                else:
-                    click.secho('done.', fg='green')
-    else:
-        extract_results = []
-        # only display a progress bar
-        with click.progressbar(extract_archives(input, verbose=verbose), show_pos=True) as extractions:
-            for xevent in extractions:
-                extract_results.append(xevent)
-        # display warnings/errors at the end
-        for xev in extract_results:
-            if xev.warnings or xev.errors:
-                if xev.warnings or xev.errors:
-                    click.secho('Extracting: ' + xev.source + ': ', nl=False, fg='green')
-                    click.secho('done.', fg='red' if xev.errors else 'yellow')
-                    display_extract_event(xev)
-
-
-def display_extract_event(xev):
-    for e in xev.errors:
-        click.secho('  ERROR: ' + e, fg='red')
-    for warn in xev.warnings:
-        click.secho('  WARNING: ' + warn, fg='yellow')
+    assert format in formats
+    if format == 'html':
+        output_file.write(as_html(results))
+
+    elif format == 'html-app':
+        output_file.write(as_html_app(results, input, output_file))
+        try:
+            create_html_app_assets(output_file)
+        except HtmlAppAssetCopyWarning:
+            click.secho('\nHTML app creation skipped when printing to terminal.',
+                       err=True, fg='yellow')
+        except HtmlAppAssetCopyError:
+            click.secho('\nFailed to create HTML app.', err=True, fg='red')
+
+    elif format == 'json':
+        meta = OrderedDict()
+        meta['scancode_notice'] = acknowledgment_text_json
+        meta['scancode_version'] = version
+        meta['resource_count'] = len(results)
+        # TODO: add scanning options to meta
+        meta['results'] = results
+        output_file.write(json.dumps(meta, indent=2))
diff --git a/tests/scancode/test_cli.py b/tests/scancode/test_cli.py
index 7c98ed120a5..91ae968c4ee 100644
--- a/tests/scancode/test_cli.py
+++ b/tests/scancode/test_cli.py
@@ -24,206 +24,168 @@
 
 from __future__ import absolute_import, print_function
 
-import os
+import codecs
 import json
+import os
 
+import click
 from click.testing import CliRunner
 
-from commoncode.testcase import FileBasedTesting
 from commoncode.fileutils import as_posixpath
+from commoncode.testcase import FileDrivenTesting
 
 from scancode import cli
-import codecs
 
 
-class TestCommandLine(FileBasedTesting):
-    test_data_dir = os.path.join(os.path.dirname(__file__), 'data')
-
-    def test_extract_option_is_exclusive_of_other_options(self):
-        test_dir = self.get_temp_dir()
-        runner = CliRunner()
-        result = runner.invoke(cli.scancode, ['--extract', '--copyright', test_dir])
-        assert result.exit_code == 2
-        assert 'option cannot be combined with other scanning options' in result.output
-
-        result = runner.invoke(cli.scancode, ['--copyright', '--extract', test_dir])
-        assert result.exit_code == 2
-        assert 'option cannot be combined with other scanning options' in result.output
-
-        result = runner.invoke(cli.scancode, ['--extract', '--license', test_dir])
-        assert result.exit_code == 2
-        assert 'option cannot be combined with other scanning options' in result.output
-
-        result = runner.invoke(cli.scancode, ['--extract', '--license', '--copyright', test_dir])
-        assert result.exit_code == 2
-        assert 'option cannot be combined with other scanning options' in result.output
-
-    def test_extract_option_can_take_an_empty_directory(self):
-        test_dir = self.get_temp_dir()
-        runner = CliRunner()
-        result = runner.invoke(cli.scancode, ['--extract', test_dir])
-        assert result.exit_code == 0
-        assert 'Extracting done' in result.output
-
-    def test_extract_option_does_extract(self):
-        test_dir = self.get_test_loc('extract', copy=True)
-        runner = CliRunner()
-        result = runner.invoke(cli.scancode, ['--extract', test_dir])
-        assert result.exit_code == 0
-        assert 'Extracting done' in result.output
-        assert 'ERROR: Unrecognized archive format' in result.output
-        assert os.path.exists(os.path.join(test_dir, 'some.tar.gz-extract'))
-
-    def test_extract_option_works_with_relative_paths(self):
-        # The setup is a tad complex because we want to have a relative dir
-        # to the base dir where we run tests from, ie the scancode-toolkit/ dir
-        # To use relative paths, we use our tmp dir at the root of the code
-        from os.path import dirname, join, abspath
-        from  commoncode import fileutils
-        import extractcode
-        import tempfile
-        import shutil
-
-        scancode_root = dirname(dirname(dirname(__file__)))
-        scancode_tmp = join(scancode_root, 'tmp')
-        fileutils.create_dir(scancode_tmp)
-        scancode_root_abs = abspath(scancode_root)
-        test_src_dir = tempfile.mkdtemp(dir=scancode_tmp).replace(scancode_root_abs, '').strip('\\/')
-        test_file = self.get_test_loc('extract_relative_path/basic.zip')
-        shutil.copy(test_file, test_src_dir)
-        test_src_file = join(test_src_dir, 'basic.zip')
-        test_tgt_dir = join(scancode_root, test_src_file) + extractcode.EXTRACT_SUFFIX
-
-        runner = CliRunner()
-        result = runner.invoke(cli.scancode, ['--extract', test_src_file])
-        assert result.exit_code == 0
-        assert 'Extracting done' in result.output
-        assert not 'WARNING' in result.output
-        assert not 'ERROR' in result.output
-        expected = ['/c/a/a.txt', '/c/b/a.txt', '/c/c/a.txt']
-        file_result = [as_posixpath(f.replace(test_tgt_dir, '')) for f in fileutils.file_iter(test_tgt_dir)]
-        assert sorted(expected) == sorted(file_result)
-
-    def test_copyright_option_detects_copyrights(self):
-        test_dir = self.get_test_loc('copyright', copy=True)
-        runner = CliRunner()
-        result_file = self.get_temp_file('json')
-        result = runner.invoke(cli.scancode, ['--copyright', test_dir, result_file])
-        assert result.exit_code == 0
-        assert 'Scanning done' in result.output
-        assert os.path.exists(result_file)
-        assert len(open(result_file).read()) > 10
-
-    def test_verbose_copyrights(self):
-        test_dir = self.get_test_loc('copyright', copy=True)
-        runner = CliRunner()
-        result_file = self.get_temp_file('json')
-        result = runner.invoke(cli.scancode, ['--copyright', '--verbose', test_dir, result_file])
-        assert result.exit_code == 0
-        assert 'Scanning done' in result.output
-        assert 'copyright_acme_c-c.c' in result.output
-        assert os.path.exists(result_file)
-        assert len(open(result_file).read()) > 10
-
-    def test_license_option_detects_licenses(self):
-        test_dir = self.get_test_loc('license', copy=True)
-        runner = CliRunner()
-        result_file = self.get_temp_file('json')
-        result = runner.invoke(cli.scancode, ['--license', test_dir, result_file])
-        assert result.exit_code == 0
-        assert 'Scanning done' in result.output
-        assert os.path.exists(result_file)
-        assert len(open(result_file).read()) > 10
-
-    def test_scancode_skip_vcs_files_and_dirs_by_default(self):
-        test_dir = self.extract_test_tar('ignore/vcs.tgz')
-        runner = CliRunner()
-        result_file = self.get_temp_file('json')
-        result = runner.invoke(cli.scancode, ['--copyright', test_dir, result_file])
-        assert result.exit_code == 0
-        scan_result = self.load_json_result(result_file, test_dir)
-        # a single test.tst file and its directory that is not a VCS file should be listed
-        assert 2 == scan_result['resource_count']
-        scan_locs = [x['location'] for x in scan_result['results']]
-        assert [u'vcs', u'vcs/test.txt'] == scan_locs
-
-    def load_json_result(self, result_file, test_dir):
-        """
-        Load the result file as utf-8 JSON and strip test_dir prefix from
-        locations.
-        Sort the results by location.
-        """
-        test_dir = as_posixpath(test_dir)
-        with codecs.open(result_file, encoding='utf-8') as res:
-            scan_result = json.load(res)
-            for result in scan_result['results']:
-                loc = result['location']
-                loc = as_posixpath(loc).replace(test_dir, '').strip('/')
-                result['location'] = loc
-        scan_result['results'].sort(key=lambda x: x['location'])
-        return scan_result
-
-    def test_usage_and_help_return_a_correct_script_name_on_all_platforms(self):
-        runner = CliRunner()
-        result = runner.invoke(cli.scancode, ['--help'])
-        assert 'Usage: scancode [OPTIONS]' in result.output
-        # this was showing up on Windows
-        assert 'scancode-script.py' not in result.output
-
-        result = runner.invoke(cli.scancode, [])
-        assert 'Usage: scancode [OPTIONS]' in result.output
-        # this was showing up on Windows
-        assert 'scancode-script.py' not in result.output
-
-        result = runner.invoke(cli.scancode, ['-xyz'])
-        # this was showing up on Windows
-        assert 'scancode-script.py' not in result.output
-
-    def test_info_collect_infos(self):
-        test_dir = self.extract_test_tar('info/basic.tgz')
-        runner = CliRunner()
-        result_file = self.get_temp_file('json')
-        result = runner.invoke(cli.scancode, ['--info', test_dir, result_file])
-        assert result.exit_code == 0
-        assert 'Scanning done' in result.output
-        expected = self.load_json_result(self.get_test_loc('info/basic.expected.json'), test_dir)
-        loaded_result = self.load_json_result(result_file, test_dir)
-        assert expected == loaded_result
-
-    def test_info_license_copyrights(self):
-        test_dir = self.extract_test_tar('info/basic.tgz')
-        runner = CliRunner()
-        result_file = self.get_temp_file('json')
-        result = runner.invoke(cli.scancode, ['--info', '--license', '--copyright', test_dir, result_file])
-        assert result.exit_code == 0
-        assert 'Scanning done' in result.output
-        expected = self.load_json_result(self.get_test_loc('info/all.expected.json'), test_dir)
-        loaded_result = self.load_json_result(result_file, test_dir)
-        assert expected == loaded_result
-
-    def test_paths_are_posix_in_html_app_format_output(self):
-        test_dir = self.get_test_loc('posix_path', copy=True)
-        runner = CliRunner()
-        result_file = self.get_temp_file('html')
-        result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'html-app', test_dir, result_file])
-        assert result.exit_code == 0
-        assert 'Scanning done' in result.output
-        assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
-
-    def test_paths_are_posix_in_html_format_output(self):
-        test_dir = self.get_test_loc('posix_path', copy=True)
-        runner = CliRunner()
-        result_file = self.get_temp_file('html')
-        result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'html', test_dir, result_file])
-        assert result.exit_code == 0
-        assert 'Scanning done' in result.output
-        assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
-
-    def test_paths_are_posix_in_json_format_output(self):
-        test_dir = self.get_test_loc('posix_path', copy=True)
-        runner = CliRunner()
-        result_file = self.get_temp_file('json')
-        result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'json', test_dir, result_file])
-        assert result.exit_code == 0
-        assert 'Scanning done' in result.output
-        assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
+test_env = FileDrivenTesting()
+test_env.test_data_dir = os.path.join(os.path.dirname(__file__), 'data')
+
+
+"""
+These CLI tests are dependent on py.test monkeypatch to  ensure we are testing
+the actual command outputs as if using a TTY or not.
+"""
+
+def load_json_result(result_file, test_dir):
+    """
+    Load the result file as utf-8 JSON and strip test_dir prefix from
+    locations.
+    Sort the results by location.
+    """
+    test_dir = as_posixpath(test_dir)
+    with codecs.open(result_file, encoding='utf-8') as res:
+        scan_result = json.load(res)
+        for result in scan_result['results']:
+            loc = result['location']
+            loc = as_posixpath(loc).replace(test_dir, '').strip('/')
+            result['location'] = loc
+    scan_result['results'].sort(key=lambda x: x['location'])
+    return scan_result
+
+
+def test_copyright_option_detects_copyrights(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.get_test_loc('copyright', copy=True)
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('json')
+    result = runner.invoke(cli.scancode, ['--copyright', test_dir, result_file])
+    assert result.exit_code == 0
+    assert 'Scanning done' in result.output
+    assert os.path.exists(result_file)
+    assert len(open(result_file).read()) > 10
+
+
+def test_verbose_option_with_copyrights(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.get_test_loc('copyright', copy=True)
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('json')
+    result = runner.invoke(cli.scancode, ['--copyright', '--verbose', test_dir, result_file])
+    assert result.exit_code == 0
+    assert 'Scanning done' in result.output
+    assert 'copyright_acme_c-c.c' in result.output
+    assert os.path.exists(result_file)
+    assert len(open(result_file).read()) > 10
+
+
+def test_license_option_detects_licenses(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.get_test_loc('license', copy=True)
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('json')
+    result = runner.invoke(cli.scancode, ['--license', test_dir, result_file])
+    assert result.exit_code == 0
+    assert 'Scanning done' in result.output
+    assert os.path.exists(result_file)
+    assert len(open(result_file).read()) > 10
+
+
+def test_scancode_skip_vcs_files_and_dirs_by_default(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.extract_test_tar('ignore/vcs.tgz')
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('json')
+    result = runner.invoke(cli.scancode, ['--copyright', test_dir, result_file])
+    assert result.exit_code == 0
+    scan_result = load_json_result(result_file, test_dir)
+    # a single test.tst file and its directory that is not a VCS file should be listed
+    assert 2 == scan_result['resource_count']
+    scan_locs = [x['location'] for x in scan_result['results']]
+    assert [u'vcs', u'vcs/test.txt'] == scan_locs
+
+
+def test_usage_and_help_return_a_correct_script_name_on_all_platforms(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    runner = CliRunner()
+    result = runner.invoke(cli.scancode, ['--help'])
+    assert 'Usage: scancode [OPTIONS]' in result.output
+    # this was showing up on Windows
+    assert 'scancode-script.py' not in result.output
+
+    result = runner.invoke(cli.scancode, [])
+    assert 'Usage: scancode [OPTIONS]' in result.output
+    # this was showing up on Windows
+    assert 'scancode-script.py' not in result.output
+
+    result = runner.invoke(cli.scancode, ['-xyz'])
+    # this was showing up on Windows
+    assert 'scancode-script.py' not in result.output
+
+
+def test_info_collect_infos(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.extract_test_tar('info/basic.tgz')
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('json')
+    result = runner.invoke(cli.scancode, ['--info', test_dir, result_file])
+    assert result.exit_code == 0
+    assert 'Scanning done' in result.output
+    expected = load_json_result(test_env.get_test_loc('info/basic.expected.json'), test_dir)
+    loaded_result = load_json_result(result_file, test_dir)
+    assert expected == loaded_result
+
+
+def test_info_license_copyrights(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.extract_test_tar('info/basic.tgz')
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('json')
+    result = runner.invoke(cli.scancode, ['--info', '--license', '--copyright', test_dir, result_file])
+    assert result.exit_code == 0
+    assert 'Scanning done' in result.output
+    expected = load_json_result(test_env.get_test_loc('info/all.expected.json'), test_dir)
+    loaded_result = load_json_result(result_file, test_dir)
+    assert expected == loaded_result
+
+
+def test_paths_are_posix_in_html_app_format_output(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.get_test_loc('posix_path', copy=True)
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('html')
+    result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'html-app', test_dir, result_file])
+    assert result.exit_code == 0
+    assert 'Scanning done' in result.output
+    assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
+
+
+def test_paths_are_posix_in_html_format_output(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.get_test_loc('posix_path', copy=True)
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('html')
+    result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'html', test_dir, result_file])
+    assert result.exit_code == 0
+    assert 'Scanning done' in result.output
+    assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()
+
+
+def test_paths_are_posix_in_json_format_output(monkeypatch):
+    monkeypatch.setattr(click._termui_impl, 'isatty', lambda _: True)
+    test_dir = test_env.get_test_loc('posix_path', copy=True)
+    runner = CliRunner()
+    result_file = test_env.get_temp_file('json')
+    result = runner.invoke(cli.scancode, [ '--copyright', '--format', 'json', test_dir, result_file])
+    assert result.exit_code == 0
+    assert 'Scanning done' in result.output
+    assert '/posix_path/copyright_acme_c-c.c' in open(result_file).read()