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 using System.Text;
  18
  19 namespace MonoTests.System.IO.Compression
  20 {
  21         [TestFixture]
  22         public class DeflateStreamTest
  23         {
  24                 private static void CopyStream (Stream src, Stream dest)
  25                 {
  26                         byte[] array = new byte[1024];
  27                         int bytes_read;
  28                         bytes_read = src.Read (array, 0, 1024);
  29                         while (bytes_read != 0) {
  30                                 dest.Write (array, 0, bytes_read);
  31                                 bytes_read = src.Read (array, 0, 1024);
  32                         }
  33                 }
  34
  35                 private static bool compare_buffers (byte[] first, byte[] second, int length)
  36                 {
  37                         if (first.Length < length || second.Length < length) {
  38                                 return false;
  39                         }
  40                         for (int i = 0; i < length; i++) {
  41                                 if (first[i] != second[i]) {
  42                                         return false;
  43                                 }
  44                         }
  45                         return true;
  46                 }
  47
  48                 [Test]
  49                 [ExpectedException (typeof (ArgumentNullException))]
  50                 public void Constructor_Null ()
  51                 {
  52                         DeflateStream ds = new DeflateStream (null, CompressionMode.Compress);
  53                 }
  54
  55                 [Test]
  56                 [ExpectedException (typeof (ArgumentException))]
  57                 public void Constructor_InvalidCompressionMode ()
  58                 {
  59                         DeflateStream ds = new DeflateStream (new MemoryStream (), (CompressionMode)Int32.MinValue);
  60                 }
  61
  62                 [Test]
  63                 public void CheckCompressDecompress ()
  64                 {
  65                         byte [] data = new byte[100000];
  66                         for (int i = 0; i < 100000; i++) {
  67                                 data[i] = (byte) i;
  68                         }
  69                         MemoryStream dataStream = new MemoryStream (data);
  70                         MemoryStream backing = new MemoryStream ();
  71                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Compress, true);
  72                         CopyStream (dataStream, compressing);
  73                         dataStream.Close();
  74                         compressing.Close();
  75                         backing.Seek (0, SeekOrigin.Begin);
  76                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
  77                         MemoryStream output = new MemoryStream ();
  78                         CopyStream (decompressing, output);
  79                         Assert.IsTrue (compare_buffers (data, output.GetBuffer(), (int) output.Length));
  80                         decompressing.Close();
  81                         output.Close();
  82                 }
  83
  84                 [Test]
  85                 public void CheckDecompress ()
  86                 {
  87                         MemoryStream backing = new MemoryStream (compressed_data);
  88                         DeflateStream decompressing = new DeflateStream (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                         MemoryStream backing = new MemoryStream (compressed_data);
  99                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 100                         decompressing.Read (null, 0, 20);
 101                 }
 102
 103                 [Test]
 104                 [ExpectedException (typeof (InvalidOperationException))]
 105                 public void CheckCompressingRead ()
 106                 {
 107                         byte [] dummy = new byte[20];
 108                         MemoryStream backing = new MemoryStream ();
 109                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Compress);
 110                         compressing.Read (dummy, 0, 20);
 111                 }
 112
 113                 [Test]
 114                 [ExpectedException (typeof (ArgumentException))]
 115                 public void CheckRangeRead ()
 116                 {
 117                         byte [] dummy = new byte[20];
 118                         MemoryStream backing = new MemoryStream (compressed_data);
 119                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 120                         decompressing.Read (dummy, 10, 20);
 121                 }
 122
 123 #if !MOBILE
 124                 [Test]
 125                 [Category("NotWorking")]
 126                 [ExpectedException (typeof (InvalidDataException))]
 127                 public void CheckInvalidDataRead ()
 128                 {
 129                         byte [] data = {0x11, 0x78, 0x89, 0x91, 0xbe, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0xe7, 0x02, 0x00 };
 130                         byte [] dummy = new byte[20];
 131                         MemoryStream backing = new MemoryStream (data);
 132                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 133                         decompressing.Read (dummy, 0, 20);
 134                 }
 135 #endif
 136
 137                 [Test]
 138                 [ExpectedException (typeof (ObjectDisposedException))]
 139                 public void CheckClosedRead ()
 140                 {
 141                         byte [] dummy = new byte[20];
 142                         MemoryStream backing = new MemoryStream (compressed_data);
 143                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 144                         decompressing.Close ();
 145                         decompressing.Read (dummy, 0, 20);
 146                 }
 147
 148                 [Test]
 149                 [ExpectedException (typeof (ObjectDisposedException))]
 150                 public void CheckClosedFlush ()
 151                 {
 152                         MemoryStream backing = new MemoryStream ();
 153                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Compress);
 154                         compressing.Close ();
 155                         compressing.Flush ();
 156                 }
 157
 158                 [Test]
 159                 [ExpectedException (typeof (NotSupportedException))]
 160                 public void CheckSeek ()
 161                 {
 162                         MemoryStream backing = new MemoryStream (compressed_data);
 163                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 164                         decompressing.Seek (20, SeekOrigin.Current);
 165                 }
 166
 167                 [Test]
 168                 [ExpectedException (typeof (NotSupportedException))]
 169                 public void CheckSetLength ()
 170                 {
 171                         MemoryStream backing = new MemoryStream (compressed_data);
 172                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 173                         decompressing.SetLength (20);
 174                 }
 175
 176                 [Test]
 177                 public void CheckGetCanSeekProp ()
 178                 {
 179                         MemoryStream backing = new MemoryStream (compressed_data);
 180                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 181                         Assert.IsFalse (decompress.CanSeek, "#A1");
 182                         Assert.IsTrue (backing.CanSeek, "#A2");
 183                         decompress.Dispose ();
 184                         Assert.IsFalse (decompress.CanSeek, "#A3");
 185                         Assert.IsFalse (backing.CanSeek, "#A4");
 186
 187                         backing = new MemoryStream ();
 188                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 189                         Assert.IsFalse (compress.CanSeek, "#B1");
 190                         Assert.IsTrue (backing.CanSeek, "#B2");
 191                         compress.Dispose ();
 192                         Assert.IsFalse (decompress.CanSeek, "#B3");
 193                         Assert.IsFalse (backing.CanSeek, "#B4");
 194                 }
 195
 196                 [Test]
 197                 public void CheckGetCanReadProp ()
 198                 {
 199                         MemoryStream backing = new MemoryStream (compressed_data);
 200                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 201                         Assert.IsTrue (decompress.CanRead, "#A1");
 202                         Assert.IsTrue (backing.CanRead, "#A2");
 203                         decompress.Dispose ();
 204                         Assert.IsFalse (decompress.CanRead, "#A3");
 205                         Assert.IsFalse (backing.CanRead, "#A4");
 206
 207                         backing = new MemoryStream ();
 208                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 209                         Assert.IsFalse (compress.CanRead, "#B1");
 210                         Assert.IsTrue (backing.CanRead, "#B2");
 211                         compress.Dispose ();
 212                         Assert.IsFalse (decompress.CanRead, "#B3");
 213                         Assert.IsFalse (backing.CanRead, "#B4");
 214                 }
 215
 216                 [Test]
 217                 public void CheckGetCanWriteProp ()
 218                 {
 219                         MemoryStream backing = new MemoryStream ();
 220                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 221                         Assert.IsFalse (decompress.CanWrite, "#A1");
 222                         Assert.IsTrue (backing.CanWrite, "#A2");
 223                         decompress.Dispose ();
 224                         Assert.IsFalse (decompress.CanWrite, "#A3");
 225                         Assert.IsFalse (backing.CanWrite, "#A4");
 226
 227                         backing = new MemoryStream ();
 228                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 229                         Assert.IsTrue (compress.CanWrite, "#B1");
 230                         Assert.IsTrue (backing.CanWrite, "#B2");
 231                         compress.Dispose ();
 232                         Assert.IsFalse (decompress.CanWrite, "#B3");
 233                         Assert.IsFalse (backing.CanWrite, "#B4");
 234                 }
 235
 236                 [Test]
 237                 [ExpectedException (typeof (NotSupportedException))]
 238                 public void CheckSetLengthProp ()
 239                 {
 240                         MemoryStream backing = new MemoryStream (compressed_data);
 241                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 242                         decompressing.SetLength (20);
 243                 }
 244
 245                 [Test]
 246                 [ExpectedException (typeof (NotSupportedException))]
 247                 public void CheckGetLengthProp ()
 248                 {
 249                         MemoryStream backing = new MemoryStream (compressed_data);
 250                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 251                         long length = decompressing.Length;
 252                 }
 253
 254                 [Test]
 255                 [ExpectedException (typeof (NotSupportedException))]
 256                 public void CheckGetPositionProp ()
 257                 {
 258                         MemoryStream backing = new MemoryStream (compressed_data);
 259                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 260                         long position = decompressing.Position;
 261                 }
 262
 263                 [Test]
 264                 public void DisposeTest ()
 265                 {
 266                         MemoryStream backing = new MemoryStream (compressed_data);
 267                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 268                         decompress.Dispose ();
 269                         decompress.Dispose ();
 270                 }
 271
 272                 static byte [] compressed_data = { 0xf3, 0x48, 0xcd, 0xc9, 0xc9,
 273                         0xe7, 0x02, 0x00 };
 274
 275
 276                 [Test]
 277                 public void JunkAtTheEnd ()
 278                 {
 279                         // Write a deflated stream, then some additional data...
 280                         using (MemoryStream ms = new MemoryStream())
 281                         {
 282                                 // The compressed stream
 283                                 using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Compress, true))
 284                                 {
 285                                         stream.WriteByte(1);
 286                                         stream.Flush();
 287                                 }
 288                                 // Junk
 289                                 ms.WriteByte(2);
 290
 291                                 ms.Position = 0;
 292                                 // Reading: this should not hang
 293                                 using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Decompress))
 294                                 {
 295                                         byte[] buffer  = new byte[512];
 296                                         int len = stream.Read(buffer, 0, buffer.Length);
 297                                         Console.WriteLine(len == 1);
 298                                 }
 299                         }
 300                 }
 301
 302                 class Bug19313Stream : MemoryStream
 303                 {
 304                         public Bug19313Stream (byte [] buffer)
 305                                 : base (buffer)
 306                         {
 307                         }
 308
 309                         public override int Read (byte [] buffer, int offset, int count)
 310                         {
 311                                 // Thread was blocking when DeflateStream uses a NetworkStream.
 312                                 // Because the NetworkStream.Read calls Socket.Receive that
 313                                 // blocks the thread waiting for at least a byte to return.
 314                                 // This assert guarantees that Read is called only when there
 315                                 // is something to be read.
 316                                 Assert.IsTrue (Position < Length, "Trying to read empty stream.");
 317
 318                                 return base.Read (buffer, offset, count);
 319                         }
 320                 }
 321
 322                 [Test]
 323                 public void Bug19313 ()
 324                 {
 325                         byte [] buffer  = new byte [512];
 326                         using (var backing = new Bug19313Stream (compressed_data))
 327                         using (var decompressing = new DeflateStream (backing, CompressionMode.Decompress))
 328                                 decompressing.Read (buffer, 0, buffer.Length);
 329                 }
 330
 331                 public MemoryStream GenerateStreamFromString(string s)
 332                 {
 333                         return new MemoryStream (Encoding.UTF8.GetBytes (s));
 334                 }
 335
 336                 [Test]
 337                 public void CheckNet45Overloads () // Xambug #21982
 338                 {
 339                         MemoryStream dataStream = GenerateStreamFromString("Hello");
 340                         MemoryStream backing = new MemoryStream ();
 341                         DeflateStream compressing = new DeflateStream (backing, CompressionLevel.Fastest, true);
 342                         CopyStream (dataStream, compressing);
 343                         dataStream.Close();
 344                         compressing.Close();
 345
 346                         backing.Seek (0, SeekOrigin.Begin);
 347                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 348                         StreamReader reader = new StreamReader (decompressing);
 349                         Assert.AreEqual ("Hello", reader.ReadLine ());
 350                         decompressing.Close();
 351                         backing.Close();
 352                 }
 353         }
 354 }
 355
 356 #endif
 357