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

   1 /* -*- Mode: csharp; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 //
   3 // DeflateStreamTest.cs - NUnit Test Cases for the System.IO.Compression.DeflateStream 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 DeflateStreamTest
  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                         DeflateStream ds = new DeflateStream (null, CompressionMode.Compress);
  52                 }
  53
  54                 [Test]
  55                 [ExpectedException (typeof (ArgumentException))]
  56                 public void Constructor_InvalidCompressionMode ()
  57                 {
  58                         DeflateStream ds = new DeflateStream (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                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Compress, true);
  71                         CopyStream (dataStream, compressing);
  72                         dataStream.Close();
  73                         compressing.Close();
  74                         backing.Seek (0, SeekOrigin.Begin);
  75                         DeflateStream decompressing = new DeflateStream (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                         MemoryStream backing = new MemoryStream (compressed_data);
  87                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
  88                         StreamReader reader = new StreamReader (decompressing);
  89                         Assert.AreEqual ("Hello", reader.ReadLine ());
  90                         decompressing.Close();
  91                 }
  92
  93                 [Test]
  94                 [ExpectedException (typeof (ArgumentNullException))]
  95                 public void CheckNullRead ()
  96                 {
  97                         MemoryStream backing = new MemoryStream (compressed_data);
  98                         DeflateStream decompressing = new DeflateStream (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                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Compress);
 109                         compressing.Read (dummy, 0, 20);
 110                 }
 111
 112                 [Test]
 113                 [ExpectedException (typeof (ArgumentException))]
 114                 public void CheckRangeRead ()
 115                 {
 116                         byte [] dummy = new byte[20];
 117                         MemoryStream backing = new MemoryStream (compressed_data);
 118                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 119                         decompressing.Read (dummy, 10, 20);
 120                 }
 121
 122 #if !MOBILE
 123                 [Test]
 124                 [Category("NotWorking")]
 125                 [ExpectedException (typeof (InvalidDataException))]
 126                 public void CheckInvalidDataRead ()
 127                 {
 128                         byte [] data = {0x11, 0x78, 0x89, 0x91, 0xbe, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0xe7, 0x02, 0x00 };
 129                         byte [] dummy = new byte[20];
 130                         MemoryStream backing = new MemoryStream (data);
 131                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 132                         decompressing.Read (dummy, 0, 20);
 133                 }
 134 #endif
 135
 136                 [Test]
 137                 [ExpectedException (typeof (ObjectDisposedException))]
 138                 public void CheckClosedRead ()
 139                 {
 140                         byte [] dummy = new byte[20];
 141                         MemoryStream backing = new MemoryStream (compressed_data);
 142                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 143                         decompressing.Close ();
 144                         decompressing.Read (dummy, 0, 20);
 145                 }
 146
 147                 [Test]
 148                 [ExpectedException (typeof (ObjectDisposedException))]
 149                 public void CheckClosedFlush ()
 150                 {
 151                         MemoryStream backing = new MemoryStream ();
 152                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Compress);
 153                         compressing.Close ();
 154                         compressing.Flush ();
 155                 }
 156
 157                 [Test]
 158                 [ExpectedException (typeof (NotSupportedException))]
 159                 public void CheckSeek ()
 160                 {
 161                         MemoryStream backing = new MemoryStream (compressed_data);
 162                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 163                         decompressing.Seek (20, SeekOrigin.Current);
 164                 }
 165
 166                 [Test]
 167                 [ExpectedException (typeof (NotSupportedException))]
 168                 public void CheckSetLength ()
 169                 {
 170                         MemoryStream backing = new MemoryStream (compressed_data);
 171                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 172                         decompressing.SetLength (20);
 173                 }
 174
 175                 [Test]
 176                 public void CheckGetCanSeekProp ()
 177                 {
 178                         MemoryStream backing = new MemoryStream (compressed_data);
 179                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 180                         Assert.IsFalse (decompress.CanSeek, "#A1");
 181                         Assert.IsTrue (backing.CanSeek, "#A2");
 182                         decompress.Dispose ();
 183                         Assert.IsFalse (decompress.CanSeek, "#A3");
 184                         Assert.IsFalse (backing.CanSeek, "#A4");
 185
 186                         backing = new MemoryStream ();
 187                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 188                         Assert.IsFalse (compress.CanSeek, "#B1");
 189                         Assert.IsTrue (backing.CanSeek, "#B2");
 190                         compress.Dispose ();
 191                         Assert.IsFalse (decompress.CanSeek, "#B3");
 192                         Assert.IsFalse (backing.CanSeek, "#B4");
 193                 }
 194
 195                 [Test]
 196                 public void CheckGetCanReadProp ()
 197                 {
 198                         MemoryStream backing = new MemoryStream (compressed_data);
 199                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 200                         Assert.IsTrue (decompress.CanRead, "#A1");
 201                         Assert.IsTrue (backing.CanRead, "#A2");
 202                         decompress.Dispose ();
 203                         Assert.IsFalse (decompress.CanRead, "#A3");
 204                         Assert.IsFalse (backing.CanRead, "#A4");
 205
 206                         backing = new MemoryStream ();
 207                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 208                         Assert.IsFalse (compress.CanRead, "#B1");
 209                         Assert.IsTrue (backing.CanRead, "#B2");
 210                         compress.Dispose ();
 211                         Assert.IsFalse (decompress.CanRead, "#B3");
 212                         Assert.IsFalse (backing.CanRead, "#B4");
 213                 }
 214
 215                 [Test]
 216                 public void CheckGetCanWriteProp ()
 217                 {
 218                         MemoryStream backing = new MemoryStream ();
 219                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 220                         Assert.IsFalse (decompress.CanWrite, "#A1");
 221                         Assert.IsTrue (backing.CanWrite, "#A2");
 222                         decompress.Dispose ();
 223                         Assert.IsFalse (decompress.CanWrite, "#A3");
 224                         Assert.IsFalse (backing.CanWrite, "#A4");
 225
 226                         backing = new MemoryStream ();
 227                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 228                         Assert.IsTrue (compress.CanWrite, "#B1");
 229                         Assert.IsTrue (backing.CanWrite, "#B2");
 230                         compress.Dispose ();
 231                         Assert.IsFalse (decompress.CanWrite, "#B3");
 232                         Assert.IsFalse (backing.CanWrite, "#B4");
 233                 }
 234
 235                 [Test]
 236                 [ExpectedException (typeof (NotSupportedException))]
 237                 public void CheckSetLengthProp ()
 238                 {
 239                         MemoryStream backing = new MemoryStream (compressed_data);
 240                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 241                         decompressing.SetLength (20);
 242                 }
 243
 244                 [Test]
 245                 [ExpectedException (typeof (NotSupportedException))]
 246                 public void CheckGetLengthProp ()
 247                 {
 248                         MemoryStream backing = new MemoryStream (compressed_data);
 249                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 250                         long length = decompressing.Length;
 251                 }
 252
 253                 [Test]
 254                 [ExpectedException (typeof (NotSupportedException))]
 255                 public void CheckGetPositionProp ()
 256                 {
 257                         MemoryStream backing = new MemoryStream (compressed_data);
 258                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 259                         long position = decompressing.Position;
 260                 }
 261
 262                 [Test]
 263                 public void DisposeTest ()
 264                 {
 265                         MemoryStream backing = new MemoryStream (compressed_data);
 266                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 267                         decompress.Dispose ();
 268                         decompress.Dispose ();
 269                 }
 270
 271                 static byte [] compressed_data = { 0xf3, 0x48, 0xcd, 0xc9, 0xc9,
 272                         0xe7, 0x02, 0x00 };
 273
 274
 275                 [Test]
 276                 public void JunkAtTheEnd ()
 277                 {
 278                         // Write a deflated stream, then some additional data...
 279                         using (MemoryStream ms = new MemoryStream())
 280                         {
 281                                 // The compressed stream
 282                                 using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Compress, true))
 283                                 {
 284                                         stream.WriteByte(1);
 285                                         stream.Flush();
 286                                 }
 287                                 // Junk
 288                                 ms.WriteByte(2);
 289
 290                                 ms.Position = 0;
 291                                 // Reading: this should not hang
 292                                 using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Decompress))
 293                                 {
 294                                         byte[] buffer  = new byte[512];
 295                                         int len = stream.Read(buffer, 0, buffer.Length);
 296                                         Console.WriteLine(len == 1);
 297                                 }
 298                         }
 299                 }
 300         }
 301 }
 302
 303 #endif
 304