sal-tools-analyze 0.0.1

data/test/test_command.rb

@@ -0,0 +1,16 @@
+#!/opt/local/bin/ruby
+
+require 'minitest/unit'
+require_relative '../lib/sal/command'
+require_relative '../lib/sal/code'
+
+class TestCommand < MiniTest::Unit::TestCase
+  
+  def test_function
+    assert_equal(false, Sal::Command.is_code_line?("Message Actions"))
+    assert_equal(true, Sal::Command.is_code_line?("Set bOk = TRUE"))
+  end
+  
+end
+
+MiniTest::Unit.autorun

data/test/test_external.rb

@@ -0,0 +1,37 @@
+#!/opt/local/bin/ruby
+
+require 'minitest/unit'
+require_relative '../lib/sal/external'
+require_relative '../lib/sal/code'
+
+class TestExternal < MiniTest::Unit::TestCase
+
+  def test_item_external
+    name = "vti41.dll"
+    code = "Library name: #{name}"
+    line = ".head 3 +  #{code}\r\n"
+    item = Sal::Item.new(line)
+    
+    extlib = Sal::External.new(item)
+    
+    assert_equal(item, extlib.item)
+    assert_equal(name, extlib.name)
+  end
+  
+  def test_external_none_in_file
+    code = Sal::Code.new('data/test.40.text.app')
+    libs = code.externals
+    assert_equal(0, libs.count)
+  end
+  
+  def test_external_in_file
+    code = Sal::Code.new('data/test.41.text.externalfunctions.app')
+    libs = code.externals
+    assert_equal(1, libs.count)
+    funcs = libs[0].functions
+    assert_equal(11, funcs.count)
+  end
+
+end
+
+MiniTest::Unit.autorun

data/test/test_externalfunction.rb

@@ -0,0 +1,76 @@
+#!/opt/local/bin/ruby
+
+require 'minitest/unit'
+require_relative '../lib/sal/externalfunction'
+
+class TestExternalFunction < MiniTest::Unit::TestCase
+
+  def get_sample_external
+    item = Sal::Item.new(".head 3 +  Library name: Test.dll\r\n")
+    item.childs << Sal::Item.new(".head 4 -  ThreadSafe: No\r\n")
+    item.childs << get_sample_external_function_item
+    return item
+  end
+
+  def get_sample_external_function_item
+    item = Sal::Item.new(".head 4 +  Function: Func1\r\n")
+    item.childs << Sal::Item.new(".head 5 -  Description: ...\r\n")
+    item.childs << Sal::Item.new(".head 5 -  Export Ordinal: 111\r\n")
+    returns = Sal::Item.new(".head 5 +  Returns\r\n")
+    returns.childs << Sal::Item.new(".head 6 -  Number: LONG\r\n")
+    item.childs << returns
+    parameters = Sal::Item.new(".head 5 +  Parameters\r\n")
+    parameters.childs << Sal::Item.new(".head 6 -  Date/Time: HARRAY\r\n")
+    parameters.childs << Sal::Item.new(".head 6 -  ! Number: HARRAY\r\n")
+    parameters.childs << Sal::Item.new(".head 6 -  Date/Time: DATETIME\r\n")
+    item.childs << parameters
+    return item
+  end
+    
+  def test_item_file_include
+    f1_name = "Func1"
+    f1_code = "Function: #{f1_name}"
+    f1_line = ".head 4 +  #{f1_code}\r\n"
+    f1_item = Sal::Item.new(f1_line)
+    
+    x1_code = "! Description"
+    x1_line = ".head 4 -  #{x1_code}\r\n"
+    x1_item = Sal::Item.new(x1_line)
+    
+    l_name = "Test.dll"
+    l_code = "Library name: #{l_name}"
+    l_line = ".head 3 +  #{l_code}\r\n"
+    l_item = Sal::Item.new(l_line)
+    
+    l_item.childs << f1_item
+    l_item.childs << x1_item
+    
+    assert_equal(2, l_item.childs.count)
+    extlib = Sal::External.new(l_item)
+    
+    assert_equal(l_item, extlib.item)
+    assert_equal(l_name, extlib.name)
+    
+    assert_equal(1, extlib.functions.count)
+    
+    extfunc = extlib.functions[0]
+    assert_equal(f1_name, extfunc.name)
+  end
+
+  def test_item_ordinal
+    item = get_sample_external
+    library = Sal::External.new(item)
+    refute_equal(nil, library)
+    assert_equal(1, library.functions.count)
+    
+    function = library.functions[0]
+    refute_equal(nil, function)
+    assert_equal("Func1", function.name)
+    assert_equal(111, function.ordinal)
+    assert_equal("Test.dll::Func1", function.key)
+    assert_equal(2, function.parameters.count)
+    assert_equal(Sal::Item, function.parameters[0].class)
+  end
+end
+
+MiniTest::Unit.autorun

data/test/test_format.rb

@@ -0,0 +1,58 @@
+#!/opt/local/bin/ruby
+
+require 'minitest/unit'
+require_relative '../lib/sal/format'
+
+class TestFileFormat < MiniTest::Unit::TestCase
+
+  def setup
+    @files = []
+    @files << "data/test.40.indented.app"
+    @files << "data/test.40.text.app"
+    @files << "data/test.40.normal.app"
+    @files << "data/test.41.indented.app"
+    @files << "data/test.41.text.app"
+    @files << "data/test.41.normal.app"
+    @files << "data/test.21.text.sql.app"
+  end
+  
+  def test_file_format
+    @files.grep(/\.indented\./).each do | file |
+      assert_equal( Sal::Format::INDENTED, Sal::Format.get_from_file(file) )
+    end
+    
+    @files.grep(/\.text\./).each do | file |
+      assert_equal( Sal::Format::TEXT, Sal::Format.get_from_file(file) )
+    end
+    
+    @files.grep(/\.normal\./).each do | file |
+      assert_equal( Sal::Format::NORMAL, Sal::Format.get_from_file(file) )
+    end
+  end
+  
+  def test_get_from_code
+    assert_equal(   Sal::Format::TEXT, 
+                    Sal::Format.get_from_code(".head 1 -  Outline Version - 4.0.34"))
+    assert_equal(   Sal::Format::INDENTED,
+                    Sal::Format.get_from_code("Outline Version - 4.0.34"))
+    assert_equal(   Sal::Format::NORMAL,
+                    Sal::Format.get_from_code("01234567890"))                
+  end
+
+  def test_check_constants
+    assert_equal( Sal::Format::TEXT, :t )
+    refute_equal( Sal::Format::TEXT, "t" )              
+    assert_equal( Sal::Format::NORMAL, :n )
+    refute_equal( Sal::Format::NORMAL, "n" )
+    assert_equal( Sal::Format::INDENTED, :i )
+    refute_equal( Sal::Format::INDENTED, "i" )
+  end
+
+  def test_get_from_line
+    assert_equal( Sal::Format::TEXT, Sal::Format.get_from_line(".head 5 - ..."))
+    assert_equal( Sal::Format::INDENTED, Sal::Format.get_from_line("Application Description"))
+    assert_equal( Sal::Format::INDENTED, Sal::Format.get_from_line("	Design-time Settings"))
+  end
+end
+
+MiniTest::Unit.autorun

data/test/test_function.rb

@@ -0,0 +1,22 @@
+#!/opt/local/bin/ruby
+
+require 'minitest/unit'
+require_relative '../lib/sal/function'
+
+class TestFunction < MiniTest::Unit::TestCase
+
+  def test_function
+    name = "Name"
+    code = "Function: #{name}"
+    line = ".head 5 +  #{code}\r\n"
+    item = Sal::Item.new(line)
+    
+    func = Sal::Function.new(item)
+    
+    assert_equal(item, func.item)
+    assert_equal(name, func.name)
+  end
+  
+end
+
+MiniTest::Unit.autorun

data/test/test_item.rb

@@ -0,0 +1,123 @@
+#!/opt/local/bin/ruby
+
+require 'minitest/unit'
+require_relative '../lib/sal/item'
+require_relative '../lib/sal/code'
+
+class TestItem < MiniTest::Unit::TestCase
+
+  def setup
+    @lines = []
+    @lines << ".head 0 +  Application Description: Gupta SQLWindows Standard Application Template\r\n"
+    @lines << ".head 1 +  ! Outline Version - 4.0.34\r\n"
+    @lines << ".head 2 +  Set bCommented = TRUE\r\n"
+    @lines << ".head 3 -  ! Set bCommented = TRUE\r\n"
+    
+    @items = []
+    parent = nil
+    @lines.each do | line |
+      item = Sal::Item.new(line, Sal::Format::TEXT)
+      item.parent = parent unless parent.nil?
+      parent.childs << item unless parent.nil?
+      parent = item
+      @items << item
+    end
+  end
+  
+  def test_item_outline_version_text
+    code = "Outline Version - 4.0.34"
+    line = ".head 1 -  #{code}\r\n"
+    item = Sal::Item.new(line)
+    
+    assert_equal(line, item.line)
+    assert_equal(Sal::Format::TEXT, item.format)
+    assert_equal(1, item.level)
+    assert_equal(false, item.commented?)
+    assert_equal(nil, item.parent)
+    assert_equal(0, item.childs.count)
+    assert_equal(code, item.code)
+    assert_equal(true, item.analyzed?)
+    assert_equal(-1, item.code_line_nr)
+    assert_equal(nil, item.tag)
+  end
+
+  def test_item_outline_version_indented
+  #  code = "Outline Version - 4.0.34"
+  #  line = "\t#{code}\r\n"
+  #  item = Sal::Item.new(line)
+    
+  #  assert_equal(line, item.line)
+  #  assert_equal(Sal::Format::INDENTED, item.format)
+  #  assert_equal(1, item.level)
+  #  assert_equal(false, item.commented?)
+  #  assert_equal(nil, item.parent)
+  #  assert_equal(0, item.childs.count)
+  #  assert_equal(code, item.code)
+  #  assert_equal(true, item.analyzed?)
+  #  assert_equal(-1, item.code_line_nr)
+  #  assert_equal(nil, item.tag)
+  end
+
+  def test_item_file_include
+    code = "File Include: qckttip.apl"
+    line = ".head 2 -  #{code}\r\n"
+    item = Sal::Item.new(line)
+    
+    assert_equal(line, item.line)
+    assert_equal(line, item.original)
+    assert_equal(Sal::Format::TEXT, item.format)
+    assert_equal(2, item.level)
+    assert_equal(false, item.commented?)
+    assert_equal(nil, item.parent)
+    assert_equal(0, item.childs.count)
+    assert_equal(true, item.analyzed?)
+    assert_equal(code, item.code)
+    assert_equal(-1, item.code_line_nr)
+    assert_equal(nil, item.tag)
+  end
+  
+  def test_item_commented
+    commented = 0
+    item_commented = 0
+    
+    @items.each do | item |
+      commented += 1 if item.commented?
+      item_commented += 1 if item.item_commented?
+    end
+    
+    assert_equal(3, commented)
+    assert_equal(2, item_commented)
+  end
+  
+  def test_item_count
+    assert_equal(1, @items.find_all {|item| item.level == 1 }.length)
+  end
+  
+  def test_is_code_line
+    counter = 0
+    @items.each do | item |
+      counter += 1 if item.is_code_line?
+    end
+    assert_equal(1, counter, "Count of code lines in sample code")
+  end
+  
+  def test_item_code_multiline
+    code = Sal::Code.new("data/test.40.text.multiline.app")
+    code.items.each do | item |
+      if item.code =~ /^Set /
+        assert_equal(2, item.code.each_line.to_a.length)
+      end
+    end
+  end
+  
+  def test_item_comment
+    code = "File Include: qckttip.apl"
+    line = ".head 2 -  #{code}\r\n"
+    item = Sal::Item.new(line)
+    item.item_comment
+    assert_equal("! #{code}", item.code)
+  end
+  
+end
+
+MiniTest::Unit.autorun

data/test/test_library.rb

@@ -0,0 +1,38 @@
+#!/opt/local/bin/ruby
+
+require 'minitest/unit'
+require_relative '../lib/sal/library'
+require_relative '../lib/sal/code'
+require_relative '../lib/sal/item'
+
+class TestLibrary < MiniTest::Unit::TestCase
+
+  def test_item_file_include
+    name = "qckttip.apl"
+    code = "File Include: #{name}"
+    line = ".head 2 -  #{code}\r\n"
+    item = Sal::Item.new(line)
+    
+    library = Sal::Library.new(item)
+    
+    assert_equal(item, library.item)
+    assert_equal(name, library.name)
+  end
+
+  def test_libraries
+    libraries = Sal::Code.new("data/test.40.text.app").libraries
+    assert_equal(2, libraries.length)
+    assert_equal("qckttip.apl", libraries[0].name)
+    assert_equal("vt.apl", libraries[1].name)
+  end
+  
+  def test_get_name
+    item = Sal::Item.new("")
+    lib = Sal::Library.new(item)
+    assert_equal("test", lib.send(:get_name,"File Include: test"))
+    assert_equal("test", lib.send(:get_name,"File Include: test ! jacka"))
+  end
+  
+end
+
+MiniTest::Unit.autorun

data/test/test_version.rb

@@ -0,0 +1,80 @@
+#!/opt/local/bin/ruby
+
+require 'minitest/unit'
+require_relative '../lib/sal/version'
+
+class TestVersion < MiniTest::Unit::TestCase
+  
+  def test_file_to_td
+    
+    # unit tests für versionen von 0 bis 100
+    i = 0
+    test_empty = Array.new
+    test_empty += (0..25).to_a
+    test_empty += [29, 30, 33, 36]
+    test_empty += (38..100).to_a
+    test_empty.each do | test | 
+      i += 1
+      begin
+        Sal::Version.file_to_td(test)
+        assert false
+      rescue RuntimeError
+        assert true
+      end
+    end
+    
+    assert_equal("1.1", Sal::Version.file_to_td(26))
+    assert_equal("1.5", Sal::Version.file_to_td(27))
+    assert_equal("2.0", Sal::Version.file_to_td(28))
+    # assert_equal("2.1", Sal::Version.file_to_td(28))
+    assert_equal("3.0", Sal::Version.file_to_td(31))
+    assert_equal("3.1", Sal::Version.file_to_td(32))
+    assert_equal("4.0", Sal::Version.file_to_td(34))
+    assert_equal("4.1", Sal::Version.file_to_td(35))
+    # assert_equal("5.0", Sal::Version.file_to_td(37))
+    assert_equal("5.1", Sal::Version.file_to_td(37))
+    
+    # unknown versions
+    
+    # assert_equal( "4.2", Sal::Version.file_to_td(??))
+    # assert_equal( "5.2", Sal::Version.file_to_td(??))
+    # assert_equal( "6.0", Sal::Version.file_to_td(??))
+  end
+  
+  def test_td_to_file
+    assert_equal(26, Sal::Version.td_to_file("1.1"))
+    assert_equal(27, Sal::Version.td_to_file("1.5"))
+    assert_equal(28, Sal::Version.td_to_file("2.0"))
+    assert_equal(28, Sal::Version.td_to_file("2.1"))
+    assert_equal(31, Sal::Version.td_to_file("3.0"))
+    assert_equal(32, Sal::Version.td_to_file("3.1"))
+    assert_equal(34, Sal::Version.td_to_file("4.0"))
+    assert_equal(35, Sal::Version.td_to_file("4.1"))
+    assert_equal(37, Sal::Version.td_to_file("5.0"))
+    assert_equal(37, Sal::Version.td_to_file("5.1"))
+    
+    # unknown versions
+    
+    # assert_equal(??, Sal::Version.td_to_file("4.2"))
+    # assert_equal(??, Sal::Version.td_to_file("5.2"))
+    # assert_equal(??, Sal::Version.td_to_file("6.0"))
+  end
+  
+  def test_initialize
+    assert_equal(26, Sal::Version.new("1.1").file)
+    assert_equal("1.1", Sal::Version.new(26).td)
+  end
+  
+  def test_from_code
+    assert_equal(26, Sal::Version.from_code(".head 1 -  Outline Version - 4.0.26").file)
+    assert_equal(26, Sal::Version.from_code("Outline Version - 4.0.26").file)
+  end
+  
+  def test_to_code
+    version = Sal::Version.new(27)
+    assert_equal("Outline Version - 4.0.27", version.to_code("Outline Version - 4.0.26"))
+  end
+	
+end
+
+MiniTest::Unit.autorun