autoproj 2.0.0.b7 → 2.0.0.rc1

data/test/package_managers/test_pip.rb

@@ -1,42 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
-require 'test/unit'
-require 'autoproj'
-require 'flexmock/test_unit'
-
-class TC_OSDependencies_Pip < Test::Unit::TestCase
-    include Autoproj
-
-    attr_reader :pip_manager
-
-    def setup
-        Autoproj::OSDependencies.operating_system = [['test', 'debian', 'default'], ['v1.0', 'v1', 'default']]
-
-        @pip_manager = PackageManagers::PipManager.new
-        Autobuild.programs['pip'] = 'mypip'
-        super
-    end
-
-    def teardown
-        super
-        Autobuild.programs['pip'] = nil
-    end
-
-    def test_install_packages
-        subprocess = flexmock(Autobuild::Subprocess)
-
-        packages = ['pkg0', 'pkg1', 'pkg2']
-        subprocess.should_receive(:run).
-            with(any, any, 'mypip', 'install', '--user', 'pkg0', 'pkg1','pkg2').once
-        pip_manager.install(packages)
-    end
-
-    def test_install_packaes_disabled_and_not_silent
-        subprocess = flexmock(Autobuild::Subprocess)
-
-        pip_manager.enabled = false
-        pip_manager.silent = false
-        subprocess.should_receive(:run).never
-        flexmock(STDIN).should_receive(:readline).once.and_return
-        pip_manager.install([['pkg0']])
-    end
-end

data/test/test_manifest.rb

@@ -1,48 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
-require 'test/unit'
-require 'autoproj'
-require 'flexmock/test_unit'
-require 'set'
-
-class TC_Manifest < Test::Unit::TestCase
-    DATA_DIR = File.expand_path('data', File.dirname(__FILE__))
-    include Autoproj
-
-    def test_each_package_set
-        Dir.chdir(File.join(DATA_DIR, 'test_manifest', 'autoproj')) do
-            manifest = Manifest.load(File.join(DATA_DIR, 'test_manifest', 'autoproj', 'manifest'))
-            sources  = manifest.each_package_set(false).to_set
-
-            test_data      = "#{DATA_DIR}/test_manifest"
-            test_data_name = test_data.gsub '/', '_'
-
-            local_set = sources.find { |pkg_set| pkg_set.name == 'local_set' }
-            assert local_set
-            assert_equal "#{test_data}/autoproj/local_set", local_set.raw_local_dir
-            assert local_set.local?
-
-            remote_set = sources.find { |pkg_set| pkg_set.name == "git:remote2.git branch=next"}
-            assert remote_set, "available package sets: #{sources.map(&:name)}"
-            assert_equal "#{test_data}/.remotes/git__home_doudou_dev_rock_master_tools_autoproj_test_data_test_manifest_remote2_git", remote_set.raw_local_dir
-        end
-    end
-
-    def test_single_expansion_uses_provided_definitions
-        flexmock(Autoproj).should_receive(:user_config).never
-        assert_equal "a_variable=val", Autoproj.single_expansion("a_variable=$CONST", 'CONST' => 'val')
-        assert_equal "val", Autoproj.single_expansion("$CONST", 'CONST' => 'val')
-    end
-
-    def test_single_expansion_uses_user_config
-        flexmock(Autoproj).should_receive(:user_config).with("CONST").and_return("val")
-        assert_equal "a_variable=val", Autoproj.single_expansion("a_variable=$CONST", Hash.new)
-        assert_equal "val", Autoproj.single_expansion("$CONST", Hash.new)
-    end
-
-    def test_single_expansion_handle_quoted_dollar_sign
-        flexmock(Autoproj).should_receive(:user_config).with("CONST").and_return("val")
-        assert_equal "a_variable=$CONST", Autoproj.single_expansion("a_variable=\\$CONST", Hash.new)
-        assert_equal "$CONST", Autoproj.single_expansion("\\$CONST", Hash.new)
-    end
-end
-

data/test/test_os_dependencies.rb

@@ -1,586 +0,0 @@
-$LOAD_PATH.unshift File.expand_path('../lib', File.dirname(__FILE__))
-$LOAD_PATH.unshift File.expand_path('../', File.dirname(__FILE__))
-require 'test/unit'
-require 'autoproj'
-require 'flexmock/test_unit'
-
-require 'test/package_managers/test_gem'
-
-class TC_OSDependencies < Test::Unit::TestCase
-    include Autoproj
-    FOUND_PACKAGES = Autoproj::OSDependencies::FOUND_PACKAGES
-    FOUND_NONEXISTENT = Autoproj::OSDependencies::FOUND_NONEXISTENT
-
-    def setup
-        Autoproj::OSDependencies.operating_system = [['test', 'debian', 'default'], ['v1.0', 'v1', 'default']]
-    end
-
-    def test_supported_operating_system
-        Autoproj::OSDependencies.operating_system = [['test', 'debian', 'default'], ['v1.0', 'v1', 'default']]
-        assert(Autoproj::OSDependencies.supported_operating_system?)
-        Autoproj::OSDependencies.operating_system = [['test', 'default'], ['v1.0', 'v1', 'default']]
-        assert(!Autoproj::OSDependencies.supported_operating_system?)
-    end
-
-    def create_osdep(data)
-        osdeps = OSDependencies.new(data)
-        # Mock the package handlers
-        osdeps.os_package_handler = flexmock(PackageManagers::Manager.new(['apt-dpkg']))
-        osdeps.package_handlers.clear
-        osdeps.package_handlers['apt-dpkg'] = osdeps.os_package_handler
-        osdeps.package_handlers['gem'] = flexmock(PackageManagers::Manager.new(['gem']))
-        osdeps.package_handlers['pip'] = flexmock(PackageManagers::Manager.new(['pip']))
-        flexmock(osdeps)
-    end
-
-    def test_resolve_package_calls_specific_formatting
-        data = { 'pkg' => {
-                'test' => {
-                    'v1.0' => 'pkg1.0 blabla',
-                    'v1.1' => 'pkg1.1 bloblo',
-                    'default' => 'pkgdef'
-                 }
-        } }
-        osdeps = create_osdep(data)
-        osdeps.os_package_handler.should_receive(:parse_package_entry).
-            and_return { |arg| arg.split(" ") }.once
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, [['pkg1.0', 'blabla']]]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_package_applies_aliases
-        data = { 'pkg' => {
-                'test' => {
-                    'v1.0' => 'pkg1.0',
-                    'v1.1' => 'pkg1.1',
-                    'default' => 'pkgdef'
-                 }
-        } }
-        Autoproj::OSDependencies.alias('pkg', 'bla')
-        osdeps = create_osdep(data)
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1.0']]]
-        assert_equal expected, osdeps.resolve_package('bla')
-    end
-
-    def test_resolve_specific_os_name_and_version_single_package
-        data = { 'pkg' => {
-                'test' => {
-                    'v1.0' => 'pkg1.0',
-                    'v1.1' => 'pkg1.1',
-                    'default' => 'pkgdef'
-                 }
-        } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1.0']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_and_version_package_list
-        data = { 'pkg' => {
-                'test' => {
-                    'v1.0' => ['pkg1.0', 'other_pkg'],
-                    'v1.1' => 'pkg1.1',
-                    'default' => 'pkgdef'
-                 }
-        } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1.0', 'other_pkg']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_and_version_ignore
-        data = { 'pkg' => {
-                'test' => {
-                    'v1.0' => 'ignore',
-                    'v1.1' => 'pkg1.1',
-                    'default' => 'pkgdef'
-                 }
-        } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, []]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_and_version_fallback
-        data = { 'pkg' =>
-                 { 'test' => 
-                   { 'v1.1' => 'pkg1.1',
-                     'default' => 'pkgdef'
-                   }
-                 }        
-               }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkgdef']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_and_version_nonexistent
-        data = { 'pkg' => {
-                'test' => {
-                    'v1.0' => 'nonexistent',
-                    'v1.1' => 'pkg1.1',
-                    'default' => 'pkgdef'
-                 }
-        } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_NONEXISTENT, []]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_and_version_not_found
-        data = { 'pkg' => {
-                'test' => { 'v1.1' => 'pkg1.1', }
-        } }
-        osdeps = create_osdep(data)
-        assert_equal [], osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_single_package
-        data = { 'pkg' => { 'test' => 'pkg1.0', 'other_test' => 'pkg1.1', 'default' => 'pkgdef' } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1.0']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_package_list
-        data = { 'pkg' => { 'test' => ['pkg1.0', 'other_pkg'], 'other_test' => 'pkg1.1', 'default' => 'pkgdef' } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1.0', 'other_pkg']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_ignore
-        data = { 'pkg' => { 'test' => 'ignore', 'other_test' => 'pkg1.1', 'default' => 'pkgdef' } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, []]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_fallback
-        data = { 'pkg' => { 'other_test' => 'pkg1.1', 'default' => 'pkgdef' } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkgdef']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_and_version_nonexistent
-        data = { 'pkg' => { 'test' => 'nonexistent', 'other_test' => 'pkg1.1' } }
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_NONEXISTENT, []]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_specific_os_name_and_version_not_found
-        data = { 'pkg' => { 'other_test' => 'pkg1.1' } }
-        osdeps = create_osdep(data)
-
-        assert_equal [], osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_os_name_global_and_specific_packages
-        data = { 'pkg' => [
-            'global_pkg1', 'global_pkg2',
-            { 'test' => 'pkg1.1',
-              'other_test' => 'pkg1.1',
-              'default' => 'nonexistent'
-            }
-        ]}
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['global_pkg1', 'global_pkg2', 'pkg1.1']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_os_name_global_and_specific_does_not_exist
-        data = { 'pkg' => [
-            'global_pkg1', 'global_pkg2',
-            {
-              'other_test' => 'pkg1.1',
-            }
-        ]}
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['global_pkg1', 'global_pkg2']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_os_name_global_and_nonexistent
-        data = { 'pkg' => [
-            'global_pkg1', 'global_pkg2',
-            { 'test' => 'nonexistent',
-              'other_test' => 'pkg1.1'
-            }
-        ]}
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_NONEXISTENT, ['global_pkg1', 'global_pkg2']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_os_name_global_and_ignore
-        data = { 'pkg' => [
-            'global_pkg1', 'global_pkg2',
-            { 'test' => 'ignore',
-              'other_test' => 'pkg1.1'
-            }
-        ]}
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['global_pkg1', 'global_pkg2']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_os_version_global_and_specific_packages
-        data = { 'pkg' => [
-            'global_pkg1', 'global_pkg2',
-            { 'test' => ['pkg0', 'pkg1', { 'v1.0' => 'pkg1.0' }],
-              'other_test' => 'pkg1.1',
-              'default' => 'nonexistent'
-            }
-        ]}
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['global_pkg1', 'global_pkg2', 'pkg0', 'pkg1', 'pkg1.0']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_os_version_global_and_specific_nonexistent
-        data = { 'pkg' => [
-            'global_pkg1', 'global_pkg2',
-            { 'test' => ['pkg0', 'pkg1', { 'v1.0' => 'nonexistent' }],
-              'other_test' => 'pkg1.1',
-              'default' => 'nonexistent'
-            }
-        ]}
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_NONEXISTENT, ['global_pkg1', 'global_pkg2', 'pkg0', 'pkg1']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_os_version_global_and_specific_ignore
-        data = { 'pkg' => [
-            'global_pkg1', 'global_pkg2',
-            { 'test' => ['pkg0', 'pkg1', { 'v1.0' => 'ignore' }],
-              'other_test' => 'pkg1.1',
-              'default' => 'nonexistent'
-            }
-        ]}
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['global_pkg1', 'global_pkg2', 'pkg0', 'pkg1']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_os_version_global_and_specific_does_not_exist
-        data = { 'pkg' => [
-            'global_pkg1', 'global_pkg2',
-            { 'test' => ['pkg0', 'pkg1', { 'v1.1' => 'pkg1.1' }],
-              'other_test' => 'pkg1.1',
-              'default' => 'nonexistent'
-            }
-        ]}
-        osdeps = create_osdep(data)
-
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['global_pkg1', 'global_pkg2', 'pkg0', 'pkg1']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_osindep_packages_global
-        data = { 'pkg' => 'gem' }
-        osdeps = create_osdep(data)
-        expected = [[osdeps.package_handlers['gem'], FOUND_PACKAGES, ['pkg']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-
-        data = { 'pkg' => { 'gem' => 'gempkg' }}
-        osdeps = create_osdep(data)
-        expected = [[osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-
-        data = { 'pkg' => { 'gem' => ['gempkg', 'gempkg1'] }}
-        osdeps = create_osdep(data)
-        expected = [[osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg', 'gempkg1']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-
-        data = { 'pkg' => 'pip' }
-        osdeps = create_osdep(data)
-        expected = [[osdeps.package_handlers['pip'], FOUND_PACKAGES, ['pkg']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_osindep_packages_specific
-        data = { 'pkg' => ['gem', { 'test' => { 'gem' => 'gempkg' } } ] }
-        osdeps = create_osdep(data)
-        expected = [[osdeps.package_handlers['gem'], FOUND_PACKAGES, ['pkg', 'gempkg']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_specific_os_version_supersedes_nonspecific_one
-        data = { 'pkg' =>
-                 {
-                   'debian' => 'binary_package',
-                   'test' => { 'gem' => 'gempkg' }
-                 }
-               }
-        osdeps = create_osdep(data)
-        expected = [[osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-
-        data = { 'pkg' =>
-                 {
-                   'default' => { 'gem' => 'gem_package' },
-                   'test' => 'binary_package'
-                 }
-               }
-        osdeps = create_osdep(data)
-        expected = [[osdeps.os_package_handler, FOUND_PACKAGES, ['binary_package']]]
-        assert_equal expected, osdeps.resolve_package('pkg')
-    end
-
-    def test_resolve_mixed_os_and_osindep_dependencies
-        data = { 'pkg' =>
-                 { 'test' => { 'default' => 'ospkg', 'gem' => 'gempkg' }
-                 }
-               }
-
-        osdeps = create_osdep(data)
-        expected = [
-            [osdeps.os_package_handler, FOUND_PACKAGES, ['ospkg']],
-            [osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg']]
-        ].to_set
-        assert_equal expected, osdeps.resolve_package('pkg').to_set
-    end
-
-    def test_availability_of
-        osdeps = flexmock(OSDependencies.new)
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1']],
-             [osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg1']]])
-        assert_equal OSDependencies::AVAILABLE, osdeps.availability_of('pkg0')
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, []],
-             [osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg1']]])
-        assert_equal OSDependencies::AVAILABLE, osdeps.availability_of('pkg0')
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, []],
-             [osdeps.package_handlers['gem'], FOUND_PACKAGES, []]])
-        assert_equal OSDependencies::IGNORE, osdeps.availability_of('pkg0')
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1']],
-             [osdeps.package_handlers['gem'], FOUND_NONEXISTENT, []]])
-        assert_equal OSDependencies::NONEXISTENT, osdeps.availability_of('pkg0')
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return([])
-        assert_equal OSDependencies::WRONG_OS, osdeps.availability_of('pkg0')
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(nil)
-        assert_equal OSDependencies::NO_PACKAGE, osdeps.availability_of('pkg0')
-    end
-
-    def test_has_p
-        osdeps = flexmock(OSDependencies.new)
-        osdeps.should_receive(:availability_of).with('pkg0').once.
-            and_return(OSDependencies::AVAILABLE)
-        assert(osdeps.has?('pkg0'))
-
-        osdeps.should_receive(:availability_of).with('pkg0').once.
-            and_return(OSDependencies::IGNORE)
-        assert(osdeps.has?('pkg0'))
-
-        osdeps.should_receive(:availability_of).with('pkg0').once.
-            and_return(OSDependencies::UNKNOWN_OS)
-        assert(!osdeps.has?('pkg0'))
-
-        osdeps.should_receive(:availability_of).with('pkg0').once.
-            and_return(OSDependencies::WRONG_OS)
-        assert(!osdeps.has?('pkg0'))
-
-        osdeps.should_receive(:availability_of).with('pkg0').once.
-            and_return(OSDependencies::NONEXISTENT)
-        assert(!osdeps.has?('pkg0'))
-
-        osdeps.should_receive(:availability_of).with('pkg0').once.
-            and_return(OSDependencies::NO_PACKAGE)
-        assert(!osdeps.has?('pkg0'))
-    end
-
-    def test_resolve_os_dependencies
-        osdeps = flexmock(OSDependencies.new)
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg0']]])
-        osdeps.should_receive(:resolve_package).with('pkg1').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1']],
-             [osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg1']]])
-        osdeps.should_receive(:resolve_package).with('pkg2').once.and_return(
-            [[osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg2']]])
-        expected =
-            [[osdeps.os_package_handler, ['pkg0', 'pkg1']],
-             [osdeps.package_handlers['gem'], ['gempkg1', 'gempkg2']]]
-        assert_equal expected, osdeps.resolve_os_dependencies(['pkg0', 'pkg1', 'pkg2'])
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg0']]])
-        osdeps.should_receive(:resolve_package).with('pkg1').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, []]])
-        osdeps.should_receive(:resolve_package).with('pkg2').once.and_return(
-            [[osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg2']]])
-        expected =
-            [[osdeps.os_package_handler, ['pkg0']],
-             [osdeps.package_handlers['gem'], ['gempkg2']]]
-        assert_equal expected, osdeps.resolve_os_dependencies(['pkg0', 'pkg1', 'pkg2'])
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(nil)
-        osdeps.should_receive(:resolve_package).with('pkg1').never
-        osdeps.should_receive(:resolve_package).with('pkg2').never
-        assert_raises(Autoproj::OSDependencies::MissingOSDep) { osdeps.resolve_os_dependencies(['pkg0', 'pkg1', 'pkg2']) }
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg0']]])
-        osdeps.should_receive(:resolve_package).with('pkg1').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1']],
-             [osdeps.package_handlers['gem'], FOUND_PACKAGES, ['gempkg1']]])
-        osdeps.should_receive(:resolve_package).with('pkg2').once.and_return(nil)
-        expected =
-            [[osdeps.os_package_handler, ['pkg0']],
-             [osdeps.package_handlers['gem'], ['gempkg1', 'gempkg2']]]
-        assert_raises(Autoproj::OSDependencies::MissingOSDep) { osdeps.resolve_os_dependencies(['pkg0', 'pkg1', 'pkg2']) }
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_NONEXISTENT, ['pkg0']]])
-        osdeps.should_receive(:resolve_package).with('pkg1').never
-        osdeps.should_receive(:resolve_package).with('pkg2').never
-        assert_raises(Autoproj::OSDependencies::MissingOSDep) { osdeps.resolve_os_dependencies(['pkg0', 'pkg1', 'pkg2']) }
-
-        osdeps.should_receive(:resolve_package).with('pkg0').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg0']]])
-        osdeps.should_receive(:resolve_package).with('pkg1').once.and_return(
-            [[osdeps.os_package_handler, FOUND_PACKAGES, ['pkg1']],
-             [osdeps.package_handlers['gem'], FOUND_NONEXISTENT, ['gempkg1']]])
-        osdeps.should_receive(:resolve_package).with('pkg2').never
-        assert_raises(Autoproj::OSDependencies::MissingOSDep) { osdeps.resolve_os_dependencies(['pkg0', 'pkg1', 'pkg2']) }
-    end
-
-    def test_install
-        osdeps = create_osdep(Hash.new)
-        osdeps.should_receive(:resolve_os_dependencies).
-            once.with(['pkg0', 'pkg1', 'pkg2'].to_set).
-            and_return([[osdeps.os_package_handler, ['os0.1', 'os0.2', 'os1']],
-                        [osdeps.package_handlers['gem'], [['gem2', '>= 0.9']]]])
-        osdeps.os_package_handler.should_receive(:filter_uptodate_packages).
-            with(['os0.1', 'os0.2', 'os1']).and_return(['os0.1', 'os1']).once
-        # Do not add filter_uptodate_packages to the gem handler to check that
-        # #install deals with that just fine
-        osdeps.os_package_handler.should_receive(:install).
-            with(['os0.1', 'os1'])
-        osdeps.package_handlers['gem'].should_receive(:install).
-            with([['gem2', '>= 0.9']])
-
-        osdeps.osdeps_mode = 'all'
-        osdeps.install(['pkg0', 'pkg1', 'pkg2'])
-    end
-
-    def test_resolve_os_dependencies_unsupported_os_non_existent_dependency
-        osdeps = create_osdep(Hash.new)
-        flexmock(OSDependencies).should_receive(:supported_operating_system?).and_return(false)
-        assert_raises(OSDependencies::MissingOSDep) { osdeps.resolve_os_dependencies(['a_package']) }
-    end
-
-    def test_resolve_package_availability_unsupported_os_non_existent_dependency
-        osdeps = create_osdep(Hash.new)
-        flexmock(OSDependencies).should_receive(:supported_operating_system?).and_return(false)
-        assert_equal OSDependencies::NO_PACKAGE, osdeps.availability_of('a_package')
-    end
-
-    def test_resolve_package_availability_unsupported_os_existent_dependency
-        osdeps = create_osdep({ 'a_package' => { 'an_os' => 'bla' }})
-        flexmock(OSDependencies).should_receive(:supported_operating_system?).and_return(false)
-        assert_equal OSDependencies::AVAILABLE, osdeps.availability_of('a_package')
-    end
-
-    def test_resolve_os_dependencies_unsupported_os_existent_dependency
-        osdeps = create_osdep({ 'a_package' => { 'an_os' => 'bla' }})
-        flexmock(OSDependencies).should_receive(:supported_operating_system?).and_return(false)
-        assert_equal [[osdeps.os_package_handler, ['a_package']]], osdeps.resolve_os_dependencies(['a_package'])
-    end
-
-    DATA_DIR = File.expand_path('data', File.dirname(__FILE__))
-    def test_os_from_os_release_returns_nil_if_the_os_release_file_is_not_found
-        assert !Autoproj::OSDependencies.os_from_os_release('does_not_exist')
-    end
-    def test_os_from_os_release_handles_quoted_and_unquoted_fields
-        names, versions = Autoproj::OSDependencies.os_from_os_release(
-            File.join(DATA_DIR, 'os_release.with_missing_optional_fields'))
-        assert_equal ['name'], names
-        assert_equal ['version_id'], versions
-    end
-    def test_os_from_os_release_handles_optional_fields
-        names, versions = Autoproj::OSDependencies.os_from_os_release(
-            File.join(DATA_DIR, 'os_release.with_missing_optional_fields'))
-        assert_equal ['name'], names
-        assert_equal ['version_id'], versions
-    end
-    def test_os_from_os_release_parses_the_version_field
-        _, versions = Autoproj::OSDependencies.os_from_os_release(
-            File.join(DATA_DIR, 'os_release.with_complex_version_field'))
-        assert_equal ['version_id', 'version', 'codename', 'codename_bis'], versions
-    end
-    def test_os_from_os_release_removes_duplicate_values
-        names, versions = Autoproj::OSDependencies.os_from_os_release(
-            File.join(DATA_DIR, 'os_release.with_duplicate_values'))
-        assert_equal ['id'], names
-        assert_equal ['version_id', 'codename'], versions
-    end
-    def test_os_from_lsb_returns_nil_if_lsb_release_is_not_found_in_path
-        flexmock(ENV).should_receive('[]').with('PATH').and_return('')
-        assert !Autoproj::OSDependencies.os_from_lsb
-    end
-
-    def test_merge_issues_a_warning_if_two_definitions_differ_by_the_operating_system_packages
-        Autoproj::OSDependencies.operating_system = [['os0'], []]
-        osdeps0 = Autoproj::OSDependencies.new
-        osdeps0.definitions['pkg'] = Hash['os0' => ['osdep0'], 'gem' => ['gem0']]
-        osdeps0.sources['pkg'] = 'bla/bla'
-        osdeps1 = Autoproj::OSDependencies.new
-        osdeps1.definitions['pkg'] = Hash['os0' => ['osdep1'], 'gem' => ['gem0']]
-        osdeps1.sources['pkg'] = 'bla/bla'
-        flexmock(Autoproj).should_receive(:warn).once
-        osdeps0.merge(osdeps1)
-    end
-    def test_merge_issues_a_warning_if_two_definitions_differ_by_an_os_independent_package
-        Autoproj::OSDependencies.operating_system = [['os0'], []]
-        osdeps0 = Autoproj::OSDependencies.new
-        osdeps0.definitions['pkg'] = Hash['os0' => ['osdep0'], 'gem' => ['gem0']]
-        osdeps0.sources['pkg'] = 'bla/bla'
-        osdeps1 = Autoproj::OSDependencies.new
-        osdeps1.definitions['pkg'] = Hash['os0' => ['osdep0'], 'gem' => ['gem1']]
-        osdeps1.sources['pkg'] = 'bla/bla'
-        flexmock(Autoproj).should_receive(:warn).once
-        osdeps0.merge(osdeps1)
-    end
-    def test_merge_does_not_issue_a_warning_if_two_definitions_are_identical_for_the_local_operating_system
-        Autoproj::OSDependencies.operating_system = [['os0'], []]
-        osdeps0 = Autoproj::OSDependencies.new
-        osdeps0.definitions['pkg'] = Hash['os0' => ['osdep0'], 'gem' => ['gem0'], 'os1' => ['osdep0']]
-        osdeps0.sources['pkg'] = 'bla/bla'
-        osdeps1 = Autoproj::OSDependencies.new
-        osdeps1.definitions['pkg'] = Hash['os0' => ['osdep0'], 'gem' => ['gem0'], 'os1' => ['osdep1']]
-        osdeps1.sources['pkg'] = 'bla/bla'
-        flexmock(Autoproj).should_receive(:warn).never
-        osdeps0.merge(osdeps1)
-    end
-end
-