fhlow 1.91.0

data/lib/module_config/unittests/config_3a.flw

@@ -0,0 +1,16 @@
+[section only in a]
+
+    name = a
+
+[common section]
+    names = {
+        john; 
+        jack; 
+        karl;
+        annonymous
+    }
+
+    aname = a
+
+    common = a
+    

data/lib/module_config/unittests/config_3b.flw

@@ -0,0 +1,15 @@
+[section only in b]
+
+    name = b
+
+[common section]
+    names = {
+        kate; kathy;
+        clair;
+        annonymous
+    }
+
+    bname = b
+
+    common = b
+

data/lib/module_config/unittests/config_test.rb

@@ -0,0 +1,579 @@
+###################### environment setup ##############################################
+# Tries to detect the root directory of the actual fhlow root directory by parsing
+# the string provided by 'Dir.pwd'. 
+
+def detectFhlowRootDir(_dir = Dir.pwd)
+
+    if _dir == ""
+        print ",-----------------------------------------------------------------+\n"
+        print "| ERROR: your actual working dir is not inside a fhlow structure! |\n"
+        print "`-----------------------------------------------------------------+\n"
+        exit
+    elsif Dir.entries(_dir).include?("flw")
+        return _dir+"/"
+    else
+        return detectFhlowRootDir(_dir.gsub(/(.*)\/\w*[\/]*/,'\1'))
+    end
+end
+
+# add the fhlow lib dir to $: so ruby can find all the files
+$:.unshift(detectFhlowRootDir+"flw/core/lib") 
+
+Dir.glob(detectFhlowRootDir+"flw/core/lib/module_*") { |entry| $:.unshift(entry) if File.directory?(entry) }
+
+
+#######################################################################################
+
+require 'test/unit'
+require 'myconfig'
+require 'configitems/simple'
+require 'configitems/simpleunit'
+require 'configitems/simplepackage'
+require 'configitems/complex'
+require 'configitems/complexpackage'
+require 'configitems/complexunit'
+
+class TC_config_test < Test::Unit::TestCase
+
+    def test_simple
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::Simple.new("bla bla bla");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::Simple.new("bla ? bla");
+        end
+            
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::Simple.new("bla =");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::Simple.new(".1.1.1.1 = .1.1.1.1.1")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::Simple.new("... = ...")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::Simple.new("1.1.1.1. = 1.1.1.1.1;;;;")
+        end
+
+        assert_nothing_raised() do
+            s = Config::Simple.new("SomeThing = Nothing")
+            s = Config::Simple.new("SomeThing = OtherValue") 
+            s = Config::Simple.new("1234 = 1234")
+        end
+
+        
+        s = Config::Simple.new("SomeThing = Nothing")
+        s1 = Config::Simple.new("SomeThing = OtherValue") 
+        s2 = Config::Simple.new("1234 = 1234")
+
+        assert_raise(Config::ConfigMergeException) do
+            s.merge(s2)
+        end
+
+        assert_nothing_raised() do
+            s.merge(s1)
+        end
+
+        assert_equal(s1.value, s.value)
+
+        assert_equal(/^\s*(\w+)\s*=\s*([\w,.;\s]+)\s*$/, Config::Simple.getRegex())
+
+        
+        str = "ComplexUnits = {
+            1,2,3(bla);
+            4,5,6(bhv)
+        }
+
+        ComplexPackage = {
+            a,b,c;
+            d,e,f
+        }
+
+        Unit = blablablal(bla)
+
+        Package = asdfja
+        some = thing else"
+
+
+        assert_equal("Package = asdfja", Config::SimpleFactory.match(str).strip)
+        assert_equal("some = thing else", Config::SimpleFactory.match(str).strip)
+        assert_equal(nil, Config::SimpleFactory.match(str))
+
+        assert_equal(10, Config::SimpleFactory.priority)
+
+        assert_nothing_raised() do
+            s = Config::SimpleFactory.create("SomeThing = Nothing")
+            s = Config::SimpleFactory.create("SomeThing = OtherValue") 
+            s = Config::SimpleFactory.create("1234 = 1234")
+        end
+
+    end
+
+    def test_simpleunit
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::SimpleUnit.new("bla bla Unit bla");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::SimpleUnit.new("bla ? bla(bhv)");
+        end
+            
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::SimpleUnit.new("blaUnit =(rtl)");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::SimpleUnit.new(".1.1.Unit1.1 = .1.1.1.1.1")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::SimpleUnit.new(".Unit.. = ...")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::SimpleUnit.new("1.1Unit.1.1. = 1.1.1.1.1(;;;;)")
+        end
+
+        s = nil
+        s1 = nil
+        s2 = nil
+        
+        assert_nothing_raised() do
+            s = Config::SimpleUnit.new("UnitThing = Nothing(Bhv)")
+            s1 = Config::SimpleUnit.new("UnitThing = OtherValue(Rtl)") 
+            s2 = Config::SimpleUnit.new("12Unit34 = 1234(45)")
+        end
+
+        assert_raise(Config::ConfigMergeException) do
+            s.merge(s2)
+        end
+
+        assert_nothing_raised() do
+            s.merge(s1)
+        end
+
+        assert_equal(s1.value, s.value)
+
+        assert_equal(/^\s*(\w*Unit\w*)\s*=\s*([\w,.;\s]+)\((.*)\)\s*$/, Config::SimpleUnit.getRegex())
+
+        
+        str = "ComplexUnits = {
+            1,2,3(bla);
+            4,5,6(bhv)
+        }
+
+        ComplexPackage = {
+            a,b,c;
+            d,e,f
+        }
+
+        Unit = blablablal(bla)
+
+        Package = asdfja
+        some = thing else"
+
+
+        assert_equal("Unit = blablablal(bla)", Config::SimpleUnitFactory.match(str).strip)
+        assert_equal(nil, Config::SimpleUnitFactory.match(str))
+
+        assert_equal(0, Config::SimpleUnitFactory.priority)
+
+        assert_nothing_raised() do
+            s = Config::SimpleUnitFactory.create("SomeUnit = Nothing(Bhv, Rtl)")
+            assert_equal(s.value["archs"], ["Bhv", "Rtl"])
+            s = Config::SimpleUnitFactory.create("UnitThing = Other,Value(Rtl, Bla)") 
+            s = Config::SimpleUnitFactory.create("12Unit34 = 1,2,3,4(2)")
+        end
+
+    end
+
+    def test_simplepackage
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::SimplePackage.new("bla bla Package bla");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::SimplePackage.new("bla ? bla");
+        end
+            
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::SimplePackage.new("blaPackage =");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::SimplePackage.new(".1.1.Package1.1 = .1.1.1.1.1")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::SimplePackage.new(".Package.. = ...")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::SimplePackage.new("1.1Package.1.1. = 1.1.1.1.1;;;;")
+        end
+
+        s = nil
+        s1 = nil
+        s2 = nil
+        
+        assert_nothing_raised() do
+            s = Config::SimplePackage.new("PackageThing = Nothing")
+            s1 = Config::SimplePackage.new("PackageThing = OtherValue") 
+            s2 = Config::SimplePackage.new("12Package34 = 1234")
+        end
+
+        assert_raise(Config::ConfigMergeException) do
+            s.merge(s2)
+        end
+
+        assert_nothing_raised() do
+            s.merge(s1)
+        end
+
+        assert_equal(s1.value, s.value)
+
+        assert_equal(/^\s*(\w*Package\w*)\s*=\s*([\w,.;\s]+)\s*$/, Config::SimplePackage.getRegex())
+
+        
+        str = "ComplexPackages = {
+            1,2,3(bla);
+            4,5,6(bhv)
+        }
+
+        ComplexPackage = {
+            a,b,c;
+            d,e,f
+        }
+
+        Unit = blablablal(bla)
+
+        Package = asdfja
+        some = thing else"
+
+
+        assert_equal("Package = asdfja", Config::SimplePackageFactory.match(str).strip)
+        assert_equal(nil, Config::SimplePackageFactory.match(str))
+
+        assert_equal(0, Config::SimplePackageFactory.priority)
+
+        assert_nothing_raised() do
+            s = Config::SimplePackageFactory.create("SomePackage = Nothing")
+            s = Config::SimplePackageFactory.create("PackageThing = Other,Value") 
+            s = Config::SimplePackageFactory.create("12Package34 = 1,2,3,4")
+        end
+
+    end
+
+    def test_complex
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::Complex.new("bla bla bla");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::Complex.new("bla =");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::Complex.new("... = { ... }")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::Complex.new("1.1.1.1. = { 1.1.1.1.1;;;; }")
+        end
+        
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::Complex.new("Complex = { something; 1324\n 1234 }")
+        end
+
+        s = nil
+        s1 = nil
+        s2 = nil
+        
+        assert_nothing_raised() do
+            s = Config::Complex.new("ComplexThing = { No; thing }")
+            s1 = Config::Complex.new("ComplexThing = { Other; Value }") 
+            s2 = Config::Complex.new("1234 = { 1; 2; 3; 4 }")
+        end
+
+        assert_raise(Config::ConfigMergeException) do
+            s.merge(s2)
+        end
+
+        assert_nothing_raised() do
+            s.merge(s1)
+        end
+
+        assert_equal(["Other", "Value", "No", "thing"], s.value)
+
+        assert_equal(/(\w+)\s*=(\s*|[\n]*)\{((\s*.+[;][\s\n]*)*(\s*.+[;]*[\s\n]*))\}/, Config::Complex.getRegex())
+
+        
+        str = "ComplexUnitss = {
+            1,2,3(bla);
+            4,5,6(bhv)
+        }
+
+        ComplexPackage = {
+            a,b,c;
+            d,e,f
+        }
+
+        Unit = blablablal(bla)
+
+        Package = asdfja
+        some = thing else"
+
+
+        assert_equal("ComplexUnitss = {\n            1,2,3(bla);\n            4,5,6(bhv)\n        }", Config::ComplexFactory.match(str).strip)
+        assert_equal("ComplexPackage = {\n            a,b,c;\n            d,e,f\n        }", Config::ComplexFactory.match(str))
+        assert_equal(nil, Config::ComplexFactory.match(str))
+
+        assert_equal(11, Config::ComplexFactory.priority)
+
+        assert_nothing_raised() do
+            s = Config::ComplexFactory.create("ComplexPackages = {\n            1,2,3(bla);\n            4,5,6(bhv)\n        }")
+            s = Config::ComplexFactory.create("ComplexPackage = {\n            a,b,c;\n            d,e,f\n        }") 
+        end
+
+    end
+
+    def test_complexpackage
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::ComplexPackage.new("bla bPackagela bla");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::ComplexPackage.new("blaPackage =");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::ComplexPackage.new("..Package. = { ... }")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::ComplexPackage.new("1.1Package.1.1. = { 1.1.1.1.1;;;; }")
+        end
+        
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::ComplexPackage.new("ComplexPackage = { something; 1324\n 1234 }")
+        end
+
+        s = nil
+        s1 = nil
+        s2 = nil
+        
+        assert_nothing_raised() do
+            s = Config::ComplexPackage.new("ComplexPackageThing = { No; thing }")
+            s1 = Config::ComplexPackage.new("ComplexPackageThing = { Other; Value }") 
+            s2 = Config::ComplexPackage.new("12Package34 = { 1; 2; 3; 4 }")
+        end
+
+        assert_raise(Config::ConfigMergeException) do
+            s.merge(s2)
+        end
+
+        assert_nothing_raised() do
+            s.merge(s1)
+        end
+
+        assert_equal(["Other", "Value", "No", "thing"], s.value)
+
+        assert_equal(/(\w*Package\w*)\s*=(\s*|[\n]*)\{((\s*[^\(\)]*[;][\s\n]*)*(\s*[^\(\)]*[;]*[\s\n]*))\}/, Config::ComplexPackage.getRegex())
+
+        
+        str = "ComplexUnits = {
+            1,2,3(bla);
+            4,5,6(bhv)
+        }
+
+        ComplexPackage = {
+            a,b,c;
+            d,e,f
+        }
+
+        Unit = blablablal(bla)
+
+        Package = asdfja
+        some = thing else"
+
+
+        assert_equal("ComplexPackage = {\n            a,b,c;\n            d,e,f\n        }", Config::ComplexPackageFactory.match(str))
+        assert_equal(nil, Config::ComplexPackageFactory.match(str))
+
+        assert_equal(0, Config::ComplexPackageFactory.priority)
+
+        assert_nothing_raised() do
+            s = Config::ComplexPackageFactory.create("ComplexPackage = {\n            1,2,3;\n            4,5,6\n        }")
+        end
+
+    end
+
+    def test_complexunit
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::ComplexUnit.new("bla bUnitla bla");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            Config::ComplexUnit.new("blaUnit =");
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::ComplexUnit.new("..Unit. = { ... }")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::ComplexUnit.new("1.1Unit.1.1. = { 1.1.1.1.1;;;; }")
+        end
+        
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::ComplexUnit.new("ComplexUnit = { something; 1324\n 1234 }")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::ComplexUnit.new("ComplexUnit = { something(bhv); 13(24);\n 1234 }")
+        end
+
+        assert_raise(Config::ConfigWrongFormatException) do
+            s = Config::ComplexUnit.new("ComplexUnit = { something; 13(24);\n 1234 }")
+        end
+
+        s = nil
+        s1 = nil
+        s2 = nil
+        
+        assert_nothing_raised() do
+            s = Config::ComplexUnit.new("ComplexUnitThing = { No(arch); thing(itecture) }")
+            s1 = Config::ComplexUnit.new("ComplexUnitThing = { Other, Value(bhv, bla, 123) }") 
+            s2 = Config::ComplexUnit.new("12Unit34 = { 1, 2(a); 3, 4(d) }")
+        end
+
+        assert_raise(Config::ConfigMergeException) do
+            s.merge(s2)
+        end
+
+        assert_nothing_raised() do
+            s.merge(s1)
+        end
+
+        assert_equal([  {"archs"=>["bhv", "bla", "123"], "deppath"=>"Other, Value"},
+                        {"archs"=>["arch"],              "deppath"=>"No"},
+                        {"archs"=>["itecture"],          "deppath"=>"thing"}], 
+                        s.value)
+
+        assert_equal(/(\w*Unit\w*)\s*=(\s*|[\n]*)\{((\s*.*[;][\s\n]*)*(\s*.*\(.*\)[;]*[\s\n]*))\}/, Config::ComplexUnit.getRegex())
+
+        
+        str = "ComplexUnits = {
+            1,2,3(bla);
+            4,5,6(bhv)
+        }
+
+        ComplexPackage = {
+            a,b,c;
+            d,e,f
+        }
+
+        Unit = blablablal(bla)
+
+        Package = asdfja
+        some = thing else"
+
+
+        assert_equal("ComplexUnits = {\n            1,2,3(bla);\n            4,5,6(bhv)\n        }", Config::ComplexUnitFactory.match(str))
+        assert_equal(nil, Config::ComplexUnitFactory.match(str))
+
+        assert_equal(0, Config::ComplexUnitFactory.priority)
+
+        assert_nothing_raised() do
+            s = Config::ComplexUnitFactory.create("ComplexUnit = {\n            1,2,3(bhv);\n            4,5,6(rtl, bhv)\n        }")
+        end
+
+    end
+
+
+
+
+=begin
+    # tests a file with an invalid value
+    def test_1
+        assert_raise(Fhlow::FhlowException) do
+            @conf = Config::Config.new("unittests/config_1.flw")
+        end
+    end
+
+    # tests a file with valid simple settings
+    def test_1_fixed
+        
+        assert_nothing_raised(Exception) do
+            @conf = Config::Config.new("unittests/config_1_fixed.flw")
+        end
+
+
+        @conf["ep"].each { |x| p x }
+
+        assert_equal(@conf["ep"]["alias"],    "yate")
+        assert_equal(@conf["ep"]["ep"],       "true")
+        assert_equal(@conf["ep"]["gkclient"], "false")
+        assert_equal(@conf["ep"]["ident"],    "yate")
+        
+        assert_equal(@conf["gk"]["server"], "false")
+
+        assert_equal(@conf["incoming"]["called"],  "8989989")
+        assert_equal(@conf["incoming"]["context"], "default")
+
+        assert_raise(Fhlow::FhlowException) { x = @conf["incoming"]["contex"] }
+        assert_raise(Fhlow::FhlowException) { x = @conf["incming"]["contex"] }
+        assert_raise(Fhlow::FhlowException) { x = @conf["incming"][""] }
+        assert_raise(Fhlow::FhlowException) { x = @conf[""]["adsfadsf"] }
+        assert_raise(Fhlow::FhlowException) { x = @conf[""][""] }
+    end
+
+    # tests a file with mixed (simple and complex) settings
+    def test_2
+        assert_nothing_raised(Exception) do
+            @conf = Config::Config.new("unittests/config_2.flw")
+        end
+
+        assert_equal(@conf["dependencies"]["foo"],   "hallo")
+        assert_equal(@conf["dependencies"]["units"], ["Test, Wiese, Bauern", "blume, handy, hiphop"])
+        assert_equal(@conf["dependencies"]["test"],  ["a, test, gogogo"])
+    end
+
+#=begin
+    def test_2
+        @conf = Config::read("config_2.flw")
+
+        assert(@conf["dependencies", "foo")    == "hallo",         '@conf.value("dependencies", "gaga")    != "hallo"')
+        
+        x = @conf["dependencies", "units")
+        assert(@conf["dependencies", "units")  == ["Test,Wiese,Bauern","blume,handy,hiphop"])
+    end
+#=end
+
+    def test_3
+        assert_nothing_raised(Exception) do
+            @confa = Config::Config.new("unittests/config_3a.flw")
+            @confb = Config::Config.new("unittests/config_3b.flw")
+        end
+
+        @confa.merge(@confb)
+    
+        assert_equal(@confa["section only in a"]["name"],    "a")
+        assert_equal(@confa["section only in b"]["name"],    "b")
+        assert_equal(@confa["common section"]["aname"],   "a")
+        assert_equal(@confa["common section"]["bname"],   "b")
+        assert_equal(@confa["common section"]["common"],  "b")
+        assert_equal(@confa["common section"]["names"],   ["kate", "kathy", "clair", "annonymous", "john", "jack", "karl"])
+
+    end
+
+=end
+end