Imports System
Imports System.IO
Imports System.IO.Compression



Public Class GZipTest
    Shared msg As String
    Private Const buffer_size As Integer = 100

    Public Shared Function ReadAllBytesFromStream(ByVal stream As Stream, ByVal buffer() As Byte) As Integer
        ' Use this method is used to read all bytes from a stream.
        Dim offset As Integer = 0
        Dim totalCount As Integer = 0
        While True
            Dim bytesRead As Integer = stream.Read(buffer, offset, buffer_size)
            If bytesRead = 0 Then
                Exit While
            End If
            offset += bytesRead
            totalCount += bytesRead
        End While
        Return totalCount
    End Function 'ReadAllBytesFromStream


    Public Shared Function CompareData(ByVal buf1() As Byte, ByVal len1 As Integer, ByVal buf2() As Byte, ByVal len2 As Integer) As Boolean
        ' Use this method to compare data from two different buffers.
        If len1 <> len2 Then
            msg = "Number of bytes in two buffer are different" & len1 & ":" & len2
            MsgBox(msg)
            Return False
        End If

        Dim i As Integer
        For i = 0 To len1 - 1
            If buf1(i) <> buf2(i) Then
                msg = "byte " & i & " is different " & buf1(i) & "|" & buf2(i)
                MsgBox(msg)
                Return False
            End If
        Next i
        msg = "All bytes compare."
        MsgBox(msg)
        Return True
    End Function 'CompareData


    Public Shared Sub GZipCompressDecompress(ByVal filename As String)
        msg = "Test compression and decompression on file " & filename
        MsgBox(msg)

        Dim infile As FileStream
        Try
            ' Open the file as a FileStream object.
            infile = New FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read)
            Dim buffer(infile.Length - 1) As Byte
            ' Read the file to ensure it is readable.
            Dim count As Integer = infile.Read(buffer, 0, buffer.Length)
            If count <> buffer.Length Then
                infile.Close()
                msg = "Test Failed: Unable to read data from file"
                MsgBox(msg)
                Return
            End If
            infile.Close()
            Dim ms As New MemoryStream()
            ' Use the newly created memory stream for the compressed data.
            Dim compressedzipStream As New GZipStream(ms, CompressionMode.Compress, True)
            compressedzipStream.Write(buffer, 0, buffer.Length)
            ' Close the stream.
            compressedzipStream.Close()

            msg = "Original size: " & buffer.Length & ", Compressed size: " & ms.Length
            MsgBox(msg)

            ' Reset the memory stream position to begin decompression.
            ms.Position = 0
            Dim zipStream As New GZipStream(ms, CompressionMode.Decompress)
            Dim decompressedBuffer(buffer.Length + buffer_size) As Byte
            ' Use the ReadAllBytesFromStream to read the stream.
            Dim totalCount As Integer = GZipTest.ReadAllBytesFromStream(zipStream, decompressedBuffer)
            msg = "Decompressed " & totalCount & " bytes"
            MsgBox(msg)

            If Not GZipTest.CompareData(buffer, buffer.Length, decompressedBuffer, totalCount) Then
                msg = "Error. The two buffers did not compare."
                MsgBox(msg)

            End If
            zipStream.Close()
        Catch e As Exception
            msg = "Error: The file being read contains invalid data."
            MsgBox(msg)
        End Try

    End Sub 'GZipCompressDecompress

    Public Shared Sub Main(ByVal args() As String)
        Dim usageText As String = "Usage: GZIPTEST <inputfilename>"
        'If no file name is specified, write usage text.
        If args.Length = 0 Then
            Console.WriteLine(usageText)
        Else
            If File.Exists(args(0)) Then
                GZipCompressDecompress(args(0))
            End If
        End If
    End Sub 'Main
End Class 'GZipTest 

using System;
using System.IO;
using System.IO.Compression;

public class GZipTest
{
    private const int buffer_size = 100;

    public static int ReadAllBytesFromStream(Stream stream, byte[] buffer)
    {
        // Use this method is used to read all bytes from a stream.
        int offset = 0;
        int totalCount = 0;
        while (true)
        {
            int bytesRead = stream.Read(buffer, offset, buffer_size);
            if (bytesRead == 0)
            {
                break;
            }
            offset += bytesRead;
            totalCount += bytesRead;
        }
        return totalCount;
    }

    public static bool CompareData(byte[] buf1, int len1, byte[] buf2, int len2)
    {
        // Use this method to compare data from two different buffers.
        if (len1 != len2)
        {
            Console.WriteLine("Number of bytes in two buffer are different {0}:{1}", len1, len2);
            return false;
        }

        for (int i = 0; i < len1; i++)
        {
            if (buf1[i] != buf2[i])
            {
                Console.WriteLine("byte {0} is different {1}|{2}", i, buf1[i], buf2[i]);
                return false;
            }
        }
        Console.WriteLine("All bytes compare.");
        return true;
    }

    public static void GZipCompressDecompress(string filename)
    {
        Console.WriteLine("Test compression and decompression on file {0}", filename);
        FileStream infile;
        try
        {
            // Open the file as a FileStream object.
            infile = new FileStream(filename, FileMode.Open, FileAccess.Read, FileShare.Read);
            byte[] buffer = new byte[infile.Length];
            // Read the file to ensure it is readable.
            int count = infile.Read(buffer, 0, buffer.Length);
            if (count != buffer.Length)
            {
                infile.Close();
                Console.WriteLine("Test Failed: Unable to read data from file");
                return;
            }
            infile.Close();
            MemoryStream ms = new MemoryStream();
            // Use the newly created memory stream for the compressed data.
            GZipStream compressedzipStream = new GZipStream(ms, CompressionMode.Compress, true);
            Console.WriteLine("Compression");
            compressedzipStream.Write(buffer, 0, buffer.Length);
            // Close the stream.
            compressedzipStream.Close();
            Console.WriteLine("Original size: {0}, Compressed size: {1}", buffer.Length, ms.Length);

            // Reset the memory stream position to begin decompression.
            ms.Position = 0;
            GZipStream zipStream = new GZipStream(ms, CompressionMode.Decompress);
            Console.WriteLine("Decompression");
            byte[] decompressedBuffer = new byte[buffer.Length + buffer_size];
            // Use the ReadAllBytesFromStream to read the stream.
            int totalCount = GZipTest.ReadAllBytesFromStream(zipStream, decompressedBuffer);
            Console.WriteLine("Decompressed {0} bytes", totalCount);

            if (!GZipTest.CompareData(buffer, buffer.Length, decompressedBuffer, totalCount))
            {
                Console.WriteLine("Error. The two buffers did not compare.");
            }
            zipStream.Close();
        } // end try
        catch (InvalidDataException)
        {
            Console.WriteLine("Error: The file being read contains invalid data.");
        }
        catch (FileNotFoundException)
        {
            Console.WriteLine("Error:The file specified was not found.");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("Error: path is a zero-length string, contains only white space, or contains one or more invalid characters");
        }
        catch (PathTooLongException)
        {
            Console.WriteLine("Error: The specified path, file name, or both exceed the system-defined maximum length. For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters.");
        }
        catch (DirectoryNotFoundException)
        {
            Console.WriteLine("Error: The specified path is invalid, such as being on an unmapped drive.");
        }
        catch (IOException)
        {
            Console.WriteLine("Error: An I/O error occurred while opening the file.");
        }
        catch (UnauthorizedAccessException)
        {
            Console.WriteLine("Error: path specified a file that is read-only, the path is a directory, or caller does not have the required permissions.");
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("Error: You must provide parameters for MyGZIP.");
        }
    }

    public static void Main(string[] args)
    {
        string usageText = "Usage: MYGZIP <inputfilename>";
        //If no file name is specified, write usage text.
        if (args.Length == 0)
        {
            Console.WriteLine(usageText);
        }
        else
        {
            if (File.Exists(args[0]))
                GZipCompressDecompress(args[0]);
        }
    }
}
    

#using <System.dll>

using namespace System;
using namespace System::IO;
using namespace System::IO::Compression;
int ReadAllBytesFromStream( Stream^ stream, array<Byte>^buffer )
{

   // Use this method is used to read all bytes from a stream.
   int offset = 0;
   int totalCount = 0;
   for ( ; ;  )
   {
      int bytesRead = stream->Read( buffer, offset, 100 );
      if ( bytesRead == 0 )
      {
         break;
      }

      offset += bytesRead;
      totalCount += bytesRead;

   }
   return totalCount;
}

bool CompareData( array<Byte>^buf1, int len1, array<Byte>^buf2, int len2 )
{

   // Use this method to compare data from two different buffers.
   if ( len1 != len2 )
   {
      Console::WriteLine( "Number of bytes in two buffer are different {0}:{1}", len1, len2 );
      return false;
   }

   for ( int i = 0; i < len1; i++ )
   {
      if ( buf1[ i ] != buf2[ i ] )
      {
         Console::WriteLine( "byte {0} is different {1}|{2}", i, buf1[ i ], buf2[ i ] );
         return false;
      }

   }
   Console::WriteLine( "All bytes compare." );
   return true;
}

void GZipCompressDecompress( String^ filename )
{
   Console::WriteLine( "Test compression and decompression on file {0}", filename );
   FileStream^ infile;
   try
   {

      // Open the file as a FileStream object.
      infile = gcnew FileStream( filename,FileMode::Open,FileAccess::Read,FileShare::Read );
      array<Byte>^buffer = gcnew array<Byte>((int)infile->Length);

      // Read the file to ensure it is readable.
      int count = infile->Read( buffer, 0, buffer->Length );
      if ( count != buffer->Length )
      {
         infile->Close();
         Console::WriteLine( "Test Failed: Unable to read data from file" );
         return;
      }
      infile->Close();
      MemoryStream^ ms = gcnew MemoryStream;

      // Use the newly created memory stream for the compressed data.
      GZipStream ^ compressedzipStream = gcnew GZipStream( ms,CompressionMode::Compress,true );
      Console::WriteLine( "Compression" );
      compressedzipStream->Write( buffer, 0, buffer->Length );

      // Close the stream.
      compressedzipStream->Close();
      Console::WriteLine( "Original size: {0}, Compressed size: {1}", buffer->Length, ms->Length );

      // Reset the memory stream position to begin decompression.
      ms->Position = 0;
      GZipStream ^ zipStream = gcnew GZipStream( ms,CompressionMode::Decompress );
      Console::WriteLine( "Decompression" );
      array<Byte>^decompressedBuffer = gcnew array<Byte>(buffer->Length + 100);

      // Use the ReadAllBytesFromStream to read the stream.
      int totalCount = ReadAllBytesFromStream( zipStream, decompressedBuffer );
      Console::WriteLine( "Decompressed {0} bytes", totalCount );
      if (  !CompareData( buffer, buffer->Length, decompressedBuffer, totalCount ) )
      {
         Console::WriteLine( "Error. The two buffers did not compare." );
      }
      zipStream->Close();
   }
   catch ( InvalidDataException ^ ) 
   {
      Console::WriteLine( "Error: The file being read contains invalid data." );
   }
   catch ( FileNotFoundException^ ) 
   {
      Console::WriteLine( "Error:The file specified was not found." );
   }
   catch ( ArgumentException^ ) 
   {
      Console::WriteLine( "Error: path is a zero-length string, contains only white space, or contains one or more invalid characters" );
   }
   catch ( PathTooLongException^ ) 
   {
      Console::WriteLine( "Error: The specified path, file name, or both exceed the system-defined maximum length."
      " For example, on Windows-based platforms, paths must be less than 248 characters, and file names must be less than 260 characters." );
   }
   catch ( DirectoryNotFoundException^ ) 
   {
      Console::WriteLine( "Error: The specified path is invalid, such as being on an unmapped drive." );
   }
   catch ( IOException^ ) 
   {
      Console::WriteLine( "Error: An I/O error occurred while opening the file." );
   }
   catch ( UnauthorizedAccessException^ ) 
   {
      Console::WriteLine( "Error: path specified a file that is read-only, the path is a directory, or caller does not have the required permissions." );
   }
   catch ( IndexOutOfRangeException^ ) 
   {
      Console::WriteLine( "Error: You must provide parameters for MyGZIP." );
   }

}

int main()
{
   array<String^>^args = Environment::GetCommandLineArgs();
   String^ usageText = "Usage: MYGZIP <inputfilename>";

   //If no file name is specified, write usage text.
   if ( args->Length == 1 )
   {
      Console::WriteLine( usageText );
   }
   else
   {
      if ( File::Exists( args[ 1 ] ) )
            GZipCompressDecompress( args[ 1 ] );
   }
}

import System.*;
import System.IO.*;
import System.IO.Compression.*;

public class GZipTest
{
    public static int ReadAllBytesFromStream(Stream stream, ubyte buffer[])
    {
        // Use this method is used to read all bytes from a stream.
        int offSet = 0;
        int totalCount = 0;
        while (true) {
            int bytesRead = stream.Read(buffer, offSet, 100);
            if (bytesRead == 0) {
                break;
            }
            offSet += bytesRead;
            totalCount += bytesRead;
        }
        return totalCount;
    } //ReadAllBytesFromStream

    public static boolean CompareData(ubyte buf1[], int len1, 
        ubyte buf2[], int len2)
    {
        // Use this method to compare data from two different buffers.
        if (len1 != len2) {
            Console.WriteLine("Number of bytes in two buffer are "
                + "different {0}:{1}", System.Convert.ToString(len1), 
                System.Convert.ToString(len2));
            return false;
        }
        for (int i = 0; i < len1; i++) {
            if (!(buf1.get_Item(i).Equals(buf2.get_Item(i)))) {
                Console.WriteLine("byte {0} is different {1}|{2}", 
                    System.Convert.ToString(i), 
                    System.Convert.ToString(buf1.get_Item(i)), 
                    System.Convert.ToString(buf2.get_Item(i)));
                return false;
            }
        }
        Console.WriteLine("All bytes compare.");
        return true;
    } //CompareData

    public static void GZipCompressDecompress(String fileName)
    {
        Console.WriteLine("Test compression and decompression on file {0}",
            fileName);
        FileStream inFile;
        try {
            // Open the file as a FileStream object.
            inFile = new FileStream(fileName, FileMode.Open, 
                FileAccess.Read, FileShare.Read);
            ubyte buffer[] = new ubyte[(ubyte)inFile.get_Length()];

            // Read the file to ensure it is readable.
            int count = inFile.Read(buffer, 0, buffer.length);
            if (count != buffer.length) {
                inFile.Close();
                Console.WriteLine("Test Failed: Unable to read data from file");
                return;
            }
            inFile.Close();
            MemoryStream ms = new MemoryStream();

            // Use the newly created memory stream for the compressed data.
            GZipStream compressedZipStream = 
                new GZipStream(ms, CompressionMode.Compress, true);
            Console.WriteLine("Compression");
            compressedZipStream.Write(buffer, 0, buffer.length);

            // Close the stream.
            compressedZipStream.Close();
            Console.WriteLine("Original size: {0}, Compressed size: {1}", 
                System.Convert.ToString(buffer.length), 
                System.Convert.ToString(ms.get_Length()));

            // Reset the memory stream position to begin decompression.
            ms.set_Position(0);
            GZipStream zipStream = 
                new GZipStream(ms, CompressionMode.Decompress);
            Console.WriteLine("Decompression");
            ubyte decompressedBuffer[] = new ubyte[buffer.length + 100];

            // Use the ReadAllBytesFromStream to read the stream.
            int totalCount = GZipTest.ReadAllBytesFromStream(zipStream, 
                decompressedBuffer);
            Console.WriteLine("Decompressed {0} bytes", 
                System.Convert.ToString(totalCount));
            if (!(GZipTest.CompareData(buffer, buffer.length, 
                decompressedBuffer, totalCount))) {
                Console.WriteLine("Error. The two buffers did not compare.");
            }
            zipStream.Close();
        } 
        catch (InvalidDataException exp) {
            Console.WriteLine("Error: The file being read contains"
                + " invalid data.");
        }
        catch (FileNotFoundException exp) {
            Console.WriteLine("Error:The file specified was not found.");
        }
        catch (ArgumentException exp) {
            Console.WriteLine("Error: path is a zero-length string, contains "
                + "only white space, or contains one or more invalid characters");
        }
        catch (PathTooLongException exp) {
            Console.WriteLine("Error: The specified path, file name, or both "
                + "exceed the system-defined maximum length. For example, on"
                + " Windows-based platforms, paths must be less than 248 "
                + "characters, and file names must be less than 260 characters.");
        }
        catch (DirectoryNotFoundException exp) {
            Console.WriteLine("Error: The specified path is invalid, such"
                + " as being on an unmapped drive.");
        }
        catch (IOException exp) {
            Console.WriteLine("Error: An I/O error occurred while "
                + "opening the file.");
        }
        catch (UnauthorizedAccessException exp) {
            Console.WriteLine("Error: path specified a file that is read-only,"
                + " the path is a directory, or caller does not have"
                + " the required permissions.");
        }
        catch (IndexOutOfRangeException exp) {
            Console.WriteLine("Error: You must provide parameters for MyGZIP.");
        }
    } //GZipCompressDecompress

    public static void main(String[] args)
    {
        String usageText = "Usage: MYGZIP <inputfilename>";

        //If no file name is specified, write usage text.
        if (args.length == 0) {
            Console.WriteLine(usageText);
        }
        else {
            if (File.Exists(args[0])) {
                GZipCompressDecompress(args[0]);
            }
        }
    } //main
} //GZipTest