ParameterParser and various mapping-by-code mappers: When parsing new lines, allow both CRLF and lone LF. Primary reason right now is some tests contain newlines that depend on the build machine EOL convention.

oskarb · oskarb · commit eca60026addc · 2014-08-26T23:13:26.000+02:00
diff --git a/src/NHibernate.Test/UtilityTest/StringHelperFixture.cs b/src/NHibernate.Test/UtilityTest/StringHelperFixture.cs
@@ -137,5 +137,35 @@ public void PurgeBackticksEnclosing()
 			Assert.That(StringHelper.PurgeBackticksEnclosing("something`"), Is.EqualTo("something`"));
 			Assert.That(StringHelper.PurgeBackticksEnclosing("`something`"), Is.EqualTo("something"));
 		}
+
+
+		[TestCase("ab", 0, -1, 0)]
+		[TestCase("a\r\nb", 0, 1, 2)]
+		[TestCase("a\nb", 0, 1, 1)]
+		[TestCase("ab\r\nfoo\r\n", 4, 7, 2)]
+		public void IndexOfAnyNewLineReturnsIndexAndLength(string str, int startIndex, int expectedIndex,
+		                                                   int expectedMatchLength)
+		{
+			int matchLength;
+			var matchIndex = str.IndexOfAnyNewLine(startIndex, out matchLength);
+
+			Assert.That(matchIndex, Is.EqualTo(expectedIndex));
+			Assert.That(matchLength, Is.EqualTo(expectedMatchLength));
+		}
+
+
+		[TestCase("ab", 0, false, 0)]
+		[TestCase("a\r\nb", 0, false, 0)]
+		[TestCase("a\nb", 1, true, 1)]
+		[TestCase("a\r\nb", 1, true, 2)]
+		public void IsAnyNewLineMatchAndLength(string str, int startIndex, bool expectNewLine,
+		                                       int expectedMatchLength)
+		{
+			int matchLength;
+			var isNewLine = str.IsAnyNewLine(startIndex, out matchLength);
+
+			Assert.That(isNewLine, Is.EqualTo(expectNewLine));
+			Assert.That(matchLength, Is.EqualTo(expectedMatchLength));
+		}
 	}
 }
diff --git a/src/NHibernate/Engine/Query/ParameterParser.cs b/src/NHibernate/Engine/Query/ParameterParser.cs
@@ -12,8 +12,6 @@ namespace NHibernate.Engine.Query
 	/// </summary>
 	public class ParameterParser
 	{
-		private static readonly int NewLineLength = Environment.NewLine.Length;
-
 		public interface IRecognizer
 		{
 			void OutParameter(int position);
@@ -56,6 +54,8 @@ public static void Parse(string sqlString, IRecognizer recognizer)
 			bool afterNewLine = false;
 			for (int indx = 0; indx < stringLength; indx++)
 			{
+				int currentNewLineLength;
+
 				// check comments
 				if (indx + 1 < stringLength && sqlString.Substring(indx,2) == "/*")
 				{
@@ -64,9 +64,11 @@ public static void Parse(string sqlString, IRecognizer recognizer)
 					indx = closeCommentIdx + 1;
 					continue;
 				}
+				
 				if (afterNewLine && (indx + 1 < stringLength) && sqlString.Substring(indx, 2) == "--")
 				{
-					var closeCommentIdx = sqlString.IndexOf(Environment.NewLine, indx + 2);
+					var closeCommentIdx = sqlString.IndexOfAnyNewLine(indx + 2, out currentNewLineLength);
+						
 					string comment;
 					if (closeCommentIdx == -1)
 					{
@@ -75,16 +77,17 @@ public static void Parse(string sqlString, IRecognizer recognizer)
 					}
 					else
 					{
-						comment = sqlString.Substring(indx, closeCommentIdx - indx + Environment.NewLine.Length);
+						comment = sqlString.Substring(indx, closeCommentIdx - indx + currentNewLineLength);
 					}
 					recognizer.Other(comment);
-					indx = closeCommentIdx + NewLineLength - 1;
+					indx = closeCommentIdx + currentNewLineLength - 1;
 					continue;
 				}
-				if (indx + NewLineLength -1 < stringLength && sqlString.Substring(indx, NewLineLength) == Environment.NewLine)
+
+				if (sqlString.IsAnyNewLine(indx, out currentNewLineLength))
 				{
 					afterNewLine = true;
-					indx += NewLineLength - 1;
+					indx += currentNewLineLength - 1;
 					recognizer.Other(Environment.NewLine);
 					continue;
 				}
diff --git a/src/NHibernate/Mapping/ByCode/Impl/DiscriminatorMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/DiscriminatorMapper.cs
@@ -2,6 +2,7 @@
 using System.Linq;
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Type;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -94,7 +95,7 @@ public void Formula(string formula)
 
 			ResetColumnPlainValues();
 			discriminatorMapping.Item = null;
-			string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (formulaLines.Length > 1)
 			{
 				discriminatorMapping.Item = new HbmFormula {Text = formulaLines};
diff --git a/src/NHibernate/Mapping/ByCode/Impl/ElementMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/ElementMapper.cs
@@ -4,6 +4,7 @@
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Type;
 using NHibernate.UserTypes;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -192,7 +193,7 @@ public void Formula(string formula)
 
 			ResetColumnPlainValues();
 			elementMapping.Items = null;
-			string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (formulaLines.Length > 1)
 			{
 				elementMapping.Items = new[] {new HbmFormula {Text = formulaLines}};
diff --git a/src/NHibernate/Mapping/ByCode/Impl/FilterMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/FilterMapper.cs
@@ -1,5 +1,6 @@
 using System;
 using NHibernate.Cfg.MappingSchema;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -35,7 +36,7 @@ public void Condition(string sqlCondition)
 				filter.Text = null;
 				return;
 			}
-			string[] conditionLines = sqlCondition.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			string[] conditionLines = sqlCondition.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (conditionLines.Length > 1)
 			{
 				filter.Text = conditionLines;
diff --git a/src/NHibernate/Mapping/ByCode/Impl/ManyToManyMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/ManyToManyMapper.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using NHibernate.Cfg.MappingSchema;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -128,7 +129,7 @@ public void Formula(string formula)
 
 			ResetColumnPlainValues();
 			manyToMany.Items = null;
-			string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (formulaLines.Length > 1)
 			{
 				manyToMany.Items = new[] {new HbmFormula {Text = formulaLines}};
diff --git a/src/NHibernate/Mapping/ByCode/Impl/ManyToOneMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/ManyToOneMapper.cs
@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Reflection;
 using NHibernate.Cfg.MappingSchema;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -82,7 +83,7 @@ public void Formula(string formula)
 
 			ResetColumnPlainValues();
 			_manyToOne.Items = null;
-			string[] formulaLines = formula.Split(new[] { Environment.NewLine }, StringSplitOptions.None);
+			string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (formulaLines.Length > 1)
 			{
 				_manyToOne.Items = new[] { new HbmFormula { Text = formulaLines } };
diff --git a/src/NHibernate/Mapping/ByCode/Impl/MapKeyManyToManyMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/MapKeyManyToManyMapper.cs
@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using NHibernate.Cfg.MappingSchema;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -36,7 +37,7 @@ public void Formula(string formula)
 
 			ResetColumnPlainValues();
 			mapping.Items = null;
-			string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (formulaLines.Length > 1)
 			{
 				mapping.Items = new[] {new HbmFormula {Text = formulaLines}};
diff --git a/src/NHibernate/Mapping/ByCode/Impl/MapKeyMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/MapKeyMapper.cs
@@ -4,6 +4,7 @@
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Type;
 using NHibernate.UserTypes;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -112,7 +113,7 @@ public void Formula(string formula)
 
 			ResetColumnPlainValues();
 			hbmMapKey.Items = null;
-			string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (formulaLines.Length > 1)
 			{
 				hbmMapKey.Items = new[] {new HbmFormula {Text = formulaLines}};
diff --git a/src/NHibernate/Mapping/ByCode/Impl/OneToOneMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/OneToOneMapper.cs
@@ -2,6 +2,7 @@
 using System.Linq.Expressions;
 using System.Reflection;
 using NHibernate.Cfg.MappingSchema;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -101,7 +102,7 @@ public void Formula(string formula)
 				return;
 			}
 
-			string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (formulaLines.Length > 1)
 			{
 				_oneToOne.formula = new[] {new HbmFormula {Text = formulaLines}};
diff --git a/src/NHibernate/Mapping/ByCode/Impl/PropertyMapper.cs b/src/NHibernate/Mapping/ByCode/Impl/PropertyMapper.cs
@@ -5,6 +5,7 @@
 using NHibernate.Cfg.MappingSchema;
 using NHibernate.Type;
 using NHibernate.UserTypes;
+using NHibernate.Util;
 
 namespace NHibernate.Mapping.ByCode.Impl
 {
@@ -231,7 +232,7 @@ public void Formula(string formula)
 
 			ResetColumnPlainValues();
 			propertyMapping.Items = null;
-			string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);
+			string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);
 			if (formulaLines.Length > 1)
 			{
 				propertyMapping.Items = new[] {new HbmFormula {Text = formulaLines}};
diff --git a/src/NHibernate/Util/StringHelper.cs b/src/NHibernate/Util/StringHelper.cs
@@ -1,15 +1,22 @@
+using System.Runtime.CompilerServices;
 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 
+[assembly: InternalsVisibleTo("NHibernate.Test")]
 
 namespace NHibernate.Util
 {
 	/// <summary></summary>
 	public static class StringHelper
 	{
+		/// <summary>
+		/// This allows for both CRLF and lone LF line separators.
+		/// </summary>
+		internal static readonly string[] LineSeparators = {"\r\n", "\n"};
+
 		public const string WhiteSpace = " \n\r\f\t";
 
 		/// <summary></summary>
@@ -724,5 +731,53 @@ public static string[] ParseFilterParameterName(string filterParameterName)
 			string parameterName = filterParameterName.Substring(dot + 1);
 			return new[] { filterName, parameterName };
 		}
+
+
+		/// <summary>
+		/// Return the index of the next line separator, starting at startIndex. If will match
+		/// the first CRLF or LF line separator. If there is no match, -1 will be returned. When
+		/// returning, newLineLength will be set to the number of characters in the matched line
+		/// separator (1 if LF was found, 2 if CRLF was found).
+		/// </summary>
+		internal static int IndexOfAnyNewLine(this string str, int startIndex, out int newLineLength)
+		{
+			newLineLength = 0;
+			var matchStartIdx = str.IndexOfAny(new[] {'\r', '\n'}, startIndex);
+
+			if (matchStartIdx == -1)
+				return -1;
+
+			if (string.Compare(str, matchStartIdx, "\r\n", 0, 2, StringComparison.OrdinalIgnoreCase) == 0)
+				newLineLength = 2;
+			else
+				newLineLength = 1;
+
+			return matchStartIdx;
+		}
+
+
+		/// <summary>
+		/// Check if the given index points to a line separator in the string. Both CRLF and LF
+		/// line separators are handled. When returning, newLineLength will be set to the number
+		/// of characters matched in the line separator. It will be 2 if a CRLF matched, 1 if LF
+		/// matched, and 0 if the index doesn't indicate (the start of) a line separator.
+		/// </summary>
+		internal static bool IsAnyNewLine(this string str, int index, out int newLineLength)
+		{
+			if (string.Compare(str, index, "\r\n", 0, 2, StringComparison.OrdinalIgnoreCase) == 0)
+			{
+				newLineLength = 2;
+				return true;
+			}
+
+			if (index < str.Length && str[index] == '\n')
+			{
+				newLineLength = 1;
+				return true;
+			}
+
+			newLineLength = 0;
+			return false;
+		}
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -12,8 +12,6 @@ namespace NHibernate.Engine.Query`
`12`	`12`	`/// </summary>`
`13`	`13`	`public class ParameterParser`
`14`	`14`	`{`
`15`		`- private static readonly int NewLineLength = Environment.NewLine.Length;`
`16`		`-`
`17`	`15`	`public interface IRecognizer`
`18`	`16`	`{`
`19`	`17`	`void OutParameter(int position);`
`@@ -56,6 +54,8 @@ public static void Parse(string sqlString, IRecognizer recognizer)`
`56`	`54`	`bool afterNewLine = false;`
`57`	`55`	`for (int indx = 0; indx < stringLength; indx++)`
`58`	`56`	`{`
	`57`	`+ int currentNewLineLength;`
	`58`	`+`
`59`	`59`	`// check comments`
`60`	`60`	`if (indx + 1 < stringLength && sqlString.Substring(indx,2) == "/*")`
`61`	`61`	`{`
`@@ -64,9 +64,11 @@ public static void Parse(string sqlString, IRecognizer recognizer)`
`64`	`64`	`indx = closeCommentIdx + 1;`
`65`	`65`	`continue;`
`66`	`66`	`}`
	`67`	`+`
`67`	`68`	`if (afterNewLine && (indx + 1 < stringLength) && sqlString.Substring(indx, 2) == "--")`
`68`	`69`	`{`
`69`		`- var closeCommentIdx = sqlString.IndexOf(Environment.NewLine, indx + 2);`
	`70`	`+ var closeCommentIdx = sqlString.IndexOfAnyNewLine(indx + 2, out currentNewLineLength);`
	`71`	`+`
`70`	`72`	`string comment;`
`71`	`73`	`if (closeCommentIdx == -1)`
`72`	`74`	`{`
`@@ -75,16 +77,17 @@ public static void Parse(string sqlString, IRecognizer recognizer)`
`75`	`77`	`}`
`76`	`78`	`else`
`77`	`79`	`{`
`78`		`- comment = sqlString.Substring(indx, closeCommentIdx - indx + Environment.NewLine.Length);`
	`80`	`+ comment = sqlString.Substring(indx, closeCommentIdx - indx + currentNewLineLength);`
`79`	`81`	`}`
`80`	`82`	`recognizer.Other(comment);`
`81`		`- indx = closeCommentIdx + NewLineLength - 1;`
	`83`	`+ indx = closeCommentIdx + currentNewLineLength - 1;`
`82`	`84`	`continue;`
`83`	`85`	`}`
`84`		`- if (indx + NewLineLength -1 < stringLength && sqlString.Substring(indx, NewLineLength) == Environment.NewLine)`
	`86`	`+`
	`87`	`+ if (sqlString.IsAnyNewLine(indx, out currentNewLineLength))`
`85`	`88`	`{`
`86`	`89`	`afterNewLine = true;`
`87`		`- indx += NewLineLength - 1;`
	`90`	`+ indx += currentNewLineLength - 1;`
`88`	`91`	`recognizer.Other(Environment.NewLine);`
`89`	`92`	`continue;`
`90`	`93`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Linq;`
`3`	`3`	`using NHibernate.Cfg.MappingSchema;`
`4`	`4`	`using NHibernate.Type;`
	`5`	`+using NHibernate.Util;`
`5`	`6`
`6`	`7`	`namespace NHibernate.Mapping.ByCode.Impl`
`7`	`8`	`{`
`@@ -94,7 +95,7 @@ public void Formula(string formula)`
`94`	`95`
`95`	`96`	`ResetColumnPlainValues();`
`96`	`97`	`discriminatorMapping.Item = null;`
`97`		`- string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);`
	`98`	`+ string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);`
`98`	`99`	`if (formulaLines.Length > 1)`
`99`	`100`	`{`
`100`	`101`	`discriminatorMapping.Item = new HbmFormula {Text = formulaLines};`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using NHibernate.Cfg.MappingSchema;`
`5`	`5`	`using NHibernate.Type;`
`6`	`6`	`using NHibernate.UserTypes;`
	`7`	`+using NHibernate.Util;`
`7`	`8`
`8`	`9`	`namespace NHibernate.Mapping.ByCode.Impl`
`9`	`10`	`{`
`@@ -192,7 +193,7 @@ public void Formula(string formula)`
`192`	`193`
`193`	`194`	`ResetColumnPlainValues();`
`194`	`195`	`elementMapping.Items = null;`
`195`		`- string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);`
	`196`	`+ string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);`
`196`	`197`	`if (formulaLines.Length > 1)`
`197`	`198`	`{`
`198`	`199`	`elementMapping.Items = new[] {new HbmFormula {Text = formulaLines}};`
Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,6 @@`
`1`	`1`	`using System;`
`2`	`2`	`using NHibernate.Cfg.MappingSchema;`
	`3`	`+using NHibernate.Util;`
`3`	`4`
`4`	`5`	`namespace NHibernate.Mapping.ByCode.Impl`
`5`	`6`	`{`
`@@ -35,7 +36,7 @@ public void Condition(string sqlCondition)`
`35`	`36`	`filter.Text = null;`
`36`	`37`	`return;`
`37`	`38`	`}`
`38`		`- string[] conditionLines = sqlCondition.Split(new[] {Environment.NewLine}, StringSplitOptions.None);`
	`39`	`+ string[] conditionLines = sqlCondition.Split(StringHelper.LineSeparators, StringSplitOptions.None);`
`39`	`40`	`if (conditionLines.Length > 1)`
`40`	`41`	`{`
`41`	`42`	`filter.Text = conditionLines;`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Collections.Generic;`
`3`	`3`	`using System.Linq;`
`4`	`4`	`using NHibernate.Cfg.MappingSchema;`
	`5`	`+using NHibernate.Util;`
`5`	`6`
`6`	`7`	`namespace NHibernate.Mapping.ByCode.Impl`
`7`	`8`	`{`
`@@ -128,7 +129,7 @@ public void Formula(string formula)`
`128`	`129`
`129`	`130`	`ResetColumnPlainValues();`
`130`	`131`	`manyToMany.Items = null;`
`131`		`- string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);`
	`132`	`+ string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);`
`132`	`133`	`if (formulaLines.Length > 1)`
`133`	`134`	`{`
`134`	`135`	`manyToMany.Items = new[] {new HbmFormula {Text = formulaLines}};`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Linq;`
`4`	`4`	`using System.Reflection;`
`5`	`5`	`using NHibernate.Cfg.MappingSchema;`
	`6`	`+using NHibernate.Util;`
`6`	`7`
`7`	`8`	`namespace NHibernate.Mapping.ByCode.Impl`
`8`	`9`	`{`
`@@ -82,7 +83,7 @@ public void Formula(string formula)`
`82`	`83`
`83`	`84`	`ResetColumnPlainValues();`
`84`	`85`	`_manyToOne.Items = null;`
`85`		`- string[] formulaLines = formula.Split(new[] { Environment.NewLine }, StringSplitOptions.None);`
	`86`	`+ string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);`
`86`	`87`	`if (formulaLines.Length > 1)`
`87`	`88`	`{`
`88`	`89`	`_manyToOne.Items = new[] { new HbmFormula { Text = formulaLines } };`
Original file line number	Diff line number	Diff line change
`@@ -2,6 +2,7 @@`
`2`	`2`	`using System.Linq.Expressions;`
`3`	`3`	`using System.Reflection;`
`4`	`4`	`using NHibernate.Cfg.MappingSchema;`
	`5`	`+using NHibernate.Util;`
`5`	`6`
`6`	`7`	`namespace NHibernate.Mapping.ByCode.Impl`
`7`	`8`	`{`
`@@ -101,7 +102,7 @@ public void Formula(string formula)`
`101`	`102`	`return;`
`102`	`103`	`}`
`103`	`104`
`104`		`- string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);`
	`105`	`+ string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);`
`105`	`106`	`if (formulaLines.Length > 1)`
`106`	`107`	`{`
`107`	`108`	`_oneToOne.formula = new[] {new HbmFormula {Text = formulaLines}};`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,7 @@`
`5`	`5`	`using NHibernate.Cfg.MappingSchema;`
`6`	`6`	`using NHibernate.Type;`
`7`	`7`	`using NHibernate.UserTypes;`
	`8`	`+using NHibernate.Util;`
`8`	`9`
`9`	`10`	`namespace NHibernate.Mapping.ByCode.Impl`
`10`	`11`	`{`
`@@ -231,7 +232,7 @@ public void Formula(string formula)`
`231`	`232`
`232`	`233`	`ResetColumnPlainValues();`
`233`	`234`	`propertyMapping.Items = null;`
`234`		`- string[] formulaLines = formula.Split(new[] {Environment.NewLine}, StringSplitOptions.None);`
	`235`	`+ string[] formulaLines = formula.Split(StringHelper.LineSeparators, StringSplitOptions.None);`
`235`	`236`	`if (formulaLines.Length > 1)`
`236`	`237`	`{`
`237`	`238`	`propertyMapping.Items = new[] {new HbmFormula {Text = formulaLines}};`