public void BasicTest()
{
YEncEncoder encoder = new YEncEncoder();
string toEncode = "encode me";
byte[] source = System.Text.ASCIIEncoding.ASCII.GetBytes(toEncode);
byte[] dest = new byte[4096];
int numBytes = encoder.GetBytes(source, 0, source.Length, dest, 0, true);
Assert.IsTrue(numBytes != 0, "Should convert some bytes");
Assert.AreEqual(source.Length, numBytes, "No escaped chars, so should be the same length");
Assert.AreEqual(numBytes, encoder.GetByteCount(source, 0, source.Length, true),
"GetByteCount should return the same count as the actual encoding");
YEncDecoder decoder = new YEncDecoder();
Assert.AreEqual(source.Length, decoder.GetByteCount(dest, 0, numBytes, true),
"Should return same number of chars as original");
byte[] source2 = new byte[4096];
int numBytes2 = decoder.GetBytes(dest, 0, numBytes, source2, 0, true);
Assert.AreEqual(numBytes, numBytes2, "Should decode to the same number of chars");
string finalText = System.Text.ASCIIEncoding.ASCII.GetString(source2, 0, numBytes2);
Assert.AreEqual(toEncode, finalText, "Decoded back to original text");
// string result = System.Text.ASCIIEncoding.ASCII.GetString(bytes, 0, numBytes);
// System.Diagnostics.Debug.WriteLine(result);
}
public IEnumerable <string> Upload(byte[] buffer)
{
var yencEncoder = new YEncEncoder();
using (MemoryStream tmpStream = new MemoryStream(buffer.Length))
{
using (CryptoStream yencStream = new CryptoStream(tmpStream, yencEncoder, CryptoStreamMode.Write))
{
yencStream.Write(buffer, 0, buffer.Length);
tmpStream.Position = 0;
StreamReader sr = new StreamReader(tmpStream, System.Text.Encoding.GetEncoding("ISO-8859-1"));
#if YENC_HEADER_FOOTER
yield return($"=ybegin line=128 size={size} name={Cryptography.GetRandomBytes(8).ToHexString()}.blob");
#endif
while (sr.Peek() >= 0)
{
yield return(sr.ReadLine());
}
#if YENC_HEADER_FOOTER
yield return($"=yend size={size}");
#endif
}
}
}
public void FullByteRangeTest()
{
//writing
MemoryStream ms = new MemoryStream(); //this could be any stream we want to write to
YEncEncoder encoder = new YEncEncoder();
CryptoStream cs = new CryptoStream(ms, encoder, CryptoStreamMode.Write);
byte[] bytes = new byte[256];
for(int i=byte.MinValue; i<=byte.MaxValue; i++)
{
bytes[i] = (byte)i;
}
BinaryWriter w = new BinaryWriter(cs);
w.Write(bytes, 0, 256);
w.Flush();
cs.Flush();
//reading back from the memorystream
ms.Position = 0;
YEncDecoder decoder = new YEncDecoder();
CryptoStream cs2 = new CryptoStream(ms, decoder, CryptoStreamMode.Read);
BinaryReader r = new BinaryReader(cs2);
byte[] newBytes = r.ReadBytes(256);
Assert.AreEqual(BitConverter.ToString(bytes, 0, 256), BitConverter.ToString(newBytes, 0, 256));
}
public PostedFileInfo PostYEncFile(InntpMessagePoster poster, String prefix, String suffix)
{
PostedFileInfo postedFileInfo = new PostedFileInfo();
postedFileInfo.FromAddress = GetFromAddress(folderConfiguration.FromAddress);
String subjectNameBase = ConstructSubjectNameBase(prefix, suffix);
postedFileInfo.NzbSubjectName = String.Format(subjectNameBase, 1);
postedFileInfo.PostedGroups.AddRange(folderConfiguration.GetTargetNewsGroups());
postedFileInfo.PostedDateTime = DateTime.Now;
var yEncoder = new YEncEncoder();
Int32 partNumber = 0;
using (var fileStream = File.Open(FileMode.Open, FileAccess.Read, FileShare.Read))
{
while (fileStream.Position < fileStream.Length - 1) //If we have more blocks to encode.
{
partNumber++;
Byte[] partBuffer = new Byte[partSize];
Int32 partBufferPos = 0;
Int32 bytesRead = 0;
CRC32 partCRCCalculator = new CRC32();
var part = new YEncFilePart();
part.SourcefileName = File.Name;
part.Number = partNumber;
part.Begin = fileStream.Position + 1;
while (partBufferPos < partSize - 1 &&
(bytesRead = fileStream.Read(partBuffer, partBufferPos, partSize - partBufferPos)) > 0)
{
partBufferPos += bytesRead;
}
//TODO: this can be split in 2 threads to spread out CPU usage.
part.EncodedLines = yEncoder.EncodeBlock(configuration.YEncLineSize, partBuffer, 0, partBufferPos);
partCRCCalculator.TransformFinalBlock(partBuffer, 0, partBufferPos);
part.CRC32 = partCRCCalculator.HashAsHexString;
part.End = fileStream.Position;
PostPart(poster, postedFileInfo, part, subjectNameBase);
}
}
return(postedFileInfo);
}
public void BasicStringTest()
{
//writing
MemoryStream ms = new MemoryStream(); //this could be any stream we want to write to
YEncEncoder encoder = new YEncEncoder();
CryptoStream cs = new CryptoStream(ms, encoder, CryptoStreamMode.Write);
StreamWriter w = new StreamWriter(cs);
w.Write("Test string");
w.Flush();
cs.Flush();
//reading back from the memorystream
ms.Position = 0;
YEncDecoder decoder = new YEncDecoder();
CryptoStream cs2 = new CryptoStream(ms, decoder, CryptoStreamMode.Read);
StreamReader r = new StreamReader(cs2);
string finalText = r.ReadToEnd();
Assert.AreEqual("Test string", finalText);
}
public IEnumerable <string> Upload(int size, Stream inputStream)
{
var yencEncoder = new YEncEncoder();
var buffer = new byte[4096];
using (MemoryStream tmpStream = new MemoryStream((int)(inputStream.Length)))
{
using (CryptoStream yencStream = new CryptoStream(tmpStream, yencEncoder, CryptoStreamMode.Write))
{
int toRead = size;
inputStream.Position = 0;
for (int i = 0; i < toRead / buffer.Length; i++)
{
inputStream.Read(buffer, 0, buffer.Length);
yencStream.Write(buffer, 0, buffer.Length);
}
if (toRead % buffer.Length != 0)
{
inputStream.Read(buffer, 0, toRead % buffer.Length);
yencStream.Write(buffer, 0, toRead % buffer.Length);
}
tmpStream.Position = 0;
StreamReader sr = new StreamReader(tmpStream, System.Text.Encoding.GetEncoding("ISO-8859-1"));
#if YENC_HEADER_FOOTER
yield return($"=ybegin line=128 size={size} name={Cryptography.GetRandomBytes(8).ToHexString()}.blob");
#endif
while (sr.Peek() >= 0)
{
yield return(sr.ReadLine());
}
#if YENC_HEADER_FOOTER
yield return($"=yend size={size}");
#endif
}
}
}
public void BinaryTest()
{
//create a binary
const int sampleSize = 2000;
byte[] original = new byte[sampleSize];
new System.Random().NextBytes(original);
YEncEncoder encoder = new YEncEncoder();
byte[] encoded = new byte[4096];
int encodedBytes = encoder.GetBytes(original, 0, sampleSize, encoded, 0, true);
Assert.IsTrue(encodedBytes > sampleSize, "Should always be larger than original");
YEncDecoder decoder = new YEncDecoder();
byte[] decoded = new byte[4096];
int decodedBytes = decoder.GetBytes(encoded, 0, encodedBytes, decoded, 0, true);
Assert.AreEqual(sampleSize, decodedBytes, "Should decode back to the orginal length");
for(int i=0; i<sampleSize; i++)
{
Assert.AreEqual(original[i], decoded[i], "Each byte should match, failed on " + i.ToString());
}
}
public void NormalUsageTest()
{
//Test normal usage - encode to a file, then open the file and decode it.
const int sampleSize = 100000;
const int batchSize = 500;
const string sampleFileName = "encodedSample.BIN";
byte[] original = new byte[sampleSize];
new System.Random().NextBytes(original);
YEncEncoder encoder = new YEncEncoder();
FileStream fs = new FileStream
(sampleFileName, FileMode.Create, FileAccess.Write, FileShare.Write);
try
{
for (int i=0; i<sampleSize/batchSize; i++)
{
bool flush = false;
int startByte = i * batchSize;
if (startByte + batchSize == sampleSize)
flush = true;
int destSize = encoder.GetByteCount(original, startByte, batchSize, flush);
byte[] destBatch = new byte[destSize];
int bytesWritten = encoder.GetBytes(original, startByte, batchSize, destBatch, 0, flush);
Assert.AreEqual(destSize, bytesWritten, "GetGyteCount must return the same as GetBytes");
//here is where we would write off the batch to a file. Lets do that.
fs.Write(destBatch, 0, bytesWritten);
}
}
finally
{
fs.Close();
}
YEncDecoder decoder = new YEncDecoder();
FileStream fs2 = new FileStream
(sampleFileName, FileMode.Open, FileAccess.Read, FileShare.Read);
byte[] decoded = new byte[sampleSize]; //I have faith, it will be right :)
int destIndex = 0;
try
{
byte[] buffer = new byte[batchSize];
int bytesRead = fs2.Read(buffer, 0, batchSize);
while (bytesRead > 0)
{
int expectedBytes = decoder.GetByteCount(buffer, 0, bytesRead, false);
int decodedBytes = decoder.GetBytes(buffer, 0, bytesRead, decoded, destIndex, false);
Assert.AreEqual(expectedBytes, decodedBytes, "GetByteCount should return the same as GetBytes");
destIndex += decodedBytes;
bytesRead = fs2.Read(buffer, 0, batchSize);
}
decoder.GetBytes(new byte[0], 0, 0, decoded, destIndex, true); //force a flush
}
finally
{
fs2.Close();
File.Delete(sampleFileName);
}
//final checks
System.Diagnostics.Debug.WriteLine("original: " + BitConverter.ToString(new CRC32().ComputeHash(original, 0, sampleSize)));
System.Diagnostics.Debug.WriteLine("encoder: " + BitConverter.ToString(encoder.CRCHash));
System.Diagnostics.Debug.WriteLine("decoder: " + BitConverter.ToString(decoder.CRCHash));
Assert.AreEqual(BitConverter.ToString(new CRC32().ComputeHash(original)),
BitConverter.ToString(encoder.CRCHash),
"Encoder should match original hash");
Assert.AreEqual(BitConverter.ToString(new CRC32().ComputeHash(original)),
BitConverter.ToString(decoder.CRCHash),
"Decoder should match original hash");
Assert.AreEqual(BitConverter.ToString(encoder.CRCHash), BitConverter.ToString(decoder.CRCHash),
"The CRC32 hashes should match");
for(int i=0; i<sampleSize; i++)
{
Assert.AreEqual(original[i], decoded[i], "Final check failed at byte " + i.ToString());
}
}
public void SampleEncode()
{
FileStream fs = File.OpenRead(@"..\..\Samples\TestFile.bin");
try
{
byte[] original = new byte[4096];
int originalBytes = fs.Read(original, 0, 4096);
Assert.AreEqual(584, originalBytes, "Unexpected amount of bytes read.");
//test file encodes period(46) and tab(9), and follows with CRLF
YEncEncoder encoder = new YEncEncoder(128, new byte[] {46,9}, true);
byte[] encoded = new byte[4096];
int encodedBytes = encoder.GetBytes(original, 0, originalBytes, encoded, 0, true);
Assert.AreEqual(606, encodedBytes, "Test file supplied encodes to 606");
FileStream fs2 = File.OpenRead(@"..\..\Samples\Encoded.bin");
try
{
byte[] check = new byte[4096];
int checkBytes = fs2.Read(check, 0, 4096);
Assert.AreEqual(606, checkBytes, "We expect 606 bytes");
for(int i=0; i<checkBytes; i++)
{
Assert.AreEqual(check[i], encoded[i], "Checked against sample encoded failed on byte " + i.ToString());
}
CRC32 extraCheck = new CRC32();
extraCheck.ComputeHash(original, 0, originalBytes);
byte[] extraCheckCRC = extraCheck.Hash;
byte[] actualCRC = encoder.CRCHash;
byte[] expectedCRC = new byte[] {0xde,0xd2,0x9f,0x4f};
Assert.AreEqual(BitConverter.ToString(expectedCRC), BitConverter.ToString(extraCheckCRC), "CRC mismatch, due to CRC algorithm failure?");
Assert.AreEqual(BitConverter.ToString(expectedCRC), BitConverter.ToString(actualCRC), "CRC mismatch");
}
finally
{
fs2.Close();
}
}
finally
{
fs.Close();
}
}
