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

   1 //
   2 // UnicodeEncodingTest.cs - NUnit Test Cases for System.Text.UnicodeEncoding
   3 //
   4 // Author:
   5 //     Patrick Kalkman  kalkman@cistron.nl
   6 //
   7 // (C) 2003 Patrick Kalkman
   8 //
   9 using NUnit.Framework;
  10 using System;
  11 using System.Text;
  12
  13 namespace MonoTests.System.Text
  14 {
  15         [TestFixture]
  16         public class UnicodeEncodingTest
  17         {
  18                 [Test]
  19                 public void TestEncodingGetBytes1()
  20                 {
  21                         //pi and sigma in unicode
  22                         string Unicode = "\u03a0\u03a3";
  23                         byte[] UniBytes;
  24                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding (); //little-endian
  25                         UniBytes = UnicodeEnc.GetBytes (Unicode);
  26
  27                         Assertion.AssertEquals ("Uni #1", 0xA0, UniBytes [0]);
  28                         Assertion.AssertEquals ("Uni #2", 0x03, UniBytes [1]);
  29                         Assertion.AssertEquals ("Uni #3", 0xA3, UniBytes [2]);
  30                         Assertion.AssertEquals ("Uni #4", 0x03, UniBytes [3]);
  31                 }
  32
  33                 [Test]
  34                 public void TestEncodingGetBytes2()
  35                 {
  36                         //pi and sigma in unicode
  37                         string Unicode = "\u03a0\u03a3";
  38                         byte[] UniBytes;
  39                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding (true, true); //big-endian
  40                         UniBytes = UnicodeEnc.GetBytes (Unicode);
  41
  42                         Assertion.AssertEquals ("Uni #1", 0x03, UniBytes [0]);
  43                         Assertion.AssertEquals ("Uni #2", 0xA0, UniBytes [1]);
  44                         Assertion.AssertEquals ("Uni #3", 0x03, UniBytes [2]);
  45                         Assertion.AssertEquals ("Uni #4", 0xA3, UniBytes [3]);
  46                 }
  47
  48                 [Test]
  49                 public void TestEncodingGetBytes3()
  50                 {
  51                         //pi and sigma in unicode
  52                         string Unicode = "\u03a0\u03a3";
  53                         byte[] UniBytes = new byte [4];
  54                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding (); //little-endian
  55                         int Cnt = UnicodeEnc.GetBytes (Unicode.ToCharArray(), 0, Unicode.Length, UniBytes, 0);
  56
  57                         Assertion.AssertEquals ("Uni #1", 4, Cnt);
  58                         Assertion.AssertEquals ("Uni #2", 0xA0, UniBytes [0]);
  59                         Assertion.AssertEquals ("Uni #3", 0x03, UniBytes [1]);
  60                         Assertion.AssertEquals ("Uni #4", 0xA3, UniBytes [2]);
  61                         Assertion.AssertEquals ("Uni #5", 0x03, UniBytes [3]);
  62                 }
  63
  64                 [Test]
  65                 public void TestEncodingDecodingGetBytes1()
  66                 {
  67                         //pi and sigma in unicode
  68                         string Unicode = "\u03a0\u03a3";
  69                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding (); //little-endian
  70                         //Encode the unicode string.
  71                         byte[] UniBytes = UnicodeEnc.GetBytes (Unicode);
  72                         //Decode the bytes to a unicode char array.
  73                         char[] UniChars = UnicodeEnc.GetChars (UniBytes);
  74                         string Result = new string(UniChars);
  75
  76                         Assertion.AssertEquals ("Uni #1", Unicode, Result);
  77                 }
  78
  79                 [Test]
  80                 public void TestEncodingDecodingGetBytes2()
  81                 {
  82                         //pi and sigma in unicode
  83                         string Unicode = "\u03a0\u03a3";
  84                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding (true, true); //big-endian
  85                         //Encode the unicode string.
  86                         byte[] UniBytes = UnicodeEnc.GetBytes (Unicode);
  87                         //Decode the bytes to a unicode char array.
  88                         char[] UniChars = UnicodeEnc.GetChars (UniBytes);
  89                         string Result = new string(UniChars);
  90
  91                         Assertion.AssertEquals ("Uni #1", Unicode, Result);
  92                 }
  93
  94                 [Test]
  95                 public void TestEncodingGetCharCount ()
  96                 {
  97                         byte[] b = new byte[] {255, 254, 115, 0, 104, 0, 105, 0};
  98                         UnicodeEncoding encoding = new UnicodeEncoding ();
  99
 100                         Assertion.AssertEquals ("GetCharCount #1", 3,
 101                                 encoding.GetCharCount (b, 2, b.Length - 2));
 102                 }
 103
 104
 105
 106                 [Test]
 107                 public void TestPreamble1()
 108                 {
 109                         //litle-endian with byte order mark.
 110                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding (false, true);
 111                         byte[] PreAmble = UnicodeEnc.GetPreamble();
 112
 113                         Assertion.AssertEquals ("Uni #1", 0xFF, PreAmble [0]);
 114                         Assertion.AssertEquals ("Uni #2", 0xFE, PreAmble [1]);
 115                 }
 116
 117                 [Test]
 118                 public void TestPreamble2()
 119                 {
 120                         //big-endian with byte order mark.
 121                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding (true, true);
 122                         byte[] PreAmble = UnicodeEnc.GetPreamble();
 123
 124                         Assertion.AssertEquals ("Uni #1", 0xFE, PreAmble [0]);
 125                         Assertion.AssertEquals ("Uni #2", 0xFF, PreAmble [1]);
 126                 }
 127
 128                 [Test]
 129                 public void TestPreamble3()
 130                 {
 131                         //little-endian without byte order mark.
 132                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding (false, false);
 133                         byte[] PreAmble = UnicodeEnc.GetPreamble();
 134
 135                         Assertion.AssertEquals ("Uni #1", 0, PreAmble.Length);
 136                 }
 137
 138                 [Test]
 139                 public void TestMaxCharCount()
 140                 {
 141                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding ();
 142                         Assertion.AssertEquals ("UTF #1", 25, UnicodeEnc.GetMaxCharCount(50));
 143                 }
 144
 145                 [Test]
 146                 public void TestMaxByteCount()
 147                 {
 148                         UnicodeEncoding UnicodeEnc = new UnicodeEncoding ();
 149                         Assertion.AssertEquals ("UTF #1", 100, UnicodeEnc.GetMaxByteCount(50));
 150                 }
 151         }
 152 }
 153
 154
 155