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
  12 using NUnit.Framework;
  13 using System;
  14 using System.IO;
  15 using System.IO.Compression;
  16 using System.Text;
  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                 // https://bugzilla.xamarin.com/show_bug.cgi?id=22346
  94                 [Test]
  95                 public void CheckEmptyRead ()
  96                 {
  97                         byte [] dummy = new byte[1];
  98                         byte [] data = new byte[0];
  99                         MemoryStream backing = new MemoryStream (data);
 100                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Decompress);
 101                         compressing.Read (dummy, 0, 1);
 102                 }
 103
 104                 [Test]
 105                 [ExpectedException (typeof (ArgumentNullException))]
 106                 public void CheckNullRead ()
 107                 {
 108                         MemoryStream backing = new MemoryStream (compressed_data);
 109                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 110                         decompressing.Read (null, 0, 20);
 111                 }
 112
 113                 [Test]
 114                 [ExpectedException (typeof (InvalidOperationException))]
 115                 public void CheckCompressingRead ()
 116                 {
 117                         byte [] dummy = new byte[20];
 118                         MemoryStream backing = new MemoryStream ();
 119                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Compress);
 120                         compressing.Read (dummy, 0, 20);
 121                 }
 122
 123                 [Test]
 124                 [ExpectedException (typeof (ArgumentException))]
 125                 public void CheckRangeRead ()
 126                 {
 127                         byte [] dummy = new byte[20];
 128                         MemoryStream backing = new MemoryStream (compressed_data);
 129                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 130                         decompressing.Read (dummy, 10, 20);
 131                 }
 132
 133 #if !MOBILE
 134                 [Test]
 135                 [Category("NotWorking")]
 136                 [ExpectedException (typeof (InvalidDataException))]
 137                 public void CheckInvalidDataRead ()
 138                 {
 139                         byte [] data = {0x11, 0x78, 0x89, 0x91, 0xbe, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0xe7, 0x02, 0x00 };
 140                         byte [] dummy = new byte[20];
 141                         MemoryStream backing = new MemoryStream (data);
 142                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 143                         decompressing.Read (dummy, 0, 20);
 144                 }
 145 #endif
 146
 147                 [Test]
 148                 [ExpectedException (typeof (ObjectDisposedException))]
 149                 public void CheckClosedRead ()
 150                 {
 151                         byte [] dummy = new byte[20];
 152                         MemoryStream backing = new MemoryStream (compressed_data);
 153                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 154                         decompressing.Close ();
 155                         decompressing.Read (dummy, 0, 20);
 156                 }
 157
 158                 [Test]
 159                 [ExpectedException (typeof (ObjectDisposedException))]
 160                 public void CheckClosedFlush ()
 161                 {
 162                         MemoryStream backing = new MemoryStream ();
 163                         DeflateStream compressing = new DeflateStream (backing, CompressionMode.Compress);
 164                         compressing.Close ();
 165                         compressing.Flush ();
 166                 }
 167
 168                 [Test]
 169                 [ExpectedException (typeof (NotSupportedException))]
 170                 public void CheckSeek ()
 171                 {
 172                         MemoryStream backing = new MemoryStream (compressed_data);
 173                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 174                         decompressing.Seek (20, SeekOrigin.Current);
 175                 }
 176
 177                 [Test]
 178                 [ExpectedException (typeof (NotSupportedException))]
 179                 public void CheckSetLength ()
 180                 {
 181                         MemoryStream backing = new MemoryStream (compressed_data);
 182                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 183                         decompressing.SetLength (20);
 184                 }
 185
 186                 [Test]
 187                 public void CheckGetCanSeekProp ()
 188                 {
 189                         MemoryStream backing = new MemoryStream (compressed_data);
 190                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 191                         Assert.IsFalse (decompress.CanSeek, "#A1");
 192                         Assert.IsTrue (backing.CanSeek, "#A2");
 193                         decompress.Dispose ();
 194                         Assert.IsFalse (decompress.CanSeek, "#A3");
 195                         Assert.IsFalse (backing.CanSeek, "#A4");
 196
 197                         backing = new MemoryStream ();
 198                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 199                         Assert.IsFalse (compress.CanSeek, "#B1");
 200                         Assert.IsTrue (backing.CanSeek, "#B2");
 201                         compress.Dispose ();
 202                         Assert.IsFalse (decompress.CanSeek, "#B3");
 203                         Assert.IsFalse (backing.CanSeek, "#B4");
 204                 }
 205
 206                 [Test]
 207                 public void CheckGetCanReadProp ()
 208                 {
 209                         MemoryStream backing = new MemoryStream (compressed_data);
 210                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 211                         Assert.IsTrue (decompress.CanRead, "#A1");
 212                         Assert.IsTrue (backing.CanRead, "#A2");
 213                         decompress.Dispose ();
 214                         Assert.IsFalse (decompress.CanRead, "#A3");
 215                         Assert.IsFalse (backing.CanRead, "#A4");
 216
 217                         backing = new MemoryStream ();
 218                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 219                         Assert.IsFalse (compress.CanRead, "#B1");
 220                         Assert.IsTrue (backing.CanRead, "#B2");
 221                         compress.Dispose ();
 222                         Assert.IsFalse (decompress.CanRead, "#B3");
 223                         Assert.IsFalse (backing.CanRead, "#B4");
 224                 }
 225
 226                 [Test]
 227                 public void CheckGetCanWriteProp ()
 228                 {
 229                         MemoryStream backing = new MemoryStream ();
 230                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 231                         Assert.IsFalse (decompress.CanWrite, "#A1");
 232                         Assert.IsTrue (backing.CanWrite, "#A2");
 233                         decompress.Dispose ();
 234                         Assert.IsFalse (decompress.CanWrite, "#A3");
 235                         Assert.IsFalse (backing.CanWrite, "#A4");
 236
 237                         backing = new MemoryStream ();
 238                         DeflateStream compress = new DeflateStream (backing, CompressionMode.Compress);
 239                         Assert.IsTrue (compress.CanWrite, "#B1");
 240                         Assert.IsTrue (backing.CanWrite, "#B2");
 241                         compress.Dispose ();
 242                         Assert.IsFalse (decompress.CanWrite, "#B3");
 243                         Assert.IsFalse (backing.CanWrite, "#B4");
 244                 }
 245
 246                 [Test]
 247                 [ExpectedException (typeof (NotSupportedException))]
 248                 public void CheckSetLengthProp ()
 249                 {
 250                         MemoryStream backing = new MemoryStream (compressed_data);
 251                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 252                         decompressing.SetLength (20);
 253                 }
 254
 255                 [Test]
 256                 [ExpectedException (typeof (NotSupportedException))]
 257                 public void CheckGetLengthProp ()
 258                 {
 259                         MemoryStream backing = new MemoryStream (compressed_data);
 260                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 261                         long length = decompressing.Length;
 262                 }
 263
 264                 [Test]
 265                 [ExpectedException (typeof (NotSupportedException))]
 266                 public void CheckGetPositionProp ()
 267                 {
 268                         MemoryStream backing = new MemoryStream (compressed_data);
 269                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 270                         long position = decompressing.Position;
 271                 }
 272
 273                 [Test]
 274                 public void DisposeTest ()
 275                 {
 276                         MemoryStream backing = new MemoryStream (compressed_data);
 277                         DeflateStream decompress = new DeflateStream (backing, CompressionMode.Decompress);
 278                         decompress.Dispose ();
 279                         decompress.Dispose ();
 280                 }
 281
 282                 static byte [] compressed_data = { 0xf3, 0x48, 0xcd, 0xc9, 0xc9,
 283                         0xe7, 0x02, 0x00 };
 284
 285
 286                 [Test]
 287                 public void JunkAtTheEnd ()
 288                 {
 289                         // Write a deflated stream, then some additional data...
 290                         using (MemoryStream ms = new MemoryStream())
 291                         {
 292                                 // The compressed stream
 293                                 using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Compress, true))
 294                                 {
 295                                         stream.WriteByte(1);
 296                                         stream.Flush();
 297                                 }
 298                                 // Junk
 299                                 ms.WriteByte(2);
 300
 301                                 ms.Position = 0;
 302                                 // Reading: this should not hang
 303                                 using (DeflateStream stream = new DeflateStream(ms, CompressionMode.Decompress))
 304                                 {
 305                                         byte[] buffer  = new byte[512];
 306                                         int len = stream.Read(buffer, 0, buffer.Length);
 307                                         Console.WriteLine(len == 1);
 308                                 }
 309                         }
 310                 }
 311
 312                 class Bug19313Stream : MemoryStream
 313                 {
 314                         public Bug19313Stream (byte [] buffer)
 315                                 : base (buffer)
 316                         {
 317                         }
 318
 319                         public override int Read (byte [] buffer, int offset, int count)
 320                         {
 321                                 // Thread was blocking when DeflateStream uses a NetworkStream.
 322                                 // Because the NetworkStream.Read calls Socket.Receive that
 323                                 // blocks the thread waiting for at least a byte to return.
 324                                 // This assert guarantees that Read is called only when there
 325                                 // is something to be read.
 326                                 Assert.IsTrue (Position < Length, "Trying to read empty stream.");
 327
 328                                 return base.Read (buffer, offset, count);
 329                         }
 330                 }
 331
 332                 [Test]
 333                 public void Bug19313 ()
 334                 {
 335                         byte [] buffer  = new byte [512];
 336                         using (var backing = new Bug19313Stream (compressed_data))
 337                         using (var decompressing = new DeflateStream (backing, CompressionMode.Decompress))
 338                                 decompressing.Read (buffer, 0, buffer.Length);
 339                 }
 340
 341                 public MemoryStream GenerateStreamFromString(string s)
 342                 {
 343                         return new MemoryStream (Encoding.UTF8.GetBytes (s));
 344                 }
 345
 346                 [Test]
 347                 public void CheckNet45Overloads () // Xambug #21982
 348                 {
 349                         MemoryStream dataStream = GenerateStreamFromString("Hello");
 350                         MemoryStream backing = new MemoryStream ();
 351                         DeflateStream compressing = new DeflateStream (backing, CompressionLevel.Fastest, true);
 352                         CopyStream (dataStream, compressing);
 353                         dataStream.Close();
 354                         compressing.Close();
 355
 356                         backing.Seek (0, SeekOrigin.Begin);
 357                         DeflateStream decompressing = new DeflateStream (backing, CompressionMode.Decompress);
 358                         StreamReader reader = new StreamReader (decompressing);
 359                         Assert.AreEqual ("Hello", reader.ReadLine ());
 360                         decompressing.Close();
 361                         backing.Close();
 362                 }
 363
 364                 [Test]
 365                 [ExpectedException (typeof (ArgumentException))]
 366                 public void CheckBufferOverrun ()
 367                 {
 368                         byte[] data = new byte [20];
 369                         MemoryStream backing = new MemoryStream ();
 370                         DeflateStream compressing = new DeflateStream (backing, CompressionLevel.Fastest, true);
 371                         compressing.Write (data, 0, data.Length + 1);
 372                         compressing.Close ();
 373                         backing.Close ();
 374                 }
 375
 376                 [Test]
 377                 public void Bug28777_EmptyFlush ()
 378                 {
 379                         MemoryStream backing = new MemoryStream ();
 380                         DeflateStream compressing = new DeflateStream (backing, CompressionLevel.Fastest, true);
 381                         compressing.Flush ();
 382                         compressing.Close ();
 383                         backing.Close ();
 384                 }
 385
 386                 [Test]
 387                 public void Bug28777_DoubleFlush ()
 388                 {
 389                         byte[] buffer = new byte [4096];
 390                         MemoryStream backing = new MemoryStream ();
 391                         DeflateStream compressing = new DeflateStream (backing, CompressionLevel.Fastest, true);
 392                         compressing.Write (buffer, 0, buffer.Length);
 393                         compressing.Flush ();
 394                         compressing.Flush ();
 395                         compressing.Close ();
 396                         backing.Close ();
 397                 }
 398
 399                 [Test]
 400                 public void Bug34916_Inflate ()
 401                 {
 402                         var base64String = @"H4sIAAAAAAAAA6yVu27bQBBF/4VtZGHeD3ZJmhTp5C5IIUiEIcCWDEUugiD/nmEQwYRNURFAsuFwd2exZ++d+farud89davT+um5aRsC1DuEO+R7lJayRV9m5gegFqBZNB83m5fjevOzadGWUPHjaXd62XYVEy3Z04wiMTKIX0dfV0G/6FO3Pu72D/+iL916W9GbOV/X58SaS6zEKKyoGUA1eNg/nLfF2jUEBBNMtT4Wzeq567Z9HkZkE1Osf93msN/+WO32m+7zsavsh30/BUU8fy+uUCC+QIHpPQW1RAXkEGWUmSnUy2iUYSMYOGpARYViiIHcqY5kExS8rg2vY8gLGEjeYsClBVE4ORQHz3kxsEF4iS01xzBIZkgYQcYQQ7C54LQaIrxWn5+4ioT1BiRQN8Fh6MrOPjOS9Eh3M8YRJJQMZioJkUODFA8RNJ9AYuYBNyGJW5D0oi3/EpZ3dWYk5X5PN81RJGJgDATMQ5X02nFS1imVlMGvu0XwBg5/K1hY1U8tecxcNDy1/FAnG+OAQSi9PliHRaNUiuoxQYFB6T8oyAUKEu9LJ6oipbr1spyZArhWX6qbi7EOUrs7SCAoDNVgzKagMlUz+q6DQ4N8/yM=";
 403
 404                         byte[] byteArray = Convert.FromBase64String(base64String);
 405                         string unZipped = null;
 406
 407                         using (var zippedMemoryStream = new MemoryStream (byteArray))
 408                         using (var gZipStream = new GZipStream (zippedMemoryStream, CompressionMode.Decompress))
 409                         using (var unzippedMemStream = new MemoryStream())
 410                         using (var unZippedStream = new StreamReader (gZipStream, Encoding.UTF8)) {
 411                                 unZipped = unZippedStream.ReadToEnd ();
 412                         }
 413
 414                         Assert.AreEqual(1877, unZipped.Length);
 415                 }
 416
 417                 [Test]
 418                 public void Bug44994_Inflate()
 419                 {
 420                         var base64String = @"7cWxCQAgDACwpeBjgqsgXiHU0fd9QzBLErX1EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADepcxcuU/atm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm3btm37zy8=";
 421
 422                         byte[] byteArray = Convert.FromBase64String(base64String);
 423                         string unZipped = null;
 424
 425                         using (var zippedMemoryStream = new MemoryStream(byteArray))
 426                         using (var gZipStream = new DeflateStream(zippedMemoryStream, CompressionMode.Decompress))
 427                         using (var unzippedMemStream = new MemoryStream())
 428                         using (var unZippedStream = new StreamReader(gZipStream, Encoding.UTF8))
 429                         {
 430                                 unZipped = unZippedStream.ReadToEnd();
 431                         }
 432
 433                         Assert.AreEqual(81942, unZipped.Length);
 434                 }
 435
 436                 [Test]
 437                 [Category ("MobileNotWorking")]
 438                 public void Bug44994_InflateByteByByte()
 439                 {
 440                         int byteCount = 0;
 441                         using (var fileStream = File.OpenRead(Path.Combine("Test", "compressed.bin")))
 442                         {
 443                                 using (var deflateStream = new DeflateStream(fileStream, CompressionMode.Decompress, false))
 444                                 {
 445                                         while (deflateStream.ReadByte() != -1)
 446                                         {
 447                                                 byteCount++;
 448                                         }
 449                                 }
 450                         }
 451
 452                         Assert.AreEqual(125387, byteCount);
 453                 }
 454         }
 455 }
 456
 457