mcs/class/System/Test/System.Collections.Specialized/BitVector32Test.cs

   1 //
   2 // BitVector32Test.cs - NUnit Test Cases for System.Net.BitVector32
   3 //
   4 // Authors:
   5 //   Lawrence Pit (loz@cable.a2000.nl)
   6 //   Martin Willemoes Hansen (mwh@sysrq.dk)
   7 //   Sebastien Pouliot  <sebastien@ximian.com>
   8 //
   9 // (C) 2003 Martin Willemoes Hansen
  10 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
  11 //
  12
  13 using NUnit.Framework;
  14 using System;
  15 using System.Collections;
  16 using System.Collections.Specialized;
  17
  18 namespace MonoTests.System.Collections.Specialized
  19 {
  20         [TestFixture]
  21         public class BitVector32Test
  22         {
  23                 [Test]
  24                 public void Constructors ()
  25                 {
  26                         BitVector32 b = new BitVector32 (31);
  27                         Assert.AreEqual (31, b.Data, "Data");
  28                         Assert.IsTrue (b.Equals (b), "Equals(self)");
  29                         Assert.IsTrue (b[31], "31");
  30                         Assert.IsFalse (b[32], "32");
  31                         Assert.AreEqual (b.ToString (), "BitVector32{00000000000000000000000000011111}", b.ToString ());
  32
  33                         BitVector32 b2 = new BitVector32 (b);
  34                         Assert.IsTrue (b.Equals (b2), "Equals(b2)");
  35                         Assert.AreEqual (b.GetHashCode (), b2.GetHashCode (), "GetHashCode==");
  36
  37                         b2[32] = true;
  38                         Assert.IsFalse (b.Equals (b2), "Equals(b32)");
  39                         Assert.IsFalse (b.GetHashCode () == b2.GetHashCode (), "GetHashCode!=");
  40                 }
  41
  42                 [Test]
  43                 public void Constructors_MaxValue ()
  44                 {
  45                         BitVector32 b = new BitVector32 (Int32.MaxValue);
  46                         Assert.AreEqual (Int32.MaxValue, b.Data, "Data");
  47                         Assert.AreEqual ("BitVector32{01111111111111111111111111111111}", BitVector32.ToString (b), "ToString(BitVector)");
  48                 }
  49
  50                 [Test]
  51                 public void Constructors_MinValue ()
  52                 {
  53                         BitVector32 b = new BitVector32 (Int32.MinValue);
  54                         Assert.AreEqual (Int32.MinValue, b.Data, "Data");
  55                         Assert.AreEqual ("BitVector32{10000000000000000000000000000000}", BitVector32.ToString (b), "ToString(BitVector)");
  56                 }
  57
  58                 [Test]
  59                 public void Indexers ()
  60                 {
  61                         BitVector32 b = new BitVector32 (7);
  62                         Assert.IsTrue (b [0], "#1");
  63                         Assert.IsTrue (b [1], "#2");
  64                         Assert.IsTrue (b [2], "#3");
  65                         Assert.IsTrue (b [4], "#4");
  66                         Assert.IsTrue (!b [8], "#5");
  67                         Assert.IsTrue (!b [16], "#6");
  68                         b [8] = true;
  69                         Assert.IsTrue (b [4], "#7");
  70                         Assert.IsTrue (b [8], "#8");
  71                         Assert.IsTrue (!b [16], "#9");
  72                         b [8] = false;
  73                         Assert.IsTrue (b [4], "#10");
  74                         Assert.IsTrue (!b [8], "#11");
  75                         Assert.IsTrue (!b [16], "#12");
  76
  77                         BitVector32.Section s = BitVector32.CreateSection (31);
  78                         s = BitVector32.CreateSection (64, s);
  79                         // Print (s);
  80
  81                         // b = new BitVector32 (0x777777);
  82                         BitVector32 b1 = new BitVector32 (0xffff77);
  83                         BitVector32 b2 = new BitVector32 (b1 [s]);
  84                         //Console.WriteLine (b1.ToString ());
  85                         //Console.WriteLine (b2.ToString ());
  86                         Assert.AreEqual (123, b1 [s], "#14");
  87
  88                         // b1 [s] = 15;
  89                         //Console.WriteLine (b1.ToString ());
  90                 }
  91
  92                 [Test]
  93                 public void CreateMask ()
  94                 {
  95                         Assert.AreEqual (1, BitVector32.CreateMask (), "#1");
  96                         Assert.AreEqual (1, BitVector32.CreateMask (0), "#2");
  97                         Assert.AreEqual (2, BitVector32.CreateMask (1), "#3");
  98                         Assert.AreEqual (32, BitVector32.CreateMask (16), "#4");
  99                         Assert.AreEqual (-2, BitVector32.CreateMask (Int32.MaxValue), "#5");
 100                         Assert.AreEqual (-4, BitVector32.CreateMask (-2), "#6");
 101                         Assert.AreEqual (2, BitVector32.CreateMask (Int32.MinValue + 1), "#7");
 102                 }
 103
 104                 [Test]
 105                 [ExpectedException (typeof (InvalidOperationException))]
 106                 public void CreateMask_MinValue ()
 107                 {
 108                         BitVector32.CreateMask (Int32.MinValue);
 109                 }
 110
 111                 [Test]
 112                 public void CreateSection ()
 113                 {
 114                         BitVector32.Section s = BitVector32.CreateSection (1);
 115                         Assert.AreEqual ((short) 1, s.Mask, "#1");
 116
 117                         s = BitVector32.CreateSection (2);
 118                         Assert.AreEqual ((short) 3, s.Mask, "#2");
 119
 120                         s = BitVector32.CreateSection (3);
 121                         Assert.AreEqual ((short) 3, s.Mask, "#3");
 122
 123                         s = BitVector32.CreateSection (5);
 124                         Assert.AreEqual ((short) 7, s.Mask, "#4");
 125
 126                         s = BitVector32.CreateSection (20);
 127                         Assert.AreEqual ((short) 0x1f, s.Mask, "#4");
 128
 129                         s = BitVector32.CreateSection (Int16.MaxValue);
 130                         Assert.AreEqual ((short) 0x7fff, s.Mask, "#5");
 131
 132                         s = BitVector32.CreateSection (Int16.MaxValue - 100);
 133                         Assert.AreEqual ((short) 0x7fff, s.Mask, "#6");
 134
 135                         try {
 136                                 BitVector32.Section s2 = BitVector32.CreateSection (0);
 137                                 Assert.Fail ("#7");
 138                         } catch (ArgumentException) {}
 139
 140                         try {
 141                                 BitVector32.Section s2 = BitVector32.CreateSection (-1);
 142                                 Assert.Fail ("#8");
 143                         } catch (ArgumentException) {}
 144
 145                         try {
 146                                 BitVector32.Section s2 = BitVector32.CreateSection (Int16.MinValue);
 147                                 Assert.Fail ("#9");
 148                         } catch (ArgumentException) {}
 149
 150                         s = BitVector32.CreateSection (20);
 151                         Assert.AreEqual ((short) 0x1f, s.Mask, "#10a");
 152                         Assert.AreEqual ((short) 0x00, s.Offset, "#10b");
 153                         s = BitVector32.CreateSection (120, s);
 154                         Assert.AreEqual ((short) 0x7f, s.Mask, "#10c");
 155                         Assert.AreEqual ((short) 0x05, s.Offset, "#10d");
 156                         s = BitVector32.CreateSection (1000, s);
 157                         Assert.AreEqual ((short) 0x3ff, s.Mask, "#10e");
 158                         Assert.AreEqual ((short) 0x0c, s.Offset, "#10f");
 159                 }
 160
 161                 [Test]
 162                 public void Section ()
 163                 {
 164                         BitVector32.Section s1 = BitVector32.CreateSection (20);
 165                         Assert.AreEqual (31, s1.Mask, "1.Mask");
 166                         Assert.AreEqual (0, s1.Offset, "1.Offset");
 167                         Assert.AreEqual ("Section{0x1f, 0x0}", BitVector32.Section.ToString (s1), "ToString(Section)");
 168
 169                         BitVector32.Section s2 = BitVector32.CreateSection (20);
 170                         Assert.IsTrue (s1.Equals (s2), "s1==s2");
 171                         Assert.IsTrue (s2.Equals ((object)s1), "s2==s1");
 172                         Assert.AreEqual (s1.GetHashCode (), s2.GetHashCode (), "GetHashCode");
 173                         Assert.AreEqual ("Section{0x1f, 0x0}", s2.ToString (), "ToString()");
 174                 }
 175
 176                 [Test]
 177                 public void SectionCorrectSize ()
 178                 {
 179                         BitVector32.Section s1 = BitVector32.CreateSection (32767);
 180                         BitVector32.Section s2 = BitVector32.CreateSection (32767, s1);
 181                         BitVector32.Section s3 = BitVector32.CreateSection (3, s2);
 182                         BitVector32 v1 = new BitVector32 (0);
 183                         v1[s3] = 3;
 184                         Assert.AreEqual (v1[s3], 3);
 185                 }
 186
 187                 [Test]
 188                 public void SectionIncorrectSize ()
 189                 {
 190                         BitVector32.Section s1 = BitVector32.CreateSection (32767);
 191                         BitVector32.Section s2 = BitVector32.CreateSection (32767, s1);
 192
 193                         BitVector32.Section s3 = BitVector32.CreateSection (4, s2);
 194                 }
 195
 196                 [Test]
 197                 public void NegativeIndexer ()
 198                 {
 199                         BitVector32 bv = new BitVector32 (-1);
 200                         Assert.IsTrue (bv [Int32.MinValue], "Int32.MinValue");
 201                 }
 202
 203                 [Test]
 204                 public void TestSectionIndexer ()
 205                 {
 206                         BitVector32 bv = new BitVector32 (-1);
 207                         BitVector32.Section sect = BitVector32.CreateSection (1);
 208                         sect = BitVector32.CreateSection (Int16.MaxValue, sect);
 209                         sect = BitVector32.CreateSection (Int16.MaxValue, sect);
 210                         sect = BitVector32.CreateSection (1, sect);
 211                         Assert.AreEqual (1, bv[sect], "bv[sect]");
 212                         bv [sect] = 0;
 213
 214                         Assert.AreEqual (Int32.MaxValue, bv.Data, "#12a");
 215                 }
 216
 217                 [Test, ExpectedException (typeof (ArgumentException))]
 218                 public void TestCreateSection1 ()
 219                 {
 220                         BitVector32.Section section = BitVector32.CreateSection (Int16.MaxValue);
 221                         section = BitVector32.CreateSection (0, section);
 222                 }
 223
 224                 [Test, ExpectedException (typeof (ArgumentException))]
 225                 public void TestCreateSection2 ()
 226                 {
 227                         BitVector32.Section section = BitVector32.CreateSection (Int16.MaxValue);
 228                         section = BitVector32.CreateSection (-1, section);
 229                 }
 230
 231                 [Test, ExpectedException (typeof (ArgumentException))]
 232                 public void TestCreateSection3 ()
 233                 {
 234                         BitVector32.Section section = BitVector32.CreateSection (Int16.MaxValue);
 235                         section = BitVector32.CreateSection (Int16.MinValue, section);
 236                 }
 237
 238                 private void Print (BitVector32.Section s)
 239                 {
 240                         Console.WriteLine (s.ToString () + " : "+ s.Mask + " : " + s.Offset);
 241                 }
 242         }
 243 }