}
// 5 path
- pos = uriString.IndexOfAny (new char[] {'/'});
+ pos = uriString.IndexOfAny (new char[] {'/', '\\'});
if (unixAbsPath)
pos = -1;
if (pos == -1) {
pos = uriString.LastIndexOf (":");
if (unixAbsPath)
pos = -1;
+ if (pos == 1 && scheme == Uri.UriSchemeFile && Char.IsLetter (uriString [0]))
+ pos = -1;
if (pos != -1 && pos != (uriString.Length - 1)) {
string portStr = uriString.Remove (0, pos + 1);
if (portStr.Length > 1 && portStr [portStr.Length - 1] != ']') {
if (url.Length == 0)
return new Zone (z);
- Uri uri = new Uri (url);
+ Uri uri = null;
+ try {
+ uri = new Uri (url);
+ }
+ catch {
+ return new Zone (z);
+ }
// TODO: apply zone configuration
// this is the only way to use the Trusted and Untrusted zones
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
+using System.Security.Permissions;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Hosting;
appBase = appBase.Substring (7);
if (Path.DirectorySeparatorChar != '/')
appBase = appBase.Replace ('/', Path.DirectorySeparatorChar);
- if (Environment.IsRunningOnWindows) {
- // Under Windows prepend "//" to indicate it's a local file
- appBase = "//" + appBase;
+ }
+ appBase = Path.GetFullPath (appBase);
+
+ if (Path.DirectorySeparatorChar != '/') {
+ bool isExtendedPath = appBase.StartsWith (@"\\?\", StringComparison.Ordinal);
+ if (appBase.IndexOf (':', isExtendedPath ? 6 : 2) != -1) {
+ throw new NotSupportedException ("The given path's format is not supported.");
}
- } else {
- appBase = Path.GetFullPath (appBase);
}
+ // Trigger a validation of the path
+ new FileIOPermission (FileIOPermissionAccess.PathDiscovery, appBase);
+
return appBase;
}
var expected = 100000.ToString ("C");
thread.Start ();
- thread.Join ();
+ Assert.IsTrue (thread.Join (5000), "#0");
CultureInfo.DefaultThreadCurrentCulture = null;
Assert.AreEqual (expected, us_str, "#1");
Assert.AreEqual (expected, br_str, "#2");
"http://*.go-mono.com",
"http://www.go-mono.com:8080/index.html",
"mono://unknown/protocol",
- Path.DirectorySeparatorChar + "mono" + Path.DirectorySeparatorChar + "index.html",
+ "/mono/index.html",
};
[Test]
private bool RunningOnWindows {
get {
- int os = (int)Environment.OSVersion.Platform;
- return (os != 4);
+ return Path.DirectorySeparatorChar == '\\';
+ }
+ }
+ private bool RunningOnMono {
+ get {
+ return (Type.GetType ("System.MonoType", false) != null);
}
}
[Test]
public void ApplicationBase1 ()
{
- string expected_path = tmpPath.Replace(@"\", @"/");
+ string expected_path = tmpPath;
AppDomainSetup setup = new AppDomainSetup ();
- string fileUri = "file://" + expected_path;
+ string fileUri = "file://" + tmpPath.Replace(@"\", @"/");
setup.ApplicationBase = fileUri;
- // with MS 1.1 SP1 the expected_path starts with "//" but this make
- // sense only under Windows (i.e. reversed \\ for local files)
- if (RunningOnWindows)
- expected_path = "//" + expected_path;
try {
- // under 2.0 the NotSupportedException is throw when getting
+ // under .NET the NotSupportedException is throw when getting
// (and not setting) the ApplicationBase property
Assert.AreEqual (expected_path, setup.ApplicationBase);
}
catch (NotSupportedException) {
- // however the path is invalid only on Windows
- if (!RunningOnWindows)
+ // however the path is invalid only on .NET
+ if (RunningOnMono)
throw;
}
}
{
AppDomainSetup setup = new AppDomainSetup ();
setup.ApplicationBase = "lala:la";
- try {
- // under 2.0 the NotSupportedException is throw when getting
- // (and not setting) the ApplicationBase property
+ if (!RunningOnWindows) {
Assert.AreEqual (Path.GetFullPath ("lala:la"), setup.ApplicationBase);
- }
- catch (NotSupportedException) {
- // however the path is invalid only on Windows
- // (same exceptions as Path.GetFullPath)
- if (!RunningOnWindows)
- throw;
+ } else {
+ // On Windows we expect a NotSupportedException to be thrown because
+ // of the illegal character (:) in the path
+ try {
+ Assert.Fail ("NotSupportedException expected but setup.ApplicationBase returned:" + setup.ApplicationBase);
+ }
+ catch (NotSupportedException) {
+ // Expected
+ }
}
}
// This is failing because of (probably) a windows-ism, so don't worry
AppDomainSetup setup = new AppDomainSetup ();
setup.ApplicationBase = "file:///lala:la";
- try {
- // under 2.0 the NotSupportedException is throw when getting
- // (and not setting) the ApplicationBase property
- Assert.AreEqual ("/lala:la", setup.ApplicationBase);
- }
- catch (NotSupportedException) {
- // however the path is invalid only on Windows
- // (same exceptions as Path.GetFullPath)
- if (!RunningOnWindows)
- throw;
+ string expected = "/lala:la";
+ if (!RunningOnWindows) {
+ Assert.AreEqual (expected, setup.ApplicationBase);
+ } else {
+ // On Windows we expect a NotSupportedException to be thrown because
+ // of the illegal character (:) in the path
+ try {
+ Assert.Fail ("NotSupportedException expected but setup.ApplicationBase returned:" + setup.ApplicationBase);
+ }
+ catch (NotSupportedException) {
+ // Expected
+ }
}
}
setup.ApplicationBase = "la?lala";
// paths containing "?" are *always* bad on Windows
// but are legal for linux so we return a full path
- if (RunningOnWindows) {
+ if (!RunningOnWindows) {
+ Assert.AreEqual (Path.GetFullPath ("la?lala"), setup.ApplicationBase);
+ } else {
+ // On Windows we expect a ArgumentException to be thrown because
+ // of the illegal character (?) in the path
try {
- // ArgumentException is throw when getting
- // (and not setting) the ApplicationBase property
- Assert.Fail ("setup.ApplicationBase returned :" + setup.ApplicationBase);
+ Assert.Fail ("ArgumentException expected but setup.ApplicationBase returned:" + setup.ApplicationBase);
}
catch (ArgumentException) {
+ // Expected
+ }
+ }
+ }
+
+ [Test]
+ public void ApplicationBase7 ()
+ {
+ if (RunningOnWindows) {
+ // Extended paths are Windows only
+ AppDomainSetup setup = new AppDomainSetup ();
+ string expected = @"\\?\" + curDir;
+ setup.ApplicationBase = expected;
+ Assert.AreEqual (expected, setup.ApplicationBase);
+ }
+ }
+
+ [Test]
+ public void ApplicationBase8 ()
+ {
+ if (RunningOnWindows) {
+ // Extended paths are Windows only
+ AppDomainSetup setup = new AppDomainSetup ();
+ setup.ApplicationBase = @"\\?\C:\lala:la";
+ try {
+ Assert.Fail ("NotSupportedException expected but setup.ApplicationBase returned:" + setup.ApplicationBase);
}
- catch (Exception e) {
- Assert.Fail ("Unexpected exception: " + e.ToString ());
+ catch (NotSupportedException) {
+ // Expected
}
- } else {
- Assert.AreEqual (Path.GetFullPath ("la?lala"), setup.ApplicationBase);
}
}
binder.ReturnType
);
+#if MONO // referencesource version
+ Expression condition;
+ // If the return type can not be assigned null then just check for type assignablity otherwise allow null.
+ if (binder.ReturnType.IsValueType && Nullable.GetUnderlyingType(binder.ReturnType) == null) {
+ condition = Expression.TypeIs(resultMO.Expression, binder.ReturnType);
+ }
+ else {
+ condition = Expression.OrElse(
+ Expression.Equal(resultMO.Expression, Expression.Constant(null)),
+ Expression.TypeIs(resultMO.Expression, binder.ReturnType));
+ }
+
+ var checkedConvert = Expression.Condition(
+ condition,
+ convert,
+ Expression.Throw(
+ Expression.New(typeof(InvalidCastException).GetConstructor(new Type[]{typeof(string)}),
+ Expression.Call(
+ typeof(string).GetMethod("Format", new Type[] {typeof(string), typeof(object[])}),
+ Expression.Constant(convertFailed),
+ Expression.NewArrayInit(typeof(object),
+ Expression.Condition(
+ Expression.Equal(resultMO.Expression, Expression.Constant(null)),
+ Expression.Constant("null"),
+ Expression.Call(
+ resultMO.Expression,
+ typeof(object).GetMethod("GetType")
+ ),
+ typeof(object)
+ )
+ )
+ )
+ ),
+ binder.ReturnType
+ ),
+ binder.ReturnType
+ );
+#else
var checkedConvert = Expression.Condition(
Expression.TypeIs(resultMO.Expression, binder.ReturnType),
convert,
),
binder.ReturnType
);
+#endif
resultMO = new DynamicMetaObject(checkedConvert, resultMO.Restrictions);
}
pow /= 10;
}
}
+ } else if (c == '\n' || c == UnicodeLS || c == UnicodePS) {
+ advance_line ();
+ break;
} else if ((c < 'a' || c > 'z') && (c < 'A' || c > 'Z') && c != '_') {
break;
}
while (c == ' ' || c == '\t')
c = get_char ();
- if (c == '\n' || c == UnicodeLS || c == UnicodePS)
- advance_line ();
-
return number;
}
--- /dev/null
+using System.Dynamic;
+
+public class TestConvert : DynamicObject
+{
+ public override bool TryConvert (ConvertBinder binder, out object result)
+ {
+ result = null;
+ return true;
+ }
+}
+
+public class Test : DynamicObject
+{
+ public override bool TryInvokeMember (InvokeMemberBinder binder, object [] args, out object result)
+ {
+ result = new TestConvert ();
+ return true;
+ }
+}
+
+public class XX
+{
+ public static void Main ()
+ {
+ dynamic t = new Test ();
+ string result = t.SomeMethod ();
+ }
+}
\ No newline at end of file
<?xml version="1.0" encoding="utf-8"?>
<symbols>
<files>
- <file id="1" name="test-debug-30.cs" checksum="d3addfa69f16faf00991ef839451a975" />
+ <file id="1" name="test-debug-30.cs" checksum="5303b32b0208123737567d53022ae3d5" />
</files>
<methods>
<method token="0x6000001">
<locals />
<scopes />
</method>
+ <method token="0x6000004">
+ <sequencepoints>
+ <entry il="0x0" row="23" col="2" file_ref="1" hidden="false" />
+ <entry il="0x1" row="24" col="3" file_ref="1" hidden="false" />
+ <entry il="0x6" row="25" col="2" file_ref="1" hidden="false" />
+ </sequencepoints>
+ <locals />
+ <scopes />
+ </method>
</methods>
</symbols>
\ No newline at end of file
{
return;
}
+
+#pragma warning disable 618
+#pragma warning restore 618
+
+ void OneMore ()
+ {
+ return;
+ }
}
\ No newline at end of file
</method>
</type>
</test>
+ <test name="dtest-065.cs">
+ <type name="TestConvert">
+ <method name="Boolean TryConvert(System.Dynamic.ConvertBinder, System.Object ByRef)" attrs="198">
+ <size>13</size>
+ </method>
+ <method name="Void .ctor()" attrs="6278">
+ <size>7</size>
+ </method>
+ </type>
+ <type name="Test">
+ <method name="Boolean TryInvokeMember(System.Dynamic.InvokeMemberBinder, System.Object[], System.Object ByRef)" attrs="198">
+ <size>17</size>
+ </method>
+ <method name="Void .ctor()" attrs="6278">
+ <size>7</size>
+ </method>
+ </type>
+ <type name="XX">
+ <method name="Void Main()" attrs="150">
+ <size>154</size>
+ </method>
+ <method name="Void .ctor()" attrs="6278">
+ <size>7</size>
+ </method>
+ </type>
+ </test>
<test name="dtest-anontype-01.cs">
<type name="C">
<method name="Void Main()" attrs="150">
<method name="Void .ctor()" attrs="6278">
<size>7</size>
</method>
+ <method name="Void OneMore()" attrs="129">
+ <size>7</size>
+ </method>
</type>
</test>
<test name="test-decl-expr-01.cs">
projects / mono.git / commitdiff