mcs/class/System/Test/System.IO.Compression/GzipStreamTest.cs

   1 /* -*- Mode: csharp; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 //
   3 // GZipStreamTest.cs - NUnit Test Cases for the System.IO.Compression.GZipStream class
   4 //
   5 // Authors:
   6 //      Christopher James Lahey  <clahey@ximian.com>
   7 //
   8 // (C) 2004 Novell, Inc. <http://www.novell.com>
   9 //
  10
  11 #if NET_2_0
  12
  13 using NUnit.Framework;
  14 using System;
  15 using System.IO;
  16 using System.IO.Compression;
  17
  18 namespace MonoTests.System.IO.Compression
  19 {
  20         [TestFixture]
  21         public class GZipStreamTest
  22         {
  23                 private static void CopyStream (Stream src, Stream dest)
  24                 {
  25                         byte[] array = new byte[1024];
  26                         int bytes_read;
  27                         bytes_read = src.Read (array, 0, 1024);
  28                         while (bytes_read != 0) {
  29                                 dest.Write (array, 0, bytes_read);
  30                                 bytes_read = src.Read (array, 0, 1024);
  31                         }
  32                 }
  33
  34                 private static bool compare_buffers (byte[] first, byte[] second, int length)
  35                 {
  36                         if (first.Length < length || second.Length < length) {
  37                                 return false;
  38                         }
  39                         for (int i = 0; i < length; i++) {
  40                                 if (first[i] != second[i]) {
  41                                         return false;
  42                                 }
  43                         }
  44                         return true;
  45                 }
  46
  47                 [Test]
  48                 [ExpectedException (typeof (ArgumentNullException))]
  49                 public void Constructor_Null ()
  50                 {
  51                         GZipStream ds = new GZipStream (null, CompressionMode.Compress);
  52                 }
  53
  54                 [Test]
  55                 [ExpectedException (typeof (ArgumentException))]
  56                 public void Constructor_InvalidCompressionMode ()
  57                 {
  58                         GZipStream ds = new GZipStream (new MemoryStream (), (CompressionMode)Int32.MinValue);
  59                 }
  60
  61                 [Test]
  62                 public void CheckCompressDecompress ()
  63                 {
  64                         byte [] data = new byte[100000];
  65                         for (int i = 0; i < 100000; i++) {
  66                                 data[i] = (byte) i;
  67                         }
  68                         MemoryStream dataStream = new MemoryStream (data);
  69                         MemoryStream backing = new MemoryStream ();
  70                         GZipStream compressing = new GZipStream (backing, CompressionMode.Compress, true);
  71                         CopyStream (dataStream, compressing);
  72                         dataStream.Close();
  73                         compressing.Close();
  74                         backing.Seek (0, SeekOrigin.Begin);
  75                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
  76                         MemoryStream output = new MemoryStream ();
  77                         CopyStream (decompressing, output);
  78                         Assert.IsTrue (compare_buffers (data, output.GetBuffer(), (int) output.Length));
  79                         decompressing.Close();
  80                         output.Close();
  81                 }
  82
  83                 [Test]
  84                 public void CheckDecompress ()
  85                 {
  86                         byte [] data = {0x1f, 0x8b, 0x08, 0x08, 0x70, 0xbb, 0x5d, 0x41, 0x00, 0x03, 0x74, 0x65, 0x73, 0x74, 0x00, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0xe7, 0x02, 0x00, 0x16, 0x35, 0x96, 0x31, 0x06, 0x00, 0x00, 0x00 };
  87                         MemoryStream backing = new MemoryStream (data);
  88                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
  89                         StreamReader reader = new StreamReader (decompressing);
  90                         Assert.AreEqual ("Hello", reader.ReadLine ());
  91                         decompressing.Close();
  92                 }
  93
  94                 [Test]
  95                 [ExpectedException (typeof (ArgumentNullException))]
  96                 public void CheckNullRead ()
  97                 {
  98                         byte [] data = {0x1f, 0x8b, 0x08, 0x08, 0x70, 0xbb, 0x5d, 0x41, 0x00, 0x03, 0x74, 0x65, 0x73, 0x74, 0x00, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0xe7, 0x02, 0x00, 0x16, 0x35, 0x96, 0x31, 0x06, 0x00, 0x00, 0x00 };
  99                         MemoryStream backing = new MemoryStream (data);
 100                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 101                         decompressing.Read (null, 0, 20);
 102                 }
 103
 104                 [Test]
 105                 [ExpectedException (typeof (InvalidOperationException))]
 106                 public void CheckCompressingRead ()
 107                 {
 108                         byte [] dummy = new byte[20];
 109                         MemoryStream backing = new MemoryStream ();
 110                         GZipStream compressing = new GZipStream (backing, CompressionMode.Compress);
 111                         compressing.Read (dummy, 0, 20);
 112                 }
 113
 114                 [Test]
 115                 [ExpectedException (typeof (ArgumentException))]
 116                 public void CheckRangeRead ()
 117                 {
 118                         byte [] data = {0x1f, 0x8b, 0x08, 0x08, 0x70, 0xbb, 0x5d, 0x41, 0x00, 0x03, 0x74, 0x65, 0x73, 0x74, 0x00, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0xe7, 0x02, 0x00, 0x16, 0x35, 0x96, 0x31, 0x06, 0x00, 0x00, 0x00 };
 119                         byte [] dummy = new byte[20];
 120                         MemoryStream backing = new MemoryStream (data);
 121                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 122                         decompressing.Read (dummy, 10, 20);
 123                 }
 124
 125                 [Test]
 126                 [Category("NotWorking")]
 127                 public void CheckInvalidDataRead ()
 128                 {
 129                         byte [] data = {0x1f, 0x8b, 0x08, 0x08, 0x70, 0xbb, 0x5d, 0x41, 0x00, 0x03, 0x74, 0x65, 0x73, 0x74, 0x00, 0x11, 0x78, 0x89, 0x91, 0xbe, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0xe7, 0x02, 0x00, 0x16, 0x35, 0x96, 0x31, 0x06, 0x00, 0x00, 0x00 };
 130                         byte [] dummy = new byte[20];
 131                         MemoryStream backing = new MemoryStream (data);
 132                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 133                         try {
 134                                 decompressing.Read (dummy, 0, 20);
 135                                 Assert.Fail ();
 136                         } catch (InvalidDataException) {
 137                         }
 138                 }
 139
 140                 [Test]
 141                 public void CheckClosedRead ()
 142                 {
 143                         byte [] dummy = new byte[20];
 144                         MemoryStream backing = new MemoryStream (compressed_data);
 145                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 146                         decompressing.Close ();
 147                         try {
 148                                 decompressing.Read (dummy, 0, 20);
 149                                 Assert.Fail ();
 150                         } catch (ObjectDisposedException) {
 151                         }
 152                 }
 153
 154                 [Test]
 155                 [ExpectedException (typeof (ObjectDisposedException))]
 156                 public void CheckClosedFlush ()
 157                 {
 158                         MemoryStream backing = new MemoryStream ();
 159                         GZipStream compressing = new GZipStream (backing, CompressionMode.Compress);
 160                         compressing.Close ();
 161                         compressing.Flush ();
 162                 }
 163
 164                 [Test]
 165                 [ExpectedException (typeof (NotSupportedException))]
 166                 public void CheckSeek ()
 167                 {
 168                         MemoryStream backing = new MemoryStream (compressed_data);
 169                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 170                         decompressing.Seek (20, SeekOrigin.Current);
 171                 }
 172
 173                 [Test]
 174                 [ExpectedException (typeof (NotSupportedException))]
 175                 public void CheckSetLength ()
 176                 {
 177                         MemoryStream backing = new MemoryStream (compressed_data);
 178                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 179                         decompressing.SetLength (20);
 180                 }
 181
 182                 [Test]
 183                 public void CheckGetCanSeekProp ()
 184                 {
 185                         MemoryStream backing = new MemoryStream (compressed_data);
 186                         GZipStream decompress = new GZipStream (backing, CompressionMode.Decompress);
 187                         Assert.IsFalse (decompress.CanSeek, "#A1");
 188                         Assert.IsTrue (backing.CanSeek, "#A2");
 189                         decompress.Dispose ();
 190                         Assert.IsFalse (decompress.CanSeek, "#A3");
 191                         Assert.IsFalse (backing.CanSeek, "#A4");
 192
 193                         backing = new MemoryStream ();
 194                         GZipStream compress = new GZipStream (backing, CompressionMode.Compress);
 195                         Assert.IsFalse (compress.CanSeek, "#B1");
 196                         Assert.IsTrue (backing.CanSeek, "#B2");
 197                         compress.Dispose ();
 198                         Assert.IsFalse (decompress.CanSeek, "#B3");
 199                         Assert.IsFalse (backing.CanSeek, "#B4");
 200                 }
 201
 202                 [Test]
 203                 public void CheckGetCanReadProp ()
 204                 {
 205                         MemoryStream backing = new MemoryStream (compressed_data);
 206                         GZipStream decompress = new GZipStream (backing, CompressionMode.Decompress);
 207                         Assert.IsTrue (decompress.CanRead, "#A1");
 208                         Assert.IsTrue (backing.CanRead, "#A2");
 209                         decompress.Dispose ();
 210                         Assert.IsFalse (decompress.CanRead, "#A3");
 211                         Assert.IsFalse (backing.CanRead, "#A4");
 212
 213                         backing = new MemoryStream ();
 214                         GZipStream compress = new GZipStream (backing, CompressionMode.Compress);
 215                         Assert.IsFalse (compress.CanRead, "#B1");
 216                         Assert.IsTrue (backing.CanRead, "#B2");
 217                         compress.Dispose ();
 218                         Assert.IsFalse (decompress.CanRead, "#B3");
 219                         Assert.IsFalse (backing.CanRead, "#B4");
 220                 }
 221
 222                 [Test]
 223                 public void CheckGetCanWriteProp ()
 224                 {
 225                         MemoryStream backing = new MemoryStream (compressed_data);
 226                         GZipStream decompress = new GZipStream (backing, CompressionMode.Decompress);
 227                         Assert.IsFalse (decompress.CanWrite, "#A1");
 228                         Assert.IsTrue (backing.CanWrite, "#A2");
 229                         decompress.Dispose ();
 230                         Assert.IsFalse (decompress.CanWrite, "#A3");
 231                         Assert.IsFalse (backing.CanWrite, "#A4");
 232
 233                         backing = new MemoryStream ();
 234                         GZipStream compress = new GZipStream (backing, CompressionMode.Compress);
 235                         Assert.IsTrue (compress.CanWrite, "#B1");
 236                         Assert.IsTrue (backing.CanWrite, "#B2");
 237                         compress.Dispose ();
 238                         Assert.IsFalse (decompress.CanWrite, "#B3");
 239                         Assert.IsFalse (backing.CanWrite, "#B4");
 240                 }
 241
 242                 [Test]
 243                 [ExpectedException (typeof (NotSupportedException))]
 244                 public void CheckSetLengthProp ()
 245                 {
 246                         MemoryStream backing = new MemoryStream (compressed_data);
 247                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 248                         decompressing.SetLength (20);
 249                 }
 250
 251                 [Test]
 252                 [ExpectedException (typeof (NotSupportedException))]
 253                 public void CheckGetLengthProp ()
 254                 {
 255                         MemoryStream backing = new MemoryStream (compressed_data);
 256                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 257                         long length = decompressing.Length;
 258                 }
 259
 260                 [Test]
 261                 [ExpectedException (typeof (NotSupportedException))]
 262                 public void CheckGetPositionProp ()
 263                 {
 264                         MemoryStream backing = new MemoryStream (compressed_data);
 265                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 266                         long position = decompressing.Position;
 267                 }
 268
 269                 [Test]
 270                 public void DisposeTest ()
 271                 {
 272                         MemoryStream backing = new MemoryStream (compressed_data);
 273                         GZipStream decompress = new GZipStream (backing, CompressionMode.Decompress);
 274                         decompress.Dispose ();
 275                         decompress.Dispose ();
 276                 }
 277
 278                 static byte [] compressed_data = {
 279                         0x1f, 0x8b, 0x08, 0x08, 0x70, 0xbb, 0x5d, 0x41, 0x00,
 280                         0x03, 0x74, 0x65, 0x73, 0x74, 0x00, 0xf3, 0x48, 0xcd,
 281                         0xc9, 0xc9, 0xe7, 0x02, 0x00, 0x16, 0x35, 0x96, 0x31,
 282                         0x06, 0x00, 0x00, 0x00};
 283         }
 284 }
 285
 286 #endif