// Copyright (C) 2004 Novell (http://www.novell.com)
//
-using NUnit.Framework;
using System;
using System.IO;
using System.Text;
+using System.Threading.Tasks;
+
+using NUnit.Framework;
namespace MonoTests.System.IO
{
-
[TestFixture]
-public class StreamReaderTest : Assertion
+public class StreamReaderTest
{
static string TempFolder = Path.Combine (Path.GetTempPath (), "MonoTests.System.IO.Tests");
private string _codeFileName = TempFolder + Path.DirectorySeparatorChar + "AFile.txt";
+ private const string TestString = "Hello World!";
[SetUp]
- public void SetUp ()
+ public void SetUp ()
{
- if (!Directory.Exists (TempFolder))
+ if (!Directory.Exists (TempFolder))
Directory.CreateDirectory (TempFolder);
if (!File.Exists (_codeFileName))
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader((Stream)null);
+ new StreamReader((Stream)null);
} catch (ArgumentNullException) {
errorThrown = true;
}
- Assert("null string error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "null string error not thrown");
}
{
bool errorThrown = false;
errorThrown = true;
}
f.Close();
- Assert("no read error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "no read error not thrown");
}
{
// this is probably incestuous, but, oh well.
FileMode.Open,
FileAccess.Read);
StreamReader r = new StreamReader(f);
- AssertNotNull("no stream reader", r);
+ Assert.IsNotNull (r, "no stream reader");
r.Close();
f.Close();
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader("");
+ new StreamReader("");
} catch (ArgumentException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 1: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 1: " + e.ToString());
}
- Assert("empty string error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "empty string error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader((string)null);
+ new StreamReader((string)null);
} catch (ArgumentNullException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 2: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 2: " + e.ToString());
}
- Assert("null string error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "null string error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader("nonexistentfile");
+ new StreamReader("nonexistentfile");
} catch (FileNotFoundException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 3: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 3: " + e.ToString());
}
- Assert("fileNotFound error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "fileNotFound error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader("nonexistentdir/file");
+ new StreamReader("nonexistentdir/file");
} catch (DirectoryNotFoundException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 4: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 4: " + e.ToString());
}
- Assert("dirNotFound error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "dirNotFound error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0]);
+ new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0]);
} catch (IOException) {
errorThrown = true;
} catch (ArgumentException) {
// compiler says 'ArgExc'...
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 5: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 5: " + e.ToString());
}
- Assert("invalid filename error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "invalid filename error not thrown");
}
{
// this is probably incestuous, but, oh well.
StreamReader r = new StreamReader(_codeFileName);
- AssertNotNull("no stream reader", r);
+ Assert.IsNotNull (r, "no stream reader");
r.Close();
}
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader((Stream)null, false);
+ new StreamReader((Stream)null, false);
} catch (ArgumentNullException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 1: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 1: " + e.ToString());
}
- Assert("null stream error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "null stream error not thrown");
}
{
bool errorThrown = false;
} catch (ArgumentException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 2: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 2: " + e.ToString());
}
f.Close();
- Assert("no read error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "no read error not thrown");
}
{
// this is probably incestuous, but, oh well.
FileMode.Open,
FileAccess.Read);
StreamReader r = new StreamReader(f, false);
- AssertNotNull("no stream reader", r);
+ Assert.IsNotNull (r, "no stream reader");
r.Close();
f.Close();
}
} catch (ArgumentNullException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 3: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 3: " + e.ToString());
}
- Assert("null string error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "null string error not thrown");
}
{
bool errorThrown = false;
} catch (ArgumentException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 4: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 4: " + e.ToString());
}
f.Close();
- Assert("no read error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "no read error not thrown");
}
{
// this is probably incestuous, but, oh well.
FileMode.Open,
FileAccess.Read);
StreamReader r = new StreamReader(f, true);
- AssertNotNull("no stream reader", r);
+ Assert.IsNotNull (r, "no stream reader");
r.Close();
f.Close();
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader("", false);
+ new StreamReader("", false);
} catch (ArgumentException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 1: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 1: " + e.ToString());
}
- Assert("empty string error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "empty string error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader((string)null, false);
+ new StreamReader((string)null, false);
} catch (ArgumentNullException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 2: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 2: " + e.ToString());
}
- Assert("null string error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "null string error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader(TempFolder + "/nonexistentfile", false);
+ new StreamReader(TempFolder + "/nonexistentfile", false);
} catch (FileNotFoundException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 3: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 3: " + e.ToString());
}
- Assert("fileNotFound error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "fileNotFound error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader(TempFolder + "/nonexistentdir/file", false);
+ new StreamReader(TempFolder + "/nonexistentdir/file", false);
} catch (DirectoryNotFoundException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 4: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 4: " + e.ToString());
}
- Assert("dirNotFound error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "dirNotFound error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0], false);
+ new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0], false);
} catch (IOException) {
errorThrown = true;
} catch (ArgumentException) {
// compiler says 'ArgExc'...
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 5: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 5: " + e.ToString());
}
- Assert("invalid filename error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "invalid filename error not thrown");
}
{
// this is probably incestuous, but, oh well.
StreamReader r = new StreamReader(_codeFileName, false);
- AssertNotNull("no stream reader", r);
+ Assert.IsNotNull (r, "no stream reader");
r.Close();
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader("", true);
+ new StreamReader("", true);
} catch (ArgumentException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 6: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 6: " + e.ToString());
}
- Assert("empty string error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "empty string error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader((string)null, true);
+ new StreamReader((string)null, true);
} catch (ArgumentNullException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 7: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 7: " + e.ToString());
}
- Assert("null string error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "null string error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader(TempFolder + "/nonexistentfile", true);
+ new StreamReader(TempFolder + "/nonexistentfile", true);
} catch (FileNotFoundException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 8: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 8: " + e.ToString());
}
- Assert("fileNotFound error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "fileNotFound error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader(TempFolder + "/nonexistentdir/file", true);
+ new StreamReader(TempFolder + "/nonexistentdir/file", true);
} catch (DirectoryNotFoundException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 9: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 9: " + e.ToString());
}
- Assert("dirNotFound error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "dirNotFound error not thrown");
}
{
bool errorThrown = false;
try {
- StreamReader r = new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0], true);
+ new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0], true);
} catch (IOException) {
errorThrown = true;
} catch (ArgumentException) {
// compiler says 'ArgExc'...
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 10: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 10: " + e.ToString());
}
- Assert("invalid filename error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "invalid filename error not thrown");
}
{
// this is probably incestuous, but, oh well.
StreamReader r = new StreamReader(_codeFileName, true);
- AssertNotNull("no stream reader", r);
+ Assert.IsNotNull (r, "no stream reader");
r.Close();
}
}
[Test]
public void TestBaseStream() {
- string progress = "beginning";
- try {
- Byte[] b = {};
- MemoryStream m = new MemoryStream(b);
- StreamReader r = new StreamReader(m);
- AssertEquals("wrong base stream ", m, r.BaseStream);
- progress = "Closing StreamReader";
- r.Close();
- progress = "Closing MemoryStream";
- m.Close();
- } catch (Exception e) {
- Fail ("At '" + progress + "' an unexpected exception was thrown: " + e.ToString());
- }
+ Byte[] b = {};
+ MemoryStream m = new MemoryStream(b);
+ StreamReader r = new StreamReader(m);
+ Assert.AreSame (m, r.BaseStream, "wrong base stream ");
+ r.Close();
+ m.Close();
}
- public void TestCurrentEncoding() {
- try {
- Byte[] b = {};
- MemoryStream m = new MemoryStream(b);
- StreamReader r = new StreamReader(m);
- AssertEquals("wrong encoding",
- Encoding.UTF8.GetType (), r.CurrentEncoding.GetType ());
- } catch (Exception e) {
- Fail ("Unexpected exception thrown: " + e.ToString());
- }
+ public void TestCurrentEncoding()
+ {
+ Byte[] b = {};
+ MemoryStream m = new MemoryStream(b);
+ StreamReader r = new StreamReader(m);
+ Assert.AreSame (Encoding.UTF8, r.CurrentEncoding, "wrong encoding");
}
// TODO - Close - annoying spec - won't commit to any exceptions. How to test?
[Test]
public void TestPeek() {
// FIXME - how to get an IO Exception?
- {
- bool errorThrown = false;
- try {
- Byte[] b = {};
- MemoryStream m = new MemoryStream(b);
- StreamReader r = new StreamReader(m);
- m.Close();
- int nothing = r.Peek();
- } catch (ObjectDisposedException) {
- errorThrown = true;
- }
- Assert("nothing-to-peek-at error not thrown", errorThrown);
+ Byte [] b;
+ MemoryStream m;
+ StreamReader r;
+
+ try {
+ b = new byte [0];
+ m = new MemoryStream (b);
+ r = new StreamReader(m);
+ m.Close();
+ int nothing = r.Peek();
+ Assert.Fail ("#1");
+ } catch (ObjectDisposedException) {
}
- {
- Byte[] b = {1, 2, 3, 4, 5, 6};
- MemoryStream m = new MemoryStream(b);
-
- StreamReader r = new StreamReader(m);
- for (int i = 1; i <= 6; i++) {
- AssertEquals("peek incorrect", i, r.Peek());
- r.Read();
- }
- AssertEquals("should be none left", -1, r.Peek());
+
+ b = new byte [] {1, 2, 3, 4, 5, 6};
+ m = new MemoryStream (b);
+ r = new StreamReader(m);
+ for (int i = 1; i <= 6; i++) {
+ Assert.AreEqual (i, r.Peek(), "#2");
+ r.Read();
}
+ Assert.AreEqual (-1, r.Peek(), "#3");
}
[Test]
} catch (ObjectDisposedException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 1: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 1: " + e.ToString());
}
- Assert("nothing-to-read error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "nothing-to-read error not thrown");
}
{
Byte[] b = {1, 2, 3, 4, 5, 6};
StreamReader r = new StreamReader(m);
for (int i = 1; i <= 6; i++) {
- AssertEquals("read incorrect", i, r.Read());
+ Assert.AreEqual (i, r.Read (), "read incorrect");
}
- AssertEquals("Should be none left", -1, r.Read());
+ Assert.AreEqual (-1, r.Read (), "Should be none left");
}
{
} catch (ArgumentException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 2: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 2: " + e.ToString());
}
- Assert("null buffer error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "null buffer error not thrown");
}
{
bool errorThrown = false;
} catch (ArgumentException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 3: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 3: " + e.ToString());
}
- Assert("too-long range error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "too-long range error not thrown");
}
{
bool errorThrown = false;
} catch (ArgumentOutOfRangeException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 4: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 4: " + e.ToString());
}
- Assert("out of range error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "out of range error not thrown");
}
{
bool errorThrown = false;
} catch (ArgumentOutOfRangeException) {
errorThrown = true;
} catch (Exception e) {
- Fail ("Incorrect exception thrown at 5: " + e.ToString());
+ Assert.Fail ("Incorrect exception thrown at 5: " + e.ToString());
}
- Assert("out of range error not thrown", errorThrown);
+ Assert.IsTrue (errorThrown, "out of range error not thrown");
}
{
int ii = 1;
r.Read(buffer, 0, 1);
ii++;
for (int i = 0; i < target.Length; i++) {
- AssertEquals("read no work",
- target[i], buffer[i]);
+ Assert.AreEqual (target[i], buffer[i], "read no work");
i++;
}
-
} catch (Exception e) {
- Fail ("Caught when ii=" + ii + ". e:" + e.ToString());
+ Assert.Fail ("Caught when ii=" + ii + ". e:" + e.ToString());
}
}
}
b[7] = (byte)'\n';
MemoryStream m = new MemoryStream(b);
StreamReader r = new StreamReader(m);
- AssertEquals("line doesn't match", "a", r.ReadLine());
- AssertEquals("line doesn't match", "b", r.ReadLine());
- AssertEquals("line doesn't match", "c", r.ReadLine());
- AssertEquals("line doesn't match", "d", r.ReadLine());
- AssertEquals("line doesn't match", null, r.ReadLine());
+ Assert.AreEqual ("a", r.ReadLine(), "#1");
+ Assert.AreEqual ("b", r.ReadLine (), "#2");
+ Assert.AreEqual ("c", r.ReadLine (), "#3");
+ Assert.AreEqual ("d", r.ReadLine(), "#4");
+ Assert.IsNull (r.ReadLine (), "#5");
}
[Test]
b[9] = (byte)'\n';
MemoryStream m = new MemoryStream(b);
StreamReader r = new StreamReader(m);
- AssertEquals("line doesn't match", "a", r.ReadLine());
- AssertEquals("line doesn't match", "b", r.ReadLine());
- AssertEquals("line doesn't match", "c", r.ReadLine());
- AssertEquals("line doesn't match", "d", r.ReadLine());
- AssertEquals("line doesn't match", "", r.ReadLine());
- AssertEquals("line doesn't match", null, r.ReadLine());
+ Assert.AreEqual ("a", r.ReadLine (), "#1");
+ Assert.AreEqual ("b", r.ReadLine (), "#2");
+ Assert.AreEqual ("c", r.ReadLine (), "#3");
+ Assert.AreEqual ("d", r.ReadLine (), "#4");
+ Assert.AreEqual (string.Empty, r.ReadLine (), "#5");
+ Assert.IsNull (r.ReadLine(), "#6");
}
[Test]
b[9] = (byte)'\n';
MemoryStream m = new MemoryStream(b);
StreamReader r = new StreamReader(m);
- AssertEquals("line doesn't match", "", r.ReadLine());
- AssertEquals("line doesn't match", "", r.ReadLine());
- AssertEquals("line doesn't match", "", r.ReadLine());
- AssertEquals("line doesn't match", "c", r.ReadLine());
- AssertEquals("line doesn't match", "d", r.ReadLine());
- AssertEquals("line doesn't match", "", r.ReadLine());
- AssertEquals("line doesn't match", null, r.ReadLine());
+ Assert.AreEqual (string.Empty, r.ReadLine (), "#1");
+ Assert.AreEqual (string.Empty, r.ReadLine (), "#2");
+ Assert.AreEqual (string.Empty, r.ReadLine (), "#3");
+ Assert.AreEqual ("c", r.ReadLine (), "#4");
+ Assert.AreEqual ("d", r.ReadLine (), "#5");
+ Assert.AreEqual (string.Empty, r.ReadLine (), "#6");
+ Assert.IsNull (r.ReadLine (), "#7");
}
[Test]
byte [] bytes = Encoding.Default.GetBytes (sb.ToString ());
MemoryStream m = new MemoryStream(bytes);
StreamReader r = new StreamReader(m);
- AssertEquals("line doesn't match", new string ('1', 32767), r.ReadLine());
- AssertEquals("line doesn't match", "Hola", r.ReadLine());
- AssertEquals("line doesn't match", null, r.ReadLine());
+ Assert.AreEqual (new string ('1', 32767), r.ReadLine(), "#1");
+ Assert.AreEqual ("Hola", r.ReadLine (), "#2");
+ Assert.IsNull (r.ReadLine (), "#3");
}
[Test]
byte [] bytes = Encoding.Default.GetBytes (sb.ToString ());
MemoryStream m = new MemoryStream(bytes);
StreamReader r = new StreamReader(m);
- AssertEquals("line doesn't match", new string ('1', 32767), r.ReadLine());
- AssertEquals("line doesn't match", "Hola", r.ReadLine());
- AssertEquals("line doesn't match", new string ('1', 32767), r.ReadLine());
- AssertEquals("line doesn't match", "Hola", r.ReadLine());
- AssertEquals("line doesn't match", null, r.ReadLine());
+ Assert.AreEqual (new string ('1', 32767), r.ReadLine (), "#1");
+ Assert.AreEqual ("Hola", r.ReadLine (), "#2");
+ Assert.AreEqual (new string ('1', 32767), r.ReadLine (), "#3");
+ Assert.AreEqual ("Hola", r.ReadLine (), "#4");
+ Assert.IsNull (r.ReadLine (), "#5");
}
[Test]
byte [] bytes = Encoding.Default.GetBytes (sb.ToString ());
MemoryStream m = new MemoryStream(bytes);
StreamReader r = new StreamReader(m);
- AssertEquals("line doesn't match", new string ('1', 32768), r.ReadLine());
- AssertEquals("line doesn't match", "Hola", r.ReadLine());
- AssertEquals("line doesn't match", null, r.ReadLine());
+ Assert.AreEqual (new string ('1', 32768), r.ReadLine (), "#1");
+ Assert.AreEqual ("Hola", r.ReadLine (), "#2");
+ Assert.IsNull (r.ReadLine (), "#3");
}
public void TestReadToEnd() {
b[7] = (byte)'\n';
MemoryStream m = new MemoryStream(b);
StreamReader r = new StreamReader(m);
- AssertEquals("line doesn't match", "a\nb\nc\nd\n", r.ReadToEnd());
- AssertEquals("line doesn't match", "", r.ReadToEnd());
+ Assert.AreEqual ("a\nb\nc\nd\n", r.ReadToEnd (), "#1");
+ Assert.AreEqual (string.Empty, r.ReadToEnd (), "#2");
}
[Test]
MemoryStream m = new MemoryStream (b);
StreamReader r = new StreamReader (m);
m.Close ();
- bool thrown = false;
try {
r.Peek ();
+ Assert.Fail ();
} catch (ObjectDisposedException) {
- thrown = true;
}
-
- AssertEquals ("#01", true, thrown);
}
[Test]
[ExpectedException (typeof (ArgumentNullException))]
public void Contructor_Stream_NullEncoding ()
{
- StreamReader r = new StreamReader (new MemoryStream (), null);
+ new StreamReader (new MemoryStream (), null);
}
[Test]
[ExpectedException (typeof (ArgumentNullException))]
public void Contructor_Path_NullEncoding ()
{
- StreamReader r = new StreamReader (_codeFileName, null);
+ new StreamReader (_codeFileName, null);
}
[Test]
{
MemoryStream ms = new MemoryStream (Encoding.ASCII.GetBytes ("Line1\rLine2\r\nLine3\nLine4"));
StreamReader reader = new StreamReader (ms);
- AssertEquals (24, reader.Read (new char[24], 0, 24));
- }
+ Assert.AreEqual (24, reader.Read (new char[24], 0, 24));
+ }
+
+ [Test]
+ public void EncodingDetection()
+ {
+ if (!CheckEncodingDetected(Encoding.UTF8))
+ Assert.Fail ("Failed to detect UTF8 encoded string");
+ if (!CheckEncodingDetected(Encoding.Unicode))
+ Assert.Fail ("Failed to detect UTF16LE encoded string");
+ if (!CheckEncodingDetected(Encoding.BigEndianUnicode))
+ Assert.Fail ("Failed to detect UTF16BE encoded string");
+ if (!CheckEncodingDetected(Encoding.UTF32))
+ Assert.Fail ("Failed to detect UTF32LE encoded string");
+ if (!CheckEncodingDetected(new UTF32Encoding(true, true)))
+ Assert.Fail ("Failed to detect UTF32BE encoded string");
+ }
+
+ // This is a special case, where the StreamReader has less than 4 bytes at
+ // encoding detection time, so it tries to check for Unicode encoding, instead of
+ // waiting for more bytes to test against the UTF32 BOM.
+ [Test]
+ public void EncodingDetectionUnicode ()
+ {
+ byte [] bytes = new byte [3];
+ bytes [0] = 0xff;
+ bytes [1] = 0xfe;
+ bytes [2] = 0;
+ MemoryStream inStream = new MemoryStream (bytes);
+ StreamReader reader = new StreamReader (inStream, Encoding.UTF8, true);
+
+ // It should start with the encoding we used in the .ctor
+ Assert.AreEqual (Encoding.UTF8, reader.CurrentEncoding, "#A1");
+
+ reader.Read ();
+ //reader.Read ();
+ Assert.AreEqual (Encoding.Unicode, reader.CurrentEncoding, "#B1");
+
+ reader.Close ();
+ }
+
+ private bool CheckEncodingDetected(Encoding encoding)
+ {
+ MemoryStream outStream = new MemoryStream();
+ using (StreamWriter outWriter = new StreamWriter(outStream, encoding))
+ {
+ outWriter.Write(TestString);
+ }
+ byte[] testBytes = outStream.ToArray();
+
+ StreamReader inReader = new StreamReader(new MemoryStream(testBytes, false));
+ string decodedString = inReader.ReadToEnd();
+
+ return decodedString == TestString;
+ }
+
+ [Test] // Bug445326
+ [Category ("MobileNotWorking")]
+ public void EndOfBufferIsCR ()
+ {
+ using (StreamReader reader = new StreamReader ("Test/resources/Fergie.GED")) {
+ string line;
+ int count = 0;
+ while ((line = reader.ReadLine ()) != null) {
+ Assert.IsFalse (line.Length > 1000, "#1 " + count);
+ count++;
+ }
+ Assert.AreEqual (16107, count, "#2");
+ }
+ }
+
+ [Test]
+ public void bug75526 ()
+ {
+ StreamReader sr = new StreamReader (new Bug75526Stream ());
+ int len = sr.Read (new char [10], 0, 10);
+ Assert.AreEqual (2, len);
+ }
+
+ class Bug75526Stream : MemoryStream
+ {
+ public override int Read (byte [] buffer, int offset, int count)
+ {
+ buffer [offset + 0] = (byte) 'a';
+ buffer [offset + 1] = (byte) 'b';
+ return 2;
+ }
+ }
+
+ [Test]
+ public void PeekWhileBlocking ()
+ {
+ StreamReader reader = new StreamReader (new MyStream ());
+ int c = reader.Read ();
+ Assert.IsFalse (reader.EndOfStream);
+ string str = reader.ReadToEnd ();
+ Assert.AreEqual ("bc", str);
+ }
+
+ [Test]
+ public void EncodingChangedAuto ()
+ {
+ int testlines = 2048; // all data should larger than stream reader default buffer size
+ string testdata = "test";
+ MemoryStream ms = new MemoryStream();
+ // write utf8 encoding data.
+ using (StreamWriter sw = new StreamWriter (ms, Encoding.UTF8)) {
+ for (int i = 0; i < testlines; i++)
+ sw.WriteLine (testdata);
+ }
+
+ MemoryStream readms = new MemoryStream (ms.GetBuffer());
+ using (StreamReader sr = new StreamReader(readms, Encoding.Unicode, true)) {
+ for (int i = 0; i < testlines; i++) {
+ string line = sr.ReadLine ();
+ if (line != testdata)
+ Assert.Fail ("Wrong line content");
+ }
+ }
+ }
+
+ [Test]
+ public void NullStream ()
+ {
+ var buffer = new char[2];
+ Assert.AreEqual (0, StreamReader.Null.ReadBlock (buffer, 0, buffer.Length));
+ }
+
+ [Test]
+ public void ReadLineAsync ()
+ {
+ MemoryStream ms = new MemoryStream ();
+ StreamWriter sw = new StreamWriter (ms, Encoding.UTF8);
+ sw.WriteLine ("a");
+ sw.WriteLine ("b");
+ sw.Flush ();
+ ms.Seek (0, SeekOrigin.Begin);
+
+ Func<Task<string>> res = async () => {
+ using (StreamReader reader = new StreamReader (ms)) {
+ return await reader.ReadLineAsync () + await reader.ReadToEndAsync () + await reader.ReadToEndAsync ();
+ }
+ };
+
+ var result = res ();
+ Assert.IsTrue (result.Wait (3000), "#1");
+ Assert.AreEqual ("ab" + Environment.NewLine, result.Result);
+ }
+}
+
+class MyStream : Stream {
+ int n;
+
+ public override int Read (byte [] buffer, int offset, int size)
+ {
+ if (n == 0) {
+ buffer [offset] = (byte) 'a';
+ n++;
+ return 1;
+ } else if (n == 1) {
+ buffer [offset] = (byte) 'b';
+ buffer [offset + 1] = (byte) 'c';
+ n++;
+ return 2;
+ }
+ return 0;
+ }
+
+ public override bool CanRead {
+ get { return true; }
+ }
+
+ public override bool CanSeek {
+ get { return false; }
+ }
+
+ public override bool CanWrite {
+ get { return false; }
+ }
+
+ public override long Length {
+ get { return 0; }
+ }
+
+ public override long Position {
+ get { return 0; }
+ set { }
+ }
+
+ public override void Flush ()
+ {
+ }
+
+ public override long Seek (long offset, SeekOrigin origin)
+ {
+ return 0;
+ }
+
+ public override void SetLength (long value)
+ {
+ }
+
+ public override void Write (byte[] buffer, int offset, int count)
+ {
+ }
}
+
}
projects / mono.git / blobdiff