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

   1 //
   2 // EnvironmentTest.cs - NUnit Test Cases for Environment
   3 //
   4 // Author:
   5 //      Sebastien Pouliot <sebastien@ximian.com>
   6 //
   7 // (C) 2004-2005 Novell (http://www.novell.com)
   8 // Copyright 2011 Xamarin Inc (http://www.xamarin.com).
   9 //
  10
  11 using System;
  12 using System.Collections;
  13
  14 using NUnit.Framework;
  15
  16 namespace MonoTests.System
  17 {
  18         [TestFixture]
  19         public class EnvironmentTest
  20         {
  21                 private void ExpandEquals (string toExpand, string toMatch)
  22                 {
  23                         string expanded = Environment.ExpandEnvironmentVariables (toExpand);
  24                         Assert.AreEqual (toMatch, expanded, "ExpandEnvironmentVariables(" + toExpand + ").Match");
  25                 }
  26
  27                 private void ExpandStartsEnds (string toExpand, string start, string end)
  28                 {
  29                         string expanded = Environment.ExpandEnvironmentVariables (toExpand);
  30                         Assert.IsTrue (expanded.StartsWith (start), "ExpandEnvironmentVariables(" + toExpand + ").Start");
  31                         Assert.IsTrue (expanded.EndsWith (end), "ExpandEnvironmentVariables(" + toExpand + ").End");
  32                 }
  33
  34                 private void ExpandDifferent (string toExpand)
  35                 {
  36                         string expanded = Environment.ExpandEnvironmentVariables (toExpand);
  37                         Assert.IsFalse ((toExpand == expanded), "ExpandEnvironmentVariables(" + toExpand + ").Different");
  38                 }
  39
  40                 [Test]
  41                 public void ExpandEnvironmentVariables_UnknownVariable ()
  42                 {
  43                         ExpandEquals ("Hello %UNKNOWN_ENV_VAR% :-)", "Hello %UNKNOWN_ENV_VAR% :-)");
  44                 }
  45
  46                 [Test]
  47                 public void ExpandEnvironmentVariables_KnownVariable ()
  48                 {
  49                         ExpandStartsEnds ("Path %PATH% :-)", "Path ", " :-)");
  50                 }
  51
  52                 [Test]
  53                 public void ExpandEnvironmentVariables_NotVariable ()
  54                 {
  55                         ExpandEquals ("100% :-)", "100% :-)");
  56                 }
  57
  58                 [Test]
  59                 public void ExpandEnvironmentVariables_Alone ()
  60                 {
  61                         ExpandDifferent ("%PATH%");
  62                 }
  63
  64                 [Test]
  65                 public void ExpandEnvironmentVariables_End ()
  66                 {
  67                         ExpandStartsEnds ("Hello %PATH%", "Hello ", "");
  68                 }
  69
  70                 [Test]
  71                 public void ExpandEnvironmentVariables_None ()
  72                 {
  73                         ExpandEquals ("Hello Mono", "Hello Mono");
  74                 }
  75
  76                 [Test]
  77                 public void ExpandEnvironmentVariables_EmptyVariable ()
  78                 {
  79                         ExpandEquals ("Hello %% Mono", "Hello %% Mono");
  80                 }
  81
  82                 [Test]
  83                 public void ExpandEnvironmentVariables_Double ()
  84                 {
  85                         ExpandDifferent ("%PATH%%PATH%");
  86                         string path = Environment.GetEnvironmentVariable ("PATH");
  87                         if (path != null) {
  88                                 string expanded = Environment.ExpandEnvironmentVariables ("%PATH%%PATH%");
  89                                 Assert.AreEqual (path + path, expanded, "#01");
  90                         }
  91                 }
  92
  93                 [Test]
  94                 public void ExpandEnvironmentVariables_ComplexExpandable ()
  95                 {
  96                         ExpandStartsEnds ("Hello %%%PATH%%%", "Hello %%", "%%");
  97                 }
  98
  99                 [Test]
 100                 public void ExpandEnvironmentVariables_ExpandableAndNonExpandable ()
 101                 {
 102                         string path = Environment.GetEnvironmentVariable ("PATH");
 103                         string expanded=Environment.ExpandEnvironmentVariables("%PATH% PATH%");
 104                         Assert.AreEqual (path + " PATH%", expanded);
 105                 }
 106
 107
 108                 [Test]
 109                 public void ExpandEnvironmentVariables_ExpandableWithTrailingPercent ()
 110                 {
 111                         string path = Environment.GetEnvironmentVariable ("PATH");
 112                         string expanded=Environment.ExpandEnvironmentVariables("%PATH% %");
 113                         Assert.AreEqual (path+" %",expanded);
 114                 }
 115
 116                 [Test]
 117                 public void ExpandEnvironmentVariables_ComplexExpandable2 ()
 118                 {
 119                         ExpandStartsEnds ("Hello %%PATH%%%", "Hello %", "%%");
 120                 }
 121
 122                 [Test]
 123                 // Bug #5169
 124                 public void ExpandEnvironmentVariables_ExpandMultiple ()
 125                 {
 126                         string path = Environment.GetEnvironmentVariable ("PATH");
 127                         var expected = "%TEST123" + path + "TEST456%";
 128                         ExpandEquals ("%TEST123%PATH%TEST456%", expected);
 129                 }
 130
 131                 [Test]
 132                 public void GetEnvironmentVariables ()
 133                 {
 134                         IDictionary d = Environment.GetEnvironmentVariables ();
 135                         Assert.IsTrue ((d is Hashtable), "Hashtable");
 136                         Assert.IsFalse (d.IsFixedSize, "IsFixedSize");
 137                         Assert.IsFalse (d.IsReadOnly, "IsReadOnly");
 138                         Assert.IsFalse (d.IsSynchronized, "IsSynchronized");
 139                 }
 140
 141 #if !NET_2_1
 142                 [Test] // bug #333740
 143                 public void GetEnvironmentVariables_NewlySet ()
 144                 {
 145                         Environment.SetEnvironmentVariable ("MonoTestVariable", "TestValue");
 146                         IDictionary d = Environment.GetEnvironmentVariables ();
 147                         Assert.AreEqual ("TestValue", d ["MonoTestVariable"], "#1");
 148                         Environment.SetEnvironmentVariable ("MonoTestVariable", string.Empty);
 149                         Assert.AreEqual ("TestValue", d ["MonoTestVariable"], "#2");
 150                         d = Environment.GetEnvironmentVariables ();
 151                         Assert.IsNull (d ["MonoTestVariable"], "#3");
 152                 }
 153 #endif
 154
 155                 [Test]
 156                 public void GetCommandLineArgs ()
 157                 {
 158                         string[] args = Environment.GetCommandLineArgs ();
 159                         Assert.IsNotNull (args, "not null");
 160                         Assert.IsTrue (((args.Length > 0) && (args.Length < 256)), "reasonable");
 161                         Assert.IsNotNull (args [0], "application");
 162                 }
 163
 164 #if !NET_2_1
 165                 [Test]
 166                 [ExpectedException (typeof (ArgumentException))]
 167                 public void GetEnvironmentVariable_Target_Invalid ()
 168                 {
 169                         Environment.GetEnvironmentVariable ("MONO", (EnvironmentVariableTarget)Int32.MinValue);
 170                 }
 171
 172                 [Test]
 173                 [ExpectedException (typeof (ArgumentException))]
 174                 public void GetEnvironmentVariables_Target_Invalid ()
 175                 {
 176                         Environment.GetEnvironmentVariables ((EnvironmentVariableTarget)Int32.MinValue);
 177                 }
 178
 179                 [Test]
 180                 [ExpectedException (typeof (ArgumentException))]
 181                 public void SetEnvironmentVariable_Target_Invalid ()
 182                 {
 183                         Environment.SetEnvironmentVariable ("MONO", "GO", (EnvironmentVariableTarget)Int32.MinValue);
 184                 }
 185
 186                 [Test]
 187                 [ExpectedException (typeof (ArgumentNullException))]
 188                 public void SetEnvironmentVariable_Name_Null ()
 189                 {
 190                         Environment.SetEnvironmentVariable (null, "A");
 191                 }
 192
 193                 [Test]
 194                 [ExpectedException (typeof (ArgumentException))]
 195                 public void SetEnvironmentVariable_Name_Empty ()
 196                 {
 197                         Environment.SetEnvironmentVariable ("", "A");
 198                 }
 199
 200                 [Test]
 201                 [ExpectedException (typeof (ArgumentException))]
 202                 public void SetEnvironmentVariable_Name_ZeroChar ()
 203                 {
 204                         Environment.SetEnvironmentVariable ("\0", "A");
 205                 }
 206
 207                 [Test]
 208                 public void SetEnvironmentVariable ()
 209                 {
 210                         // Test set
 211                         Environment.SetEnvironmentVariable ("A1", "B1");
 212                         Environment.SetEnvironmentVariable ("A2", "B2");
 213                         Environment.SetEnvironmentVariable ("A3", "B3");
 214                         Assert.AreEqual (Environment.GetEnvironmentVariable ("A1"), "B1");
 215                         Assert.AreEqual (Environment.GetEnvironmentVariable ("A2"), "B2");
 216                         Assert.AreEqual (Environment.GetEnvironmentVariable ("A3"), "B3");
 217
 218                         // Test update
 219                         Environment.SetEnvironmentVariable ("A3", "B4");
 220                         Assert.AreEqual (Environment.GetEnvironmentVariable ("A3"), "B4");
 221
 222                         // Test delete
 223                         Environment.SetEnvironmentVariable ("A1", null);
 224                         Assert.IsNull (Environment.GetEnvironmentVariables ()["A1"]);
 225                         Environment.SetEnvironmentVariable ("A2", "");
 226                         Assert.IsNull (Environment.GetEnvironmentVariables ()["A2"]);
 227                         Environment.SetEnvironmentVariable ("A3", "\0");
 228                         Assert.IsNull (Environment.GetEnvironmentVariables ()["A3"]);
 229                 }
 230 #endif
 231         }
 232 }