public void FileIsCopiedCorrectlyForNumberOfBitsBetween8And32()
        {
            var stopWatch = new Stopwatch();

            using (var fileReader = new FileReader(filePathSource, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathDestination, new Buffer()))
                {
                    stopWatch.Start();

                    while (!fileReader.ReachedEndOfFile)
                    {
                        var random       = new Random();
                        var numberOfBits = fileReader.BitsLeft < 32
                            ? (byte)fileReader.BitsLeft
                            : (byte)random.Next(8, 32);

                        var readStuff = fileReader.ReadBits(numberOfBits);

                        fileWriter.WriteValueOnBits(readStuff, numberOfBits);
                    }

                    stopWatch.Stop();
                }
            }
            Console.WriteLine($"File copying in '{TestMethods.GetCurrentMethodName()}' took {stopWatch.ElapsedMilliseconds} ms for {originalFileSizeInBytes} bytes");

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filePathSource, filePathDestination));
        }
        public void TestThatFileIsEncodedThenDecodedCorrectly(string fileTextContents)
        {
            TestMethods.CreateFileWithTextContents(filepathSource, fileTextContents);

            arithmeticEncoder.EncodeFile(filepathSource, filepathEncodedFile);
            arithmeticDecoder.DecodeFile(filepathEncodedFile, filepathDecodedFile);

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filepathSource, filepathDecodedFile));
        }
Esempio n. 3
0
        public void TestThatFileIsEncodedThenDecodedCorrectly2(NearLosslessPredictorType predictorType)
        {
            var filepathImage = $"{Environment.CurrentDirectory}\\Images\\Peppers256an.bmp";

            TestMethods.CopyFileAndReplaceIfAlreadyExists(filepathImage, filepathSource);

            encoder.Encode(filepathSource, filepathEncodedFile, GetOptions(predictorType));
            decoder.Decode(filepathEncodedFile, filepathDecodedFile);

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filepathSource, filepathDecodedFile));
        }
        public void FileIsCodedThenDecodedCorrectly3()
        {
            using (var fileReader = new FileReader(filePathSource, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathEncodedFile, new Buffer()))
                {
                    lzWEncoder.EncodeFile(fileReader, fileWriter, OnFullDictionaryOption.Empty, 9);
                }
            }

            using (var fileReader = new FileReader(filePathEncodedFile, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathDecodedFile, new Buffer()))
                {
                    lzWDecoder.DecodeFile(fileReader, fileWriter);
                }
            }

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filePathSource, filePathDecodedFile));
        }
        public void FileIsEncryptedThenDecryptedCorrectly()
        {
            using (var fileReader = new FileReader(filePathSource, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathEncryptedFile, new Buffer()))
                {
                    rsaEncrypter.EncryptFile(fileReader, fileWriter, Constants.N, Constants.E);
                }
            }

            using (var fileReader = new FileReader(filePathEncryptedFile, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathDecryptedFile, new Buffer()))
                {
                    rsaDecrypter.DecryptFile(fileReader, fileWriter, Constants.D);
                }
            }

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filePathSource, filePathDecryptedFile));
        }
        public void ImageIsEncodedThenDecodedCorrectly()
        {
            using (var fileReader = new FileReader(filePathSource, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathEncodedFile, new Buffer()))
                {
                    huffmanEncoder.EncodeFile(fileReader, fileWriter);
                    fileWriter.Buffer.Flush();
                }
            }

            using (var fileReader = new FileReader(filePathEncodedFile, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathDecodedFile, new Buffer()))
                {
                    huffmanDecoder.DecodeFile(fileReader, fileWriter);
                }
            }

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filePathSource, filePathDecodedFile));
        }
Esempio n. 7
0
        public void ImageIsEncodedThenDecodedCorrectlyWithImagePredictor2()
        {
            var imagePredictor = new ImagePredictor2();

            using (var fileReader = new FileReader(filePathSource, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathEncodedFile, new Buffer()))
                {
                    imagePredictionEncoder.EncodeImage(fileReader, fileWriter, imagePredictor);
                }
            }

            using (var fileReader = new FileReader(filePathEncodedFile, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathDecodedFile, new Buffer()))
                {
                    imagePredictionDecoder.DecodeImage(fileReader, fileWriter);
                }
            }

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filePathSource, filePathDecodedFile));
        }
        public void FileIsEncodedThenDecodedCorrectly3()
        {
            TestMethods.CreateBmpFileFromImage(filePathSource, Resources.capture);

            using (var fileReader = new FileReader(filePathSource, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathEncodedFile, new Buffer()))
                {
                    lz77Encoder.EncodeFile(fileReader, fileWriter, Constants.BitsForOffset1, Constants.BitsForLength1);
                }
            }

            using (var fileReader = new FileReader(filePathEncodedFile, new Buffer()))
            {
                using (var fileWriter = new FileWriter(filePathDecodedFile, new Buffer()))
                {
                    lz77Decoder.DecodeFile(fileReader, fileWriter);
                }
            }

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filePathSource, filePathDecodedFile));
        }
        public void TestThatFileIsCopiedCorrectlyForNumberOfBitsBetween8And32(string fileTextContents)
        {
            TestMethods.CreateFileWithTextContents(filepathSource, fileTextContents);
            var random = new Random();

            fileReader.Open(filepathSource);
            fileWriter.Open(filepathDestination);

            while (!fileReader.ReachedEndOfFile)
            {
                var numberOfBits = fileReader.BitsLeft < 32
                    ? (byte)fileReader.BitsLeft
                    : (byte)random.Next(8, 32);

                var readStuff = fileReader.ReadBits(numberOfBits);
                fileWriter.WriteValueOnBits(readStuff, numberOfBits);
            }

            fileReader.Close();
            fileWriter.Close();

            Assert.IsTrue(TestMethods.FilesHaveTheSameContent(filepathSource, filepathDestination));
        }