// Copyright (C) 2004 Novell (http://www.novell.com)
//
-using NUnit.Framework;
using System;
using System.IO;
using System.Text;
+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());
- }
+ Byte[] b = {};
+ MemoryStream m = new MemoryStream(b);
+ StreamReader r = new StreamReader(m);
+ Assert.AreEqual (Encoding.UTF8.GetType (), r.CurrentEncoding.GetType (),
+ "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 NET_2_0
+ 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");
+#endif
+ }
+
+ 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]
+ 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;
+ }
+ }
}
}
projects / mono.git / blobdiff