reflex-packager 0.2.0 → 0.3.0

data/test/test_packager_config.rb

@@ -10,13 +10,15 @@ class TestPackagerConfig < Test::Unit::TestCase
 
   MAIN = File.basename(__FILE__)
 
-  def config(dir: __dir__, main: nil, parent: nil, stderr: nil, **hash)
+  def config(dir: __dir__, main: nil, parent: nil, stderr: nil, env: {}, **hash)
     main ||= MAIN
-    Config.new TEST_PROFILE, dir, {main: main, **hash}, stderr: stderr
+    with_env(ENV_TO_SIGN.merge env) do
+      Config.new TEST_PROFILE, dir, {main: main, **hash}, stderr: stderr
+    end
   end
 
   def load_config(dir, path = nil)
-    Config.load TEST_PROFILE, dir, path
+    with_env(ENV_TO_SIGN) {Config.load TEST_PROFILE, dir, path}
   end
 
   def stderr()
@@ -73,11 +75,11 @@ class TestPackagerConfig < Test::Unit::TestCase
       main:      app.rb
       icon:      icon.png
       files:     ['*.rb', data]
-      pods:
-        reflex: {git: https://example.com/reflex, tag: v1}
       macos:
         deployment_target: '12.0'
         archs: [arm64, x86_64]
+        cruby: 4.0.600
+        category: public.app-category.games
         codesign: {identity: Developer ID, team_id: ABCDE12345}
     YAML
       touch 'icon.png'
@@ -90,10 +92,11 @@ class TestPackagerConfig < Test::Unit::TestCase
       assert_equal 'app.rb',                                       c.main
       assert_equal 'icon.png',                                     c.icon
       assert_equal %w[*.rb data],                                  c.files
-      assert_equal %w[1.rb app.rb data],                           c.app_files
-      assert_equal({git: 'https://example.com/reflex', tag: 'v1'}, c.pods[:reflex])
+      assert_equal %w[1.rb app.rb data/2.json],                    c.app_files
       assert_equal '12.0',                                         c.macos.deployment_target
       assert_equal %w[arm64 x86_64],                               c.macos.archs
+      assert_equal '4.0.600',                                      c.macos.cruby
+      assert_equal 'public.app-category.games',                    c.macos.category
       assert_equal 'Developer ID',                                 c.macos.codesign_identity
       assert_equal 'ABCDE12345',                                   c.macos.codesign_team_id
     end
@@ -103,6 +106,10 @@ class TestPackagerConfig < Test::Unit::TestCase
     assert_equal 'test', config()         .name
     assert_equal '1',    config(name: 1)  .name
     assert_equal 'test', config(name: nil).name
+    assert_raise(RP::Error) {config name: '',    bundle_id: 'a.b'}
+    assert_raise(RP::Error) {config name: ' ',   bundle_id: 'a.b'}
+    assert_raise(RP::Error) {config name: 'A/B', bundle_id: 'a.b'}
+    assert_raise(RP::Error) {config name: 'A:B', bundle_id: 'a.b'}
   end
 
   def test_bundle_id()
@@ -121,7 +128,63 @@ class TestPackagerConfig < Test::Unit::TestCase
     assert_equal '1',        config(version: '1')  .version
     assert_equal '2.3',      config(version: '2.3').version
     assert_equal '0.1.0',    config(version: nil)  .version
+    assert_equal '1',        config(version: 1)    .version
     assert_raise(RP::Error) {config version: '4.'}
+    assert_raise(RP::Error) {config version: '2.3beta'}
+    assert_raise(RP::Error) {config version: 1.10} # read as 1.1
+
+    # the VERSION file of the app, which the config comes before
+    tmpdir do |dir|
+      assert_equal '0.1.0', load_config(dir).version
+      File.write 'VERSION', "1.2.3\n"
+      assert_equal '1.2.3', load_config(dir).version
+      File.binwrite 'VERSION', "\xEF\xBB\xBF1.2.4\r\n" # with a BOM
+      assert_equal '1.2.4', load_config(dir).version
+      File.write 'reflex.yaml', "version: '4.5'"
+      assert_equal '4.5',   load_config(dir).version
+    end
+    tmpdir do |dir|
+      File.write 'VERSION', '1.2.3beta'
+      error = assert_raise(RP::Error) {load_config dir}
+      assert_include error.message, 'VERSION file'
+      File.write 'reflex.yaml', "version: '4.5'"
+      assert_equal '4.5', load_config(dir).version # the file not read
+    end
+    assert_not_include assert_raise(RP::Error) {config version: '2.3beta'}.message, 'VERSION file'
+  end
+
+  def test_copyright()
+    assert_nil                config()                       .copyright
+    assert_equal '© 2026 Me', config(copyright: '© 2026 Me').copyright
+    assert_equal '2026',      config(copyright: 2026)       .copyright
+  end
+
+  def test_localizations()
+    assert_equal({'en' => {name: 'test', copyright: nil}}, config.localizations)
+
+    l10n = config(copyright: 'C', localizations: {ja: {name: 'Tesuto'}, 'zh-Hans': nil}).localizations
+    assert_equal %w[en ja zh-Hans],                l10n.keys
+    assert_equal({name: 'test',   copyright: 'C'}, l10n['en'])
+    assert_equal({name: 'Tesuto', copyright: 'C'}, l10n['ja'])
+    assert_equal({name: 'test',   copyright: 'C'}, l10n['zh-Hans'])
+    assert_equal({name: '1',      copyright: nil}, config(localizations: {ja: {name: 1}}).localizations['ja'])
+
+    assert_raise(RP::Error) {config localizations: 1}
+    assert_raise(RP::Error) {config localizations: {ja: 1}}
+    assert_raise(RP::Error) {config localizations: {ja: {name: {}}}}
+    assert_raise(RP::Error) {config localizations: {en: {name: 'Test'}}} # the values out of it
+    assert_raise(RP::Error) {config localizations: {Japanese: {name: 'Tesuto'}}}
+  end
+
+  def test_display_and_build_versions()
+    [
+      [{version: '1.2.3'},   '1.2.3', '1.2.3'],
+      [{version: '1.2.3.4'}, '1.2.3', '1.2.3.4'],
+      [{version: '2.3'},     '2.3',   '2.3'],
+    ].each do |hash, display, build|
+      c = config(**hash)
+      assert_equal [display, build], [c.display_version, c.build_version], hash.inspect
+    end
   end
 
   def test_main()
@@ -142,12 +205,17 @@ class TestPackagerConfig < Test::Unit::TestCase
     assert_equal %w[a b],       config(files: %w[a b])    .files
   end
 
-  def test_pods()
-    assert_equal({cruby: {}, reflex: {}}, config()                            .pods)
-    assert_equal({tag:    '6'},           config(pods: {cruby: {tag:    '6'}}).pods[:cruby])
-    assert_equal({branch: '7'},           config(pods: {cruby: {branch: '7'}}).pods[:cruby])
-    assert_equal({git:    '8'},           config(pods: {cruby: {git:    '8'}}).pods[:cruby])
-    assert_equal({path:   '9'},           config(pods: {cruby: {path:   '9'}}).pods[:cruby])
+  def test_excludes()
+    assert_nil                  config()                     .excludes
+    assert_equal %w[helper.rb], config(excludes: 'helper.rb').excludes
+    assert_equal %w[a b],       config(excludes: %w[a b])    .excludes
+    assert_raise(RP::Error)    {config excludes: {a: 1}}
+    assert_raise(RP::Error)    {config excludes: [{a: 1}]}
+    assert_raise(RP::Error)    {config excludes: [%w[a]]}
+    assert_raise(RP::Error)    {config excludes: [nil]}
+    assert_raise(RP::Error)    {config excludes: ['']}
+    assert_raise(RP::Error)    {config excludes: MAIN}
+    assert_raise(RP::Error)    {config excludes: "./#{MAIN}"}
   end
 
   def test_app_files()
@@ -162,12 +230,32 @@ class TestPackagerConfig < Test::Unit::TestCase
     end
 
     tmpdir yaml: "files: ['*']" do |dir|
-      %w[build dist].each {Dir.mkdir _1}
-      touch 'build/1.rb'
+      %w[.build dist].each {Dir.mkdir _1}
+      touch '.build/1.rb'
       touch 'dist/2.rb'
       assert_equal %w[main.rb],      load_config(dir).app_files
     end
 
+    tmpdir yaml: "files: ['lib/**/*', res]\nexcludes: [lib/a/debug.rb, 'res/*.wav']" do |dir|
+      %w[lib/a/b.rb lib/a/debug.rb res/c.png res/d.wav].each {touch _1}
+      assert_equal %w[lib/a/b.rb main.rb res/c.png], load_config(dir).app_files
+    end
+
+    tmpdir yaml: "files: [lib, ./res]\nexcludes: [./lib/a/debug.rb, res/d.wav]" do |dir|
+      %w[lib/a/b.rb lib/a/debug.rb res/c.png res/d.wav].each {touch _1}
+      assert_equal %w[lib/a/b.rb main.rb res/c.png], load_config(dir).app_files
+    end
+
+    tmpdir yaml: "files: ['*']" do |dir|
+      touch 'a[1]/b.png'
+      assert_equal %w[a[1]/b.png main.rb], load_config(dir).app_files
+    end
+
+    tmpdir yaml: "files: [res, res/.b]" do |dir|
+      %w[res/.a res/.b res/.c/d res/e].each {touch _1}
+      assert_equal %w[main.rb res/.b res/e], load_config(dir).app_files
+    end
+
     tmpdir yaml_path: 'a.yaml', yaml: <<~YAML, main_path: 'b.rb' do |dir|
       main: b.rb
       files: '*'
@@ -188,15 +276,35 @@ class TestPackagerConfig < Test::Unit::TestCase
   end
 
   def test_macos_archs()
-    assert_equal ['arm64'],  config()                      .macos.archs
-    assert_equal ['arm64'],  config(macos: {})             .macos.archs
-    assert_equal ['1'],      config(macos: {archs: 1})     .macos.archs
-    assert_equal ['2', '3'], config(macos: {archs: [2, 3]}).macos.archs
-    assert_equal ['arm64'],  config(macos: {archs: nil})   .macos.archs
+    assert_equal %w[arm64 x86_64], config()                       .macos.archs
+    assert_equal %w[arm64 x86_64], config(macos: {})              .macos.archs
+    assert_equal ['arm64'],        config(macos: {archs: 'arm64'}).macos.archs
+    assert_equal ['1'],            config(macos: {archs: 1})      .macos.archs
+    assert_equal ['2', '3'],       config(macos: {archs: [2, 3]}) .macos.archs
+    assert_equal %w[arm64 x86_64], config(macos: {archs: nil})    .macos.archs
     assert_raise(RP::Error) {config(macos: {archs: []})}
     assert_raise(RP::Error) {config(macos: {archs: {}})}
   end
 
+  def test_macos_cruby()
+    assert_nil               config()                           .macos.cruby
+    assert_nil               config(macos: {})                  .macos.cruby
+    assert_equal '4.0.600',  config(macos: {cruby: '4.0.600'})  .macos.cruby
+    assert_equal '../cruby', config(macos: {cruby: '../cruby'}) .macos.cruby
+    assert_raise(RP::Error) {config(macos: {cruby: {}})}
+  end
+
+  def test_macos_category()
+    assert_nil               config()                       .macos.category
+    assert_nil               config(macos: {})              .macos.category
+    assert_nil               config(macos: {category: nil}) .macos.category
+    assert_equal 'public.app-category.sports-games',
+      config(macos: {category: 'public.app-category.sports-games'}).macos.category
+    assert_raise(RP::Error) {config(macos: {category: 'games'})}
+    assert_raise(RP::Error) {config(macos: {category: 'public.app-category.Games'})}
+    assert_raise(RP::Error) {config(macos: {category: {}})}
+  end
+
   def test_macos_codesign_identity()
     assert_equal '-',        config()                                  .macos.codesign_identity
     assert_equal '-',        config(macos: {})                         .macos.codesign_identity
@@ -206,6 +314,9 @@ class TestPackagerConfig < Test::Unit::TestCase
     assert_equal '-',        config(macos: {codesign: {identity: nil}}).macos.codesign_identity
     assert_raise(RP::Error) {config(macos: {codesign: 2})}
     assert_raise(RP::Error) {config(macos: {codesign: {identity: {}}})}
+
+    assert_equal 'ID',       config(macos: {codesign: {identity: 1}}, env: {'APPLE_CODESIGN_IDENTITY' => 'ID'}).macos.codesign_identity
+    assert_equal '1',        config(macos: {codesign: {identity: 1}}, env: {'APPLE_CODESIGN_IDENTITY' => ''})  .macos.codesign_identity
   end
 
   def test_macos_codesign_team_id()
@@ -217,24 +328,52 @@ class TestPackagerConfig < Test::Unit::TestCase
     assert_nil               config(macos: {codesign: {team_id: nil}}).macos.codesign_team_id
     assert_raise(RP::Error) {config(macos: {codesign: 2})}
     assert_raise(RP::Error) {config(macos: {codesign: {team_id: {}}})}
+
+    assert_equal 'ID',       config(macos: {codesign: {team_id: 1}}, env: {'APPLE_TEAM_ID' => 'ID'}).macos.codesign_team_id
+    assert_equal '1',        config(macos: {codesign: {team_id: 1}}, env: {'APPLE_TEAM_ID' => ''})  .macos.codesign_team_id
+  end
+
+  def test_windows_console()
+    assert_equal false,      config()                         .windows.console?
+    assert_equal false,      config(windows: {})              .windows.console?
+    assert_equal false,      config(windows: nil)             .windows.console?
+    assert_equal false,      config(windows: {console: nil})  .windows.console?
+    assert_equal true,       config(windows: {console: true}) .windows.console?
+    assert_equal false,      config(windows: {console: false}).windows.console?
+    assert_raise(RP::Error) {config(windows: 1)}
+    assert_raise(RP::Error) {config(windows: {console: 'yes'})}
+    assert_raise(RP::Error) {config(windows: {console: {}})}
+  end
+
+  def test_upload_itchio_project()
+    assert_nil               config()                                      .upload.itchio_project
+    assert_nil               config(upload: {})                            .upload.itchio_project
+    assert_nil               config(upload: {itchio: {}})                  .upload.itchio_project
+    assert_equal 'a/b-c_1',  config(upload: {itchio: {project: 'a/b-c_1'}}).upload.itchio_project
+    assert_raise(RP::Error) {config(upload: {itchio: 'a/b'})}
+    assert_raise(RP::Error) {config(upload: {itchio: {project: 'a'}})}
+    assert_raise(RP::Error) {config(upload: {itchio: {project: 'a/b/c'}})}
+    assert_raise(RP::Error) {config(upload: {itchio: {project: 'A/b'}})} # lower case only
   end
 
   def test_warn_unknown_key()
     e = stderr
 
-    config stderr: e,                                k1: 1
-    assert_equal "unknown key '/k1'",                e.shift
+    config stderr: e,                                  k1: 1
+    assert_equal "unknown key '/k1'",                  e.shift
+
+    config stderr: e,                                  macos: {k2: 2}
+    assert_equal "unknown key '/macos/k2'",            e.shift
 
-    config stderr: e,                                macos: {k2: 2}
-    assert_equal "unknown key '/macos/k2'",          e.shift
+    config stderr: e,                                  macos: {codesign: {k3: 3}}
+    assert_equal "unknown key '/macos/codesign/k3'",   e.shift
 
-    config stderr: e,                                macos: {codesign: {k3: 3}}
-    assert_equal "unknown key '/macos/codesign/k3'", e.shift
+    config stderr: e,                                  localizations: {ja: {k4: 4}}
+    assert_equal "unknown key '/localizations/ja/k4'", e.shift
   end
 
   def test_invalid_value_type()
     assert_raise(RP::Error) {config macos: 'arm64'}
-    assert_raise(RP::Error) {config pods:  ['cruby']}
   end
 
 end# TestPackagerConfig

data/test/test_packager_data_file.rb

@@ -0,0 +1,96 @@
+require_relative 'helper'
+
+
+class TestPackagerDataFile < Test::Unit::TestCase
+
+  RP       = Reflex::Packager
+  DataFile = RP::DataFile
+
+  def data_file(files, **options, &block)
+    Dir.mktmpdir do |dir|
+      path = File.join dir, 'data.bin'
+      DataFile.write path, files, **options
+      block.call path
+    end
+  end
+
+  def test_write_and_read()
+    files = {
+      'main.rb'          => 'puts :hello',
+      'data/日本語.txt'  => 'テキスト',
+      'data/bytes.bin'   => (0..255).map(&:chr).join.b,
+      'data/empty.txt'   => ''
+    }
+    data_file files do |path|
+      DataFile.open path do |data|
+        assert_equal files.keys, data.names
+        files.each do |name, bytes|
+          assert_equal bytes.b, data.read(name), name
+          assert_equal bytes.bytesize, data.size(name)
+          assert_include data.names, name
+        end
+        assert_nil   data.read('none.rb')
+        assert_nil   data.size('none.rb')
+        assert_false data.include?('none.rb')
+        assert_true  data.include?('main.rb')
+      end
+      raw = File.binread path
+      assert_equal 'RXDF', raw[0, 4] # the header as it is
+      assert_not_include raw, 'puts :hello'
+      assert_not_include raw, 'main.rb'
+    end
+
+    # a random seed for each
+    raws = 2.times.map {data_file(files) {File.binread _1}}
+    assert_not_equal raws[0], raws[1]
+    data_file(files, seed: 1) {|path| DataFile.open(path) {assert_equal 'puts :hello', _1.read('main.rb')}}
+
+    data_file({}) {|path| DataFile.open(path) {assert_empty _1.names}}
+
+    assert_raise(ArgumentError) {data_file("a\tb" => '') {}}
+    assert_raise(ArgumentError) {data_file("a\nb" => '') {}}
+    assert_raise(ArgumentError) {data_file('../a' => '') {}}
+    assert_raise(ArgumentError) {data_file('a/../../b' => '') {}}
+    assert_raise(ArgumentError) {data_file('/a' => '') {}}
+
+    Dir.mktmpdir do |dir|
+      path = File.join dir, 'data.bin'
+      assert_raise(ArgumentError) {DataFile.write path, files, seed: 0}
+      assert_false File.exist?(path) # not written at all
+    end
+  end
+
+  def test_encode()
+    bytes   = (0..255).map(&:chr).join.b
+    encoded = DataFile.encode bytes, 0x7f4a7c15
+    assert_equal bytes,              encoded.bytes.sort.pack('C*') # each byte once
+    assert_equal bytes,              DataFile.decode(encoded, 0x7f4a7c15)
+    assert_not_equal bytes,          encoded
+    assert_not_equal bytes.reverse,  encoded # not inverted
+    assert_not_equal encoded,        DataFile.encode(bytes, 0x7f4a7c16)
+    assert_equal '89e68061414636a9', encoded.unpack1('H16') # the same on any Ruby
+
+    assert_raise(ArgumentError) {DataFile.encode bytes, 0}
+    assert_raise(ArgumentError) {DataFile.encode bytes, 0x100000000}
+  end
+
+  def test_not_a_data_file()
+    Dir.mktmpdir do |dir|
+      path = File.join dir, 'data.bin'
+      File.write path, 'not a data file'
+      assert_raise(RuntimeError) {DataFile.new path}
+      File.write path, ''
+      assert_raise(RuntimeError) {DataFile.new path}
+    end
+  end
+
+  def test_requires_nothing()
+    # a package carries the file to read its data file
+    path = File.expand_path '../lib/reflex/packager/data_file.rb', __dir__
+    out  = IO.popen(
+      [RbConfig.ruby, '--disable-gems', '-e', "load #{path.dump}; p Reflex::Packager::DataFile::VERSION"],
+      err: [:child, :out], &:read)
+    assert_equal "1\n", out
+  end
+
+end# TestPackagerDataFile

data/test/test_packager_data_loader.rb

@@ -0,0 +1,114 @@
+require_relative 'helper'
+
+
+class TestPackagerDataLoader < Test::Unit::TestCase
+
+  RP = Reflex::Packager
+
+  LIB_DIR = File.expand_path '../lib/reflex/packager', __dir__
+
+  APP = {
+    'main.rb' => <<~RUBY,
+      $log = []
+      $log << require('foo')
+      $log << require('foo')
+      require_relative 'lib/bar'
+      load 'once.rb'
+      load 'once.rb'
+      $log << require('shellwords') # from the files
+      $log << [__FILE__, __dir__]
+      $log << $LOADED_FEATURES.grep(/\\/(foo|lib\\/ba[rz])\\.rb\\z/).map {File.basename _1}
+      p $log
+    RUBY
+    'foo.rb'     => '$log << :foo',
+    'lib/bar.rb' => "require_relative 'baz'; $log << [:bar, __FILE__]",
+    'lib/baz.rb' => '$log << :baz',
+    'once.rb'    => '$log << :once',
+    'image.png'  => "\x89PNG".b
+  }
+
+  # Packs +files+ as an app, and runs the main script of it in another Ruby,
+  # as a package does.
+  #
+  def run_app(files = APP, ruby_version: nil)
+    Dir.mktmpdir do |dir|
+      src = File.join dir, 'src'
+      dir = File.join dir, 'app'
+      files.each do |name, content|
+        path = File.join src, name
+        FileUtils.mkdir_p File.dirname(path)
+        File.binwrite path, content
+      end
+      RP::Platform.pack_app src, dir
+      yield src, dir if block_given?
+      if ruby_version
+        RP::DataFile.open(File.join dir, 'data.bin') do |data|
+          RP::DataFile.write data.path, data.names.to_h {[_1, data.read(_1)]}
+            .merge('.ruby-version' => ruby_version)
+        end
+      end
+
+      script = <<~RUBY
+        require #{File.join(LIB_DIR, 'data_loader.rb').dump} # with data_file.rb beside
+        Dir.chdir #{dir.dump}
+        $LOAD_PATH.unshift Dir.pwd
+        Reflex::Packager::DataLoader.setup Dir.pwd
+        load 'main.rb'
+      RUBY
+      IO.popen [RbConfig.ruby, '-e', script], err: [:child, :out], &:read
+    end
+  end
+
+  def test_pack_app()
+    run_app do |src, dir|
+      assert_equal APP.keys.sort,  Dir.glob('**/*.*', base: src).sort # as they are
+      assert_equal %w[data.bin image.png], Dir.children(dir).sort # the others as they are
+      assert_equal "\x89PNG".b, File.binread(File.join dir, 'image.png')
+      RP::DataFile.open File.join(dir, 'data.bin') do |data|
+        assert_equal %w[.ruby-version foo.rbc lib/bar.rbc lib/baz.rbc main.rbc once.rbc],
+          data.names.sort
+        assert_equal RUBY_VERSION, data.read('.ruby-version')
+        assert_not_include data.read('main.rbc'), '$log << require' # compiled
+      end
+    end
+  end
+
+  def test_require()
+    log = eval run_app
+    assert_equal [
+      :foo, true, false,
+      :baz, [:bar, 'lib/bar.rb'],
+      :once, :once,
+      true,
+      ['main.rb', '.'],
+      %w[foo.rb bar.rb baz.rb] # each before it runs, for one it requires to require it back
+    ], log
+  end
+
+  def test_files()
+    files = {
+      'main.rb' => <<~RUBY,
+        r = []
+        r << File.read('data/a.txt')
+        r << Dir.glob('**/*').sort # with none of the scripts
+        r << [File.exist?('main.rb'), File.exist?('sub.rb')]
+        r << require_relative('sub')
+        p r
+      RUBY
+      'sub.rb'     => '',
+      'data/a.txt' => 'abc'
+    }
+    assert_equal [
+      'abc',
+      %w[data data.bin data/a.txt],
+      [false, false],
+      true
+    ], eval(run_app files)
+  end
+
+  def test_ruby_version()
+    assert_match(/data file is for Ruby 0\.0\.0, not #{Regexp.escape RUBY_VERSION}/,
+      run_app(ruby_version: '0.0.0'))
+  end
+
+end# TestPackagerDataLoader

data/test/test_packager_library.rb

@@ -0,0 +1,81 @@
+require_relative 'helper'
+
+
+class TestPackagerLibrary < Test::Unit::TestCase
+
+  RP = Reflex::Packager
+
+  # Makes the gems in a directory and puts their lib/ on the load path, as
+  # RUBYLIB does for the gems of a repository being worked on.
+  #
+  # @param gems [Hash] {dir => [gem name, dependencies, files]}
+  #
+  def fake_gems(gems, &block)
+    Dir.mktmpdir do |root|
+      gems.each do |dir, (name, deps, files)|
+        FileUtils.mkdir_p File.join(root, dir)
+        File.write File.join(root, dir, "#{dir}.gemspec"), <<~GEMSPEC
+          Gem::Specification.new do |s|
+            s.name    = '#{name}'
+            s.version = '1.0'
+            #{deps.map {"s.add_dependency '#{_1}'"}.join "\n  "}
+          end
+        GEMSPEC
+        files.each do |file|
+          path = File.join root, dir, file
+          FileUtils.mkdir_p File.dirname(path)
+          FileUtils.touch path
+        end
+      end
+      libs = gems.keys.map {File.join root, _1, 'lib'}
+      $LOAD_PATH.unshift(*libs)
+      block.call root
+    ensure
+      $LOAD_PATH.replace $LOAD_PATH - libs.to_a
+    end
+  end
+
+  def test_collect()
+    gems = {
+      'fakebase'   => [
+        'fakebase',
+        [],
+        %w[lib/fakebase/extension.rb]
+      ],
+      # the name of the gem differs from the one of the library, as reflexion
+      'fakenative' => [
+        'fakenativeion',
+        %w[fakebase],
+        %w[lib/fakenative/extension.rb lib/fakenative/ext.rb]
+      ],
+      # not a library, which has no lib/*/extension.rb as reflex-packager
+      'faketool'   => [
+        'faketool',
+        %w[fakebase],
+        %w[lib/faketool.rb]
+      ],
+      'fakeapp'    => [
+        'fakeapp',
+        %w[faketool fakenativeion no-such-gem],
+        %w[lib/fakeapp/extension.rb]
+      ]
+    }
+    fake_gems gems do |root|
+      libs = RP::Library.collect File.join(root, 'fakeapp')
+      assert_equal %w[fakebase fakenative fakeapp],    libs.map(&:name)
+      assert_equal [nil, 'fakenative_ext', nil],       libs.map(&:extension)
+      assert_equal libs.map {File.join root, _1.name}, libs.map(&:root)
+
+      # leaving out the ones collected already
+      libs = RP::Library.collect File.join(root, 'fakeapp'), known: libs.first(1)
+      assert_equal %w[fakenative fakeapp], libs.map(&:name)
+    end
+  end
+
+  def test_collect_the_libraries_of_the_profiles()
+    # this repository, which the helper puts on the load path
+    assert_equal %w[xot rucy rays reflex], TEST_PROFILE.libraries.map(&:name)
+    assert_equal %w[rays_ext reflex_ext],  TEST_PROFILE.extensions
+  end
+
+end# TestPackagerLibrary