mcs/class/corlib/Test/System.IO/StreamWriterTest.cs

   1 // StreamWriterTest.cs - NUnit Test Cases for the SystemIO.StreamWriter class\r
   2 //\r
   3 // David Brandt (bucky@keystreams.com)\r
   4 //\r
   5 // (C) Ximian, Inc.  http://www.ximian.com\r
   6 // \r
   7 \r
   8 using NUnit.Framework;\r
   9 using System;\r
  10 using System.IO;\r
  11 using System.Text;\r
  12 \r
  13 namespace MonoTests.System.IO\r
  14 {\r
  15 \r
  16 public class StreamWriterTest : TestCase\r
  17 {\r
  18         public StreamWriterTest() : \r
  19                 base ("MonoTests.System.StreamWriterTest testsuite") {}\r
  20         public StreamWriterTest(string name) : base(name) {}\r
  21 \r
  22         protected override void SetUp() \r
  23         {\r
  24         }\r
  25 \r
  26         protected override void TearDown() \r
  27         {\r
  28         }\r
  29 \r
  30         public static ITest Suite {\r
  31                 get { \r
  32                         return new TestSuite(typeof(StreamWriterTest)); \r
  33                 }\r
  34         }\r
  35 \r
  36         private string _codeFileName = "StreamWriterTest.temp";\r
  37         private string _thisCodeFileName = "System.IO/StreamReaderTest.cs";\r
  38 \r
  39         // TODO - ctors\r
  40         public void TestCtor1() {\r
  41                 {\r
  42                         bool errorThrown = false;\r
  43                         try {\r
  44                                 StreamWriter r = new StreamWriter((Stream)null);\r
  45                         } catch (ArgumentNullException) {\r
  46                                 errorThrown = true;\r
  47                         }\r
  48                         Assert("null string error not thrown", errorThrown);\r
  49                 }\r
  50                 {\r
  51                         bool errorThrown = false;\r
  52                         FileStream f = new FileStream(_thisCodeFileName, \r
  53                                                       FileMode.Open, \r
  54                                                       FileAccess.Read);\r
  55                         try {\r
  56                                 StreamWriter r = new StreamWriter(f);\r
  57                                 r.Close();\r
  58                         } catch (ArgumentException) {\r
  59                                 errorThrown = true;\r
  60                         }\r
  61                         f.Close();\r
  62                         Assert("no read error not thrown", errorThrown);\r
  63                 }\r
  64                 {\r
  65                         FileStream f = new FileStream(_codeFileName, \r
  66                                                       FileMode.Append, \r
  67                                                       FileAccess.Write);\r
  68                         StreamWriter r = new StreamWriter(f);\r
  69                         AssertNotNull("no stream writer", r);\r
  70                         r.Close();\r
  71                         f.Close();\r
  72                 }\r
  73         }\r
  74         public void TestCtor2() {\r
  75                 {\r
  76                         bool errorThrown = false;\r
  77                         try {\r
  78                                 StreamWriter r = new StreamWriter("");\r
  79                         } catch (ArgumentException) {\r
  80                                 errorThrown = true;\r
  81                         }\r
  82                         Assert("empty string error not thrown", errorThrown);\r
  83                 }\r
  84                 {\r
  85                         bool errorThrown = false;\r
  86                         try {\r
  87                                 StreamWriter r = new StreamWriter((string)null);\r
  88                         } catch (ArgumentNullException) {\r
  89                                 errorThrown = true;\r
  90                         }\r
  91                         Assert("null string error not thrown", errorThrown);\r
  92                 }\r
  93                 {\r
  94                         bool errorThrown = false;\r
  95                         try {\r
  96                                 StreamWriter r = new StreamWriter("nonexistentdir/file");\r
  97                         } catch (DirectoryNotFoundException) {\r
  98                                 errorThrown = true;\r
  99                         }\r
 100                         Assert("dirNotFound error not thrown", errorThrown);\r
 101                 }\r
 102                 {\r
 103                         bool errorThrown = false;\r
 104                         try {\r
 105                                 StreamWriter r = new StreamWriter("!$what? what? Huh? !$*#");\r
 106                         } catch (IOException) {\r
 107                                 errorThrown = true;\r
 108                         } catch (ArgumentException) {\r
 109                                 // FIXME - the spec says 'IOExc', but the\r
 110                                 //   compiler says 'ArgExc'...\r
 111                                 errorThrown = true;\r
 112                         }\r
 113                         Assert("invalid filename error not thrown", errorThrown);\r
 114                 }\r
 115                 // TODO - Security/Auth exceptions\r
 116                 {\r
 117                         StreamWriter r = new StreamWriter(_codeFileName);\r
 118                         AssertNotNull("no stream writer", r);\r
 119                         r.Close();\r
 120                 }\r
 121         }\r
 122         public void TestCtor3() {\r
 123                 {\r
 124                         bool errorThrown = false;\r
 125                         try {\r
 126                                 StreamWriter r = new StreamWriter("", false);\r
 127                         } catch (ArgumentException) {\r
 128                                 errorThrown = true;\r
 129                         }\r
 130                         Assert("empty string error not thrown", errorThrown);\r
 131                 }\r
 132                 {\r
 133                         bool errorThrown = false;\r
 134                         try {\r
 135                                 StreamWriter r = new StreamWriter((string)null, false);\r
 136                         } catch (ArgumentNullException) {\r
 137                                 errorThrown = true;\r
 138                         }\r
 139                         Assert("null string error not thrown", errorThrown);\r
 140                 }\r
 141                 {\r
 142                         bool errorThrown = false;\r
 143                         try {\r
 144                                 StreamWriter r = new StreamWriter("nonexistentdir/file", false);\r
 145                         } catch (DirectoryNotFoundException) {\r
 146                                 errorThrown = true;\r
 147                         }\r
 148                         Assert("dirNotFound error not thrown", errorThrown);\r
 149                 }\r
 150                 {\r
 151                         bool errorThrown = false;\r
 152                         try {\r
 153                                 StreamWriter r = new StreamWriter("!$what? what? Huh? !$*#", false);\r
 154                         } catch (IOException) {\r
 155                                 errorThrown = true;\r
 156                         } catch (ArgumentException) {\r
 157                                 // FIXME - the spec says 'IOExc', but the\r
 158                                 //   compiler says 'ArgExc'...\r
 159                                 errorThrown = true;\r
 160                         }\r
 161                         Assert("invalid filename error not thrown", errorThrown);\r
 162                 }\r
 163                 {\r
 164                         StreamWriter r = new StreamWriter(_codeFileName, false);\r
 165                         AssertNotNull("no stream writer", r);\r
 166                         r.Close();\r
 167                 }\r
 168                 {\r
 169                         bool errorThrown = false;\r
 170                         try {\r
 171                                 StreamWriter r = new StreamWriter("", true);\r
 172                         } catch (ArgumentException) {\r
 173                                 errorThrown = true;\r
 174                         }\r
 175                         Assert("empty string error not thrown", errorThrown);\r
 176                 }\r
 177                 {\r
 178                         bool errorThrown = false;\r
 179                         try {\r
 180                                 StreamWriter r = new StreamWriter((string)null, true);\r
 181                         } catch (ArgumentNullException) {\r
 182                                 errorThrown = true;\r
 183                         }\r
 184                         Assert("null string error not thrown", errorThrown);\r
 185                 }\r
 186                 {\r
 187                         bool errorThrown = false;\r
 188                         try {\r
 189                                 StreamWriter r = new StreamWriter("nonexistentdir/file", true);\r
 190                         } catch (DirectoryNotFoundException) {\r
 191                                 errorThrown = true;\r
 192                         }\r
 193                         Assert("dirNotFound error not thrown", errorThrown);\r
 194                 }\r
 195                 {\r
 196                         bool errorThrown = false;\r
 197                         try {\r
 198                                 StreamWriter r = new StreamWriter("!$what? what? Huh? !$*#", true);\r
 199                         } catch (IOException) {\r
 200                                 errorThrown = true;\r
 201                         } catch (ArgumentException) {\r
 202                                 // FIXME - the spec says 'IOExc', but the\r
 203                                 //   compiler says 'ArgExc'...\r
 204                                 errorThrown = true;\r
 205                         }\r
 206                         Assert("invalid filename error not thrown", errorThrown);\r
 207                 }\r
 208                 {\r
 209                         StreamWriter r = new StreamWriter(_codeFileName, true);\r
 210                         AssertNotNull("no stream writer", r);\r
 211                         r.Close();\r
 212                 }\r
 213         }\r
 214 \r
 215         // TODO - ctors with Encoding\r
 216 \r
 217         // TODO - AutoFlush\r
 218         public void TestAutoFlush() {\r
 219                 {\r
 220                         MemoryStream m = new MemoryStream();\r
 221                         StreamWriter w = new StreamWriter(m);\r
 222                         w.AutoFlush = false;\r
 223                         w.Write(1);\r
 224                         w.Write(2);\r
 225                         w.Write(3);\r
 226                         w.Write(4);\r
 227                         AssertEquals("Should be nothing before flush",\r
 228                                      0, m.Length);\r
 229                         w.Flush();\r
 230                         AssertEquals("Should be something after flush",\r
 231                                      4, m.Length);\r
 232                 }               \r
 233                 {\r
 234                         MemoryStream m = new MemoryStream();\r
 235                         StreamWriter w = new StreamWriter(m);\r
 236                         w.AutoFlush = true;\r
 237                         w.Write(1);\r
 238                         w.Write(2);\r
 239                         w.Write(3);\r
 240                         w.Write(4);\r
 241                         AssertEquals("Should be something before flush",\r
 242                                      4, m.Length);\r
 243                         w.Flush();\r
 244                         AssertEquals("Should be something after flush",\r
 245                                      4, m.Length);\r
 246                 }               \r
 247         }\r
 248 \r
 249         public void TestBaseStream() {\r
 250                 FileStream f = new FileStream(_codeFileName, \r
 251                                               FileMode.Append, \r
 252                                               FileAccess.Write);\r
 253                 StreamWriter r = new StreamWriter(f);\r
 254                 AssertEquals("wrong base stream ", f, r.BaseStream);\r
 255                 r.Close();\r
 256                 f.Close();\r
 257         }\r
 258 \r
 259         public void TestEncoding() {\r
 260                 StreamWriter r = new StreamWriter(_codeFileName);\r
 261                 AssertEquals("wrong encoding", \r
 262                              Encoding.UTF8.GetType(), r.Encoding.GetType());\r
 263                 r.Close();\r
 264         }\r
 265 \r
 266         // TODO - Close - not entirely sure how to test Close\r
 267         //public void TestClose() {\r
 268         //{\r
 269         //MemoryStream m = new MemoryStream();\r
 270         //StreamWriter w = new StreamWriter(m);\r
 271         //StreamReader r = new StreamReader(m);\r
 272         //w.Write(1);\r
 273         //w.Write(2);\r
 274         //w.Write(3);\r
 275         //w.Write(4);\r
 276         //AssertEquals("Should be nothing before close",\r
 277         //0, m.Length);\r
 278         //AssertEquals("Should be nothing in reader",\r
 279         //-1, r.Peek());\r
 280         //w.Close();\r
 281         //AssertEquals("Should be something after close",\r
 282         //1, r.Peek());\r
 283         //}             \r
 284         //}\r
 285 \r
 286         // TODO - Flush\r
 287         public void TestFlush() {\r
 288                 {\r
 289                         bool errorThrown = false;\r
 290                         try {\r
 291                                 FileStream f = new FileStream(_codeFileName, \r
 292                                                               FileMode.Append, \r
 293                                                               FileAccess.Write);\r
 294                                 StreamWriter r = new StreamWriter(f);\r
 295                                 r.Close();\r
 296                                 r.Flush();\r
 297                         } catch (ObjectDisposedException) {\r
 298                                 errorThrown = true;\r
 299                         }\r
 300                         Assert("can't flush closed error not thrown", errorThrown);\r
 301                 }\r
 302                 {\r
 303                         MemoryStream m = new MemoryStream();\r
 304                         StreamWriter w = new StreamWriter(m);\r
 305                         w.Write(1);\r
 306                         w.Write(2);\r
 307                         w.Write(3);\r
 308                         w.Write(4);\r
 309                         AssertEquals("Should be nothing before flush",\r
 310                                      0, m.Length);\r
 311                         w.Flush();\r
 312                         AssertEquals("Should be something after flush",\r
 313                                      4, m.Length);\r
 314                 }               \r
 315         }\r
 316 \r
 317         // TODO - Write - test errors, functionality tested in TestFlush.\r
 318 }\r
 319 }\r