In JavaScriptEngineSwitcher.ChakraCore fixed a errors, that occurred during marshaling of Unicode strings in Unix-based operating systems

Author: Taritsyn

NuGet/JavaScriptEngineSwitcher.ChakraCore/JavaScriptEngineSwitcher.ChakraCore.nuspec

@@ -14,7 +14,7 @@
 
 For correct working of the ChakraCore require assemblies `msvcp120.dll` and `msvcr120.dll` from the Visual C++ Redistributable Packages for Visual Studio 2013.</description>
 		<summary>JavaScriptEngineSwitcher.ChakraCore contains adapter `ChakraCoreJsEngine` (wrapper for the ChakraCore version 1.3).</summary>
-		<releaseNotes>Fixed a text encoding errors.</releaseNotes>
+		<releaseNotes>Fixed a errors, that occurred during marshaling of Unicode strings in Unix-based operating systems.</releaseNotes>
 		<copyright>Copyright (c) 2013-2016 Andrey Taritsyn - http://www.taritsyn.ru</copyright>
 		<language>en-US</language>
 		<tags>JavaScriptEngineSwitcher JavaScript ECMAScript ChakraCore</tags>

NuGet/JavaScriptEngineSwitcher.ChakraCore/readme.txt

@@ -24,7 +24,8 @@
    =============
    RELEASE NOTES
    =============
-   Fixed a text encoding errors.
+   Fixed a errors, that occurred during marshaling of Unicode strings in Unix-based
+   operating systems.
 
    ====================
    POST-INSTALL ACTIONS

src/JavaScriptEngineSwitcher.ChakraCore/JsRt/JsValue.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Runtime.InteropServices;
+using System.Text;
 
 using JavaScriptEngineSwitcher.Core.Utilities;
 
@@ -303,11 +304,18 @@ public static JsValue FromInt32(int value)
 		public static JsValue FromString(string value)
 		{
 			JsValue reference;
-			JsErrorCode errorCode = Utils.IsWindows() ?
-				NativeMethods.JsPointerToString(value, new UIntPtr((uint)value.Length), out reference)
-				:
-				NativeMethods.JsPointerToStringUtf8(value, new UIntPtr((uint)value.Length), out reference)
-				;
+			JsErrorCode errorCode;
+
+			if (Utils.IsWindows())
+			{
+				int stringLength = value.Length;
+				errorCode = NativeMethods.JsPointerToString(value, new UIntPtr((uint)stringLength), out reference);
+			}
+			else
+			{
+				int byteCount = Encoding.GetEncoding(0).GetByteCount(value);
+				errorCode = NativeMethods.JsPointerToStringUtf8(value, new UIntPtr((uint)byteCount), out reference);
+			}
 
 			JsErrorHelpers.ThrowIfError(errorCode);
 
@@ -574,24 +582,25 @@ public double ToDouble()
 		/// <returns>The string</returns>
 		public new string ToString()
 		{
-			IntPtr buffer;
-			UIntPtr length;
+			IntPtr ptr;
 			JsErrorCode errorCode;
 			string result;
 
 			if (Utils.IsWindows())
 			{
-				errorCode = NativeMethods.JsStringToPointer(this, out buffer, out length);
+				UIntPtr stringLength;
+				errorCode = NativeMethods.JsStringToPointer(this, out ptr, out stringLength);
 				JsErrorHelpers.ThrowIfError(errorCode);
 
-				result = Marshal.PtrToStringUni(buffer, (int)length);
+				result = Marshal.PtrToStringUni(ptr, (int)stringLength);
 			}
 			else
 			{
-				errorCode = NativeMethods.JsStringToPointerUtf8Copy(this, out buffer, out length);
+				UIntPtr byteCount;
+				errorCode = NativeMethods.JsStringToPointerUtf8Copy(this, out ptr, out byteCount);
 				JsErrorHelpers.ThrowIfError(errorCode);
 
-				result = Marshal.PtrToStringAnsi(buffer, (int)length);
+				result = Marshal.PtrToStringAnsi(ptr, (int)byteCount);
 			}
 
 			return result;

src/JavaScriptEngineSwitcher.ChakraCore/JsRt/NativeMethods.cs

@@ -124,10 +124,10 @@ internal static extern JsErrorCode JsRunSerializedScriptUtf8(JsSerializedScriptL
 		internal static extern JsErrorCode JsGetStringLength(JsValue sringValue, out int length);
 
 		[DllImport(DllName)]
-		internal static extern JsErrorCode JsPointerToStringUtf8(string value, UIntPtr stringLength, out JsValue stringValue);
+		internal static extern JsErrorCode JsPointerToStringUtf8(string value, UIntPtr byteCount, out JsValue stringValue);
 
 		[DllImport(DllName)]
-		internal static extern JsErrorCode JsStringToPointerUtf8Copy(JsValue value, out IntPtr stringValue, out UIntPtr stringLength);
+		internal static extern JsErrorCode JsStringToPointerUtf8Copy(JsValue value, out IntPtr bytes, out UIntPtr byteCount);
 
 		[DllImport(DllName)]
 		internal static extern JsErrorCode JsConvertValueToString(JsValue value, out JsValue stringValue);

test/JavaScriptEngineSwitcher.Tests/CommonTestsBase.cs

@@ -132,6 +132,25 @@ public virtual void EvaluationOfExpressionWithStringResultIsCorrect()
 			Assert.Equal(targetOutput, output);
 		}
 
+		[Fact]
+		public virtual void EvaluationOfExpressionWithUnicodeStringResultIsCorrect()
+		{
+			// Arrange
+			const string input = "'Привет, ' + \"Вася\" + '?';";
+			const string targetOutput = "Привет, Вася?";
+
+			// Act
+			string output;
+
+			using (var jsEngine = CreateJsEngine())
+			{
+				output = jsEngine.Evaluate<string>(input);
+			}
+
+			// Assert
+			Assert.Equal(targetOutput, output);
+		}
+
 		#endregion
 
 		#region Execution of code
@@ -392,6 +411,29 @@ public virtual void CallingOfFunctionWithStringResultIsCorrect()
 			Assert.Equal(targetOutput, output);
 		}
 
+		[Fact]
+		public virtual void CallingOfFunctionWithUnicodeStringResultIsCorrect()
+		{
+			// Arrange
+			const string functionCode = @"function privet(name) {
+	return 'Привет, ' + name + '!';
+}";
+			const string input = "Вован";
+			const string targetOutput = "Привет, Вован!";
+
+			// Act
+			string output;
+
+			using (var jsEngine = CreateJsEngine())
+			{
+				jsEngine.Execute(functionCode);
+				output = jsEngine.CallFunction<string>("privet", input);
+			}
+
+			// Assert
+			Assert.Equal(targetOutput, output);
+		}
+
 		[Fact]
 		public virtual void CallingOfFunctionWithManyParametersIsCorrect()
 		{
@@ -554,6 +596,36 @@ public virtual void CallingOfFunctionWithManyParametersAndStringResultIsCorrect(
 			Assert.Equal("Hello, Petya!", output);
 		}
 
+		[Fact]
+		public virtual void CallingOfFunctionWithManyParametersAndUnicodeStringResultIsCorrect()
+		{
+			// Arrange
+			const string functionCode = @"function obedinit() {
+	var result = '',
+		argumentIndex,
+		argumentCount = arguments.length
+		;
+
+	for (argumentIndex = 0; argumentIndex < argumentCount; argumentIndex++) {
+		result += arguments[argumentIndex];
+	}
+
+	return result;
+}";
+
+			// Act
+			string output;
+
+			using (var jsEngine = CreateJsEngine())
+			{
+				jsEngine.Execute(functionCode);
+				output = jsEngine.CallFunction<string>("obedinit", "Привет", ",", " ", "Петя", "!");
+			}
+
+			// Assert
+			Assert.Equal("Привет, Петя!", output);
+		}
+
 		#endregion
 
 		#region Getting, setting and removing variables
@@ -740,6 +812,40 @@ public virtual void SettingAndGettingVariableWithStringValueIsCorrect()
 			Assert.Equal(input2, output2);
 		}
 
+		[Fact]
+		public virtual void SettingAndGettingVariableWithUnicodeStringValueIsCorrect()
+		{
+			// Arrange
+			const string variableName = "slovo";
+
+			const string input1 = "Ура";
+			const string targetOutput1 = "Ура!";
+
+			const string input2 = "Урааа";
+
+			// Act
+			bool variableExists;
+			string output1;
+			string output2;
+
+			using (var jsEngine = CreateJsEngine())
+			{
+				jsEngine.SetVariableValue(variableName, input1);
+				variableExists = jsEngine.HasVariable(variableName);
+				jsEngine.Execute(string.Format("{0} += '!';", variableName));
+				output1 = jsEngine.GetVariableValue<string>(variableName);
+
+				jsEngine.SetVariableValue(variableName, input2);
+				output2 = jsEngine.GetVariableValue<string>(variableName);
+			}
+
+			// Assert
+			Assert.True(variableExists);
+			Assert.Equal(targetOutput1, output1);
+
+			Assert.Equal(input2, output2);
+		}
+
 		[Fact]
 		public virtual void RemovingVariableIsCorrect()
 		{