[corlib] Fix tests for watchOS. (#3131)

[mono.git] / mcs / class / corlib / Test / System / EnvironmentTest.cs

diff --git a/mcs/class/corlib/Test/System/EnvironmentTest.cs b/mcs/class/corlib/Test/System/EnvironmentTest.cs
index 9fa5ca6208b94b698713cb51af72aca3b589c1bb..fed370974e584b8d5c33dd49eca0a75dc87de8e6 100644 (file)
--- a/mcs/class/corlib/Test/System/EnvironmentTest.cs
+++ b/mcs/class/corlib/Test/System/EnvironmentTest.cs
@@ -5,17 +5,19 @@
 //     Sebastien Pouliot <sebastien@ximian.com>
 //
 // (C) 2004-2005 Novell (http://www.novell.com)
+// Copyright 2011 Xamarin Inc (http://www.xamarin.com).
 //
 
-using NUnit.Framework;
-using System;\r
+using System;
 using System.Collections;
 
-namespace MonoTests.System {
+using NUnit.Framework;
 
+namespace MonoTests.System
+{
        [TestFixture]
-       public class EnvironmentTest {
-
+       public class EnvironmentTest
+       {
                private void ExpandEquals (string toExpand, string toMatch) 
                {
                        string expanded = Environment.ExpandEnvironmentVariables (toExpand);
@@ -25,7 +27,7 @@ namespace MonoTests.System {
                private void ExpandStartsEnds (string toExpand, string start, string end) 
                {
                        string expanded = Environment.ExpandEnvironmentVariables (toExpand);
-                       Assert.IsTrue (expanded.StartsWith (start), "ExpandEnvironmentVariables(" + toExpand + ").Start");\r
+                       Assert.IsTrue (expanded.StartsWith (start), "ExpandEnvironmentVariables(" + toExpand + ").Start");
                        Assert.IsTrue (expanded.EndsWith (end), "ExpandEnvironmentVariables(" + toExpand + ").End");
                }
 
@@ -83,7 +85,7 @@ namespace MonoTests.System {
                        ExpandDifferent ("%PATH%%PATH%");
                        string path = Environment.GetEnvironmentVariable ("PATH");
                        if (path != null) {
-                               string expanded = Environment.ExpandEnvironmentVariables ("%PATH%%PATH%");\r
+                               string expanded = Environment.ExpandEnvironmentVariables ("%PATH%%PATH%");
                                Assert.AreEqual (path + path, expanded, "#01");
                        }
                }
@@ -98,7 +100,7 @@ namespace MonoTests.System {
                public void ExpandEnvironmentVariables_ExpandableAndNonExpandable () 
                {
                        string path = Environment.GetEnvironmentVariable ("PATH");
-                       string expanded=Environment.ExpandEnvironmentVariables("%PATH% PATH%");\r
+                       string expanded=Environment.ExpandEnvironmentVariables("%PATH% PATH%");
                        Assert.AreEqual (path + " PATH%", expanded);
                }
 
@@ -115,67 +117,93 @@ namespace MonoTests.System {
                public void ExpandEnvironmentVariables_ComplexExpandable2 () 
                {
                        ExpandStartsEnds ("Hello %%PATH%%%", "Hello %", "%%");
-               }\r
-\r
-               [Test]\r
-               public void GetEnvironmentVariables ()\r
-               {\r
-                       IDictionary d = Environment.GetEnvironmentVariables ();\r
-                       Assert.IsTrue ((d is Hashtable), "Hashtable");\r
-                       Assert.IsFalse (d.IsFixedSize, "IsFixedSize");\r
-                       Assert.IsFalse (d.IsReadOnly, "IsReadOnly");\r
-                       Assert.IsFalse (d.IsSynchronized, "IsSynchronized");\r
                }
 
+               [Test]
+               // Bug #5169
+               public void ExpandEnvironmentVariables_ExpandMultiple ()
+               {
+                       string path = Environment.GetEnvironmentVariable ("PATH");
+                       var expected = "%TEST123" + path + "TEST456%";
+                       ExpandEquals ("%TEST123%PATH%TEST456%", expected);
+               }
+
+               [Test]
+               public void GetEnvironmentVariables ()
+               {
+                       IDictionary d = Environment.GetEnvironmentVariables ();
+                       Assert.IsTrue ((d is Hashtable), "Hashtable");
+                       Assert.IsFalse (d.IsFixedSize, "IsFixedSize");
+                       Assert.IsFalse (d.IsReadOnly, "IsReadOnly");
+                       Assert.IsFalse (d.IsSynchronized, "IsSynchronized");
+               }
+
+#if !NET_2_1
+               [Test] // bug #333740
+               public void GetEnvironmentVariables_NewlySet ()
+               {
+                       Environment.SetEnvironmentVariable ("MonoTestVariable", "TestValue");
+                       IDictionary d = Environment.GetEnvironmentVariables ();
+                       Assert.AreEqual ("TestValue", d ["MonoTestVariable"], "#1");
+                       Environment.SetEnvironmentVariable ("MonoTestVariable", string.Empty);
+                       Assert.AreEqual ("TestValue", d ["MonoTestVariable"], "#2");
+                       d = Environment.GetEnvironmentVariables ();
+                       Assert.IsNull (d ["MonoTestVariable"], "#3");
+               }
+#endif
+
                [Test]
                public void GetCommandLineArgs ()
                {
                        string[] args = Environment.GetCommandLineArgs ();
+#if !__WATCHOS__
                        Assert.IsNotNull (args, "not null");
                        Assert.IsTrue (((args.Length > 0) && (args.Length < 256)), "reasonable");
                        Assert.IsNotNull (args [0], "application");
+#else
+                       Assert.AreEqual (0, args.Length, "length");
+#endif
                }
 
-#if NET_2_0
+#if !NET_2_1
                [Test]
                [ExpectedException (typeof (ArgumentException))]
-               public void GetEnvironmentVariable_Target ()
+               public void GetEnvironmentVariable_Target_Invalid ()
                {
                        Environment.GetEnvironmentVariable ("MONO", (EnvironmentVariableTarget)Int32.MinValue);
                }
 
-               [Test]\r
-               [ExpectedException (typeof (ArgumentException))]\r
-               public void GetEnvironmentVariables_Target ()
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void GetEnvironmentVariables_Target_Invalid ()
                {
                        Environment.GetEnvironmentVariables ((EnvironmentVariableTarget)Int32.MinValue);
                }
 
-#if !TARGET_JVM // Environment.SetEnvironmentVariable not supported under TARGET_JVM
-               [Test]\r
-               [ExpectedException (typeof (ArgumentException))]\r
-               public void SetEnvironmentVariable_Target ()
+               [Test]
+               [ExpectedException (typeof (ArgumentException))]
+               public void SetEnvironmentVariable_Target_Invalid ()
                {
                        Environment.SetEnvironmentVariable ("MONO", "GO", (EnvironmentVariableTarget)Int32.MinValue);
                }
 
                [Test]
                [ExpectedException (typeof (ArgumentNullException))]
-               public void SetEnvironmentVariable_NameNull ()
+               public void SetEnvironmentVariable_Name_Null ()
                {
                        Environment.SetEnvironmentVariable (null, "A");
                }
 
                [Test]
                [ExpectedException (typeof (ArgumentException))]
-               public void SetEnvironmentVariable_NameEmpty ()
+               public void SetEnvironmentVariable_Name_Empty ()
                {
                        Environment.SetEnvironmentVariable ("", "A");
                }
 
                [Test]
                [ExpectedException (typeof (ArgumentException))]
-               public void SetEnvironmentVariable_NameZeroChar ()
+               public void SetEnvironmentVariable_Name_ZeroChar ()
                {
                        Environment.SetEnvironmentVariable ("\0", "A");
                }
@@ -197,13 +225,12 @@ namespace MonoTests.System {
 
                        // Test delete
                        Environment.SetEnvironmentVariable ("A1", null);
-                       Assert.AreEqual (Environment.GetEnvironmentVariables ()["A1"], null);
+                       Assert.IsNull (Environment.GetEnvironmentVariables ()["A1"]);
                        Environment.SetEnvironmentVariable ("A2", "");
-                       Assert.AreEqual (Environment.GetEnvironmentVariables ()["A2"], null);
+                       Assert.IsNull (Environment.GetEnvironmentVariables ()["A2"]);
                        Environment.SetEnvironmentVariable ("A3", "\0");
-                       Assert.AreEqual (Environment.GetEnvironmentVariables ()["A3"], null);
+                       Assert.IsNull (Environment.GetEnvironmentVariables ()["A3"]);
                }
-#endif // TARGET_JVM
 #endif
        }
 }