nera 0.0.1

data/test/test_nera_database.rb

@@ -0,0 +1,221 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TC_NERA_DB < Test::Unit::TestCase
+
+  def setup
+    @test_dir = "test_filelock"
+    FileUtils.mkdir(@test_dir)
+    FileUtils.chdir(@test_dir)
+    @path_to_db = "./testdb"
+    NERA::Database.create_table( @path_to_db)
+    @db = NERA::Database.new( @path_to_db)
+  end
+
+  def teardown
+    FileUtils.chdir("..")
+    FileUtils.rm_r(@test_dir)
+  end
+
+  def test_constructor
+    assert_raise( RuntimeError ) { ( NERA::Database.new("Unknown") ) }
+  end
+
+  def test_create_table
+    assert_nil( NERA::Database.create_table( @path_to_db) )
+  end
+
+  def test_add_find
+    # test of add and find
+    rec = { :key1 => 0.8, :key2 => DateTime.now}
+    given_id = @db.add( rec)
+    assert_equal( 1, given_id)
+    found = @db.find_by_id( 1)
+    rec[:id] = 1
+    assert_equal( rec, found)
+
+    # test of id
+    given_id = @db.add( rec)
+    assert_equal( 2,given_id)
+    found = @db.find_by_id( 2)
+    rec[:id] = 2
+    assert_equal( rec, found)
+
+    # test of find
+    found = @db.find_by_id( 3)
+    assert_equal( nil, found)
+    found = @db.find_by_id( 0)
+    assert_equal( nil, found)
+
+    assert_raise( ArgumentError) {
+      @db.find_by_id("3")
+    }
+
+    # test of find_all
+    found = @db.find_all do |r| true end
+    a = rec.dup
+    a[:id] = 1
+    b = rec.dup
+    b[:id] = 2
+    assert_equal( [ a, b], found.sort do |a,b| a[:id] <=> b[:id] end )
+
+    all1 = @db.find_all do |r| true end
+    all2 = @db.find_all do |r|
+      r[:key1000] = 1000
+    end
+    assert_equal( all1, all2)
+    all3 = @db.find_all do |r| true end
+    assert_equal( all1, all3)
+
+    found = @db.find_all do |r| false end
+    assert_equal( nil, found)
+
+    # test of add ( type check)
+    rec = { :key1 => 1, :key2 => 2.1, :key3 => "value3", :key4 => Date.new, :key5 => DateTime.now }
+    new_id = @db.add( rec)
+    rec[:id] = new_id
+    found = @db.find_all do |r|
+      r == rec
+    end
+    assert_equal( 1, found.size)
+    assert_equal( rec, found[0])
+
+    before = @db.find_all do |r| true end
+    rec = { :key1 => { 'another' => 'hash' } }
+    assert_raise( ArgumentError) {
+      flag = @db.add( rec)
+    }
+    after = @db.find_all do |r| true end
+    assert_equal( after, before)
+  end
+  
+  def test_update
+    10.times do |i|
+      record = { :key1 => i, :key2 => i.to_f}
+      @db.add( record)
+    end
+    found = @db.find_all do |r| true end
+    assert_equal( found.size, 10)
+
+    rec_to_update = found.find do |rec|
+      rec[:id] == 5
+    end
+    rec_to_update[:key1] = 'updated'
+    flag = @db.update( rec_to_update)
+    assert_equal(true, flag)
+    rec5 = @db.find_by_id( 5)
+    assert_equal( rec5, rec_to_update)
+
+    rec_to_update[:id] = 30
+    flag = @db.update( rec_to_update)
+    assert_nil(flag)
+  end
+
+  def test_destroy
+    10.times do |i|
+      record = { :key1 => i, :key2 => i.to_f}
+      @db.add( record)
+    end
+
+    found = @db.find_all do |r| true end
+    assert_equal( 10, found.size)
+    
+    # destroy by id
+    rec3 = @db.find_by_id(3)
+    flag = @db.destroy(3)
+    assert( flag)
+    assert_equal( rec3, flag)
+    found = @db.find_all do |r| true end
+    assert_equal( 9, found.size)
+    flag = found.find do |r| r[:id] == 3 end
+    assert_nil( flag)
+
+    flag = @db.destroy(30)
+    assert_nil( flag)
+    
+    # should be nil
+    flag = @db.destroy(3)
+    assert_nil( flag)
+    found = @db.find_all do |r| true end
+    assert_equal( 9, found.size)
+    
+    # destroy by array
+    destroyed = @db.destroy([1,3,9])
+    assert( destroyed[0])
+    assert_nil( destroyed[1])
+    assert( destroyed[2])
+    found = @db.find_all do |r| true end
+    assert_equal( 7, found.size)
+    flag = found.find do |r| r[:id] == 1 end
+    assert_nil( flag)
+    flag = found.find do |r| r[:id] == 9 end
+    assert_nil( flag)
+
+    # destroy by range
+    destroyed = @db.destroy( 9..10)
+    assert( destroyed)
+    destroyed = @db.destroy( 9..10)
+    assert_nil( destroyed)
+    found = @db.find_all do |r| true end
+    assert_equal( 6, found.size)
+    flag = found.find do |r| r[:id] == 10 end
+    assert_nil( flag)
+
+    # test max_id
+    @db.add( { :key1 => "11'th"} )
+    found = @db.find_all do |r| true end
+    assert_equal( 7, found.size)
+    flag = found.find do |r| r[:id] == 11 end
+    assert( flag)
+
+    # test type
+    assert_raise( ArgumentError) {
+      @db.destroy("hoge")
+    }
+  end
+
+  def test_block
+    10.times do |i|
+      record = { :key1 => i+1, :key2 => (i+1).to_f}
+      @db.add( record)
+    end
+
+    @db.transaction do
+      arr = @db.find_all do |rec|
+        rec[:id] <= 5
+      end
+      arr.each do |rec|
+        rec[:key1] += 100
+        @db.update( rec)
+      end
+    end
+
+    a = @db.find_all do |r| true end
+    assert_equal( 10, a.size)
+    a = @db.find_all do |rec| rec[:key1] > 100 end
+    assert_equal( 5, a.size)
+    flag = a.find do |rec| rec[:key1] == 101 end
+    assert( flag)
+    flag = a.find do |rec| rec[:key1] == 102 end
+    assert( flag)
+    flag = a.find do |rec| rec[:key1] == 103 end
+    assert( flag)
+    flag = a.find do |rec| rec[:key1] == 104 end
+    assert( flag)
+    flag = a.find do |rec| rec[:key1] == 105 end
+    assert( flag)
+
+    a = @db.find_all do |r| true end
+    t = nil
+    assert_raise(RuntimeError) {
+      @db.transaction {
+        t = @db.destroy(3)
+        raise RuntimeError
+      }
+    }
+    assert(t)
+    b = @db.find_all do |r| true end
+    assert_equal( a, b)
+
+  end
+
+end

data/test/test_nera_db_folders.rb

@@ -0,0 +1,209 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TC_NERA_DB_FOLDERS < Test::Unit::TestCase
+
+  def setup
+    @testdir = "test"
+    FileUtils.mkdir(@testdir)
+    FileUtils.chdir(@testdir)
+    
+    @db_folder = "nera_db"
+    NERA::DbFolders.create_db( @db_folder)
+    @dbf = NERA::DbFolders.new( @db_folder)
+  end
+  
+  def teardown
+    FileUtils.chdir('..')
+    FileUtils.rm_r(@testdir)
+  end
+
+  def test_constructor
+    FileUtils.mkdir("dummy")
+    assert_raise( RuntimeError) {
+      NERA::DbFolders.new("dummy")
+    }
+    assert_raise( RuntimeError) {
+      NERA::DbFolders.new("unknown")
+    }
+  end
+  
+  def test_createdb
+    assert( FileTest.directory?(@db_folder) )
+    assert( FileTest.directory?(@db_folder+"/Jobs/") )
+    assert( FileTest.directory?(@db_folder+"/Jobs/Include") )
+    assert( FileTest.directory?(@db_folder+"/Tables") )
+    assert( FileTest.directory?(@db_folder+"/Simulator_classes") )
+    assert( FileTest.exist?(@db_folder+"/Tables/jobs.pstore") )
+    assert( FileTest.exist?(@db_folder+"/simulators.yml") )
+    assert( FileTest.exist?(@db_folder+"/Jobs/jobs.yml") )
+    assert_raise( RuntimeError) {
+      NERA::DbFolders.create_db( @db_folder)
+    }
+
+  end
+  
+  def test_path_to_sim_layer
+    p = @dbf.path_to_simulator_layer
+    assert_equal( @db_folder+'/', p)
+  end
+
+  def test_path_to_sim_tables
+    p = @dbf.path_to_simulators_table
+    assert_equal( @db_folder+"/Tables/simulators.pstore", p)
+    p = @dbf.path_to_simulators_yaml
+    assert_equal( @db_folder+"/simulators.yml", p)
+  end
+
+  def test_create_new_simulator_folder
+    r = @dbf.create_new_simulator_folder( Ising )
+    assert_equal( true, r)
+    assert( FileTest.directory?( @db_folder+"/Ising/") )
+    assert( FileTest.directory?( @db_folder+"/Tables/Ising/") )
+    assert( FileTest.exist?( @db_folder+"/Ising/parameters.yml") )
+    
+    r = @dbf.create_new_simulator_folder( XY )
+    assert_equal( true, r)
+    assert( FileTest.directory?( @db_folder+"/XY/") )
+    assert( FileTest.directory?( @db_folder+"/Tables/XY/") )
+    assert( FileTest.exist?( @db_folder+"/XY/parameters.yml") )
+    
+    assert_raise( ArgumentError) {
+      @dbf.create_new_simulator_folder( Temp)
+    }
+    
+    r = @dbf.create_new_simulator_folder( Ising )
+    assert_nil( r)
+  end
+
+  def test_path_to_param_layer
+    r = @dbf.path_to_parameter_layer( Ising)
+    assert_nil(r)
+    r = @dbf.create_new_simulator_folder( Ising )
+    r = @dbf.path_to_parameter_layer( Ising)
+    assert_equal( @db_folder+"/Ising/", r)
+    assert_raise( ArgumentError) {
+      @dbf.path_to_parameter_layer( Temp)
+    }
+  end
+
+  def test_path_to_param_table
+    r = @dbf.path_to_parameters_table( Ising)
+    assert_nil(r)
+    r = @dbf.create_new_simulator_folder( Ising )
+    assert_equal( true, r)
+    r = @dbf.path_to_parameters_table( Ising)
+    assert_equal( @db_folder+"/Tables/Ising/parameters.pstore", r)
+    r = @dbf.path_to_parameters_yaml( Ising)
+    assert_equal( @db_folder+ "/Ising/parameters.yml", r)
+    assert_raise( ArgumentError) {
+      @dbf.path_to_parameters_table( Temp)
+    }
+  end
+
+  def test_create_new_param_folder
+    r = @dbf.create_new_parameter_folder( Ising, 5)
+    assert_nil( r)
+    @dbf.create_new_simulator_folder( Ising )
+    r = @dbf.create_new_parameter_folder( Ising, 1)
+    assert_equal( true, r)
+    assert( FileTest.directory?( @db_folder+"/Ising/00001/") )
+    assert( FileTest.directory?( @db_folder+"/Tables/Ising/00001/") )
+    assert( FileTest.exist?( @db_folder+"/Ising/00001/runs.yml") )
+    r = @dbf.create_new_parameter_folder( Ising, 2)
+    assert_equal( true, r)
+    assert( FileTest.directory?( @db_folder+"/Ising/00002/") )
+    assert( FileTest.directory?( @db_folder+"/Tables/Ising/00002/") )
+    assert( FileTest.exist?( @db_folder+"/Ising/00002/runs.yml") )
+    r = @dbf.create_new_parameter_folder( Ising, 2)
+    assert_equal( nil, r)
+    
+    assert_raise( RuntimeError) {
+      r = @dbf.create_new_parameter_folder( Ising, 100000)
+    }
+    assert_raise( RuntimeError) {
+      r = @dbf.create_new_parameter_folder( Ising, 0)
+    }
+    assert_raise( ArgumentError) {
+      @dbf.create_new_parameter_folder( Temp)
+    }
+  end
+
+  def test_path_to_run_layer
+    assert_raise( ArgumentError) {
+      s = @dbf.path_to_run_layer( Temp, 1)
+    }
+
+    s = @dbf.path_to_run_layer( Ising, 1)
+    assert_nil( s)
+    @dbf.create_new_simulator_folder( Ising)
+    s = @dbf.path_to_run_layer( Ising, 1)
+    assert_equal( false, FileTest.directory?(s))
+    @dbf.create_new_parameter_folder( Ising, 1)
+    s = @dbf.path_to_run_layer( Ising, 1)
+    assert_equal( @db_folder+"/Ising/00001/", s)
+
+    s = @dbf.path_to_run_layer( Ising, 1000)
+    assert_equal( @db_folder+"/Ising/01000/", s)
+  end
+
+  def test_path_to_runs_table
+    assert_raise( ArgumentError) {
+      s = @dbf.path_to_runs_table( Temp, 1)
+    }
+
+    s = @dbf.path_to_runs_table( Ising, 1)
+    assert_nil( s)
+    @dbf.create_new_simulator_folder( Ising)
+    s = @dbf.path_to_runs_table( Ising, 1)
+    assert_equal( false, FileTest.exist?(s))
+    @dbf.create_new_parameter_folder( Ising, 1)
+    s = @dbf.path_to_runs_table( Ising, 1)
+    assert_equal( @db_folder+"/Tables/Ising/00001/runs.pstore", s)
+    s = @dbf.path_to_runs_yaml( Ising, 1)
+    assert_equal( @db_folder+"/Ising/00001/runs.yml", s)
+
+    s = @dbf.path_to_runs_table( Ising, 999)
+    assert_equal( @db_folder+"/Tables/Ising/00999/runs.pstore", s)
+    s = @dbf.path_to_runs_yaml( Ising, 999)
+    assert_equal( @db_folder+"/Ising/00999/runs.yml", s)
+
+  end
+
+  def test_path_to_job_layer
+    p = @dbf.path_to_job_layer
+    assert_equal( @db_folder+"/Jobs/", p)
+  end
+
+  def test_path_to_jobs_table
+    p = @dbf.path_to_jobs_table
+    assert_equal( @db_folder+"/Tables/jobs.pstore", p)
+    p = @dbf.path_to_jobs_yaml
+    assert_equal( @db_folder+"/Jobs/jobs.yml", p)
+  end
+
+  def test_to_job_script( job_id)
+    p = @dbf.path_to_job_script(125)
+    assert_equal( @db_folder+"/Jobs/j000125.sh", p)
+  end
+
+  def test_path_to_include_layer
+    p = @dbf.path_to_include_layer
+    assert_equal( @db_folder+"/Jobs/Include/", p)
+  end
+
+  def test_search_include_files
+    FileUtils.touch( @dbf.path_to_include_layer + "j000001.tar.bz2")
+    FileUtils.touch( @dbf.path_to_include_layer + "j000003.tar.bz2")
+    FileUtils.touch( @dbf.path_to_include_layer + "j00001.tar.bz2")
+    should_be = [ @dbf.path_to_include_layer + "j000001.tar.bz2", @dbf.path_to_include_layer + "j000003.tar.bz2"]
+    l = @dbf.search_include_files
+    assert_equal( should_be, l)
+  end
+
+  def test_path_to_finished_jobs_file
+    p = @dbf.path_to_finished_jobs_file
+    assert_equal( @db_folder+"/Tables/finished_jobs.yml", p)
+  end
+
+end
+  

data/test/test_nera_dialog.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+class TC_NERA_DIALOG < Test::Unit::TestCase
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  def test_select_one
+    a = ["first","second","third"]
+    i = Dialog::select_one( a, "Input a number for a test of 'Dialog::select_one'", 1)
+    assert( i.is_a?(Integer) )
+    assert( i < 3 )
+    assert( i >= 0 )
+
+    b = []
+    assert_raise( ArgumentError) {
+      i = Dialog::select_one( b, "Select one")
+    }
+
+    c = "hoge"
+    assert_raise( ArgumentError) {
+      i = Dialog::select_one( c, "Select one")
+    }
+    
+    assert_raise( ArgumentError) {
+      i = Dialog::select_one( a, "Select one", 100)
+    }
+  end
+  
+  def test_select_one_or_return_string
+    a = ["first","second","third"]
+    i = Dialog::select_one_or_return_string( a, "Input a number for a test of 'Dialog::select_one_or_return_string'",2)
+    assert( i.is_a?(Integer) )
+    assert( i < 3 )
+    assert( i >= 0 )
+
+    i = Dialog::select_one_or_return_string( a, "Input a string for a test of 'Dialog::select_one_or_return_string'","test string")
+    assert( i.is_a?(String) )
+    
+    b = []
+    assert_raise( ArgumentError) {
+      i = Dialog::select_one_or_return_string( b, "Select one")
+    }
+    c = []
+    assert_raise( ArgumentError) {
+      i = Dialog::select_one_or_return_string( c, "Select one")
+    }
+  end
+
+  def test_select_many
+    a = ["first","second","third","fourth","fifth"]
+    s = Dialog::select_many( a, "Input 3 for a test of 'Dialog::select_many'", 3)
+    assert( s.is_a?(Array) )
+    assert_equal( 1, s.size)
+    assert( s[0].is_a?(Integer) )
+    assert( s[0] < a.size )
+    assert( s[0] >= 0)
+    
+    s = Dialog::select_many( a, "Input '0,3,4' for a test of 'Dialog::select_many'", '0,3,4')
+    assert( s.is_a?(Array) )
+    assert_equal( 3, s.size)
+    s.each do |i|
+      assert( i.is_a?(Integer) )
+      assert( i < a.size )
+      assert( i >= 0 )
+    end
+
+    s = Dialog::select_many( a, "Input '1-3' for a test of 'Dialog::select_many'", '1-3')
+    assert( s.is_a?(Array) )
+    assert_equal( 3, s.size)
+    s.each do |i|
+      assert( i.is_a?(Integer) )
+      assert( i < a.size )
+      assert( i >= 0)
+    end
+
+    b = []
+    assert_raise(ArgumentError) {
+      s = Dialog::select_many( b, "Input '1-3' for a test of 'Dialog::select_many'", '1-3')
+    }
+
+    c = "hoge"
+    assert_raise(ArgumentError) {
+      s = Dialog::select_many( c, "Input '1-3' for a test of 'Dialog::select_many'", '1-3')
+    }
+
+  end
+  
+  def test_message
+    str = "This is a test"
+    Dialog::message( str)
+  end
+
+  def test_set_multiple_values
+    arg = [ [:L,Integer,32], [:K,Float,0.22], [:txt,String,'hoge'] ]
+    h = Dialog::set_multiple_values( arg)
+    assert( h.is_a?(Hash) )
+    assert( h[:L].is_a?(Integer) )
+    assert( h[:K].is_a?(Float) )
+    assert( h[:txt].is_a?(String) )
+    assert_equal( 3, h.size)
+
+    arg = [ [:L,Integer], [:K,Float], [:txt,String] ]
+    assert_raise(ArgumentError) {
+      h = Dialog::set_multiple_values( arg)
+    }
+    arg = [ [:L,32], [:K,0.22], [:txt,"hoge"] ]
+    assert_raise(ArgumentError) {
+      h = Dialog::set_multiple_values( arg)
+    }
+    arg = [ [:L,Integer,32], [:K,Float,0.22], [:L,String,"hoge"] ]
+    assert_raise(ArgumentError) {
+      h = Dialog::set_multiple_values( arg)
+    }
+
+  end
+
+  def test_get_integer
+    s = Dialog::get_integer( "Input a positive number", 0) do |i|
+      i >= 0
+    end
+    assert( s.is_a?(Integer))
+    assert( s >= 0 )
+
+    assert_raise( ArgumentError) {
+      Dialog::get_integer( "Input a number", "hoge")
+    }
+  end
+    
+  end

data/test/test_nera_job_layer_controller.rb

@@ -0,0 +1,132 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+
+class TC_NERA_JOB_LAYER_CONTROLLER < Test::Unit::TestCase
+
+  def setup
+    @testdir = 'test_sim_controller'
+    FileUtils.mkdir(@testdir)
+    FileUtils.chdir(@testdir)
+    @db_folder = "nera_db"
+    NERA::DbFolders.create_db( @db_folder)
+    @dbf = NERA::DbFolders.new( @db_folder)
+    @slc = NERA::SimulatorLayerController.new( @db_folder)
+    @plc = NERA::ParameterLayerController.new( @db_folder, Ising)
+    pid = @plc.create_a_new_parameter_set({:L => 32, :K => 0.01, :tmax => 1})
+    @rlc = NERA::RunLayerController.new( @db_folder, Ising, pid)
+    @rlc.create_jobs( 3, 1)
+    @jlc = NERA::JobLayerController.new( @db_folder)
+  end
+
+  def teardown
+    FileUtils.chdir('..')
+    FileUtils.rm_r(@testdir)
+  end
+  
+  def test_constructor
+    assert_raise( ArgumentError) {
+      NERA::JobLayerController.new( @dbf)
+    }
+  end
+  
+  def test_path_to_job_layer
+    assert_equal( @dbf.path_to_job_layer, @jlc.path_to_job_layer)
+  end
+
+  def test_not_finished_list_in_csv
+    h, l = @jlc.not_finished_list_in_csv
+    assert_equal( "id, state, simulator, param_id, run_id, num_runs, created_at, updated_at, host_name", h)
+    assert_equal( 3, l.size)
+    dstr = DateTime.now.to_s.split('T')[0]
+    assert_equal( "1, created, Ising, 1, 1, 1, #{dstr}, #{dstr}, ", l[0])
+    assert_equal( "2, created, Ising, 1, 2, 1, #{dstr}, #{dstr}, ", l[1])
+    assert_equal( "3, created, Ising, 1, 3, 1, #{dstr}, #{dstr}, ", l[2])
+
+    f = @jlc.cancel_jobs( [2])
+    h, l = @jlc.not_finished_list_in_csv
+    assert_equal( "id, state, simulator, param_id, run_id, num_runs, created_at, updated_at, host_name", h)
+    assert_equal( 2, l.size)
+    assert_equal( "1, created, Ising, 1, 1, 1, #{dstr}, #{dstr}, ", l[0])
+    assert_equal( "3, created, Ising, 1, 3, 1, #{dstr}, #{dstr}, ", l[1])
+  end
+
+  def test_cancel_jobs
+    assert_raise( ArgumentError) {
+      @jlc.cancel_jobs(1)
+    }
+
+    f = @jlc.cancel_jobs( [1,2] )
+    assert(f)
+    h, l = @jlc.not_finished_list_in_csv
+    assert_equal( 1, l.size)
+    assert_equal( 3, l[0].split(',')[0].to_i)
+
+    flag = File.exist?( @dbf.path_to_job_script(1))
+    assert_equal( false, flag)
+    flag = File.exist?( @dbf.path_to_job_script(2))
+    assert_equal( false, flag)
+
+    h, l = @rlc.not_finished_jobs_list_in_csv
+    assert_equal( 1, l.size)
+
+    f = @jlc.cancel_jobs( [1000] )
+    assert_nil( f)
+  end
+
+  def test_include_list
+    l = @jlc.include_list
+    assert_equal( 0, l.size)
+    
+    FileUtils.touch( @dbf.path_to_include_layer + "j000001.tar.bz2")
+    FileUtils.touch( @dbf.path_to_include_layer + "j000003.tar.bz2")
+    l = @jlc.include_list
+    assert_equal( ["j000001.tar.bz2","j000003.tar.bz2"], l)
+
+    FileUtils.touch( @dbf.path_to_include_layer + "g000001.tar.bz2")
+    l2 = @jlc.include_list
+    assert_equal( l, l2)
+  end
+  
+  def test_include
+    prepare_zipped_file
+    fname = "j000001.tar.bz2"
+    @jlc.include(fname)
+    f = FileTest.exist?(fname)
+    assert_equal( false, f)
+    count = 0
+    File.open( @dbf.path_to_finished_jobs_file, 'r') do |io|
+      YAML.load_documents( io) do |doc|
+        p doc
+        count += 1
+      end
+    end
+    assert_equal( 1, count)
+    h, l = @jlc.not_finished_list_in_csv
+    assert_equal( 2, l.size)
+    h, l = @rlc.not_finished_jobs_list_in_csv
+    assert_equal( 2, l.size)
+  end
+
+  def test_include_all
+    prepare_zipped_file
+    @jlc.include_all
+    a = Dir.glob( @dbf.path_to_include_layer + "*" )
+    assert_equal( [], a)
+    h, l = @jlc.not_finished_list_in_csv
+    assert_equal( [], l)
+    h, l = @rlc.not_finished_jobs_list_in_csv
+    assert_equal( [], l)
+  end
+
+  def prepare_zipped_file
+    Dir.chdir( @dbf.path_to_job_layer) {
+      system "sh ./j000001.sh"
+      system "mv j000001.tar.bz2 Include/"
+      system "sh ./j000002.sh"
+      system "mv j000002.tar.bz2 Include/"
+      system "sh ./j000003.sh"
+      system "mv j000003.tar.bz2 Include/"
+    }
+  end
+  
+end