294 lines
12 KiB
C#
294 lines
12 KiB
C#
//
|
|
// UTF7EncodingTest.cs - NUnit Test Cases for System.Text.UTF7Encoding
|
|
//
|
|
// Authors
|
|
// Patrick Kalkman kalkman@cistron.nl
|
|
// Sebastien Pouliot <sebastien@ximian.com>
|
|
//
|
|
// (C) 2003 Patrick Kalkman
|
|
// Copyright (C) 2004 Novell (http://www.novell.com)
|
|
//
|
|
|
|
using NUnit.Framework;
|
|
using System;
|
|
using System.Text;
|
|
|
|
using AssertType = NUnit.Framework.Assert;
|
|
|
|
namespace MonoTests.System.Text
|
|
{
|
|
[TestFixture]
|
|
public class UTF7EncodingTest
|
|
{
|
|
[Test]
|
|
public void IsBrowserDisplay ()
|
|
{
|
|
UTF7Encoding utf7 = new UTF7Encoding ();
|
|
Assert.IsTrue (!utf7.IsBrowserDisplay);
|
|
}
|
|
|
|
[Test]
|
|
public void IsBrowserSave ()
|
|
{
|
|
UTF7Encoding utf7 = new UTF7Encoding ();
|
|
Assert.IsTrue (!utf7.IsBrowserSave);
|
|
}
|
|
|
|
[Test]
|
|
public void IsMailNewsDisplay ()
|
|
{
|
|
UTF7Encoding utf7 = new UTF7Encoding ();
|
|
Assert.IsTrue (utf7.IsMailNewsDisplay);
|
|
}
|
|
|
|
[Test]
|
|
public void IsMailNewsSave ()
|
|
{
|
|
UTF7Encoding utf7 = new UTF7Encoding ();
|
|
Assert.IsTrue (utf7.IsMailNewsSave);
|
|
}
|
|
|
|
[Test]
|
|
public void TestDirectlyEncoded1()
|
|
{
|
|
// Unicode characters a-z, A-Z, 0-9 and '()_./:? are directly encoded.
|
|
string UniCodeString = "\u0061\u007A\u0041\u005A\u0030\u0039\u0027\u003F";
|
|
byte[] UTF7Bytes = null;
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
|
|
UTF7Bytes = UTF7enc.GetBytes (UniCodeString);
|
|
|
|
Assert.AreEqual (0x61, UTF7Bytes [0], "UTF7 #1");
|
|
Assert.AreEqual (0x7A, UTF7Bytes [1], "UTF7 #2");
|
|
Assert.AreEqual (0x41, UTF7Bytes [2], "UTF7 #3");
|
|
Assert.AreEqual (0x5A, UTF7Bytes [3], "UTF7 #4");
|
|
Assert.AreEqual (0x30, UTF7Bytes [4], "UTF7 #5");
|
|
Assert.AreEqual (0x39, UTF7Bytes [5], "UTF7 #6");
|
|
Assert.AreEqual (0x27, UTF7Bytes [6], "UTF7 #7");
|
|
Assert.AreEqual (0x3F, UTF7Bytes [7], "UTF7 #8");
|
|
}
|
|
|
|
[Test]
|
|
public void TestDirectlyEncoded2()
|
|
{
|
|
// Unicode characters a-z, A-Z, 0-9 and '()_./:? are directly encoded.
|
|
string UniCodeString = "\u0061\u007A\u0041\u005A\u0030\u0039\u0027\u003F";
|
|
byte[] UTF7Bytes = new byte [8];
|
|
int Length = UniCodeString.Length;
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
|
|
int Cnt = UTF7enc.GetBytes (UniCodeString.ToCharArray(), 0, Length, UTF7Bytes, 0);
|
|
|
|
Assert.AreEqual (0x61, UTF7Bytes [0], "UTF7 #1");
|
|
Assert.AreEqual (0x7A, UTF7Bytes [1], "UTF7 #2");
|
|
Assert.AreEqual (0x41, UTF7Bytes [2], "UTF7 #3");
|
|
Assert.AreEqual (0x5A, UTF7Bytes [3], "UTF7 #4");
|
|
Assert.AreEqual (0x30, UTF7Bytes [4], "UTF7 #5");
|
|
Assert.AreEqual (0x39, UTF7Bytes [5], "UTF7 #6");
|
|
Assert.AreEqual (0x27, UTF7Bytes [6], "UTF7 #7");
|
|
Assert.AreEqual (0x3F, UTF7Bytes [7], "UTF7 #8");
|
|
}
|
|
|
|
[Test]
|
|
public void TestEncodeOptionalEncoded()
|
|
{
|
|
string UniCodeString = "\u0021\u0026\u002A\u003B";
|
|
byte[] UTF7Bytes = null;
|
|
|
|
//Optional Characters are allowed.
|
|
UTF7Encoding UTF7enc = new UTF7Encoding (true);
|
|
UTF7Bytes = UTF7enc.GetBytes (UniCodeString);
|
|
|
|
Assert.AreEqual (0x21, UTF7Bytes [0], "UTF7 #1");
|
|
Assert.AreEqual (0x26, UTF7Bytes [1], "UTF7 #2");
|
|
Assert.AreEqual (0x2A, UTF7Bytes [2], "UTF7 #3");
|
|
Assert.AreEqual (0x3B, UTF7Bytes [3], "UTF7 #4");
|
|
|
|
//Optional characters are not allowed.
|
|
UTF7enc = new UTF7Encoding (false);
|
|
UTF7Bytes = UTF7enc.GetBytes (UniCodeString);
|
|
|
|
Assert.AreEqual (0x2B, UTF7Bytes [0], "UTF7 #5");
|
|
Assert.AreEqual (0x41, UTF7Bytes [1], "UTF7 #6");
|
|
Assert.AreEqual (0x43, UTF7Bytes [2], "UTF7 #7");
|
|
Assert.AreEqual (0x45, UTF7Bytes [3], "UTF7 #8");
|
|
Assert.AreEqual (0x41, UTF7Bytes [1], "UTF7 #6");
|
|
}
|
|
|
|
[Test]
|
|
public void TestEncodeUnicodeShifted1()
|
|
{
|
|
string UniCodeString = "\u0041\u2262\u0391\u002E";
|
|
byte[] UTF7Bytes = null;
|
|
|
|
UTF7Encoding UTF7enc = new UTF7Encoding();
|
|
UTF7Bytes = UTF7enc.GetBytes (UniCodeString);
|
|
|
|
//"A<NOT IDENTICAL TO><ALPHA>." is encoded as A+ImIDkQ-. see RFC 1642
|
|
Assert.AreEqual (0x41, UTF7Bytes [0], "UTF7 #1");
|
|
Assert.AreEqual (0x2B, UTF7Bytes [1], "UTF7 #2");
|
|
Assert.AreEqual (0x49, UTF7Bytes [2], "UTF7 #3");
|
|
Assert.AreEqual (0x6D, UTF7Bytes [3], "UTF7 #4");
|
|
Assert.AreEqual (0x49, UTF7Bytes [4], "UTF7 #5");
|
|
Assert.AreEqual (0x44, UTF7Bytes [5], "UTF7 #6");
|
|
Assert.AreEqual (0x6B, UTF7Bytes [6], "UTF7 #7");
|
|
Assert.AreEqual (0x51, UTF7Bytes [7], "UTF7 #8");
|
|
Assert.AreEqual (0x2D, UTF7Bytes [8], "UTF7 #9");
|
|
Assert.AreEqual (0x2E, UTF7Bytes [9], "UTF7 #10");
|
|
}
|
|
|
|
[Test]
|
|
public void TestEncodeUnicodeShifted2()
|
|
{
|
|
string UniCodeString = "\u0041\u2262\u0391\u002E";
|
|
byte[] UTF7Bytes = new byte [10];
|
|
int Length = UniCodeString.Length;
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
|
|
int Cnt = UTF7enc.GetBytes (UniCodeString.ToCharArray(), 0, Length, UTF7Bytes, 0);
|
|
|
|
//"A<NOT IDENTICAL TO><ALPHA>." is encoded as A+ImIDkQ-. see RFC 1642
|
|
Assert.AreEqual (0x41, UTF7Bytes [0], "UTF7 #1");
|
|
Assert.AreEqual (0x2B, UTF7Bytes [1], "UTF7 #2");
|
|
Assert.AreEqual (0x49, UTF7Bytes [2], "UTF7 #3");
|
|
Assert.AreEqual (0x6D, UTF7Bytes [3], "UTF7 #4");
|
|
Assert.AreEqual (0x49, UTF7Bytes [4], "UTF7 #5");
|
|
Assert.AreEqual (0x44, UTF7Bytes [5], "UTF7 #6");
|
|
Assert.AreEqual (0x6B, UTF7Bytes [6], "UTF7 #7");
|
|
Assert.AreEqual (0x51, UTF7Bytes [7], "UTF7 #8");
|
|
Assert.AreEqual (0x2D, UTF7Bytes [8], "UTF7 #9");
|
|
Assert.AreEqual (0x2E, UTF7Bytes [9], "UTF7 #10");
|
|
}
|
|
|
|
[Test]
|
|
public void RFC1642_Example1 ()
|
|
{
|
|
string UniCodeString = "\u0041\u2262\u0391\u002E";
|
|
char[] expected = UniCodeString.ToCharArray ();
|
|
|
|
byte[] UTF7Bytes = new byte [] {0x41, 0x2B, 0x49, 0x6D, 0x49, 0x44, 0x6B, 0x51, 0x2D, 0x2E};
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
char[] actual = UTF7enc.GetChars (UTF7Bytes);
|
|
|
|
// "A+ImIDkQ-." is decoded as "A<NOT IDENTICAL TO><ALPHA>." see RFC 1642
|
|
Assert.AreEqual (expected [0], actual [0], "UTF #1");
|
|
Assert.AreEqual (expected [1], actual [1], "UTF #2");
|
|
Assert.AreEqual (expected [2], actual [2], "UTF #3");
|
|
Assert.AreEqual (expected [3], actual [3], "UTF #4");
|
|
|
|
Assert.AreEqual (UniCodeString, UTF7enc.GetString (UTF7Bytes), "GetString");
|
|
}
|
|
|
|
[Test]
|
|
public void RFC1642_Example2 ()
|
|
{
|
|
string UniCodeString = "\u0048\u0069\u0020\u004D\u006F\u004D\u0020\u263A\u0021";
|
|
char[] expected = UniCodeString.ToCharArray ();
|
|
|
|
byte[] UTF7Bytes = new byte[] { 0x48, 0x69, 0x20, 0x4D, 0x6F, 0x4D, 0x20, 0x2B, 0x4A, 0x6A, 0x6F, 0x41, 0x49, 0x51, 0x2D };
|
|
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
char[] actual = UTF7enc.GetChars (UTF7Bytes);
|
|
|
|
// "Hi Mom +Jjo-!" is decoded as "Hi Mom <WHITE SMILING FACE>!"
|
|
Assert.AreEqual (expected [0], actual [0], "UTF #1");
|
|
Assert.AreEqual (expected [1], actual [1], "UTF #2");
|
|
Assert.AreEqual (expected [2], actual [2], "UTF #3");
|
|
Assert.AreEqual (expected [3], actual [3], "UTF #4");
|
|
Assert.AreEqual (expected [4], actual [4], "UTF #5");
|
|
Assert.AreEqual (expected [5], actual [5], "UTF #6");
|
|
Assert.AreEqual (expected [6], actual [6], "UTF #7");
|
|
Assert.AreEqual (expected [7], actual [7], "UTF #8");
|
|
Assert.AreEqual (expected [8], actual [8], "UTF #9");
|
|
|
|
Assert.AreEqual (UniCodeString, UTF7enc.GetString (UTF7Bytes), "GetString");
|
|
}
|
|
|
|
[Test]
|
|
public void RFC1642_Example3 ()
|
|
{
|
|
string UniCodeString = "\u65E5\u672C\u8A9E";
|
|
char[] expected = UniCodeString.ToCharArray ();
|
|
|
|
byte[] UTF7Bytes = new byte[] { 0x2B, 0x5A, 0x65, 0x56, 0x6E, 0x4C, 0x49, 0x71, 0x65, 0x2D };
|
|
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
char[] actual = UTF7enc.GetChars (UTF7Bytes);
|
|
|
|
// "+ZeVnLIqe-" is decoded as Japanese "nihongo"
|
|
Assert.AreEqual (expected [0], actual [0], "UTF #1");
|
|
Assert.AreEqual (expected [1], actual [1], "UTF #2");
|
|
Assert.AreEqual (expected [2], actual [2], "UTF #3");
|
|
|
|
Assert.AreEqual (UniCodeString, UTF7enc.GetString (UTF7Bytes), "GetString");
|
|
}
|
|
|
|
[Test]
|
|
public void RFC1642_Example4 ()
|
|
{
|
|
string UniCodeString = "\u0049\u0074\u0065\u006D\u0020\u0033\u0020\u0069\u0073\u0020\u00A3\u0031\u002E";
|
|
char[] expected = UniCodeString.ToCharArray ();
|
|
|
|
byte[] UTF7Bytes = new byte[] { 0x49, 0x74, 0x65, 0x6D, 0x20, 0x33, 0x20, 0x69, 0x73, 0x20, 0x2B, 0x41, 0x4B, 0x4D, 0x2D, 0x31, 0x2E };
|
|
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
char[] actual = UTF7enc.GetChars (UTF7Bytes);
|
|
|
|
// "Item 3 is +AKM-1." is decoded as "Item 3 is <POUND SIGN>1."
|
|
Assert.AreEqual (expected [0], actual [0], "UTF #1");
|
|
Assert.AreEqual (expected [1], actual [1], "UTF #2");
|
|
Assert.AreEqual (expected [2], actual [2], "UTF #3");
|
|
Assert.AreEqual (expected [3], actual [3], "UTF #4");
|
|
Assert.AreEqual (expected [4], actual [4], "UTF #5");
|
|
Assert.AreEqual (expected [5], actual [5], "UTF #6");
|
|
Assert.AreEqual (expected [6], actual [6], "UTF #7");
|
|
Assert.AreEqual (expected [7], actual [7], "UTF #8");
|
|
Assert.AreEqual (expected [8], actual [8], "UTF #9");
|
|
Assert.AreEqual (expected [9], actual [9], "UTF #10");
|
|
Assert.AreEqual (expected [10], actual [10], "UTF #11");
|
|
Assert.AreEqual (expected [11], actual [11], "UTF #12");
|
|
Assert.AreEqual (expected [12], actual [12], "UTF #13");
|
|
|
|
Assert.AreEqual (UniCodeString, UTF7enc.GetString (UTF7Bytes), "GetString");
|
|
}
|
|
|
|
[Test]
|
|
public void TestMaxCharCount()
|
|
{
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
Assert.AreEqual (50, UTF7enc.GetMaxCharCount(50), "UTF #1");
|
|
}
|
|
|
|
[Test]
|
|
[Category ("NotWorking")]
|
|
public void TestMaxByteCount()
|
|
{
|
|
UTF7Encoding UTF7enc = new UTF7Encoding ();
|
|
Assert.AreEqual (152, UTF7enc.GetMaxByteCount(50), "UTF #1");
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
[Ignore ("referencesource bug")]
|
|
public void Bug77315 ()
|
|
{
|
|
string s = new UTF7Encoding ().GetString (
|
|
Encoding.ASCII.GetBytes ("+2AA-"));
|
|
}
|
|
|
|
[Test]
|
|
public void GetCharCount ()
|
|
{
|
|
string original = "*123456789*123456789*123456789*123456789*123456789*123456789*123456789*123456789";
|
|
byte [] bytes = Encoding.UTF7.GetBytes (original);
|
|
AssertType.AreEqual (112, bytes.Length, "#1");
|
|
AssertType.AreEqual (80, Encoding.UTF7.GetCharCount (bytes), "#2");
|
|
string decoded = Encoding.UTF7.GetString(Encoding.UTF7.GetBytes(original));
|
|
AssertType.AreEqual (original, decoded, "#3");
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|