trxl 0.1.5

data/spec/trxl/constants_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "The language" do
+  
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should evaluate the constant 'NULL' to nil" do
+    eval("NULL").should be_nil
+  end
+
+  it "should evaluate the constant 'TRUE' to true" do
+    eval("TRUE").should be_true
+  end
+  
+  it "should evaluate the constant 'FALSE' to false" do
+    eval("FALSE").should be_false
+  end
+  
+end

data/spec/trxl/environment_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+describe "A newly created environment" do
+  
+  before :each do
+    @env = Trxl::Environment.new
+  end
+  
+  it "should be empty" do
+    @env.should be_empty
+  end
+  
+  it "should have a depth of 1 (one)" do
+    @env.depth.should == 1
+  end
+  
+end
+
+describe "For storing variables" do
+  
+  before :each do
+    @env = Trxl::Environment.new
+  end
+  
+  it "should allow to bind variables to any given value" do
+    @env[:a] = "foo"
+    @env[:a].should == "foo"
+  end
+  
+  it "should allow to test if it's empty" do
+    @env.should be_empty
+    @env[:a] = "foo"
+    @env.should_not be_empty
+  end
+  
+  it "should allow to assign new values to already initialized variables" do
+    @env[:a] = "foo"
+    @env[:a].should == "foo"
+    @env[:a] = "bar"
+    @env[:a].should == "bar"
+  end
+  
+end
+
+describe "For scoping variables" do
+  
+  before :each do
+    @env = Trxl::Environment.new({
+      :a => "foo",
+      :b => "bar"
+    })
+  end
+  
+  it "should allow to enter a new scope" do
+    @env.enter_scope
+    @env.depth.should == 2
+  end
+  
+  it "should allow to pop any nested scope" do
+    @env.enter_scope
+    @env.exit_scope
+    @env.depth.should == 1
+  end
+  
+  it "should not allow to pop the toplevel scope" do
+    lambda { @env.exit_scope }.should raise_error
+  end
+  
+  it "should override any existing variable in a new scope" do
+    @env.enter_scope
+    @env[:a] = "bam"
+    @env[:a].should == "bam"
+    @env.exit_scope
+    @env[:a].should == "foo"
+  end
+  
+  it "should allow to merge an existing environment into the current local one" do
+    other_env = { :c => "c", :d => "d" }
+    @env.merge!(other_env)
+    @env.local[:c].should == "c"
+    @env.local[:a].should == "foo"
+    @env.local[:b].should == "bar"
+    @env[:c].should == "c"
+    @env[:a].should == "foo"
+    @env[:b].should == "bar"
+
+    other_env = { :a => "a", :c => "c" }
+    @env.merge!(other_env)
+    @env.local[:a].should == "a"
+    @env.local[:b].should == "bar"
+    @env.local[:c].should == "c"
+    @env[:a].should == "a"
+    @env[:b].should == "bar"
+    @env[:c].should == "c"
+  end
+  
+  it "should allow to return a new merged environment leaving the original intact" do
+    other_env = { :c => "c", :d => "d" }
+    env = @env.merge(other_env)
+    env.local[:c].should == "c"
+    env.local[:a].should == "foo"
+    env.local[:b].should == "bar"
+    env[:c].should == "c"
+    env[:a].should == "foo"
+    env[:b].should == "bar"
+
+    other_env = { :a => "a", :c => "c" }
+    env = @env.merge(other_env)
+    env.local[:a].should == "a"
+    env.local[:b].should == "bar"
+    env.local[:c].should == "c"
+    env[:a].should == "a"
+    env[:b].should == "bar"
+    env[:c].should == "c"
+  end
+  
+end

data/spec/trxl/hashes_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe "For working with Hashes, the Trxl::Calculator" do
+
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+
+
+  it "should evaluate hash literal expressions" do
+    eval("{}").should == {}
+    eval("{ 1 => 2 }").should == { 1 => 2 }
+    eval("{ 1 => 2, 3 => 4 }").should == { 1 => 2, 3 => 4 }
+  end
+
+  it "should allow hash variable definitions" do
+    eval("a = {}").should == {}
+    eval("a = {}; a;").should == {}
+    eval("a = { 1 => 2 }").should == { 1 => 2 }
+    eval("a = { 1 => 2 }; a;").should == { 1 => 2 }
+    eval("a = { 1 => 2, 3 => 4 }; a;").should == { 1 => 2, 3 => 4 }
+  end
+
+  it "should allow nested hash variable definitions" do
+    eval("a = { 1 => { 2 => 3 } }").should == { 1 => { 2 => 3 } }
+    eval("a = { 1 => { 2 => 3 }, 4 => 5 }").should == { 1 => { 2 => 3 }, 4 => 5 }
+  end
+
+  it "should allow arbitrary expressions in hash literal" do
+    eval("x = 1; foo = fun(x) {x}; h = { fun(){2}() => foo(3) }").should == { 2 => 3 }
+  end
+  
+  it "should be able to index hashes by their keys" do
+    eval("h = { 1 => 2 }; h[0]").should == nil
+    eval("h = { 1 => 2 }; h[1]").should == 2
+    eval("h = { 1 => 2 }; h[2]").should == nil
+  end
+
+  it "should recognize primary expressions as hash offset specifiers" do
+    eval("h = { 1 => 2 }; h[fun(x){x}(0)]").should == nil
+    eval("h = { 1 => 2 }; h[fun(x){x}(1)]").should == 2
+    eval("h = { 1 => 2 }; h[fun(x){x}(2)]").should == nil
+  end
+  
+  it "should resolve exact matching expressions" do
+    env = { :foo => { :a => "bar", :b => "bar", :c => "baz" } }
+    eval("foo[='bar']", env).should == [ [:a, "bar"], [:b, "bar"] ]
+    eval("foo[='baz']", env).should == [ [:c, "baz"] ]
+    eval("foo[='bam']", env).should == []
+  end
+
+  it "should resolve exact matching expressions followed by offset access expressions" do
+    env = { :foo => { :a => "bar", :b => "bar", :c => "baz" } }
+    eval("foo[='bar'][0]", env).should == [ :a, "bar" ]
+    eval("foo[='bar'][1]", env).should == [ :b, "bar" ]
+    eval("foo[='baz'][0]", env).should == [ :c, "baz" ]
+    eval("foo[='bam'][0]", env).should be_nil
+  end
+
+end

data/spec/trxl/numbers_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe "The calculation grammar" do
+  
+  include Trxl::SpecHelper
+
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+
+  it "should evaluate a given positive integer number to itself" do
+    eval("7").should == 7
+  end
+
+  it "should evaluate a given negative integer number to itself" do
+    eval("-7").should == -7
+  end
+
+  it "should evaluate a given positive real number to itself" do
+    eval("7.0").should == 7.0
+  end
+
+  it "should evaluate a given negative real number to itself" do
+    eval("-7.0").should == -7.0
+  end
+  
+end

data/spec/trxl/ranges_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe "When working with Ranges, the Trxl::Calculator" do
+
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should return arrays for range literal expressions" do
+    eval("0..0").should == [ 0 ]
+    eval("0..-1").should == [ ]
+    eval("0...0").should == [ ]
+    eval("0...-1").should == [ ]
+    
+    eval("1..5").should == [ 1, 2, 3, 4, 5 ]
+    eval("1 .. 5").should == [ 1, 2, 3, 4, 5 ]
+    eval("a = 1; b = 5; a..b").should == [ 1, 2, 3, 4, 5 ]
+    eval("1...5").should == [ 1, 2, 3, 4 ]
+    eval("1 ... 5").should == [ 1, 2, 3, 4 ]
+    eval("a = 1; b = 5; a...b").should == [ 1, 2, 3, 4 ]
+    
+    eval("\"a\"..\"a\"").should == [ "a" ]
+    eval("\"a\"..\"c\"").should == [ "a", "b", "c" ]
+    eval("\"a\" .. \"c\"").should == [ "a", "b", "c" ]
+    eval("\"a\"...\"c\"").should == [ "a", "b" ]
+    eval("\"a\" ... \"c\"").should == [ "a", "b" ]
+
+    eval("'a'..'a'").should == [ "a" ]
+    eval("'a'..'c'").should == [ "a", "b", "c" ]
+    eval("'a' .. 'c'").should == [ "a", "b", "c" ]
+    eval("'a'...'c'").should == [ "a", "b" ]
+    eval("'a' ... 'c'").should == [ "a", "b" ]
+    
+    eval("'aa'..'aa'").should == [ "aa" ]
+    eval("'aa'..'ac'").should == [ "aa", "ab", "ac" ]
+    eval("'aa'...'ac'").should == [ "aa", "ab" ]
+
+    eval("1..5 == [ 1, 2, 3, 4, 5 ]").should be_true
+    eval("1...5 == [ 1, 2, 3, 4 ]").should be_true
+    
+    eval("SIZE(1..5)").should == 5
+      
+    eval("a..b == [ 1, 2 ]", { :a => 1, :b => 2 }).should be_true
+    eval("a..c", { :a => 1, :b => nil, :c => 2 }).should == [ 1, 2]
+    
+    lambda { eval("a..b", { :a => nil, :b => nil }) }.should raise_error
+    
+  end
+  
+  it "should store ranges as arrays" do
+    eval("a = 1..5; a;").should == [ 1, 2, 3, 4, 5 ]
+    eval("a = 1 .. 5; a;").should == [ 1, 2, 3, 4, 5 ]
+    eval("a = 1; b = 5; c = a..b; c;").should == [ 1, 2, 3, 4, 5 ]
+    eval("a = 1...5; a;").should == [ 1, 2, 3, 4 ]
+    eval("a = 1 ... 5; a;").should == [ 1, 2, 3, 4 ]
+    eval("a = 1; b = 5; c = a...b; c;").should == [ 1, 2, 3, 4 ]
+  end
+
+end
+
+describe "When working with Strings, the Trxl::Calculator" do
+
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should evaluate string literals to strings using double quotes (\"\")" do
+    eval("\"Test String\"").should == "Test String"
+    eval("s = \"Test String\"; s;").should == "Test String"
+  end
+  
+  it "should evaluate string literals to strings using single quotes ('')" do
+    eval("'Test String'").should == "Test String"
+    eval("s = 'Test String'; s;").should == "Test String"
+  end
+  
+end

data/spec/trxl/require_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe "For defining Trxl::StdLib, the Trxl::Calculator" do
+  
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should be able to require trxl code snippets and merge them into the current env" do
+    program = "require 'stdlib'"
+    env_after_require = eval(program)
+    env_after_require.should have_key(:foreach_in)
+    env_after_require.should have_key(:_foreach_in_)
+    env_after_require.should have_key(:inject)
+    env_after_require.should have_key(:_inject_)
+    env_after_require.should have_key(:map)
+    env_after_require.should have_key(:ratio)
+  end
+  
+  it "should be able to require scoped trxl code snippets and merge them into the current env" do
+    program = "require 'stdlib/foreach_in'"
+    env_after_require = eval(program)
+    env_after_require.should have_key(:foreach_in)
+    
+    program = "require 'stdlib/inject'"
+    env_after_require = eval(program)
+    env_after_require.should have_key(:inject)
+  end
+  
+  it "should be able to require scoped trxl code snippets and merge them into the current env" do
+    program = "require 'stdlib/foreach_in'"
+    env_after_require = eval(program)
+    env_after_require.should have_key(:foreach_in)
+    
+    program = "require 'stdlib/inject'"
+    env_after_require = eval(program)
+    env_after_require.should have_key(:inject)
+  end
+  
+  it "should ignore a require statement if the library has already been loaded" do
+    program = "require 'stdlib/inject'"
+    program = "require 'stdlib/map'"
+    env_after_require = eval(program)
+    env_after_require.should have_key(:inject)
+    env_after_require.should have_key(:map)
+  end
+  
+end

data/spec/trxl/stdlib_spec.rb

@@ -0,0 +1,370 @@
+require 'spec_helper'
+
+describe "The Trxl::StdLib" do
+
+  include Trxl::SpecHelper
+  
+  before(:each) do
+    @parser = Trxl::Calculator.new
+  end
+  
+  it "should be able to parse the whole Trxl::StdLib code" do
+    lambda { parse(Trxl::Calculator.stdlib) }.should_not raise_error
+  end
+  
+  it "should define a foreach function with read access to the outer env" do
+    program = <<-PROGRAM
+      require 'stdlib/foreach_in';
+      foreach_in(1..3, fun(c) { c });
+    PROGRAM
+    eval(program).should == 3
+  end
+  
+  it "should define a foreach function with write access to the outer env" do
+    program = <<-PROGRAM
+      require 'stdlib/foreach_in';
+      sum = 0;
+      a = 1..10;
+      foreach_in(a, fun(e) { 
+        sum = sum + e 
+      });
+      sum;
+    PROGRAM
+    eval(program).should == 55
+  end
+
+  it "should define an inject function with read access to the outer env" do
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      inject(0, 1..6, fun(memo, val) { memo + val });
+    PROGRAM
+    eval(program).should == 21
+  end
+
+  it "should define an inject function with write access to the outer env" do
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      ratio = fun(values) {
+        base = 0;
+        positives = inject(0, values, fun(memo, val) {
+          if(ENV[val] == "yes")
+            base = base + 1; 
+            memo + 1
+          elsif(ENV[val] == "no") 
+            base = base + 1; 
+            memo
+          else 
+            memo
+          end
+        });
+        if(base > 0)
+          ROUND((ROUND(positives, 10) / base) * 100, 2)
+        else
+          0
+        end        
+      };
+      ratio('a'..'c');
+    PROGRAM
+    eval(program, { :a => 'yes', :b => 'no', :c => 'n/a' }).should == 50
+  end
+
+  it "should define a map function with read access to the outer env" do
+    program = <<-PROGRAM
+      require 'stdlib/map';
+      map([[1,2],[3,4],[5,6]], fun(a) { a[1]; });
+    PROGRAM
+    eval(program).should == [2,4,6]
+  end
+
+  it "should define a map function with write access to the outer env" do
+    program = <<-PROGRAM
+      require 'stdlib/map';
+      a = [];
+      map([[1,2],[3,4],[5,6]], fun(x) { a << x[1]; });
+      a;
+    PROGRAM
+    eval(program).should == [2,4,6]
+
+    program = <<-PROGRAM
+      require 'stdlib/map';
+      sum = 0;
+      map([[1,2],[3,4],[5,6]], fun(x) { sum = sum + x[1]; });
+      sum;
+    PROGRAM
+    eval(program).should == 12
+  end
+
+  it "should define a 'select' function for any enumerable collection" do
+    program = <<-PROGRAM
+      require 'stdlib/select';
+      select([ 1, 2, 3, 4 ], fun(e) { e % 2 == 0 });
+    PROGRAM
+    eval(program).should == [ 2, 4 ]
+
+    program = <<-PROGRAM
+      require 'stdlib/select';
+      select(1..4, fun(e) { e % 2 == 0 });
+    PROGRAM
+    eval(program).should == [ 2, 4 ]
+  end
+
+  it "should define a 'reject' function for any enumerable collection" do
+    program = <<-PROGRAM
+      require 'stdlib/reject';
+      reject([ 1, 2, 3, 4 ], fun(e) { e % 2 == 0 });
+    PROGRAM
+    eval(program).should == [ 1, 3 ]
+
+    program = <<-PROGRAM
+      require 'stdlib/reject';
+      reject(1..4, fun(e) { e % 2 == 0 });
+    PROGRAM
+    eval(program).should == [ 1, 3 ]
+  end
+
+  it "should define a 'ratio' function for any enumerable collection" do
+    env = {
+      :a => "Ja", 
+      :b => "Ja",
+      :c => "Ja",
+      :d => "Ja"
+    }
+    req_stmt = "require 'stdlib/ratio';"
+    eval("#{req_stmt} ratio('a'..'d', 'Ja', 'keine Angabe');", env).should == 100
+    
+    env = {
+      :a => "Ja", 
+      :b => "Ja",
+      :c => "Nein",
+      :d => "Nein"
+    }
+    req_stmt = "require 'stdlib/ratio';"
+    eval("#{req_stmt} ratio('a'..'d', 'Ja', 'keine Angabe');", env).should == 50
+    
+    env = {
+      :a => "Nein", 
+      :b => "Nein",
+      :c => "Nein",
+      :d => "Nein"
+    }
+    req_stmt = "require 'stdlib/ratio';"
+    eval("#{req_stmt} ratio('a'..'d', 'Ja', 'keine Angabe');", env).should == 0
+    
+    env = {
+      :a => "Ja", 
+      :b => "Nein",
+      :c => "Nein",
+      :d => "Nein",
+      :e => "keine Angabe"
+    }
+    req_stmt = "require 'stdlib/ratio';"
+    eval("#{req_stmt} ratio('a'..'e', 'Ja', 'keine Angabe');", env).should == 25
+    
+    env = {
+      :a => "keine Angabe"
+    }
+    req_stmt = "require 'stdlib/ratio';"
+    eval("#{req_stmt} ratio(['a'], 'Ja', 'keine Angabe');", env).should be_nil
+    
+    env = {
+      :a => "keine Angabe",
+      :b => "keine Angabe",
+      :c => "keine Angabe"
+    }
+    req_stmt = "require 'stdlib/ratio';"
+    eval("#{req_stmt} ratio('a'..'c', 'Ja', 'keine Angabe');", env).should be_nil
+    
+    env = {
+      :a => "Ja",
+      :b => "keine Angabe"
+    }
+    req_stmt = "require 'stdlib/ratio';"
+    eval("#{req_stmt} ratio('a'..'b', 'Ja', 'keine Angabe');", env).should == 100
+    
+    env = {
+      :a => "Nein",
+      :b => "keine Angabe"
+    }
+    req_stmt = "require 'stdlib/ratio';"
+    eval("#{req_stmt} ratio('a'..'b', 'Ja', 'keine Angabe');", env).should == 0
+  end
+
+  it "should define a 'in_groups_of' function for any enumerable collection" do
+    program = <<-PROGRAM
+      require 'stdlib/in_groups_of';
+      in_groups_of(2, [ 1, 2, 3, 4 ], fun(group) { group });
+    PROGRAM
+    eval(program).should == [ [ 1, 2 ], [ 3, 4 ] ]
+
+    program = <<-PROGRAM
+      require 'stdlib/in_groups_of';
+      in_groups_of(2, 1..4, fun(group) { group });
+    PROGRAM
+    eval(program).should == [ [ 1, 2 ], [ 3, 4 ] ]
+
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      require 'stdlib/in_groups_of';
+      in_groups_of(2, 1..4, fun(group) { SUM(group) });
+    PROGRAM
+    eval(program).should == [ 3, 7 ]
+    
+    program = <<-PROGRAM
+      require 'stdlib/in_groups_of';
+      in_groups_of(2, 'a'..'d', fun(group) { group });
+    PROGRAM
+    eval(program).should == [ [ 'a', 'b' ], [ 'c', 'd' ] ]
+    
+    env = Trxl::Environment.new({
+      :a => { 
+        1 => "Building 1", 
+        2 => "Building 2", 
+        3 => "Building 3" 
+      },
+      :b => { 
+        1 => "Feuerwehrgebäude",
+        2 => "Schulgebäude",
+        3 => "Wohngebäude"
+      },
+      :c => { 1 => 100, 2 => 200, 3 => 300 },
+      :d => { 1 => 100, 2 => 200, 3 => 300 },
+      :e => { 1 => 100, 2 => 200, 3 => 300 },
+      :f => { 1 => 100, 2 => 200, 3 => 300 },
+      :g => { 1 => 100, 2 => 200, 3 => 300 },
+      :h => { 1 => 100, 2 => 200, 3 => 300 },
+      :i => { 1 => 100, 2 => 200, 3 => 300 },
+      :j => { 1 => 100, 2 => 200, 3 => 300 },
+      :k => { 1 => 100, 2 => 200, 3 => 300 },
+      :l => { 1 => 100, 2 => 200, 3 => 300 },
+      :m => { 1 => 100, 2 => 200, 3 => 300 },
+      :n => { 1 => 100, 2 => 200, 3 => 300 },
+      :o => { 1 => 100, 2 => 200, 3 => 300 },
+      :p => { 1 => 100, 2 => 200, 3 => 300 },
+      :q => { 1 => 100, 2 => 200, 3 => 300 },
+      :r => { 1 => 100, 2 => 200, 3 => 300 },
+      :s => { 1 => 100, 2 => 200, 3 => 300 },
+      :t => { 1 => 100, 2 => 200, 3 => 300 },
+      :u => { 
+        1 => [ 15, 15, 15 ],
+        1 => [ 20, 20, 20 ],
+        1 => [ 30, 30, 30 ]
+      }
+    })
+  end
+  
+  it "should allow recursive functions as accumulator in 'in_groups_of' function calls" do
+    program = <<-PROGRAM
+      require 'stdlib/inject';
+      require 'stdlib/in_groups_of';
+      in_groups_of(2, 1..4, fun(group) {
+        inject(0, group, fun(sum, e) {
+          sum + e
+        });
+      });
+    PROGRAM
+    eval(program).should == [ 3, 7 ]
+  end
+  
+  it "should define a 'sum_of_type' function" do
+    env = {
+      :types => {
+        1 => "Feuerwehrgebäude", 
+        2 => "Schulgebäude", 
+        3 => "Sonstige",
+      },
+      :values => { 
+        1 => [ 100, 100, 100 ],
+        2 => [ 200, 200, 200 ],
+        3 => [ 300, 300, 300 ]
+      }
+    }
+    req_stmt = "require 'stdlib/sum_of_type';"
+    eval("#{req_stmt} sum_of_type('Feuerwehrgebäude', types, values);", env).should == 300
+    eval("#{req_stmt} sum_of_type('Schulgebäude', types, values);", env).should == 600
+    eval("#{req_stmt} sum_of_type('Sonstige', types, values);", env).should == 900
+  end
+  
+  it "should define a 'avg_sum_of_type' function" do
+    env = {
+      :types => {
+        1 => "Feuerwehrgebäude", 
+        2 => "Schulgebäude", 
+        3 => "Sonstige",
+      },
+      :values => { 
+        1 => [ 100, 100, 100 ],
+        2 => [ 200, 200, 200 ],
+        3 => [ 300, 300, 300 ]
+      }
+    }
+    req_stmt = "require 'stdlib/avg_sum_of_type';"
+    eval("#{req_stmt} avg_sum_of_type('Feuerwehrgebäude', types, values);", env).should == 100
+    eval("#{req_stmt} avg_sum_of_type('Schulgebäude', types, values);", env).should == 200
+    eval("#{req_stmt} avg_sum_of_type('Sonstige', types, values);", env).should == 300
+  end
+  
+  it "should define a 'total_range_sum_of_type' function" do
+    env = {
+      :types => {
+        1 => "Feuerwehrgebäude", 
+        2 => "Schulgebäude", 
+        3 => "Sonstige",
+      },
+      :a => { 
+        1 => [ 100, 100, 100 ],
+        2 => [ 200, 200, 200 ],
+        3 => [ 300, 300, 300 ]
+      },
+      :b => { 
+        1 => [ 100, 100, 100 ],
+        2 => [ 200, 200, 200 ],
+        3 => [ 300, 300, 300 ]
+      }
+    }
+    req_stmt = "require 'stdlib/total_range_sum_of_type';"
+    eval("#{req_stmt} total_range_sum_of_type('Feuerwehrgebäude', types, 'a'..'b');", env).should == 600
+    eval("#{req_stmt} total_range_sum_of_type('Schulgebäude', types, 'a'..'b');", env).should == 1200
+    eval("#{req_stmt} total_range_sum_of_type('Sonstige', types, 'a'..'b');", env).should == 1800
+  end
+  
+  it "should define a 'avg_range_sum_of_type' function" do
+    env = {
+      :types => {
+        1 => "Feuerwehrgebäude", 
+        2 => "Schulgebäude", 
+        3 => "Sonstige",
+      },
+      :a => { 
+        1 => [ 100, 100, 100 ],
+        2 => [ 200, 200, 200 ],
+        3 => [ 300, 300, 300 ]
+      },
+      :b => { 
+        1 => [ 100, 100, 100 ],
+        2 => [ 200, 200, 200 ],
+        3 => [ 300, 300, 300 ]
+      }
+    }
+    req_stmt = "require 'stdlib/avg_range_sum_of_type';"
+    eval("#{req_stmt} avg_range_sum_of_type('Feuerwehrgebäude', types, 'a'..'b');", env).should == 200
+    eval("#{req_stmt} avg_range_sum_of_type('Schulgebäude', types, 'a'..'b');", env).should == 400
+    eval("#{req_stmt} avg_range_sum_of_type('Sonstige', types, 'a'..'b');", env).should == 600
+  end
+  
+  it "should define a 'year_from_date' function" do
+    req_stmt = "require 'stdlib/year_from_date';"
+    eval("#{req_stmt} year_from_date('01/1999');").should == 1999
+    eval("#{req_stmt} year_from_date('12/1999');").should == 1999
+    eval("#{req_stmt} year_from_date('12/2008');").should == 2008
+    eval("#{req_stmt} year_from_date('12/2008');").should == 2008
+  end
+  
+  it "should define a 'month_from_date' function" do
+    req_stmt = "require 'stdlib/month_from_date';"
+    eval("#{req_stmt} month_from_date('01/1999');").should == 1
+    eval("#{req_stmt} month_from_date('12/1999');").should == 12
+    eval("#{req_stmt} month_from_date('1/2008');").should == 1
+    eval("#{req_stmt} month_from_date('12/2008');").should == 12
+  end
+  
+end