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 using NUnit.Framework;
  12 using System;
  13 using System.IO;
  14 using System.IO.Compression;
  15
  16 namespace MonoTests.System.IO.Compression
  17 {
  18         [TestFixture]
  19         public class GZipStreamTest
  20         {
  21                 private static void CopyStream (Stream src, Stream dest)
  22                 {
  23                         byte[] array = new byte[1024];
  24                         int bytes_read;
  25                         bytes_read = src.Read (array, 0, 1024);
  26                         while (bytes_read != 0) {
  27                                 dest.Write (array, 0, bytes_read);
  28                                 bytes_read = src.Read (array, 0, 1024);
  29                         }
  30                 }
  31
  32                 private static bool compare_buffers (byte[] first, byte[] second, int length)
  33                 {
  34                         if (first.Length < length || second.Length < length) {
  35                                 return false;
  36                         }
  37                         for (int i = 0; i < length; i++) {
  38                                 if (first[i] != second[i]) {
  39                                         return false;
  40                                 }
  41                         }
  42                         return true;
  43                 }
  44
  45                 [Test]
  46                 [ExpectedException (typeof (ArgumentNullException))]
  47                 public void Constructor_Null ()
  48                 {
  49                         GZipStream ds = new GZipStream (null, CompressionMode.Compress);
  50                 }
  51
  52                 [Test]
  53                 [ExpectedException (typeof (ArgumentException))]
  54                 public void Constructor_InvalidCompressionMode ()
  55                 {
  56                         GZipStream ds = new GZipStream (new MemoryStream (), (CompressionMode)Int32.MinValue);
  57                 }
  58
  59                 [Test]
  60                 public void CheckCompressDecompress ()
  61                 {
  62                         byte [] data = new byte[100000];
  63                         for (int i = 0; i < 100000; i++) {
  64                                 data[i] = (byte) i;
  65                         }
  66                         MemoryStream dataStream = new MemoryStream (data);
  67                         MemoryStream backing = new MemoryStream ();
  68                         GZipStream compressing = new GZipStream (backing, CompressionMode.Compress, true);
  69                         CopyStream (dataStream, compressing);
  70                         dataStream.Close();
  71                         compressing.Close();
  72                         backing.Seek (0, SeekOrigin.Begin);
  73                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
  74                         MemoryStream output = new MemoryStream ();
  75                         CopyStream (decompressing, output);
  76                         Assert.IsTrue (compare_buffers (data, output.GetBuffer(), (int) output.Length));
  77                         decompressing.Close();
  78                         output.Close();
  79                 }
  80
  81                 [Test]
  82                 public void CheckDecompress ()
  83                 {
  84                         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 };
  85                         MemoryStream backing = new MemoryStream (data);
  86                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
  87                         StreamReader reader = new StreamReader (decompressing);
  88                         Assert.AreEqual ("Hello", reader.ReadLine ());
  89                         decompressing.Close();
  90                 }
  91
  92                 [Test]
  93                 [ExpectedException (typeof (ArgumentNullException))]
  94                 public void CheckNullRead ()
  95                 {
  96                         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 };
  97                         MemoryStream backing = new MemoryStream (data);
  98                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
  99                         decompressing.Read (null, 0, 20);
 100                 }
 101
 102                 [Test]
 103                 [ExpectedException (typeof (InvalidOperationException))]
 104                 public void CheckCompressingRead ()
 105                 {
 106                         byte [] dummy = new byte[20];
 107                         MemoryStream backing = new MemoryStream ();
 108                         GZipStream compressing = new GZipStream (backing, CompressionMode.Compress);
 109                         compressing.Read (dummy, 0, 20);
 110                 }
 111
 112                 [Test]
 113                 [ExpectedException (typeof (ArgumentException))]
 114                 public void CheckRangeRead ()
 115                 {
 116                         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 };
 117                         byte [] dummy = new byte[20];
 118                         MemoryStream backing = new MemoryStream (data);
 119                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 120                         decompressing.Read (dummy, 10, 20);
 121                 }
 122
 123 #if !MOBILE
 124                 [Test]
 125                 [Category("NotWorking")]
 126                 public void CheckInvalidDataRead ()
 127                 {
 128                         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 };
 129                         byte [] dummy = new byte[20];
 130                         MemoryStream backing = new MemoryStream (data);
 131                         GZipStream decompressing = new GZipStream (backing, CompressionMode.Decompress);
 132                         try {
 133                                 decompressing.Read (dummy, 0, 20);
 134                                 Assert.Fail ();
 135                         } catch (InvalidDataException) {
 136                         }
 137                 }
 138 #endif
 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                 [Test]
 279                 public void DisposeOrderTest ()
 280                 {
 281                         var fs = new MemoryStream();
 282                         GZipStream compressed = new GZipStream(fs, CompressionMode.Compress);
 283                         byte[] buffer = new byte[1024];
 284                         compressed.Write(buffer, 0, buffer.Length);
 285                         compressed.Close();
 286
 287                         try {
 288                                 fs.WriteByte(2);
 289                                 Assert.Fail ();
 290                         } catch (ObjectDisposedException) {
 291                         }
 292                 }
 293
 294                 static byte [] compressed_data = {
 295                         0x1f, 0x8b, 0x08, 0x08, 0x70, 0xbb, 0x5d, 0x41, 0x00,
 296                         0x03, 0x74, 0x65, 0x73, 0x74, 0x00, 0xf3, 0x48, 0xcd,
 297                         0xc9, 0xc9, 0xe7, 0x02, 0x00, 0x16, 0x35, 0x96, 0x31,
 298                         0x06, 0x00, 0x00, 0x00};
 299         }
 300 }
 301