rcs-common 9.6.0

data/test/test_mime.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+class TestRcsCommon < Test::Unit::TestCase
+
+  def test_mime_cod
+    mime = RCS::MimeType::get('test.cod')
+    expected = 'application/vnd.rim.cod'
+    assert_equal expected, mime
+  end
+
+  def test_mime_jad
+    mime = RCS::MimeType::get('test.jad')
+    expected = 'text/vnd.sun.j2me.app-descriptor'
+    assert_equal expected, mime
+  end
+
+  def test_mime_jnlp
+    mime = RCS::MimeType::get('test.jnlp')
+    expected = 'application/x-java-jnlp-file'
+    assert_equal expected, mime
+  end
+
+  def test_mime_cab
+    mime = RCS::MimeType::get('test.cab')
+    #expected = 'application/vnd.ms-cab-compressed'
+    # fucking IE mobile not understanding the real mime type
+    expected = 'binary/octet-stream'
+    assert_equal expected, mime
+  end
+
+  def test_mime_apk
+    mime = RCS::MimeType::get('test.apk')
+    expected = 'application/vnd.android.package-archive'
+    assert_equal expected, mime
+  end
+
+  def test_mime_exe
+    mime = RCS::MimeType::get('test.exe')
+    expected = 'application/x-msdos-program'
+    assert_equal expected, mime
+  end
+
+  def test_mime_unknown
+    mime = RCS::MimeType::get('test.unknown')
+    expected = 'binary/octet-stream'
+    assert_equal expected, mime
+  end
+
+end

data/test/test_pascalize.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+
+require 'helper'
+require 'securerandom'
+
+class PascalizeTest < Test::Unit::TestCase
+  def test_pascalize
+    source = "ciao"
+    #            length             c            i            a            o           null
+    dest = "\x0a\x00\x00\x00" + "\x63\x00" + "\x69\x00" + "\x61\x00" + "\x6f\x00" + "\x00\x00"
+    pascal = source.pascalize
+    assert_equal dest, pascal
+    # this is a stream of bytes represented as ASCII
+    assert_equal 'ASCII-8BIT', pascal.encoding.to_s
+  end
+
+  def test_unpascalize
+    #              length             c            i            a            o           null
+    source = "\x0a\x00\x00\x00" + "\x63\x00" + "\x69\x00" + "\x61\x00" + "\x6f\x00" + "\x00\x00"
+    dest = "ciao"
+    pascal = source.unpascalize
+    assert_equal dest, pascal
+    assert_equal dest.encoding, pascal.encoding
+  end
+
+  def test_pascalize_unicode
+    source = "スパイ"
+    #            length             ス            パ            イ         null
+    dest = "\x08\x00\x00\x00" + "\xb9\x30" + "\xd1\x30" + "\xa4\x30" + "\x00\x00"
+    pascal = source.pascalize
+    # we have to force the comparison in BINARY (alias for ASCII-8BIT) otherwise the
+    # assert_equal function will complain about invalid UTF-8 sequence
+    assert_equal dest.force_encoding('BINARY'), pascal.force_encoding('BINARY')
+  end
+
+  def test_unpascalize_unicode
+    #              length             ス            パ            イ         null
+    source = "\x08\x00\x00\x00" + "\xb9\x30" + "\xd1\x30" + "\xa4\x30" + "\x00\x00"
+    dest = "スパイ"
+    pascal = source.unpascalize
+    assert_equal dest, pascal
+  end
+
+  def test_pascalize_with_zero
+    source = "a\x00s"
+    #            length             a           null           s          null
+    dest = "\x08\x00\x00\x00" + "\x61\x00" + "\x00\x00" + "\x73\x00" + "\x00\x00"
+    assert_equal dest, source.pascalize
+  end
+
+  def test_unpascalize_with_zero
+    #              length             a           null           s          null
+    source = "\x08\x00\x00\x00" + "\x61\x00" + "\x00\x00" + "\x73\x00" + "\x00\x00"
+    dest = "a\x00s"
+    pascal = source.unpascalize
+    assert_equal dest, pascal
+    assert_equal dest.encoding, pascal.encoding
+  end
+
+  def test_pascalize_null
+    source = ""
+    #            length            null
+    dest = "\x02\x00\x00\x00" + "\x00\x00"
+    assert_equal dest, source.pascalize
+  end
+
+  def test_unpascalize_null
+    #              length            null
+    source = "\x02\x00\x00\x00" + "\x00\x00"
+    dest = ""
+    assert_equal dest, source.unpascalize
+  end
+  
+  def test_unpascalize_multi
+    multi_source = "\x0a\x00\x00\x00\x41\x00\x4c\x00\x6f\x00\x52\x00\x00\x00" +
+                   "\x08\x00\x00\x00\xb9\x30\xd1\x30\xa4\x30\x00\x00" +
+                   "\x1c\x00\x00\x00\x31\x00\x39\x00\x32\x00\x2e\x00\x31\x00\x36\x00\x38\x00\x2e\x00\x31\x00\x2e\x00\x31\x00\x37\x00\x35\x00\x00\x00"
+    multi_dest = ["ALoR", "スパイ", "192.168.1.175"]
+    assert_equal multi_dest, multi_source.unpascalize_ary
+  end
+
+  def test_unpascalize_multi_and_random
+    multi_source = "\x0a\x00\x00\x00c\x00i\x00a\x00o\x00\x00\x00" +
+                   "\x0a\x00\x00\x00m\x00i\x00a\x00o\x00\x00\x00" +
+                   "\x08\x00\x00\x00b\x00a\x00o\x00\x00\x00" +
+                   SecureRandom.random_bytes(32)
+
+    # the last part of random bytes should be ignored as error
+    multi_dest = ["ciao", "miao", "bao"]
+    assert_equal multi_dest, multi_source.unpascalize_ary
+  end
+
+  def test_unpascalize_random
+    source = SecureRandom.random_bytes(64)
+
+    assert_nil source.unpascalize
+    assert_equal [], source.unpascalize_ary
+  end
+
+end

data/test/test_path_utils.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'helper'
+require 'rcs-common/path_utils'
+
+class PathutilsTest < Test::Unit::TestCase
+
+  class IncludePathUtils; include RCS::Common::PathUtils; end
+
+	def setup
+    @subject = IncludePathUtils.new
+  end
+
+  def test_require_release
+    assert_raise { @subject.require_release 'folder/file' }
+    assert_raise { @subject.require_release 'rcsdb/folder/folder/file' }
+
+    assert_respond_to(Object.new, :require_release)
+    assert_respond_to(self, :require_release)
+
+    assert_raise(LoadError) { @subject.require_release 'rcs-project/file1' }
+    assert_raise(LoadError) { @subject.require_release 'rcs-project-release/file1' }
+  end
+end

data/test/test_rcs-common.rb

@@ -0,0 +1,7 @@
+require 'helper'
+
+class TestRcsCommon < Test::Unit::TestCase
+  def test_something_for_real
+  #  flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/test/test_sanitize.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+
+require "test/unit"
+
+class SanitizeTest < Test::Unit::TestCase
+
+  def test_binary
+    input = "keep this and not those \x90 \x91 \x92"
+    output = 'keep this and not those '
+    assert_equal output, input.remove_invalid_chars
+  end
+
+  def test_punctuation
+    input = "keep all .,;:!? and also @#%&*()[]{}\"'\\/+="
+    output = "keep all .,;:!? and also @#%&*()[]{}\"'\\/+="
+    assert_equal output, input.remove_invalid_chars
+  end
+
+  def test_specials
+    input = "keep them \$ ^ |"
+    output = "keep them \$ ^ |"
+    assert_equal output, input.remove_invalid_chars
+  end
+
+  def test_strip_html_tags
+    input = "Strip <i>these</i> tags!"
+    output = "Strip these tags!"
+    assert_equal output, input.strip_html_tags
+
+    input = "<b>Bold</b> no more!  <a href='more.html'>See more here</a>..."
+    output = "Bold no more!  See more here..."
+    assert_equal output, input.strip_html_tags
+
+    input = "<div id='top-bar'>Welcome to my website!</div>"
+    output = "Welcome to my website!"
+    assert_equal output, input.strip_html_tags
+  end
+
+
+end

data/test/test_serialization.rb

@@ -0,0 +1,20 @@
+require "helper"
+
+class TestSerialization < Test::Unit::TestCase
+
+  # Fake test
+  def test_generate_prefix
+    type = 0xff
+    size = 0xaabbcc
+
+    assert_equal "\xCC\xBB\xAA\xFF".force_encoding('BINARY'), RCS::Serialization::prefix(type, size)
+  end
+
+  def test_decode_prefix
+    type, size = RCS::Serialization::decode_prefix("\xCC\xBB\xAA\xFF")
+
+    assert_equal type, 0xff
+    assert_equal size, 0xaabbcc
+  end
+
+end

data/test/test_stats.rb

@@ -0,0 +1,90 @@
+require "helper"
+
+module RCS
+
+
+class StatsManager < Stats
+  def initialize
+    @sections = {:minutes => 0, :hours => 60, :days => 24, :weeks => 7}
+    @template = {count: 0}
+    super
+  end
+end
+
+class TestStats < Test::Unit::TestCase
+  
+  def setup
+
+  end
+  
+  def test_single_minute
+    statistic = StatsManager.new
+    statistic.add count: 1
+    stats = statistic.stats
+
+    assert_equal 1, stats[:total][:count]
+    assert_equal 1, stats[:minutes][:last][0][:count]
+    assert_equal 1, stats[:hours][:last][0][:count]
+    assert_equal 1, stats[:days][:last][0][:count]
+    assert_equal 1, stats[:weeks][:last][0][:count]
+  end
+
+  def test_two_minute
+    statistic = StatsManager.new
+    statistic.add count: 1
+    statistic.calculate
+    statistic.add count: 1
+    stats = statistic.stats
+
+    assert_equal 2, stats[:total][:count]
+    assert_equal 1, stats[:minutes][:last][0][:count]
+    assert_equal 2, stats[:hours][:last][0][:count]
+    assert_equal 2, stats[:days][:last][0][:count]
+    assert_equal 2, stats[:weeks][:last][0][:count]
+  end
+
+  def test_one_hour
+    statistic = StatsManager.new
+
+    1.upto(60) do
+      statistic.add count: 1
+      statistic.calculate
+    end
+
+    stats = statistic.stats
+
+    assert_equal 60, stats[:total][:count]
+    assert_equal 0, stats[:minutes][:last][0][:count]
+    assert_equal 0, stats[:hours][:last][0][:count]
+    assert_equal 60, stats[:days][:last][0][:count]
+    assert_equal 60, stats[:weeks][:last][0][:count]
+
+    assert_equal 1, stats[:minutes][:average][:count]
+    assert_equal 60, stats[:hours][:average][:count]
+  end
+
+  def test_one_day
+    statistic = StatsManager.new
+
+    1.upto(1440) do
+      statistic.add count: 1
+      statistic.calculate
+    end
+
+    stats = statistic.stats
+
+    assert_equal 1440, stats[:total][:count]
+    assert_equal 0, stats[:minutes][:last][0][:count]
+    assert_equal 0, stats[:hours][:last][0][:count]
+    assert_equal 0, stats[:days][:last][0][:count]
+    assert_equal 1440, stats[:weeks][:last][0][:count]
+
+    assert_equal 1, stats[:minutes][:average][:count]
+    assert_equal 60, stats[:hours][:average][:count]
+    assert_equal 1440, stats[:days][:average][:count]
+  end
+
+
+end
+
+end #RCS

data/test/test_symbolize.rb

@@ -0,0 +1,20 @@
+require 'helper'
+
+class TestRcsCommon < Test::Unit::TestCase
+
+  def test_symbolize
+    src = {'one' => 1, 'two' => 2}
+    dst = {:one => 1, :two => 2}
+
+    assert_equal dst, src.symbolize
+  end
+
+  def test_symbolize_mixed
+    src = {'one' => 1, 'two' => 2, 1 => 'one', 2 => 'two'}
+    dst = {:one => 1, :two => 2, 1 => 'one', 2 => 'two'}
+
+    assert_equal dst, src.symbolize
+  end
+
+
+end

data/test/test_systemstatus.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+module RCS
+
+class TestStatus < Test::Unit::TestCase
+
+  def test_disk
+    disk = SystemStatus.disk_free
+
+    # it should return a number
+    assert_kind_of Fixnum, disk
+    # it is a percentage
+    assert_equal true, (disk >= 0 and disk <= 100)
+  end
+
+  def test_load
+    load = SystemStatus.cpu_load
+
+    # it should return a number
+    assert_kind_of Fixnum, load
+    # it could be even greater than 100 on high load
+    assert_equal true, (load >= 0)
+  end
+
+  def test_process_cpu
+    cpu = SystemStatus.my_cpu_load('test')
+
+    # it should return a number
+    assert_kind_of Fixnum, cpu
+    # it is a percentage
+    assert_equal true, (cpu >= 0 and cpu <= 100)
+  end
+end
+
+end #RCS::

data/test/test_time.rb

@@ -0,0 +1,56 @@
+require "helper"
+
+class TestTime < Test::Unit::TestCase
+  
+  def setup
+    @high_memory = "\x90\xd9\xcb\x01"
+    @low_memory = "\x50\x67\xe0\x63"
+    @high = 0x01cbd990
+    @low = 0x63e06750
+  end
+  
+  def test_from_filetime
+    assert_equal '2011-03-03 10:47:28 UTC', Time.from_filetime(@high, @low).to_s
+  end
+  
+  def test_from_filetime_has_millisec
+    assert_equal Time.from_filetime(@high, @low).usec, 436001
+  end
+  
+  def test_unpack_from_memory
+    h = @high_memory.unpack('I').shift
+    l = @low_memory.unpack('I').shift
+    assert_equal '2011-03-03 10:47:28 UTC', Time.from_filetime(h, l).to_s
+  end
+
+  def test_to_filetime
+    date = Time.parse('2011-03-03 10:47:28 UTC')
+    date = Time.at(date.to_i, 436001)
+
+    filetime = date.to_filetime.pack('L*')
+
+    memory = (@low_memory + @high_memory).force_encoding('ASCII-8BIT')
+
+    assert_equal memory, filetime
+  end
+
+  def test_epoch
+    epoch = Time.from_filetime(0, 0)
+
+    assert_equal '1601-01-01 00:00:00 UTC', epoch.to_s
+  end
+
+  def test_from_and_to
+    now = Time.now.getutc
+
+    buff = StringIO.new
+
+    buff.write now.to_filetime.pack('L*')
+    buff.rewind
+    low, high = buff.read(8).unpack('L*')
+    check = Time.from_filetime(high, low)
+
+    # we explicitly ignore the usec, msec part
+    assert_equal now.to_s, check.to_s
+  end
+end