Imported Upstream version 5.10.0.47

Former-commit-id: d0813289fa2d35e1f8ed77530acb4fb1df441bc0

mcs/class/corlib/Test/System.Text/Latin1EncodingTest.cs

@@ -27,6 +27,7 @@
 //
 
 using System;
+using System.Collections.Generic;
 using System.Text;
 
 using NUnit.Framework;
@@ -34,6 +35,13 @@ using NUnit.Framework.Constraints;
 
 namespace MonoTests.System.Text
 {
+	//
+	// NOTE: when adding/updating tests here consider updating
+	//       the following files as well since they have similar tests:
+	//
+	// - mcs/class/corlib/Test/System.Text/ASCIIEncodingTest.cs
+	// - mcs/class/I18N/EncodingTestBase.cs
+	//
 	[TestFixture]
 	public class Latin1EncodingTest
 	{
@@ -105,7 +113,7 @@ namespace MonoTests.System.Text
 			byte[] bytes = latin1_encoding.GetBytes(testchars);
 			Assert.AreEqual ('T', (char) bytes [0], "#1");
 			Assert.AreEqual ('e', (char) bytes [1], "#2");
-			Assert.AreEqual ('?', (char) bytes [2], "#3");
+			Assert.AreEqual ('A', (char) bytes [2], "#3");
 			Assert.AreEqual ('t', (char) bytes [3], "#4");
 		}
 
@@ -252,6 +260,31 @@ namespace MonoTests.System.Text
 			e.GetBytes ("\u24c8");
 		}
 
+		[Test]
+		public void EncoderFallback2 ()
+		{
+			Encoding e = Encoding.GetEncoding ("latin1").Clone () as Encoding;
+			e.EncoderFallback = new BackslashEncoderReplaceFallback ();
+
+			byte[] bytes = e.GetBytes ("a\xac\u1234\u20ac\u8000");
+			var expected = new byte[] { 0x61, 0xAC, 0x5C, 0x75, 0x31, 0x32, 0x33, 0x34, 0x5C, 0x75, 0x32, 0x30, 0x61, 0x63, 0x5C, 0x75, 0x38, 0x30, 0x30, 0x30 };
+			Assert.AreEqual (expected, bytes);
+
+			bytes = e.GetBytes ("1\u04d92");
+			expected = new byte[] { 0x31, 0x5C, 0x75, 0x30, 0x34, 0x64, 0x39, 0x32 };
+			Assert.AreEqual (expected, bytes);
+
+			e.EncoderFallback = new EncoderExceptionOnWrongIndexFallback ('\u04d9', 1);
+			bytes = e.GetBytes ("1\u04d92");
+			expected = new byte[] { 0x31, 0x21, 0x32 };
+			Assert.AreEqual (expected, bytes);
+
+			e.EncoderFallback = new EncoderExceptionOnWrongIndexFallback ('\u04d9', 0);
+			bytes = e.GetBytes ("\u04d921");
+			expected = new byte[] { 0x21, 0x32, 0x31 };
+			Assert.AreEqual (expected, bytes);
+		}
+
 		[Test]
 	//	[ExpectedException (typeof (ArgumentException))]
 		public void DecoderFallback2 ()
@@ -264,12 +297,6 @@ namespace MonoTests.System.Text
 			
 			var chars = new char [7];
 			var ret = enc.GetChars (bytes, 0, bytes.Length, chars, 0);
-			Console.WriteLine (ret);
-			
-			for (int i = 0; i < chars.Length; i++) {
-				Console.Write ("{0:x2} ", (int)chars [i]);
-			}
-			Console.WriteLine ();
 		}
 		
 		[Test]
@@ -342,5 +369,142 @@ namespace MonoTests.System.Text
 			}
 		}
 
+		class BackslashEncoderReplaceFallback : EncoderFallback
+		{
+			class BackslashReplaceFallbackBuffer : EncoderFallbackBuffer
+			{
+				List<char> _buffer = new List<char> ();
+				int _index;
+
+				public override bool Fallback (char charUnknownHigh, char charUnknownLow, int index)
+				{
+					throw new NotImplementedException ();
+					return false;
+				}
+
+				public override bool Fallback (char charUnknown, int index)
+				{
+					_buffer.Add('\\');
+					int val = (int)charUnknown;
+					if (val > 0xFF) {
+						_buffer.Add ('u');
+						AddCharacter (val >> 8);
+						AddCharacter (val & 0xFF);
+					} else {
+						_buffer.Add ('x');
+						AddCharacter (charUnknown);
+					}
+					return true;
+				}
+
+				private void AddCharacter (int val)
+				{
+					AddOneDigit (((val) & 0xF0) >> 4);
+					AddOneDigit (val & 0x0F);
+				}
+
+				private void AddOneDigit (int val)
+				{
+					if (val > 9) {
+						_buffer.Add ((char)('a' + val - 0x0A));
+					} else {
+						_buffer.Add ((char)('0' + val));
+					}
+				}
+
+				public override char GetNextChar ()
+				{
+					if (_index == _buffer.Count)
+						return Char.MinValue;
+
+					return _buffer[_index++];
+				}
+
+				public override bool MovePrevious ()
+				{
+					if (_index > 0){
+						_index--;
+						return true;
+					}
+					return false;
+				}
+
+				public override int Remaining
+				{
+					get { return _buffer.Count - _index; }
+				}
+			}
+
+			public override EncoderFallbackBuffer CreateFallbackBuffer ()
+			{
+				return new BackslashReplaceFallbackBuffer ();
+			}
+
+			public override int MaxCharCount
+			{
+				get { throw new NotImplementedException (); }
+			}
+		}
+
+		class EncoderExceptionOnWrongIndexFallback : EncoderFallback
+		{
+			char _expectedCharUnknown;
+			int _expectedIndex;
+
+			public EncoderExceptionOnWrongIndexFallback (char expectedCharUnknown, int expectedIndex)
+			{
+				_expectedCharUnknown = expectedCharUnknown;
+				_expectedIndex = expectedIndex;
+			}
+
+			public override EncoderFallbackBuffer CreateFallbackBuffer ()
+			{
+				return new EncoderExceptionOnWrongIndexFallbackBuffer (_expectedCharUnknown, _expectedIndex);
+			}
+
+			public override int MaxCharCount => 1;
+
+			class EncoderExceptionOnWrongIndexFallbackBuffer : EncoderFallbackBuffer
+			{
+				char _expectedCharUnknown;
+				int _expectedIndex;
+				bool read;
+
+				public EncoderExceptionOnWrongIndexFallbackBuffer (char expectedCharUnknown, int expectedIndex)
+				{
+					_expectedCharUnknown = expectedCharUnknown;
+					_expectedIndex = expectedIndex;
+				}
+
+				public override int Remaining => read ? 0 : 1;
+
+				public override bool Fallback (char charUnknown, int index)
+				{
+					Assert.AreEqual (_expectedCharUnknown, charUnknown);
+					Assert.AreEqual (_expectedIndex, index);
+					return true;
+				}
+
+				public override bool Fallback (char charUnknownHigh, char charUnknownLow, int index)
+				{
+					throw new NotImplementedException ();
+					return true;
+				}
+
+				public override char GetNextChar ()
+				{
+					if (!read) {
+						read = true;
+						return '!';
+					}
+					return '\0';
+				}
+
+				public override bool MovePrevious ()
+				{
+					return false;
+				}
+			}
+		}
 	}
 }