bc3 0.1.0

data/lib/bc3/time.rb

@@ -0,0 +1 @@
+=begin rdoc
  bignum too big to convert into `unsigned long' (RangeError)
  AD_EPOCH      = 116_444_736_000_000_000
  AD_MULTIPLIER = 10_000_000
  # convert a Time object to AD's epoch
  def time2ad()
    (self.to_i * AD_MULTIPLIER) + AD_EPOCH
  end
  # convert from AD's time string to a Time object
  def self.ad2time(time)
    Time.at((time.to_i - AD_EPOCH) / AD_MULTIPLIER)
  end

data/unittest/unittest_bc3.rb

@@ -0,0 +1,66 @@
+gem 'test-unit'
+require 'test/unit'
+
+$:.unshift('../lib')
+require 'bc3'
+
+class Test_helper < Test::Unit::TestCase
+  include BC3::Helper
+  def test_fixnum2int64()
+    assert_equal("\x05\x00\x00\x00\x00\x00\x00\x00", fixnum2int64(5))
+    assert_equal("\xff\x00\x00\x00\x00\x00\x00\x00", fixnum2int64(255))
+    assert_equal("\x00\x01\x00\x00\x00\x00\x00\x00", fixnum2int64(256))
+    assert_equal("\x01\x01\x00\x00\x00\x00\x00\x00", fixnum2int64(257))
+    assert_equal("\x00\x04\x00\x00\x00\x00\x00\x00", fixnum2int64(1024))
+  end
+  def test_fixnum2int32()
+    assert_equal("\x05\x00\x00\x00", fixnum2int32(5))
+    assert_equal("\xff\x00\x00\x00", fixnum2int32(255))
+    assert_equal("\x00\x01\x00\x00", fixnum2int32(256))
+    assert_equal("\x01\x01\x00\x00", fixnum2int32(257))
+    assert_equal("\x00\x04\x00\x00", fixnum2int32(1024))
+  end
+  def test_crc32()
+    assert_equal('CBF43926', '%X' % BC3::Helper.crc32('123456789'))
+    assert_equal('D87F7E0C', '%X' % BC3::Helper.crc32('test'))
+  end
+end
+
+
+class Test_time < Test::Unit::TestCase
+  #Nonoseconds are ignored (missing feature in Time-class?)
+  def test_ad2time()
+    assert_equal('2006-08-17 09:19:04 000000000', 
+          Time.ad2time(128002727440808261).strftime("%Y-%m-%d %H:%M:%S %9N")
+          )
+    assert_equal('2006-08-17 09:19:04 000000000', 
+          Time.ad2time(128002727440000000).strftime("%Y-%m-%d %H:%M:%S %9N")
+          )
+  end
+  def test_time2ad()
+    assert_equal(128002464000000000, Time.utc(2006,8,17).time2ad())
+    assert_equal(128002727440000000, Time.local(2006,8,17,9,19,4).time2ad())
+    
+    #Test does not work. Split in two areas (high/Low) makes calculating unpossible.
+    #~ p 60 * 60 * 1_000_000_000  #one hour in nanoseconds
+    #~ assert_equal( 3_600_000_000_000, #one hour in nanoseconds
+        #~ Time.utc(2006,8,17,12).time2ad() - Time.utc(2006,8,17,11).time2ad()
+    #~ )
+
+    #~ assert_equal( 3_600_000_000_000, #one hour in nanoseconds
+        #~ Time.utc(2006,8,17).time2ad() - Time.local(2006,8,17).time2ad()
+    #~ )
+  end
+  def test_conversions()
+    testtime = Time.utc(2006,8,17)
+    assert_equal(testtime, Time.ad2time(testtime.time2ad))
+    
+    testtime = Time.local(2006,8,17)
+    assert_equal(testtime, Time.ad2time(testtime.time2ad))
+    
+    #Test with now does not work. Changed nanoseconds?
+    #~ testtime = Time.now
+    #~ assert_equal(testtime, Time.ad2time(testtime.time2ad))
+  end
+end
+

data/unittest/unittest_bc3_file.rb

@@ -0,0 +1,35 @@
+gem 'test-unit'
+require 'test/unit'
+require 'yaml'
+
+$:.unshift('../lib')
+require 'bc3'
+$log.level = Log4r::FATAL
+
+#<just a timestamp for testing
+$timestamp= Time.local(2010,1,1)
+
+class Test_file < Test::Unit::TestCase
+  def self.startup
+    $log.level = Log4r::FATAL
+  end
+  def test_interface()
+    #Test all keys
+    assert_nothing_raised{ BC3::File.new( filename: 'f', filesize: 5, crc: 4, timestamp: Time.now )}
+    #Test all needed keys
+    assert_nothing_raised{ BC3::File.new( filename: 'f', filesize: 5 )}
+    #Test additional key (returns warning in log)
+    assert_nothing_raised{ BC3::File.new( filename: 'f', filesize: 5, xxx: nil )}
+    #Must be a hash
+    assert_raise(ArgumentError){ BC3::File.new( 'f' )}
+    assert_raise(ArgumentError){ BC3::File.new( 1 )}
+  end
+  def test_hash()
+    assert_equal(   { filename: 'f', filesize: 5, timestamp: $timestamp, attributes: BC3::Attrib::Archive, crc: nil},
+        BC3::File.new( filename: 'f', filesize: 5, timestamp: $timestamp ).to_hash
+      )
+    assert_equal(   { filename: 'f', filesize: 5, crc: 27, timestamp: $timestamp, attributes: 127 },
+        BC3::File.new( filename: 'f', filesize: 5, crc: 27, timestamp: $timestamp, attributes: 127 ).to_hash
+      )
+  end
+end

data/unittest/unittest_bc3_folder.rb

@@ -0,0 +1,179 @@
+gem 'test-unit'
+require 'test/unit'
+require 'yaml'
+
+$:.unshift('../lib')
+require 'bc3'
+$log.level = Log4r::FATAL
+
+#<just a timestamp for testing
+$timestamp= Time.local(2010,1,1)
+
+class Test_folder < Test::Unit::TestCase
+  def test_add_content()
+    folder = BC3::Folder.new('x')
+    assert_nothing_raised{ folder << BC3::Folder.new('dir1')}
+    assert_nothing_raised{ folder << BC3::File.new( filename: 'file1', filesize: 1) }
+    assert_raise(ArgumentError){ folder << 1 }
+    
+    assert_equal(2, folder.each.size)
+  end
+  def test_add_duplicate_filename()
+    folder = BC3::Folder.new('x')
+    assert_nothing_raised{ folder << BC3::Folder.new('name')}
+    #Overwrite content (Warning)
+    assert_nothing_raised{ folder << BC3::File.new( filename: 'name', filesize: 1) }
+    assert_equal(1, folder.each.size)
+    assert_kind_of(BC3::File, folder.each.first.last)
+    
+  end
+  def test_hash()
+    folder = BC3::Folder.new('dir', $timestamp)
+    folder << BC3::File.new( filename: 'f', filesize: 5, timestamp: $timestamp )
+    assert_equal(   
+      {
+        dirname: 'dir',
+        timestamp: $timestamp,
+        attributes: BC3::Attrib::Directory,
+        content: [
+          { filename: 'f', filesize: 5, timestamp: $timestamp, crc: nil, attributes: BC3::Attrib::Archive,},
+        ]
+      },
+        folder.to_hash
+      )    
+    end
+  def test_newh_interface()
+    #Test no-hash
+    assert_raise(ArgumentError){ BC3::Folder.newh('x')}
+    assert_raise(ArgumentError){ BC3::Folder.newh('1')}
+    #Hash must contain dirname (and content?)
+    assert_raise(ArgumentError){ BC3::Folder.newh({})}
+    #~ assert_raise(ArgumentError){ BC3::Folder.newh({dirname: 'x' })}
+    #~ assert_raise(ArgumentError){ BC3::Folder.newh({dirname: 'x' })}
+    #~ assert_raise(ArgumentError){ BC3::Folder.newh({dirname: 'x', timestamp: $timestamp })}
+    
+    assert_nothing_raised{ bc3 = BC3::Folder.newh({ dirname: 'x', content: [] })}
+    #Content must be an array
+    assert_raise(ArgumentError){ bc3 = BC3::Folder.newh({ dirname: 'x', content: :x })}
+  end
+
+  def test_newh()
+    hash = {
+      dirname: 'dir', timestamp: $timestamp, attributes: BC3::Attrib::Directory,
+      content: [
+        filename: 'file1', filesize: 5, timestamp: $timestamp, crc: nil, attributes: BC3::Attrib::Archive,
+      ]      
+    }
+    assert_equal(hash, BC3::Folder.newh( hash ).to_hash)
+    
+    hash = {
+      dirname: 'dir', timestamp: $timestamp, attributes: BC3::Attrib::Directory,
+      content: []      
+    }
+    assert_equal(hash, BC3::Folder.newh( hash ).to_hash)
+    #Test w/o content
+    assert_equal(hash, BC3::Folder.newh( {dirname: 'dir', timestamp: $timestamp} ).to_hash)
+  end
+  def test_newh_yaml()
+    hash = YAML.load(%{
+    :dirname: dir
+    :timestamp: 2011-01-21 11:57:22 +01:00
+    :attributes: 16
+    :content: 
+    - :filename: file1
+      :filesize: 5
+      :crc: 
+      :attributes: 32
+      :timestamp: 2011-01-21 11:57:22 +01:00
+    })
+    assert_equal(hash, BC3::Folder.newh( hash ).to_hash)
+    
+    hash = {
+      dirname: 'dir', timestamp: $timestamp, attributes: BC3::Attrib::Directory,
+      content: []      
+    }
+    assert_equal(hash, BC3::Folder.newh( hash ).to_hash)
+    #Test w/o content
+    assert_equal(hash, BC3::Folder.newh( {dirname: 'dir', timestamp: $timestamp} ).to_hash)
+    
+  end
+  
+  def test_each_file()
+    hash = {
+      dirname: 'dir', timestamp: $timestamp, attributes: BC3::Attrib::Directory,
+      content: [
+        filename: 'file1', filesize: 5, timestamp: $timestamp, crc: nil, attributes: BC3::Attrib::Archive,
+      ]      
+    }
+    folder =  BC3::Folder.newh( hash )
+    #each without block
+    assert_instance_of(Hash, folder.each)
+    
+    folder.each{|key, object|
+      assert_equal('file1', key)
+      assert_instance_of(BC3::File, object)
+    }
+  end
+
+  def test_each()
+    folder =  BC3::Folder.newh( YAML.load(%{
+          :dirname: dir
+          :content: 
+          - :dirname: subdir
+            :content:
+            - :filename: subfile
+              :filesize: 10
+          - :filename: file1
+            :filesize: 5
+          - :filename: file2
+            :filesize: 15
+      }))
+    #each without block
+    assert_instance_of(Hash, folder.each)
+    assert_equal(3, folder.each.size)
+    assert_equal(2, folder.each(:files).size)
+    assert_equal(1, folder.each(:folders).size)
+    
+    assert_equal(%w{subdir file1 file2}, folder.each.keys)
+    assert_equal(%w{file1 file2}, folder.each(:files).keys)
+    assert_equal(%w{subdir}, folder.each(:folders).keys)
+    
+    assert_equal(1, folder.each(:folders, :recursive).size)
+    assert_equal(3, folder.each(:files, :recursive).size)
+    assert_equal(4, folder.each(:folders,:files, :recursive).size)
+    
+    
+    assert_equal(%w{subdir}, folder.each(:folders, :recursive).keys)
+    assert_equal(%w{subdir/subfile file1 file2}, folder.each(:files, :recursive).keys)
+    assert_equal(%w{subdir subdir/subfile file1 file2}, folder.each(:folders,:files, :recursive).keys)
+    
+  end
+
+  def test_each_2()
+    folder =  BC3::Folder.newh( YAML.load(%{
+          :dirname: dir
+          :content: 
+          - :dirname: subdir
+            :content:
+            - :dirname: subsubdir
+              :content:
+              - :filename: subsubfile
+                :filesize: 10
+            - :filename: subfile
+              :filesize: 10
+          - :filename: file
+            :filesize: 5
+      }))
+    #each without block
+    
+    assert_equal(2, folder.each(:folders, :recursive).size)
+    assert_equal(3, folder.each(:files, :recursive).size)
+    assert_equal(5, folder.each(:folders,:files, :recursive).size)
+    
+    assert_equal(%w{subdir subdir/subsubdir}, folder.each(:folders, :recursive).keys)
+    assert_equal(%w{subdir/subsubdir/subsubfile subdir/subfile file}, folder.each(:files, :recursive).keys)
+    assert_equal(%w{subdir subdir/subsubdir subdir/subsubdir/subsubfile subdir/subfile file}, folder.each(:folders,:files, :recursive).keys)
+    
+  end
+end
+

data/unittest/unittest_bc3_merge.rb

@@ -0,0 +1,102 @@
+gem 'test-unit'
+require 'test/unit'
+
+$:.unshift('../lib')
+require 'bc3'
+$log.level = Log4r::WARN
+
+#<just a timestamp for testing
+$timestamp= Time.local(2010,1,1)
+class Time
+  def self.now()
+    $timestamp
+  end
+end
+
+#Start with local sources
+$call_bc3_merge = 'ruby -I ../lib ../bin/bc3_merge.rb'
+
+
+class Test_merge < Test::Unit::TestCase
+  Snap1 = { 
+        snapshot: 'c:\usr\snap1',
+        timestamp: $timestamp,
+        content: [
+          {
+            dirname: 'dir1',
+            timestamp: $timestamp,
+            attributes: BC3::Attrib::Directory,
+            content: [
+              { filename: 'file1_1', filesize: 1, timestamp: $timestamp, crc: 111, attributes: BC3::Attrib::Archive },
+            ]
+          }
+        ],
+      }
+  Snap2 = { 
+        snapshot: 'c:\usr\snap2',
+        timestamp: $timestamp,
+        content: [
+          {
+            dirname: 'dir2',
+            timestamp: $timestamp,
+            attributes: BC3::Attrib::Directory,
+            content: [
+              { filename: 'file2_1', filesize: 2, timestamp: $timestamp, crc: 222, attributes: BC3::Attrib::Archive },
+            ]
+          }
+        ],
+      }
+  TestFiles = %w{snap1.bcss snap2.bcss
+          merge_i.bcss merge_b_1.bcss merge_b_2.bcss merge_r.bcss 
+    }
+      
+  def self.startup
+    TestFiles.each{|f| File.delete(f) if File.exist?(f)}
+    BC3::Snapshot.newh(Snap1).save('snap1.bcss')
+    BC3::Snapshot.newh(Snap2).save('snap2.bcss')
+  end
+  
+  def self.shutdown
+    TestFiles.each{|f| File.delete(f) if File.exist?(f)}
+  end
+  
+  def test_merge_b_1()
+    mergetest_b('merge_b_1.bcss', "-s merge_b -t merge_b_1.bcss -b 'snap?.bcss'")
+  end
+  def test_merge_b_2()
+    mergetest_b('merge_b_2.bcss', '-s merge_b -t merge_b_2.bcss snap?.bcss')
+  end
+  #~ def test_merge_r()
+    #~ mergetest_b('merge_r.bcss', "-s merge_b -t merge_r.bcss -r 'snap?.bcss'")
+  #~ end
+  def mergetest_b(filename, par)
+    assert_false(File.exist?(filename))
+    `#{$call_bc3_merge} #{par}`
+    assert_true(File.exist?(filename))
+    
+    result = BC3::SnapshotParser.new(filename).snapshot.to_hash
+    merge = { 
+      snapshot: 'merge_b',
+      timestamp: result[:timestamp],
+      content: [
+        { dirname: 'snap1', timestamp: $timestamp, attributes: 16, content: Snap1[:content] },
+        { dirname: 'snap2', timestamp: $timestamp, attributes: 16, content: Snap2[:content] },
+        ]
+      }
+    assert_equal(merge, result)
+  end
+  
+  def test_merge_i()
+    assert_false(File.exist?('merge_i.bcss'))
+    `#{$call_bc3_merge} -s merge_i -t merge_i.bcss -i 'snap?.bcss'`
+    assert_true(File.exist?('merge_i.bcss'))
+    
+    result = BC3::SnapshotParser.new('merge_i.bcss').snapshot.to_hash
+    merge = { 
+      snapshot: 'merge_i',
+      timestamp: result[:timestamp],
+      content: Snap1[:content] + Snap2[:content]
+      }
+    assert_equal(merge, result)
+  end
+end

data/unittest/unittest_bc3_snapshot.rb

@@ -0,0 +1,121 @@
+gem 'test-unit'
+require 'test/unit'
+require 'yaml'
+
+$:.unshift('../lib')
+require 'bc3'
+$log.level = Log4r::FATAL
+
+#<just a timestamp for testing
+$timestamp= Time.local(2010,1,1)
+
+class Test_snapshot < Test::Unit::TestCase
+  def test_add_content()
+    bc3 = BC3::Snapshot.new('x')
+    assert_nothing_raised{ bc3 << BC3::Folder.new('dir')}
+    assert_nothing_raised{ bc3 << BC3::File.new( filename: 'file', filesize: 1 )}
+    assert_raise(ArgumentError){ bc3 << 1 }
+    
+    assert_equal(2, bc3.each.size)
+  end
+  def test_hash()
+    bc3 = BC3::Snapshot.new('x', $timestamp)
+    bc3 << folder = BC3::Folder.new('dir', $timestamp)
+    folder << BC3::File.new( filename: 'f', filesize: 5, timestamp: $timestamp )
+    
+    assert_equal(
+      { snapshot: 'x',
+        timestamp: $timestamp,
+        content: [
+          {
+            dirname: 'dir',
+            timestamp: $timestamp,
+            attributes: BC3::Attrib::Directory,
+            content: [
+              { filename: 'f', filesize: 5, timestamp: $timestamp, crc: nil, attributes: BC3::Attrib::Archive },
+            ]
+          }
+        ],
+      }, bc3.to_hash
+    )    
+  end
+  def test_newh_interface()
+    #Test no-hash
+    assert_raise(ArgumentError){ BC3::Snapshot.newh('x')}
+    assert_raise(ArgumentError){ BC3::Snapshot.newh('1')}
+    #Hash must contain snapshot and content
+    assert_raise(ArgumentError){ BC3::Snapshot.newh({})}
+    assert_raise(ArgumentError){ BC3::Snapshot.newh({snapshot: 'x' })}
+    assert_raise(ArgumentError){ BC3::Snapshot.newh({snapshot: 'x' })}
+    assert_raise(ArgumentError){ BC3::Snapshot.newh({snapshot: 'x', timestamp: $timestamp })}
+    
+    assert_nothing_raised{ bc3 = BC3::Snapshot.newh({ snapshot: 'x', content: [] })}
+    #Content must be an array
+    assert_raise(ArgumentError){ bc3 = BC3::Snapshot.newh({ snapshot: 'x', content: :x })}
+  end
+  def test_newh()
+    hash = {     snapshot: 'x', timestamp: $timestamp,
+      content: [
+        filename: 'file1', filesize: 5, timestamp: $timestamp, crc: nil, attributes: BC3::Attrib::Archive,
+      ]      
+    }
+    assert_equal(hash, BC3::Snapshot.newh( hash ).to_hash)
+    
+    hash[:content] << { filename: 'file2', filesize: 15, timestamp: $timestamp, crc: nil, attributes: BC3::Attrib::Archive, }
+    assert_equal(hash, BC3::Snapshot.newh( hash ).to_hash)
+    
+    hash[:content] << { dirname: 'dir1', timestamp: $timestamp, :content => [], attributes: BC3::Attrib::Directory, }
+    assert_equal(hash, BC3::Snapshot.newh( hash ).to_hash)
+  end
+  def test_newd()
+    bc3 = BC3::Snapshot.newd( '../examples/folder1' )
+    
+    #timestamp change
+    #~ assert_equal(%{
+          #~ :snapshot: C:/usr/Script/bc3/examples/folder1
+          #~ :timestamp: 2011-01-21 23:53:45.875000 +01:00
+          #~ :content: 
+          #~ - :filename: file1.txt
+            #~ :filesize: 0
+            #~ :crc: 0
+            #~ :attributes: 32
+            #~ :timestamp: 2011-01-21 16:58:38 +01:00
+          #~ }, bc3.to_hash.to_yaml)
+    
+    assert_equal(1, bc3.each.size)
+    assert_equal(1, bc3.each(:files).size)
+    assert_equal(1, bc3.each(:recursive).size)
+    assert_equal(1, bc3.each(:recursive, :files).size)
+    
+    assert_equal('file1.txt', bc3.each.first.first)
+    
+  end
+  def test_new_list()
+    pend 'BC3::Snapshot.new_list'
+    bc3 = BC3::Snapshot.new_list( 'dir', %w{
+                file
+                folder/file1
+                folder/subfolder/subfile1
+                folder/subfolder2/
+      }
+    )
+    
+    assert_equal(2, bc3.each.size)
+    assert_equal(1, bc3.each(:files).size)
+    assert_equal(5, bc3.each(:recursive).size)
+    assert_equal(2, bc3.each(:recursive, :files).size)
+    assert_equal(3, bc3.each(:recursive, :folders).size)
+
+    assert_equal( %w{
+                file
+                folder
+                folder/file1
+                folder/subfolder
+                folder/subfolder/subfile1
+                folder/subfolder2
+      }, bc3.each(:recursive, :files).keys)
+    
+    
+  end
+end
+