931 lines
24 KiB
C#
931 lines
24 KiB
C#
// StreamReaderTest.cs - NUnit Test Cases for the SystemIO.StreamReader class
|
|
//
|
|
// David Brandt (bucky@keystreams.com)
|
|
//
|
|
// (C) Ximian, Inc. http://www.ximian.com
|
|
// Copyright (C) 2004 Novell (http://www.novell.com)
|
|
//
|
|
|
|
using System;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
using NUnit.Framework;
|
|
|
|
namespace MonoTests.System.IO
|
|
{
|
|
[TestFixture]
|
|
public class StreamReaderTest
|
|
{
|
|
private string _tmpFolder;
|
|
private string _codeFileName;
|
|
private const string TestString = "Hello World!";
|
|
|
|
[SetUp]
|
|
public void SetUp ()
|
|
{
|
|
_tmpFolder = Path.GetTempFileName ();
|
|
if (File.Exists (_tmpFolder))
|
|
File.Delete (_tmpFolder);
|
|
_codeFileName = _tmpFolder + Path.DirectorySeparatorChar + "AFile.txt";
|
|
|
|
if (!Directory.Exists (_tmpFolder))
|
|
Directory.CreateDirectory (_tmpFolder);
|
|
|
|
if (!File.Exists (_codeFileName))
|
|
File.Create (_codeFileName).Close ();
|
|
}
|
|
|
|
[TearDown]
|
|
public void TearDown ()
|
|
{
|
|
if (Directory.Exists (_tmpFolder))
|
|
Directory.Delete (_tmpFolder, true);
|
|
}
|
|
|
|
|
|
[Test]
|
|
public void TestCtor1() {
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader((Stream)null);
|
|
} catch (ArgumentNullException) {
|
|
errorThrown = true;
|
|
}
|
|
Assert.IsTrue (errorThrown, "null string error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
FileStream f = new FileStream(_codeFileName, FileMode.Open, FileAccess.Write);
|
|
try {
|
|
StreamReader r = new StreamReader(f);
|
|
r.Close();
|
|
} catch (ArgumentException) {
|
|
errorThrown = true;
|
|
}
|
|
f.Close();
|
|
Assert.IsTrue (errorThrown, "no read error not thrown");
|
|
}
|
|
{
|
|
// this is probably incestuous, but, oh well.
|
|
FileStream f = new FileStream(_codeFileName,
|
|
FileMode.Open,
|
|
FileAccess.Read);
|
|
StreamReader r = new StreamReader(f);
|
|
Assert.IsNotNull (r, "no stream reader");
|
|
r.Close();
|
|
f.Close();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCtor2() {
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader("");
|
|
} catch (ArgumentException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 1: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "empty string error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader((string)null);
|
|
} catch (ArgumentNullException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 2: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "null string error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader("nonexistentfile");
|
|
} catch (FileNotFoundException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 3: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "fileNotFound error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader("nonexistentdir/file");
|
|
} catch (DirectoryNotFoundException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 4: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "dirNotFound error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0]);
|
|
} catch (IOException) {
|
|
errorThrown = true;
|
|
} catch (ArgumentException) {
|
|
// FIXME - the spec says 'IOExc', but the
|
|
// compiler says 'ArgExc'...
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 5: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "invalid filename error not thrown");
|
|
}
|
|
{
|
|
// this is probably incestuous, but, oh well.
|
|
StreamReader r = new StreamReader(_codeFileName);
|
|
Assert.IsNotNull (r, "no stream reader");
|
|
r.Close();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCtor3() {
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader((Stream)null, false);
|
|
} catch (ArgumentNullException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 1: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "null stream error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
FileStream f = new FileStream(_codeFileName, FileMode.Open, FileAccess.Write);
|
|
try {
|
|
StreamReader r = new StreamReader(f, false);
|
|
r.Close();
|
|
} catch (ArgumentException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 2: " + e.ToString());
|
|
}
|
|
f.Close();
|
|
Assert.IsTrue (errorThrown, "no read error not thrown");
|
|
}
|
|
{
|
|
// this is probably incestuous, but, oh well.
|
|
FileStream f = new FileStream(_codeFileName,
|
|
FileMode.Open,
|
|
FileAccess.Read);
|
|
StreamReader r = new StreamReader(f, false);
|
|
Assert.IsNotNull (r, "no stream reader");
|
|
r.Close();
|
|
f.Close();
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
StreamReader r = new StreamReader((Stream)null, true);
|
|
} catch (ArgumentNullException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 3: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "null string error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
FileStream f = new FileStream(_codeFileName, FileMode.Open, FileAccess.Write);
|
|
try {
|
|
StreamReader r = new StreamReader(f, true);
|
|
r.Close();
|
|
} catch (ArgumentException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 4: " + e.ToString());
|
|
}
|
|
f.Close();
|
|
Assert.IsTrue (errorThrown, "no read error not thrown");
|
|
}
|
|
{
|
|
// this is probably incestuous, but, oh well.
|
|
FileStream f = new FileStream(_codeFileName,
|
|
FileMode.Open,
|
|
FileAccess.Read);
|
|
StreamReader r = new StreamReader(f, true);
|
|
Assert.IsNotNull (r, "no stream reader");
|
|
r.Close();
|
|
f.Close();
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestCtor4() {
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader("", false);
|
|
} catch (ArgumentException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 1: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "empty string error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader((string)null, false);
|
|
} catch (ArgumentNullException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 2: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "null string error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader(_tmpFolder + "/nonexistentfile", false);
|
|
} catch (FileNotFoundException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 3: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "fileNotFound error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader(_tmpFolder + "/nonexistentdir/file", false);
|
|
} catch (DirectoryNotFoundException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 4: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "dirNotFound error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0], false);
|
|
} catch (IOException) {
|
|
errorThrown = true;
|
|
} catch (ArgumentException) {
|
|
// FIXME - the spec says 'IOExc', but the
|
|
// compiler says 'ArgExc'...
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 5: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "invalid filename error not thrown");
|
|
}
|
|
{
|
|
// this is probably incestuous, but, oh well.
|
|
StreamReader r = new StreamReader(_codeFileName, false);
|
|
Assert.IsNotNull (r, "no stream reader");
|
|
r.Close();
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader("", true);
|
|
} catch (ArgumentException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 6: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "empty string error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader((string)null, true);
|
|
} catch (ArgumentNullException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 7: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "null string error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader(_tmpFolder + "/nonexistentfile", true);
|
|
} catch (FileNotFoundException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 8: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "fileNotFound error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader(_tmpFolder + "/nonexistentdir/file", true);
|
|
} catch (DirectoryNotFoundException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 9: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "dirNotFound error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
new StreamReader("!$what? what? Huh? !$*#" + Path.InvalidPathChars[0], true);
|
|
} catch (IOException) {
|
|
errorThrown = true;
|
|
} catch (ArgumentException) {
|
|
// FIXME - the spec says 'IOExc', but the
|
|
// compiler says 'ArgExc'...
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 10: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "invalid filename error not thrown");
|
|
}
|
|
{
|
|
// this is probably incestuous, but, oh well.
|
|
StreamReader r = new StreamReader(_codeFileName, true);
|
|
Assert.IsNotNull (r, "no stream reader");
|
|
r.Close();
|
|
}
|
|
}
|
|
|
|
// TODO - Ctor with Encoding
|
|
|
|
[Test]
|
|
public void TestBaseStream() {
|
|
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()
|
|
{
|
|
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?
|
|
// TODO - DiscardBufferedData - I have no clue how to test this function.
|
|
|
|
[Test]
|
|
public void TestPeek() {
|
|
// FIXME - how to get an IO Exception?
|
|
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) {
|
|
}
|
|
|
|
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]
|
|
public void TestRead() {
|
|
// 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.Read();
|
|
} catch (ObjectDisposedException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 1: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "nothing-to-read error not thrown");
|
|
}
|
|
{
|
|
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++) {
|
|
Assert.AreEqual (i, r.Read (), "read incorrect");
|
|
}
|
|
Assert.AreEqual (-1, r.Read (), "Should be none left");
|
|
}
|
|
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
Byte[] b = {};
|
|
StreamReader r = new StreamReader(new MemoryStream(b));
|
|
r.Read(null, 0, 0);
|
|
} catch (ArgumentNullException) {
|
|
errorThrown = true;
|
|
} catch (ArgumentException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 2: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "null buffer error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
Byte[] b = {};
|
|
StreamReader r = new StreamReader(new MemoryStream(b));
|
|
Char[] c = new Char[1];
|
|
r.Read(c, 0, 2);
|
|
} catch (ArgumentException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 3: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "too-long range error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
Byte[] b = {};
|
|
StreamReader r = new StreamReader(new MemoryStream(b));
|
|
Char[] c = new Char[1];
|
|
r.Read(c, -1, 2);
|
|
} catch (ArgumentOutOfRangeException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 4: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "out of range error not thrown");
|
|
}
|
|
{
|
|
bool errorThrown = false;
|
|
try {
|
|
Byte[] b = {};
|
|
StreamReader r = new StreamReader(new MemoryStream(b));
|
|
Char[] c = new Char[1];
|
|
r.Read(c, 0, -1);
|
|
} catch (ArgumentOutOfRangeException) {
|
|
errorThrown = true;
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Incorrect exception thrown at 5: " + e.ToString());
|
|
}
|
|
Assert.IsTrue (errorThrown, "out of range error not thrown");
|
|
}
|
|
{
|
|
int ii = 1;
|
|
try {
|
|
Byte[] b = {(byte)'a', (byte)'b', (byte)'c',
|
|
(byte)'d', (byte)'e', (byte)'f',
|
|
(byte)'g'};
|
|
MemoryStream m = new MemoryStream(b);
|
|
ii++;
|
|
StreamReader r = new StreamReader(m);
|
|
ii++;
|
|
|
|
char[] buffer = new Char[7];
|
|
ii++;
|
|
char[] target = {'g','d','e','f','b','c','a'};
|
|
ii++;
|
|
r.Read(buffer, 6, 1);
|
|
ii++;
|
|
r.Read(buffer, 4, 2);
|
|
ii++;
|
|
r.Read(buffer, 1, 3);
|
|
ii++;
|
|
r.Read(buffer, 0, 1);
|
|
ii++;
|
|
for (int i = 0; i < target.Length; i++) {
|
|
Assert.AreEqual (target[i], buffer[i], "read no work");
|
|
i++;
|
|
}
|
|
} catch (Exception e) {
|
|
Assert.Fail ("Caught when ii=" + ii + ". e:" + e.ToString());
|
|
}
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
public void TestReadLine() {
|
|
// TODO Out Of Memory Exc? IO Exc?
|
|
Byte[] b = new Byte[8];
|
|
b[0] = (byte)'a';
|
|
b[1] = (byte)'\n';
|
|
b[2] = (byte)'b';
|
|
b[3] = (byte)'\n';
|
|
b[4] = (byte)'c';
|
|
b[5] = (byte)'\n';
|
|
b[6] = (byte)'d';
|
|
b[7] = (byte)'\n';
|
|
MemoryStream m = new MemoryStream(b);
|
|
StreamReader r = new StreamReader(m);
|
|
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]
|
|
public void ReadLine1() {
|
|
Byte[] b = new Byte[10];
|
|
b[0] = (byte)'a';
|
|
b[1] = (byte)'\r';
|
|
b[2] = (byte)'b';
|
|
b[3] = (byte)'\n';
|
|
b[4] = (byte)'c';
|
|
b[5] = (byte)'\n';
|
|
b[5] = (byte)'\r';
|
|
b[6] = (byte)'d';
|
|
b[7] = (byte)'\n';
|
|
b[8] = (byte)'\r';
|
|
b[9] = (byte)'\n';
|
|
MemoryStream m = new MemoryStream(b);
|
|
StreamReader r = new StreamReader(m);
|
|
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]
|
|
public void ReadLine2() {
|
|
Byte[] b = new Byte[10];
|
|
b[0] = (byte)'\r';
|
|
b[1] = (byte)'\r';
|
|
b[2] = (byte)'\n';
|
|
b[3] = (byte)'\n';
|
|
b[4] = (byte)'c';
|
|
b[5] = (byte)'\n';
|
|
b[5] = (byte)'\r';
|
|
b[6] = (byte)'d';
|
|
b[7] = (byte)'\n';
|
|
b[8] = (byte)'\r';
|
|
b[9] = (byte)'\n';
|
|
MemoryStream m = new MemoryStream(b);
|
|
StreamReader r = new StreamReader(m);
|
|
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]
|
|
public void ReadLine3() {
|
|
StringBuilder sb = new StringBuilder ();
|
|
sb.Append (new string ('1', 32767));
|
|
sb.Append ('\r');
|
|
sb.Append ('\n');
|
|
sb.Append ("Hola\n");
|
|
byte [] bytes = Encoding.Default.GetBytes (sb.ToString ());
|
|
MemoryStream m = new MemoryStream(bytes);
|
|
StreamReader r = new StreamReader(m);
|
|
Assert.AreEqual (new string ('1', 32767), r.ReadLine(), "#1");
|
|
Assert.AreEqual ("Hola", r.ReadLine (), "#2");
|
|
Assert.IsNull (r.ReadLine (), "#3");
|
|
}
|
|
|
|
[Test]
|
|
public void ReadLine4() {
|
|
StringBuilder sb = new StringBuilder ();
|
|
sb.Append (new string ('1', 32767));
|
|
sb.Append ('\r');
|
|
sb.Append ('\n');
|
|
sb.Append ("Hola\n");
|
|
sb.Append (sb.ToString ());
|
|
byte [] bytes = Encoding.Default.GetBytes (sb.ToString ());
|
|
MemoryStream m = new MemoryStream(bytes);
|
|
StreamReader r = new StreamReader(m);
|
|
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]
|
|
public void ReadLine5() {
|
|
StringBuilder sb = new StringBuilder ();
|
|
sb.Append (new string ('1', 32768));
|
|
sb.Append ('\r');
|
|
sb.Append ('\n');
|
|
sb.Append ("Hola\n");
|
|
byte [] bytes = Encoding.Default.GetBytes (sb.ToString ());
|
|
MemoryStream m = new MemoryStream(bytes);
|
|
StreamReader r = new StreamReader(m);
|
|
Assert.AreEqual (new string ('1', 32768), r.ReadLine (), "#1");
|
|
Assert.AreEqual ("Hola", r.ReadLine (), "#2");
|
|
Assert.IsNull (r.ReadLine (), "#3");
|
|
}
|
|
|
|
public void TestReadToEnd() {
|
|
// TODO Out Of Memory Exc? IO Exc?
|
|
Byte[] b = new Byte[8];
|
|
b[0] = (byte)'a';
|
|
b[1] = (byte)'\n';
|
|
b[2] = (byte)'b';
|
|
b[3] = (byte)'\n';
|
|
b[4] = (byte)'c';
|
|
b[5] = (byte)'\n';
|
|
b[6] = (byte)'d';
|
|
b[7] = (byte)'\n';
|
|
MemoryStream m = new MemoryStream(b);
|
|
StreamReader r = new StreamReader(m);
|
|
Assert.AreEqual ("a\nb\nc\nd\n", r.ReadToEnd (), "#1");
|
|
Assert.AreEqual (string.Empty, r.ReadToEnd (), "#2");
|
|
}
|
|
|
|
[Test]
|
|
public void TestBaseStreamClosed ()
|
|
{
|
|
byte [] b = {};
|
|
MemoryStream m = new MemoryStream (b);
|
|
StreamReader r = new StreamReader (m);
|
|
m.Close ();
|
|
try {
|
|
r.Peek ();
|
|
Assert.Fail ();
|
|
} catch (ObjectDisposedException) {
|
|
}
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void Contructor_Stream_NullEncoding ()
|
|
{
|
|
new StreamReader (new MemoryStream (), null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void Contructor_Path_NullEncoding ()
|
|
{
|
|
new StreamReader (_codeFileName, null);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentNullException))]
|
|
public void Read_Null ()
|
|
{
|
|
StreamReader r = new StreamReader (new MemoryStream ());
|
|
r.Read (null, 0, 0);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void Read_IndexOverflow ()
|
|
{
|
|
char[] array = new char [16];
|
|
StreamReader r = new StreamReader (new MemoryStream (16));
|
|
r.Read (array, 1, Int32.MaxValue);
|
|
}
|
|
|
|
[Test]
|
|
[ExpectedException (typeof (ArgumentException))]
|
|
public void Read_CountOverflow ()
|
|
{
|
|
char[] array = new char [16];
|
|
StreamReader r = new StreamReader (new MemoryStream (16));
|
|
r.Read (array, Int32.MaxValue, 1);
|
|
}
|
|
|
|
[Test]
|
|
public void Read_DoesntStopAtLineEndings ()
|
|
{
|
|
MemoryStream ms = new MemoryStream (Encoding.ASCII.GetBytes ("Line1\rLine2\r\nLine3\nLine4"));
|
|
StreamReader reader = new StreamReader (ms);
|
|
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)
|
|
{
|
|
}
|
|
}
|
|
|
|
}
|