rtext 0.7.0 → 0.8.0.pre1

data/test/integration/model/test_metamodel.ect

@@ -1,10 +1,16 @@
 EPackage StatemachineMM {
   EClass State, abstract: true {
     EAttribute name, eType: /StatemachineMM/StringType
-    EReference parent, eType: /StatemachineMM/CompositeState, eOpposite: /StatemachineMM/CompositeState/substates
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
   }
   EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
-  EClass CompositeState, eSuperTypes: [/StatemachineMM/State] {
+  EClass CompositeState, 
+    eSuperTypes: [
+      /StatemachineMM/State
+    ],
+    abstract: false {
     EReference substates, upperBound: -1, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
   }
   EClass Transition {

data/test/integration/test.rb

@@ -350,6 +350,160 @@ EPackage StatemachineMM {
   ]
 end
 
+def test_complete_feature_after_linebreak
+  setup_connector(ModelFile)
+  load_model
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      |eType: /StatemachineMM/CompositeState, 
+  END
+  assert_completions context, [
+   "containment:",
+   "resolveProxies:",
+   "eOpposite:",
+   "changeable:",
+   "defaultValueLiteral:",
+   "derived:",
+   "transient:",
+   "unsettable:",
+   "volatile:",
+   "lowerBound:",
+   "ordered:",
+   "unique:",
+   "upperBound:",
+   "eType:"
+  ]
+end
+
+def test_complete_reference_after_linebreak
+  setup_connector(ModelFile)
+  load_model
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: |/StatemachineMM/CompositeState, 
+  END
+  assert_completions context, [
+    "/StatemachineMM/CompositeState",
+    "/StatemachineMM/SimpleState",
+    "/StatemachineMM/State",
+    "/StatemachineMM/StringType",
+    "/StatemachineMM/Transition",
+    "/StatemachineMM2/SimpleState",
+    "/StatemachineMM2/State"
+  ]
+end
+
+def test_complete_command_after_linebreak
+  setup_connector(ModelFile)
+  load_model
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
+  }
+  EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
+  EClass CompositeState, 
+    eSuperTypes: [
+      /StatemachineMM/State
+    ],
+    abstract: false {
+    |EReference substates, upperBound: -1, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
+  END
+  assert_completions context, [
+    "EAnnotation",
+    "EAttribute",
+    "EOperation",
+    "EReference",
+    "EStructuralFeature"
+  ]
+end
+
+def test_complete_value_after_linebreak
+  setup_connector(ModelFile)
+  load_model
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
+  }
+  EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
+  EClass CompositeState, 
+    eSuperTypes: [
+      /StatemachineMM/State
+    ],
+    abstract: |false {
+  END
+  assert_completions context, [
+    "true",
+    "false"
+  ]
+end
+
+def test_complete_in_array_after_linebreak
+  setup_connector(ModelFile)
+  load_model
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
+  }
+  EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
+  EClass CompositeState, 
+    eSuperTypes: [
+      |/StatemachineMM/State
+  END
+  assert_completions context, [
+    "/StatemachineMM/CompositeState",
+    "/StatemachineMM/SimpleState",
+    "/StatemachineMM/State",
+    "/StatemachineMM/Transition",
+    "/StatemachineMM2/SimpleState",
+    "/StatemachineMM2/State"
+  ]
+end
+
+def test_complete_in_array_after_linebreak2
+  setup_connector(ModelFile)
+  load_model
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
+  }
+  EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
+  EClass CompositeState, 
+    eSuperTypes: [
+      /StatemachineMM/State
+    |],
+  END
+  assert_completions context, [
+    "/StatemachineMM/CompositeState",
+    "/StatemachineMM/SimpleState",
+    "/StatemachineMM/State",
+    "/StatemachineMM/Transition",
+    "/StatemachineMM2/SimpleState",
+    "/StatemachineMM2/State"
+  ]
+end
+
 def test_reference_completion
   setup_connector(ModelFile)
   load_model
@@ -418,7 +572,9 @@ def test_reference_completion_in_array
 EPackage StatemachineMM {
   EClass State, abstract: true {
     EAttribute name, eType: /StatemachineMM/StringType
-    EReference parent, eType: /StatemachineMM/CompositeState, eOpposite: /StatemachineMM/CompositeState/substates
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
   }
   EClass SimpleState, eSuperTypes: [|/StatemachineMM/State]
   END
@@ -434,7 +590,9 @@ EPackage StatemachineMM {
 EPackage StatemachineMM {
   EClass State, abstract: true {
     EAttribute name, eType: /StatemachineMM/StringType
-    EReference parent, eType: /StatemachineMM/CompositeState, eOpposite: /StatemachineMM/CompositeState/substates
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
   }
   EClass SimpleState, eSuperTypes: [/StatemachineMM/S|tate]
   END
@@ -450,7 +608,9 @@ EPackage StatemachineMM {
 EPackage StatemachineMM {
   EClass State, abstract: true {
     EAttribute name, eType: /StatemachineMM/StringType
-    EReference parent, eType: /StatemachineMM/CompositeState, eOpposite: /StatemachineMM/CompositeState/substates
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
   }
   EClass SimpleState, eSuperTypes: [/StatemachineMM/State|]
   END
@@ -466,7 +626,9 @@ EPackage StatemachineMM {
 EPackage StatemachineMM {
   EClass State, abstract: true {
     EAttribute name, eType: /StatemachineMM/StringType
-    EReference parent, eType: /StatemachineMM/CompositeState, eOpposite: /StatemachineMM/CompositeState/substates
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
   }
   EClass SimpleState, eSuperTypes: [/StatemachineMM/State]|
   END
@@ -481,10 +643,16 @@ def test_integer_completion
 EPackage StatemachineMM {
   EClass State, abstract: true {
     EAttribute name, eType: /StatemachineMM/StringType
-    EReference parent, eType: /StatemachineMM/CompositeState, eOpposite: /StatemachineMM/CompositeState/substates
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
   }
   EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
-  EClass CompositeState, eSuperTypes: [/StatemachineMM/State] {
+  EClass CompositeState, 
+    eSuperTypes: [
+      /StatemachineMM/State
+    ],
+    abstract: false {
     EReference substates, upperBound: |-1, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
   END
   assert_completions context, [
@@ -494,10 +662,16 @@ EPackage StatemachineMM {
 EPackage StatemachineMM {
   EClass State, abstract: true {
     EAttribute name, eType: /StatemachineMM/StringType
-    EReference parent, eType: /StatemachineMM/CompositeState, eOpposite: /StatemachineMM/CompositeState/substates
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
   }
   EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
-  EClass CompositeState, eSuperTypes: [/StatemachineMM/State] {
+  EClass CompositeState, 
+    eSuperTypes: [
+      /StatemachineMM/State
+    ],
+    abstract: false {
     EReference substates, upperBound: -1|, containment: true, eType: /StatemachineMM/State, eOpposite: /StatemachineMM/State/parent
   END
   assert_completions context, [
@@ -515,7 +689,7 @@ EPackage StatemachineMM {
   END
   assert_link_targets context, :begin => 29, :end => 54, :targets => [
     {"file"=> File.expand_path(@infile),
-     "line"=>14,
+     "line"=>20,
      "display"=>"/StatemachineMM/StringType [EDataType]"}
   ]
   context = build_context <<-END
@@ -525,7 +699,7 @@ EPackage StatemachineMM {
   END
   assert_link_targets context, :begin => 29, :end => 54, :targets => [
     {"file"=> File.expand_path(@infile),
-     "line"=>14,
+     "line"=>20,
      "display"=>"/StatemachineMM/StringType [EDataType]"}
   ]
   context = build_context <<-END
@@ -535,7 +709,7 @@ EPackage StatemachineMM {
   END
   assert_link_targets context, :begin => 29, :end => 54, :targets => [
     {"file"=> File.expand_path(@infile),
-     "line"=>14,
+     "line"=>20,
      "display"=>"/StatemachineMM/StringType [EDataType]"}
   ]
   context = build_context <<-END
@@ -557,17 +731,19 @@ EPackage StatemachineMM {
   END
   assert_link_targets context, :begin => 3, :end => 8, :targets => [
     {"file"=> File.expand_path(@infile),
-     "line"=>6,
+     "line"=>8,
      "display"=>"/StatemachineMM/SimpleState [EClass]"},
     {"file"=> File.expand_path(@infile),
-     "line"=>7,
+     "line"=>9,
      "display"=>"/StatemachineMM/CompositeState [EClass]"}
   ]
   context = build_context <<-END
 EPackage StatemachineMM {
   EClass State, abstract: true {
     EAttribute name, eType: /StatemachineMM/StringType
-    EReference parent, eType: /StatemachineMM/CompositeState, eOpposite: /StatemachineMM/CompositeState/substates
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState, 
+      eOpposite: /StatemachineMM/CompositeState/substates
   }
   |EClass SimpleState, eSuperTypes: [/StatemachineMM/State]
   END
@@ -594,6 +770,58 @@ EPackage StatemachineMM2 {
   ]
 end
 
+def test_link_targets_after_linebreak
+  setup_connector(ModelFile)
+  load_model
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: /St|atemachineMM/CompositeState, 
+  END
+  # in case of linebreaks, the begin and end column refer to the string which
+  # was passed to the backend as the context; in this case the context extractor
+  # appends each broken line to the previous line with all the leading whitespace removed 
+  assert_link_targets context, :begin => 30, :end => 59, :targets => [
+    {"file"=> File.expand_path(@infile),
+     "line"=>9,
+     "display"=>"/StatemachineMM/CompositeState [EClass]"}
+  ]
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: |/StatemachineMM/CompositeState, 
+  END
+  assert_link_targets context, :begin => 30, :end => 59, :targets => [
+    {"file"=> File.expand_path(@infile),
+     "line"=>9,
+     "display"=>"/StatemachineMM/CompositeState [EClass]"}
+  ]
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: /StatemachineMM/CompositeStat|e, 
+  END
+  assert_link_targets context, :begin => 30, :end => 59, :targets => [
+    {"file"=> File.expand_path(@infile),
+     "line"=>9,
+     "display"=>"/StatemachineMM/CompositeState [EClass]"}
+  ]
+  context = build_context <<-END
+EPackage StatemachineMM {
+  EClass State, abstract: true {
+    EAttribute name, eType: /StatemachineMM/StringType
+    EReference parent, 
+      eType: /StatemachineMM/CompositeState|, 
+  END
+  assert_link_targets context, :begin => nil, :end => nil, :targets => []
+end
+
 def test_find_elements
   setup_connector(ModelFile)
   load_model
@@ -617,7 +845,7 @@ def test_find_elements
   assert_equal \
     [{"display"=>"target [EReference] - /StatemachineMM/Transition",
       "file"=> File.expand_path(@infile),
-      "line"=>11}], response["elements"]
+      "line"=>17}], response["elements"]
   response = @con.execute_command( 
     {"command" => "find_elements", "search_pattern" => ""})
   assert_equal [], response["elements"]
@@ -654,9 +882,9 @@ def assert_link_targets(context, options)
   infile = options[:file] || @infile
   content = File.open(infile, "rb") {|f| f.read}
   lines = content.split(/\r?\n/)[0..context.line-1]
-  lines =  RText::Frontend::Context.extract(lines)
+  lines, col =  RText::Frontend::Context.new.extract(lines, context.col)
   response = @con.execute_command( 
-    {"command" => "link_targets", "context" => lines, "column" => context.col})
+    {"command" => "link_targets", "context" => lines, "column" => col})
   assert_equal "response", response["type"]
   assert_equal options[:targets], response["targets"]
   assert_equal options[:begin], response["begin_column"]
@@ -666,9 +894,9 @@ end
 def assert_completions(context, expected)
   content = File.open(@infile, "rb"){|f| f.read}
   lines = content.split(/\r?\n/)[0..context.line-1]
-  lines =  RText::Frontend::Context.extract(lines)
+  lines, col =  RText::Frontend::Context.new.extract(lines, context.col)
   response = @con.execute_command( 
-    {"command" => "content_complete", "context" => lines, "column" => context.col})
+    {"command" => "content_complete", "context" => lines, "column" => col})
   assert_equal expected, response["options"].collect{|o| o["insert"]}
 end
 

data/test/link_detector_test.rb

@@ -189,6 +189,14 @@ TestNode |SomeNode
   assert_link_desc ld, :element => "TestNode", :feature => "name", :index => 0, :backward => true, :value => "SomeNode", :scol => 10, :ecol => 17
 end
 
+def test_command_and_name_curly_no_ws
+  ld = build_link_desc(TestMM, {:backward_ref => "name"}, <<-END
+TestNode Some|Node{
+  END
+  )
+  assert_link_desc ld, :element => "TestNode", :element_name => "SomeNode", :feature => "name", :index => 0, :backward => true, :value => "SomeNode", :scol => 10, :ecol => 17
+end
+
 def test_child_within_command
   ld = build_link_desc(TestMM, {:backward_ref => "name"}, <<-END
 TestNode SomeNode {
@@ -256,6 +264,9 @@ def assert_link_desc(ld, options)
   else
     assert_nil ld.element
   end
+  if options[:element_name]
+    assert_equal options[:element_name], ld.element.name
+  end
   if options[:feature]
     assert_equal options[:feature], ld.feature.name
   else

data/test/rtext_test.rb

@@ -8,3 +8,4 @@ require 'tokenizer_test'
 require 'link_detector_test'
 require 'integration/test'
 require 'message_helper_test'
+require 'frontend/context_test'

data/test/serializer_test.rb

@@ -27,6 +27,12 @@ class SerializerTest < Test::Unit::TestCase
     class TestNode < RGen::MetamodelBuilder::MMBase
       has_attr 'text', String
       has_many_attr 'texts', String
+      has_many_attr 'more_texts', String
+      has_attr 'unlabled', String
+      has_attr 'unquoted', String
+      has_attr 'both', String
+      has_attr 'none', String
+      has_attr 'comment', String
       has_attr 'integer', Integer
       has_attr 'float', Float
       has_attr 'enum', SomeEnum
@@ -297,6 +303,25 @@ TestNode name: "Target2"
 ),output
   end
 
+  def test_identifier_provider_nil
+    testModel = [
+      TestMMRef::TestNode.new(:name => "Source"),
+      TestMMRef::TestNode.new(:name => "Target")]
+    testModel[0].refOne = testModel[1]
+
+    output = StringWriter.new
+    serialize(testModel, TestMMRef, output,
+      :identifier_provider => proc{|e, context, feature, index| 
+        nil
+      }
+    )
+
+    assert_equal %Q(\
+TestNode name: "Source"
+TestNode name: "Target"
+),output
+  end
+
   def test_references
     testModel = [ 
       TestMMRef::TestNode.new(:name => "Source"),
@@ -349,6 +374,7 @@ TestNode name: "Target" {
     end
     class TestNode < RGen::MetamodelBuilder::MMBase
       has_attr 'text', String
+      has_many_attr 'texts', String
       contains_one 'child1', TestNode, 'parent1'
       contains_many 'childs2', TestNode, 'parent2'
       contains_one 'child3', TestNodeA, 'parent3'
@@ -450,6 +476,13 @@ TestNode1 text: "some text" {
     assert_equal %q(TestNode integer: 7)+"\n", output
   end
 
+  def test_integer_big
+    testModel = TestMM::TestNode.new(:integer => 12345678901234567890)
+    output = StringWriter.new
+    serialize(testModel, TestMM, output) 
+    assert_equal %q(TestNode integer: 12345678901234567890)+"\n", output
+  end
+
   def test_integer_format_spec
     testModel = TestMM::TestNode.new(:integer => 10)
     output = StringWriter.new
@@ -462,6 +495,18 @@ TestNode1 text: "some text" {
     assert_equal %q(TestNode integer: 0x0A)+"\n", output
   end
 
+  def test_integer_format_spec_big
+    testModel = TestMM::TestNode.new(:integer => 0xabcdefabcdefabcdef)
+    output = StringWriter.new
+    serialize(testModel, TestMM, output, :argument_format_provider => proc {|a|
+      if a.name == "integer"
+        "0x%x"
+      else
+        nil
+      end}) 
+    assert_equal %q(TestNode integer: 0xabcdefabcdefabcdef)+"\n", output
+  end
+
   def test_float
     testModel = TestMM::TestNode.new(:float => 1.23)
     output = StringWriter.new
@@ -606,6 +651,349 @@ TestNode text: "some text"
 ), output.string
   end
 
+  #
+  # line breaks
+  #
+  All_features = proc {|clazz|
+    res = []
+    clazz.eAllStructuralFeatures.reject{|f| f.name =~ /parent|2$/}.each{|f| res << f.name}
+    res
+  }
+
+  def test_linebreak
+    testModel = TestMM::TestNode.new(
+      :text => "some text",
+      :texts => ["some more text", "some more text", "some more text"])
+
+    output = StringWriter.new
+    serialize(testModel, TestMM, output,
+      :newline_arguments => All_features,
+      :newline_arrays => All_features)
+
+    assert_equal %Q(\
+TestNode \\
+  text: "some text",
+  texts: [
+    "some more text",
+    "some more text",
+    "some more text"
+  ]
+), output 
+  end
+
+  def test_linebreak_child
+    testModel1 = TestMM::TestNode.new(
+      :text => "some text1",
+      :texts => ["some more text", "some more text", "some more text"])
+    testModel0 = TestMM::TestNode.new(
+      :text => "some text0",
+      :integer => 10,
+      :childs => [testModel1])
+
+    output = StringWriter.new
+    serialize(testModel0, TestMM, output,
+      :newline_arguments => All_features,
+      :newline_arrays => All_features)
+
+    assert_equal %Q(\
+TestNode \\
+  text: "some text0",
+  integer: 10 {
+    TestNode \\
+      text: "some text1",
+      texts: [
+        "some more text",
+        "some more text",
+        "some more text"
+      ]
+}
+), output 
+  end
+
+  def test_linebreak_child_no_arguments
+    testModel1 = TestMM::TestNode.new(
+      :text => "some text1",
+      :texts => ["some more text", "some more text", "some more text"])
+    testModel0 = TestMM::TestNode.new(:childs => [testModel1])
+
+    output = StringWriter.new
+    serialize(testModel0, TestMM, output,
+      :newline_arguments => All_features,
+      :newline_arrays => All_features)
+
+    assert_equal %Q(\
+TestNode {
+  TestNode \\
+    text: "some text1",
+    texts: [
+      "some more text",
+      "some more text",
+      "some more text"
+    ]
+}
+), output 
+  end
+
+  def test_linebreak_unlabled_array_arguments
+    testModel = TestMM::TestNode.new(
+      :none => "some text",
+      :texts => ["some more text", "some more text", "some more text"])
+
+    output = StringWriter.new
+    serialize(testModel, TestMM, output,
+      :unlabled_arguments => proc {|clazz| ["texts"]},
+      :newline_arguments => proc {|clazz| All_features.call(clazz) - ["texts"]},
+      :newline_arrays => All_features)
+
+    assert_equal %Q(\
+TestNode [
+    "some more text",
+    "some more text",
+    "some more text"
+  ],
+  none: "some text"
+), output 
+  end
+
+  def test_linebreak_unlabled_array_arguments_sameline
+    testModel = TestMM::TestNode.new(
+      :none => "some text",
+      :texts => ["some more text", "some more text", "some more text"])
+
+    output = StringWriter.new
+    serialize(testModel, TestMM, output,
+      :unlabled_arguments => proc {|clazz| ["texts"]},
+      :newline_arguments => proc {|clazz| All_features.call(clazz) - ["texts"]},
+      :newline_arrays => proc {|clazz| All_features.call(clazz) - ["texts"]})
+
+    assert_equal %Q(\
+TestNode ["some more text", "some more text", "some more text"],
+  none: "some text"
+), output 
+  end
+
+  def test_linebreak_unlabled_both_arguments_and_child
+    testModel1 = TestMM::TestNode.new(
+      :texts => ["some more text", "some more text", "some more text"])
+    testModel0 = TestMM::TestNode.new(
+      :unlabled => "unlabled",
+      :both => "both",
+      :childs => [testModel1])
+
+    output = StringWriter.new
+    serialize(testModel0, TestMM, output,
+      :unlabled_arguments => proc {|clazz| ["unlabled", "both"]},
+      :unquoted_arguments => proc {|clazz| ["both"]},
+      :newline_arguments => proc {|clazz| All_features.call(clazz) - ["unlabled"]},
+      :newline_arrays => All_features)
+
+    assert_equal %Q(\
+TestNode "unlabled",
+  both {
+    TestNode \\
+      texts: [
+        "some more text",
+        "some more text",
+        "some more text"
+      ]
+}
+), output 
+  end
+
+  def test_linebreak_child_two_attributes
+    testModel1 = TestMM::TestNode.new(
+      :text => "some text1",
+      :texts => ["some more text", "some more text", "some more text"],
+      :more_texts => ["even more text", "even more text"])
+    testModel0 = TestMM::TestNode.new(:text => "some text0", :childs => [testModel1])
+
+    output = StringWriter.new
+    serialize(testModel0, TestMM, output,
+      :newline_arguments => proc {|clazz| All_features.call(clazz) - ["text"]},
+      :newline_arrays => proc {|clazz| All_features.call(clazz) - ["text"]})
+
+    assert_equal %Q(\
+TestNode text: "some text0" {
+  TestNode text: "some text1",
+    texts: [
+      "some more text",
+      "some more text",
+      "some more text"
+    ],
+    more_texts: [
+      "even more text",
+      "even more text"
+    ]
+}
+), output 
+  end
+
+  def test_linebreak_child_two_attributes_one_sameline
+    testModel1 = TestMM::TestNode.new(
+      :text => "some text1",
+      :texts => ["some more text", "some more text", "some more text"],
+      :more_texts => ["even more text", "even more text"])
+    testModel0 = TestMM::TestNode.new(:text => "some text0", :childs => [testModel1])
+
+    output = StringWriter.new
+    serialize(testModel0, TestMM, output,
+      :newline_arguments => proc {|clazz| All_features.call(clazz) - ["more_texts"]},
+      :newline_arrays => proc {|clazz| All_features.call(clazz) - ["more_texts"]})
+
+    assert_equal %Q(\
+TestNode \\
+  text: "some text0" {
+    TestNode \\
+      text: "some text1",
+      texts: [
+        "some more text",
+        "some more text",
+        "some more text"
+      ], more_texts: ["even more text", "even more text"]
+}
+), output 
+  end
+
+  def test_linebreak_two_children
+    testModel2 = TestMM::TestNode.new(:text => "some text2", :texts => ["some more text"])
+    testModel1 = TestMM::TestNode.new(:text => "some text1", :texts => ["some more text", "some more text", "some more text"])
+    testModel0 = TestMM::TestNode.new(:text => "some text0", :childs => [testModel1, testModel2])
+
+    output = StringWriter.new
+    serialize(testModel0, TestMM, output,
+      :newline_arguments => proc {|clazz| All_features.call(clazz) - ["text"]},
+      :newline_arrays => All_features)
+
+    assert_equal %Q(\
+TestNode text: "some text0" {
+  TestNode text: "some text1",
+    texts: [
+      "some more text",
+      "some more text",
+      "some more text"
+    ]
+  TestNode text: "some text2",
+    texts: "some more text"
+}
+), output 
+  end
+
+  def test_linebreak_nested_children
+    testModel2 = TestMM::TestNode.new(
+      :text => "some text2",
+      :texts => ["some more text", "some more text", "some more text"])
+    testModel1 = TestMM::TestNode.new(
+      :text => "some text1",
+      :childs => [testModel2])
+    testModel0 = TestMM::TestNode.new(
+      :text => "some text0",
+      :integer => 10,
+      :childs => [testModel1])
+
+    output = StringWriter.new
+    serialize(testModel0, TestMM, output,
+      :newline_arguments => All_features,
+      :newline_arrays => All_features)
+
+    assert_equal %Q(\
+TestNode \\
+  text: "some text0",
+  integer: 10 {
+    TestNode \\
+      text: "some text1" {
+        TestNode \\
+          text: "some text2",
+          texts: [
+            "some more text",
+            "some more text",
+            "some more text"
+          ]
+    }
+}
+), output 
+  end
+
+  def test_linebreak_no_break
+    testModel = TestMM::TestNode.new(:text => "some text", :texts => ["some more text", "some more text", "some more text"])
+
+    output = StringWriter.new
+    serialize(testModel, TestMM, output)
+
+    assert_equal %Q(\
+TestNode text: "some text", texts: ["some more text", "some more text", "some more text"]
+), output 
+  end
+
+  def test_linebreak_child_role
+    testModel = TestMMChildRole::TestNode.new(
+      :child1 => TestMMChildRole::TestNode.new(:text => "child1"),
+      :childs2 => [
+        TestMMChildRole::TestNode.new(
+          :text => "child2a",
+          :texts => ["some more text", "some more text"]),
+        TestMMChildRole::TestNode.new(
+          :text => "child2b",
+          :texts => ["some more text", "some more text"])
+      ])
+
+    output = StringWriter.new
+    serialize(testModel, TestMMChildRole, output,
+      :newline_arguments => proc {|clazz| All_features.call(clazz) - ["text"]},
+      :newline_arrays => proc {|clazz| All_features.call(clazz) - ["text"]})
+
+    assert_equal %Q(\
+TestNode {
+  child1:
+    TestNode text: "child1"
+  childs2: [
+    TestNode text: "child2a",
+      texts: [
+        "some more text",
+        "some more text"
+      ]
+    TestNode text: "child2b",
+      texts: [
+        "some more text",
+        "some more text"
+      ]
+  ]
+}
+), output 
+  end
+
+  def test_linebreak_comment
+    testModel = TestMM::TestNode.new(
+      :text => "some text",
+      :comment => "this is a comment",
+      :childs => [
+        TestMM::TestNode.new(:comment => "\n\ncomment of a child node\n  multiline\n\n\nanother\n\n\n")
+        ])
+
+    output = StringWriter.new
+    serialize(testModel, TestMM, output,
+      :newline_arguments => All_features,
+      :comment_provider => proc { |e| 
+        c = e.comment
+        e.comment = nil
+        c
+      })
+
+    assert_equal %Q(\
+#this is a comment
+TestNode \\
+  text: "some text" {
+    #
+    #
+    #comment of a child node
+    #  multiline
+    #
+    #
+    #another
+    TestNode
+}
+), output 
+  end
+
   def serialize(model, mm, output, options={})
     lang = RText::Language.new(mm.ecore, options)
     ser = RText::Serializer.new(lang)