gisele 0.5.0 → 0.5.1

data/spec/unit/language/syntax/grammar/test_spacing.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar, 'spacing' do
-
-    it 'parses all kind of spaces' do
-      parse(' ', :spacing).should eq(' ')
-      parse("\t", :spacing).should eq("\t")
-      parse("\n", :spacing).should eq("\n")
-      parse(" \t\n", :spacing).should eq(" \t\n")
-    end
-
-    it 'does not enforces mandatory spacing' do
-      parse('', :spacing).should eq('')
-    end
-
-  end
-end

data/spec/unit/language/syntax/grammar/test_task_def.rb

@@ -1,35 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar, 'task_def' do
-
-    it 'parses a simple implicit task definition' do
-      taskdef = <<-TASKDEF.strip
-        task Process
-          Diagnosis
-        end
-      TASKDEF
-      parse(taskdef, :task_def).should eq(taskdef)
-    end
-
-    it 'allows any statement' do
-      taskdef = <<-TASKDEF.strip
-        task Process
-          while true Diagnosis end
-        end
-      TASKDEF
-      parse(taskdef, :task_def).should eq(taskdef)
-    end
-
-    it 'supports optional variable definitions in the signature' do
-      taskdef = <<-TASKDEF.strip
-        task Process
-          fluent   diagKnown {Diagnosis:start}, {} initially false
-          trackvar mplus     {Diagnosis:end}
-          Diagnosis
-        end
-      TASKDEF
-      parse(taskdef, :task_def).should eq(taskdef)
-    end
-
-  end
-end

data/spec/unit/language/syntax/grammar/test_task_name.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar,'task_name' do
-
-    it 'parses correct task names' do
-      parse('A',          :task_name).should eq('A')
-      parse('Diagnosis',  :task_name).should eq('Diagnosis')
-      parse('TaskName',   :task_name).should eq('TaskName')
-      parse('Task_Name',  :task_name).should eq('Task_Name')
-    end
-
-    it 'raises on invalid task names' do
-      lambda{
-        parse('not_a_task_name', :task_name)
-      }.should raise_error(Citrus::ParseError)
-    end
-
-  end
-end

data/spec/unit/language/syntax/grammar/test_task_start_or_end.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar, 'task_start_or_end' do
-
-    it 'parses correct event names' do
-      parse('Task:start', :task_start_or_end).should eq('Task:start')
-      parse('Task:end',   :task_start_or_end).should eq('Task:end')
-    end
-
-    it 'raises on simple task names' do
-      lambda{
-        parse('Task', :task_start_or_end)
-      }.should raise_error(Citrus::ParseError)
-    end
-
-  end
-end

data/spec/unit/language/syntax/grammar/test_trackvar_def.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar, 'trackvar_def' do
-
-    it 'parses valid tracking variable definitions' do
-      defn = 'trackvar plateletLow {BloodTest:end}'
-      parse(defn, :trackvar_def).should eq(defn)
-    end
-
-    it 'supports an optional initial value' do
-      defn = 'trackvar plateletLow {BloodTest:end} initially false'
-      parse(defn, :trackvar_def).should eq(defn)
-    end
-
-    it 'supports optional obsolete events' do
-      defn = 'trackvar plateletLow {BloodTest:end}, {Chemotherapy:end}'
-      parse(defn, :trackvar_def).should eq(defn)
-    end
-
-  end
-end

data/spec/unit/language/syntax/grammar/test_unit_def.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar, 'unit' do
-
-    it 'parses a single task definition' do
-      expr = <<-UNIT.strip
-        task Task1 end
-      UNIT
-      parse(expr, :unit_def).should eq(expr)
-    end
-
-    it 'accepts multiple task definitions' do
-      expr = <<-UNIT.strip
-        task Task1 end
-        task Task2 end
-      UNIT
-      parse(expr, :unit_def).should eq(expr)
-    end
-
-    it 'allows trailing spaces' do
-      expr = <<-UNIT
-        task Task1 end
-        task Task2 end
-      UNIT
-      parse(expr, :unit_def).should eq(expr)
-    end
-
-  end
-end

data/spec/unit/language/syntax/grammar/test_variable_name.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar, 'variable_name' do
-
-    RESERVED_WORDS = [
-      "if",
-      "else",
-      "elsif",
-      "when",
-      "while",
-      "seq",
-      "par",
-      "task",
-      "refinement",
-      "fluent",
-      "trackvar",
-      "initially",
-      "end",
-      "not",
-      "or",
-      "and",
-      "true",
-      "false"
-    ]
-
-    it 'parses correct variable names' do
-      parse('a',         :variable_name).should eq('a')
-      parse('diagnosis', :variable_name).should eq('diagnosis')
-      parse('varName',   :variable_name).should eq('varName')
-    end
-
-    it 'does not allow reserved words' do
-      RESERVED_WORDS.each do |word|
-        lambda{
-          parse(word.to_s + " ", :variable_name)
-        }.should raise_error(Citrus::ParseError)
-      end
-    end
-
-    it 'allows a reserved word as prefix' do
-      parse('ifSomething', :variable_name).should eq('ifSomething')
-    end
-
-    it 'raises on invalid variable names' do
-      lambda{
-        parse('NotAVarName', :variable_name)
-      }.should raise_error(Citrus::ParseError)
-    end
-
-  end
-end

data/spec/unit/language/syntax/grammar/test_when_clause.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar, 'when_clause' do
-
-    it 'parses a single when clause statement' do
-      expr = 'when goodCond Task'
-      parse(expr, :when_clause).should eq(expr)
-    end
-
-    it 'supports a boolean expression' do
-      expr = 'when not(goodCond and badCond) Task'
-      parse(expr, :when_clause).should eq(expr)
-    end
-
-    it 'supports an complex process statement' do
-      expr = 'when goodCond Task1 par Task2 Task3 end'
-      parse(expr, :when_clause).should eq(expr)
-    end
-
-  end
-end

data/spec/unit/language/syntax/grammar/test_while_st.rb

@@ -1,11 +0,0 @@
-require 'spec_helper'
-module Gisele::Language
-  describe Grammar, 'while_st' do
-
-    it 'parses a single while statement' do
-      expr = 'while badCond Task end'
-      parse(expr, :while_st).should eq(expr)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_bool_expr.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe BoolExpr, "to_ast" do
-
-    it 'is correctly extended by Sexpr' do
-      ast("true", :bool_expr).should be_a(Gisele::Language::AST::BoolExpr)
-    end
-
-    it 'returns expected ast on simple expressions' do
-      expected = \
-        [:bool_expr, [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]]]
-      ast("diagKnown and platLow", :bool_expr).should eq(expected)
-    end
-
-    it 'respects priorities' do
-      expected = [:bool_expr,
-        [:bool_or, [:bool_and, [:var_ref, "diagKnown"], [:var_ref, "platLow"]], [:var_ref, "platHigh"]]]
-      ast("diagKnown and platLow or platHigh", :bool_expr).should eq(expected)
-    end
-
-    it 'supports double negations' do
-      expected = [:bool_expr, [:bool_not, [:bool_not, [:var_ref, "diagKnown"]]]]
-      ast("not not(diagKnown)", :bool_expr).should eq(expected)
-    end
-
-    it 'makes boolean literals explicit' do
-      ast("true",  :bool_expr).should eq([:bool_expr, [:bool_lit, true]])
-      ast("false", :bool_expr).should eq([:bool_expr, [:bool_lit, false]])
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_case_st.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe CaseSt, "to_ast" do
-
-    it 'arranges when clauses as expected' do
-      expr = <<-CASE_ST.strip
-        case
-        when good
-          Task1
-        when bad
-          Task2
-        end
-      CASE_ST
-      when_clause1 = ast("when good Task1", :when_clause)
-      when_clause2 = ast("when bad Task2", :when_clause)
-      expected = [:case_st, nil, when_clause1, when_clause2]
-      ast(expr, :case_st).should eq(expected)
-    end
-
-    it 'puts the else clause at the end' do
-      expr = <<-CASE_ST.strip
-        case
-        when good
-          Task1
-        else
-          Task2
-        end
-      CASE_ST
-      when_clause = ast("when good Task1", :when_clause)
-      else_clause = ast("else Task2", :else_clause)
-      expected = [:case_st, nil, when_clause, else_clause]
-      ast(expr, :case_st).should eq(expected)
-    end
-
-    it 'supports an optional variable name' do
-      expr = <<-CASE_ST.strip
-        case someVariable
-        when good
-          Task1
-        end
-      CASE_ST
-      expected = [:var_ref, "someVariable"]
-      ast(expr, :case_st)[1].should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_else_clause.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe ElseClause, "to_ast" do
-
-    it 'parses as expected' do
-      expr     = "else Task1"
-      expected = \
-        [:else_clause, [:task_call_st, "Task1"]]
-      ast(expr, :else_clause).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_elsif_clause.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe ElsifClause, "to_ast" do
-
-    it 'parses as expected' do
-      expr     = "elsif goodCond Task1"
-      expected = \
-        [:elsif_clause,
-          [:bool_expr, [:var_ref, "goodCond"]],
-          [:task_call_st, "Task1"]]
-      ast(expr, :elsif_clause).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_event_set.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe EventSet, "to_ast" do
-
-    it 'converts empty lists as expected' do
-      expr     = '{ }'
-      expected = [:event_set]
-      ast(expr, :event_set).should eq(expected)
-    end
-
-    it 'converts singleton lists as expected' do
-      expr     = '{Diagnosis:start}'
-      expected = [:event_set, "Diagnosis:start"]
-      ast(expr, :event_set).should eq(expected)
-    end
-
-    it 'converts non empty lists as expected' do
-      expr     = '{Diagnosis:start, an_event, another_one}'
-      expected = [:event_set, "Diagnosis:start", "an_event", "another_one"]
-      ast(expr, :event_set).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_fluent_def.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe FluentDef, "to_ast" do
-
-    it 'converts fluent definitions as expected' do
-      defn     = "fluent diagKnown {Diagnosis:start, diagnosis}, {Treatment:end} initially false"
-      expected = [:fluent_def,
-                   "diagKnown",
-                   [:event_set, "Diagnosis:start", "diagnosis"],
-                   [:event_set, "Treatment:end"],
-                   false]
-      ast(defn, :fluent_def).should eq(expected)
-    end
-
-    it 'does not require the initial value' do
-      defn     = "fluent diagKnown {Diagnosis:start, diagnosis}, {Treatment:end}"
-      expected = [:fluent_def,
-                   "diagKnown",
-                   [:event_set, "Diagnosis:start", "diagnosis"],
-                   [:event_set, "Treatment:end"],
-                   nil]
-      ast(defn, :fluent_def).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_if_st.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe IfSt, "to_ast" do
-
-    it 'parses as expected' do
-      expr     = "if goodCond Task1 end"
-      expected = \
-        [:if_st,
-          [:bool_expr, [:var_ref, "goodCond"]],
-          [:task_call_st, "Task1"]]
-      ast(expr, :if_st).should eq(expected)
-    end
-
-    it 'supports a else clause' do
-      expr     = "if goodCond Task1 else Task2 end"
-      expected = \
-        [:if_st,
-          [:bool_expr, [:var_ref, "goodCond"]],
-          [:task_call_st, "Task1"],
-          [:else_clause, [:task_call_st, "Task2"]] ]
-      ast(expr, :if_st).should eq(expected)
-    end
-
-    it 'supports elsif clauses' do
-      expr     = "if goodCond Task1 elsif otherCond Task2 elsif stillAnother Task3 else Task4 end"
-      expected = \
-        [:if_st,
-          [:bool_expr, [:var_ref, "goodCond"]], [:task_call_st, "Task1"],
-          [:elsif_clause,
-            [:bool_expr, [:var_ref, "otherCond"]], [:task_call_st, "Task2"]],
-          [:elsif_clause,
-            [:bool_expr, [:var_ref, "stillAnother"]], [:task_call_st, "Task3"]],
-          [:else_clause,
-            [:task_call_st, "Task4"]] ]
-      ast(expr, :if_st).should eq(expected)
-    end
-
-  end
-end

data/spec/unit/language/syntax/to_ast/test_par_st.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-module Gisele::Language::Syntax
-  describe ParSt, "to_ast" do
-
-    it 'parses as expected' do
-      expr     = "par Task1 Task2 end"
-      expected = [:par_st, [:task_call_st, "Task1"], [:task_call_st, "Task2"]]
-      ast(expr, :par_st).should eq(expected)
-    end
-
-  end
-end