mcs/class/corlib/Test/System/ConsoleTest.cs

   1 // ConsoleTest.cs - NUnit Test Cases for the System.Console class
   2 //
   3 // David Brandt (bucky@keystreams.com)
   4 //
   5 // (C) Ximian, Inc.  http://www.ximian.com
   6 //
   7
   8 using NUnit.Framework;
   9 using System;
  10 using System.IO;
  11
  12
  13 namespace MonoTests.System
  14 {
  15
  16 public class ConsoleTest : TestCase
  17 {
  18         public ConsoleTest() {}
  19
  20         TextWriter _err;
  21         TextReader _in;
  22         TextWriter _out;
  23         protected override void SetUp()
  24         {
  25                 _err = Console.Error;
  26                 _in = Console.In;
  27                 _out = Console.Out;
  28         }
  29
  30         protected override void TearDown()
  31         {
  32                 Console.SetError(_err);
  33                 Console.SetIn(_in);
  34                 Console.SetOut(_out);
  35         }
  36
  37         public void TestError() {
  38                 AssertNotNull("No error", Console.Error);
  39         }
  40
  41         public void TestIn() {
  42                 AssertNotNull("No in", Console.In);
  43         }
  44
  45         public void TestOut() {
  46                 AssertNotNull("No out", Console.Out);
  47         }
  48
  49         public void TestOpenStandardError() {
  50                 {
  51                         Stream err = Console.OpenStandardError();
  52                         AssertNotNull("Can't open error", err);
  53                 }
  54                 {
  55                         Stream err = Console.OpenStandardError(512);
  56                         AssertNotNull("Can't open error", err);
  57                 }
  58                 // Spec says these are here, MS implementation says no.
  59                 //{
  60                 //bool errorThrown = false;
  61                 //try {
  62                 //Stream err = Console.OpenStandardError(-1);
  63                 //} catch (ArgumentOutOfRangeException) {
  64                 //errorThrown = true;
  65                 //}
  66                 //Assert("negative buffer error not thrown",
  67                 //errorThrown);
  68                 //}
  69                 //{
  70                 //bool errorThrown = false;
  71                 //try {
  72                 //Stream err = Console.OpenStandardError(0);
  73                 //} catch (ArgumentOutOfRangeException) {
  74                 //errorThrown = true;
  75                 //}
  76                 //Assert("zero buffer error not thrown", errorThrown);
  77                 //}
  78         }
  79
  80         public void TestOpenStandardInput() {
  81                 {
  82                         Stream in1 = Console.OpenStandardInput();
  83                         AssertNotNull("Can't open input", in1);
  84                 }
  85                 {
  86                         Stream in1 = Console.OpenStandardInput(512);
  87                         AssertNotNull("Can't open input", in1);
  88                 }
  89                 // see commented-out tests in TestOpenStandardError
  90         }
  91
  92         public void TestOpenStandardOutput() {
  93                 {
  94                         Stream out1 = Console.OpenStandardOutput();
  95                         AssertNotNull("Can't open output", out1);
  96                 }
  97                 {
  98                         Stream out1 = Console.OpenStandardOutput(512);
  99                         AssertNotNull("Can't open output", out1);
 100                 }
 101                 // see commented-out tests in TestOpenStandardError
 102         }
 103
 104         public void TestRead() {
 105                 String testStr = "This is a readline test";
 106                 Stream s = new MemoryStream();
 107                 TextWriter w = new StreamWriter(s);
 108                 ((StreamWriter)w).AutoFlush = true;
 109                 TextReader r = new StreamReader(s);
 110                 Console.SetIn(r);
 111                 w.WriteLine(testStr);
 112                 s.Position = 0;
 113                 char val = (char) Console.Read();
 114                 AssertEquals("Wrong read", 'T', val);
 115         }
 116
 117         public void TestReadLine() {
 118                 String testStr = "This is a readline test";
 119                 Stream s = new MemoryStream();
 120                 TextWriter w = new StreamWriter(s);
 121                 ((StreamWriter)w).AutoFlush = true;
 122                 TextReader r = new StreamReader(s);
 123                 Console.SetIn(r);
 124                 w.WriteLine(testStr);
 125                 s.Position = 0;
 126                 String line = Console.ReadLine();
 127                 AssertEquals("Wrong line", testStr, line);
 128         }
 129
 130         public void TestSetError() {
 131                 {
 132                         bool errorThrown = false;
 133                         try {
 134                                 Console.SetError(null);
 135                         } catch (ArgumentNullException) {
 136                                 errorThrown = true;
 137                         }
 138                         Assert("null error error not thrown", errorThrown);
 139                 }
 140                 {
 141                         String testStr = "This is a stderr test";
 142                         Stream s = new MemoryStream();
 143                         TextWriter w = new StreamWriter(s);
 144                         ((StreamWriter)w).AutoFlush = true;
 145                         TextReader r = new StreamReader(s);
 146                         Console.SetError(w);
 147                         Console.Error.WriteLine(testStr);
 148                         s.Position = 0;
 149                         String line = r.ReadLine();
 150                         AssertEquals("Wrong line", testStr, line);
 151                 }
 152         }
 153
 154         public void TestSetIn() {
 155                 {
 156                         bool errorThrown = false;
 157                         try {
 158                                 Console.SetIn(null);
 159                         } catch (ArgumentNullException) {
 160                                 errorThrown = true;
 161                         }
 162                         Assert("null in error not thrown", errorThrown);
 163                 }
 164                 {
 165                         String testStr = "This is a stdin test";
 166                         Stream s = new MemoryStream();
 167                         TextWriter w = new StreamWriter(s);
 168                         ((StreamWriter)w).AutoFlush = true;
 169                         TextReader r = new StreamReader(s);
 170                         Console.SetIn(r);
 171                         w.WriteLine(testStr);
 172                         s.Position = 0;
 173                         String line = Console.In.ReadLine();
 174                         AssertEquals("Wrong line", testStr, line);
 175                 }
 176         }
 177
 178         public void TestSetOut() {
 179                 {
 180                         bool errorThrown = false;
 181                         try {
 182                                 Console.SetOut(null);
 183                         } catch (ArgumentNullException) {
 184                                 errorThrown = true;
 185                         }
 186                         Assert("null out error not thrown", errorThrown);
 187                 }
 188                 {
 189                         String testStr = "This is a stdout test";
 190                         Stream s = new MemoryStream();
 191                         TextWriter w = new StreamWriter(s);
 192                         ((StreamWriter)w).AutoFlush = true;
 193                         TextReader r = new StreamReader(s);
 194                         Console.SetOut(w);
 195                         Console.Out.WriteLine(testStr);
 196                         s.Position = 0;
 197                         String line = r.ReadLine();
 198                         AssertEquals("Wrong line", testStr, line);
 199                 }
 200         }
 201
 202         public void TestWrite() {
 203                 Stream s = new MemoryStream();
 204                 TextWriter w = new StreamWriter(s);
 205                 ((StreamWriter)w).AutoFlush = true;
 206                 TextReader r = new StreamReader(s);
 207                 Console.SetOut(w);
 208
 209                 long endPos = 0;
 210
 211                 String testStr = "This is a stdout write test";
 212                 Console.Write(testStr);
 213                 s.Position = endPos;
 214                 String line = r.ReadToEnd();
 215                 AssertEquals("Wrong line", testStr, line);
 216                 endPos = s.Position;
 217
 218                 Boolean[] booleans = {true, false};
 219                 foreach (bool b in booleans ) {
 220                         Console.Write(b);
 221                         s.Position = endPos;
 222                         line = r.ReadToEnd();
 223                         AssertEquals("Wrong boolean", b.ToString(), line);
 224                         endPos = s.Position;
 225                 }
 226
 227                 Char[] chars = {'a', ';', '?'};
 228                 foreach (Char c in chars ) {
 229                         Console.Write(c);
 230                         s.Position = endPos;
 231                         line = r.ReadToEnd();
 232                         AssertEquals("Wrong char", c.ToString(), line);
 233                         endPos = s.Position;
 234                 }
 235
 236                 // test writing a null value
 237                 string x = null;
 238                 Console.Write (x);
 239
 240                 // TODO - Likewise for char[], decimal, double, int, long, object, single, uint32, uint64
 241                 // TODO - write with format string
 242         }
 243         public void TestWriteLine() {
 244                 Stream s = new MemoryStream();
 245                 TextWriter w = new StreamWriter(s);
 246                 ((StreamWriter)w).AutoFlush = true;
 247                 TextReader r = new StreamReader(s);
 248                 Console.SetOut(w);
 249
 250                 long endPos = 0;
 251
 252                 String testStr = "This is a stdout writeline test";
 253                 Console.WriteLine(testStr);
 254                 s.Position = endPos;
 255                 String line = r.ReadLine();
 256                 AssertEquals("Wrong line", testStr, line);
 257                 endPos = s.Position;
 258
 259                 Boolean[] booleans = {true, false};
 260                 foreach (bool b in booleans ) {
 261                         Console.WriteLine(b);
 262                         s.Position = endPos;
 263                         line = r.ReadLine();
 264                         AssertEquals("Wrong boolean", b.ToString(), line);
 265                         endPos = s.Position;
 266                 }
 267
 268                 Char[] chars = {'a', ';', '?'};
 269                 foreach (Char c in chars ) {
 270                         Console.WriteLine(c);
 271                         s.Position = endPos;
 272                         line = r.ReadLine();
 273                         AssertEquals("Wrong char", c.ToString(), line);
 274                         endPos = s.Position;
 275                 }
 276
 277                 // test writing a null value
 278                 string x = null;
 279                 Console.WriteLine (x);
 280
 281                 // TODO - Likewise for char[], decimal, double, int, long, object, single, uint32, uint64
 282                 // TODO - write with format string
 283         }
 284
 285 }
 286 }