namespace Microsoft.Win32.SafeHandles {
- [MonoTODO]
+ [MonoTODO("Not implemented on Mono")]
public sealed class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid {
public SafeFileHandle (IntPtr preexistingHandle, bool ownsHandle) : base (ownsHandle)
namespace Microsoft.Win32.SafeHandles {
- [MonoTODO]
+ [MonoTODO ("Not implemented on Mono")]
public abstract class SafeHandleZeroOrMinusOneIsInvalid : SafeHandle, IDisposable {
protected SafeHandleZeroOrMinusOneIsInvalid (bool ownsHandle) : base ((IntPtr) 0, ownsHandle) {
}
j = (p - 1) / q;
}
- [MonoTODO()]
private bool Validate ()
{
// J is optional
return true;
}
-/* [MonoTODO ("Find out what this should do")]
- protected virtual void Canonicalize ()
- {
- }*/
-
public static bool CheckSchemeName (string schemeName)
{
if (schemeName == null || schemeName.Length == 0)
return true;
}
-/* [MonoTODO ("Find out what this should do")]
- protected virtual void CheckSecurity ()
- {
- }*/
-
public override bool Equals (object comparant)
{
if (comparant == null)
return loc != -1;
}
- [MonoTODO ("I can make it faster than this...")]
+ // FIXME: this could probably be made faster.
public int RemoveAll (Predicate <T> match)
{
CheckMatch (match);
+2006-11-16 Miguel de Icaza <miguel@novell.com>
+
+ * Hashtable.cs: Serialize EqualityComparer.
+
2006-08-16 Miguel de Icaza <miguel@novell.com>
* Hashtable.cs (PutImpl): Do not access the table twice, only
return ht;
}
-#if NET_2_0
- [MonoTODO ("Serialize equalityComparer")]
-#endif
public virtual void GetObjectData (SerializationInfo info, StreamingContext context)
{
if (info == null)
info.AddValue ("LoadFactor", loadFactor);
info.AddValue ("Version", modificationCount);
- info.AddValue ("Comparer", comparerRef);
+#if NET_2_0
+ if (equalityComparer != null)
+ info.AddValue ("KeyComparer", equalityComparer);
+ else
+ info.AddValue ("Comparer", comparerRef);
+#else
+ info.AddValue ("Comparer", comparerRef);
+#endif
info.AddValue ("HashCodeProvider", hcpRef);
info.AddValue ("HashSize", this.table.Length);
// Create Keys
info.AddValue ("Keys", keys);
info.AddValue ("Values", values);
+#if NET_2_0
+ info.AddValue ("equalityComparer", equalityComparer);
+#endif
}
#if NET_2_0
loadFactor = (float) serializationInfo.GetValue ("LoadFactor", typeof(float));
modificationCount = (int) serializationInfo.GetValue ("Version", typeof(int));
+#if NET_2_0
+ equalityComparer = (IEqualityComparer) serializationInfo.GetValue ("KeyComparer", typeof (object));
+ if (equalityComparer == null)
+ comparerRef = (IComparer) serializationInfo.GetValue ("Comparer", typeof (object));
+#else
comparerRef = (IComparer) serializationInfo.GetValue ("Comparer", typeof (object));
+#endif
+
hcpRef = (IHashCodeProvider) serializationInfo.GetValue ("HashCodeProvider", typeof (object));
int size = (int) serializationInfo.GetValue ("HashSize", typeof(int));
}
- [MonoTODO]
public virtual object this [int index] {
get {
return host.GetByIndex (index);
}
set {
- // FIXME: It seems (according to tests)
- // that modifications are allowed
- // in Beta2.
- // ? host.SetByIndex (index, value);
- throw new NotSupportedException("attempt to modify a value");
+ throw new NotSupportedException("This operation is not supported on GetValueList return");
}
}
/// <summary>
/// Enables communication with a debugger.
/// </summary>
- [MonoTODO]
+ [MonoTODO ("The Debugger class is not functional")]
public sealed class Debugger
{
private static bool isAttached;
/// <summary>
/// Checks to see if logging is enabled by an attached debugger.
/// </summary>
- [MonoTODO]
public static bool IsLogging()
{
// Return false. DefaultTraceListener invokes this method, so throwing
// a NotImplementedException wouldn't be appropriate.
- return false;
+ return false;
}
/// <summary>
/// Launches and attaches a debugger to the process.
/// </summary>
- [MonoTODO]
+ [MonoTODO ("Not implemented")]
public static bool Launch()
{
throw new NotImplementedException();
/// <param name="message">
/// A string representing the message to show.
/// </param>
- [MonoTODO]
public static void Log(int level, string category, string message)
{
// Do nothing. DefaultTraceListener invokes this method, so throwing
namespace System.Diagnostics {
[Serializable]
- [MonoTODO ("Fix serialization compatibility with MS.NET")]
+ [MonoTODO ("Serialized objects are not compatible with MS.NET")]
public class StackFrame {
public const int OFFSET_UNKNOWN = -1;
namespace System.Diagnostics {
[Serializable]
- [MonoTODO ("Fix serialization compatibility with MS.NET")]
+ [MonoTODO ("Serialized objects are not compatible with .NET")]
public class StackTrace {
public const int METHODS_TO_SKIP = 0;
#if ONLY_1_1
[ReflectionPermission (SecurityAction.Demand, TypeInformation = true)]
#endif
- [MonoTODO]
+ [MonoTODO ("Not possible to create StackTraces from other threads")]
public StackTrace (Thread targetThread, bool needFileInfo)
{
throw new NotImplementedException ();
CompareOptions.None));
}
- [MonoTODO("Add support for CompareOptions.OrdinalIgnoreCase")]
+ [MonoTODO("Does not support CompareOptions.OrdinalIgnoreCase")]
public virtual int Compare (string string1, int offset1,
int length1, string string2,
int offset2, int length2,
internal_index (s, sindex, count, c, opt, first);
}
- [MonoTODO("Add support for CompareOptions.OrdinalIgnoreCase")]
+ [MonoTODO("Does not support CompareOptions.OrdinalIgnoreCase")]
public virtual int IndexOf (string source, char value,
int startIndex, int count,
CompareOptions options)
internal_index (s1, sindex, count, s2, opt, first);
}
- [MonoTODO("Add support for CompareOptions.OrdinalIgnoreCase")]
+ [MonoTODO("Does not support CompareOptions.OrdinalIgnoreCase")]
public virtual int IndexOf (string source, string value,
int startIndex, int count,
CompareOptions options)
CompareOptions.None));
}
- [MonoTODO("Add support for CompareOptions.OrdinalIgnoreCase")]
+ [MonoTODO("Does not support CompareOptions.OrdinalIgnoreCase")]
public virtual int LastIndexOf(string source, char value,
int startIndex, int count,
CompareOptions options)
}
}
- [MonoTODO]
+ [MonoTODO ("Always returns null")]
public static CultureInfo InstalledUICulture
{
get {
}
}
- [MonoTODO]
+ [MonoTODO ("Currently it ignores the altName parameter")]
public static CultureInfo GetCultureInfo (string name, string altName) {
- throw new NotImplementedException ();
+ if (name == null)
+ throw new ArgumentNullException ("null");
+ if (altName == null)
+ throw new ArgumentNullException ("null");
+
+ return GetCultureInfo (name);
}
#endif
#if !NET_1_0
void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context)
{
- info.AddValue ("m_userToken", _token);
+ info.AddValue ("m_userToken", (long) _token);
// can be null when not resolved
info.AddValue ("m_name", _name);
info.AddValue ("m_type", _type);
Dispose (false);
}
- [MonoTODO ("default ?")]
public ContextForm Form {
get { return _form; }
}
get { return _appid; }
}
- [MonoTODO]
+ [MonoTODO ("Missing validation")]
static public ActivationContext CreatePartialActivationContext (ApplicationIdentity identity)
{
if (identity == null)
return new ActivationContext (identity);
}
- [MonoTODO]
+ [MonoTODO("Missing validation")]
static public ActivationContext CreatePartialActivationContext (ApplicationIdentity identity, string[] manifestPaths)
{
if (identity == null)
}
}
- [MonoTODO]
+ [MonoTODO("Missing serialization support")]
void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context)
{
if (info == null)
{
}
- [MonoTODO]
+ [MonoTODO ("No COM support")]
public static ObjectHandle CreateComInstanceFrom (string assemblyName, string typeName)
{
if (assemblyName == null)
refusedPermissions, false);
}
- [MonoTODO ("FIXME: examine all other parameters")]
public AssemblyBuilder DefineDynamicAssembly (AssemblyName name, AssemblyBuilderAccess access, string dir,
Evidence evidence,
PermissionSet requiredPermissions,
[MethodImplAttribute (MethodImplOptions.InternalCall)]
public extern int ExecuteAssembly (string assemblyFile, Evidence assemblySecurity, string[] args);
- [MonoTODO]
+ [MonoTODO ("No support for ExecuteAssembly")]
public int ExecuteAssembly (string assemblyFile, Evidence assemblySecurity, string[] args, byte[] hashValue, AssemblyHashAlgorithm hashAlgorithm)
{
throw new NotImplementedException ();
return Object.ReferenceEquals (this, DefaultDomain);
}
- [MonoTODO ("see Assembly.ReflectionOnlyLoad")]
public Assembly[] ReflectionOnlyGetAssemblies ()
{
return GetAssemblies (true);
// static
- [MonoTODO ("maybe AppDomain.CreateDomain should be calling this ?")]
+ // FIXME: maybe AppDomain.CreateDomain should be calling this?
protected static AppDomain CreateDomainHelper (string friendlyName, Evidence securityInfo, AppDomainSetup appDomainInfo)
{
return AppDomain.CreateDomain (friendlyName, securityInfo, appDomainInfo);
// (C) 2001 Ximian, Inc. http://www.ximian.com
// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
//
+// Known Problems:
+// Fix serialization compatibility with MS.NET.
+//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
{
[Serializable]
[ClassInterface (ClassInterfaceType.None)]
- [MonoTODO ("Fix serialization compatibility with MS.NET")]
#if NET_2_0
[ComVisible (true)]
#endif
}
}
- [MonoTODO ("--share-code")]
+ [MonoTODO ("In Mono this is controlled by the --share-code flag")]
public LoaderOptimization LoaderOptimization {
get {
return loader_optimization;
_fullName = applicationIdentityFullName;
}
- [MonoTODO ("URL for deployment manifest")]
+ //
+ // FIXME: "URL for deployment manifest", this message should be clearer!
+ //
public string CodeBase {
get { return _codeBase; }
}
return _fullName;
}
- [MonoTODO]
+ [MonoTODO ("Missing serialization")]
void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context)
{
if (info == null)
return array.GetLowerBound (0) - 1;
}
- [MonoTODO]
public void Initialize()
{
//FIXME: We would like to find a compiler that uses
return element.IsDefined (attributeType, inherit);
}
- [MonoTODO]
+ // FIXME: MS apparently walks the inheritance way in some form.
public static bool IsDefined (ParameterInfo element, Type attributeType, bool inherit)
{
CheckParameters (element, attributeType);
ConsoleDriver.Clear ();
}
- [MonoTODO]
+ [MonoTODO ("Not implemented")]
public static void MoveBufferArea (int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight,
int targetLeft, int targetTop)
{
throw new NotImplementedException ();
}
- [MonoTODO]
+ [MonoTODO("Not implemented")]
public static void MoveBufferArea (int sourceLeft, int sourceTop, int sourceWidth, int sourceHeight,
int targetLeft, int targetTop, Char sourceChar,
ConsoleColor sourceForeColor, ConsoleColor sourceBackColor)
#endif
}
- [MonoTODO ("Calendar is unused")]
+ [MonoTODO ("The Calendar is not taken into consideration")]
public DateTime (int year, int month, int day, Calendar calendar)
: this (year, month, day, 0, 0, 0, 0, calendar)
{
}
- [MonoTODO ("Calendar is unused")]
+ [MonoTODO ("The Calendar is not taken into consideration")]
public DateTime (int year, int month, int day, int hour, int minute, int second, Calendar calendar)
: this (year, month, day, hour, minute, second, 0, calendar)
{
}
- [MonoTODO ("Calendar is unused")]
+ [MonoTODO ("The Calendar is not taken into consideration")]
public DateTime (int year, int month, int day, int hour, int minute, int second, int millisecond, Calendar calendar)
: this (year, month, day, hour, minute, second, millisecond)
{
if (calendar == null)
throw new ArgumentNullException ("calendar");
- // FIXME: we're not using the calendar anywhere???
}
internal DateTime (bool check, TimeSpan value)
return Parse (s, fp, DateTimeStyles.AllowWhiteSpaces);
}
- [MonoTODO ("see the comments inline")]
public static DateTime Parse (string s, IFormatProvider fp, DateTimeStyles styles)
{
// This method should try only expected patterns.
return result;
}
- [MonoTODO("check if digits are group in correct numbers between the group separators")]
+ // FIXME: check if digits are group in correct numbers between the group separators
internal static bool Parse (string s, NumberStyles style, IFormatProvider provider, bool tryParse, out double result, out Exception exc)
{
result = 0;
*/
private const int mono_corlib_version = 54;
- [MonoTODO]
public enum SpecialFolder
{ // TODO: Determine if these windoze style folder identifiers
// have unix/linux counterparts
/// <summary>
/// Gets a flag indicating whether the process is in interactive mode
/// </summary>
- [MonoTODO]
+ [MonoTODO ("Currently always returns false, regardless of interactive state")]
public static bool UserInteractive {
get {
return false;
/// <summary>
/// Get the amount of physical memory mapped to process
/// </summary>
- [MonoTODO]
+ [MonoTODO ("Currently always returns zero")]
public static long WorkingSet {
[EnvironmentPermission (SecurityAction.Demand, Unrestricted=true)]
get { return 0; }
get;
}
- [MonoTODO ("not much documented")]
+ [MonoTODO ("Not implemented")]
[SecurityPermission (SecurityAction.LinkDemand, UnmanagedCode=true)]
public static void FailFast (string message)
{
#if NET_2_0
[ReliabilityContractAttribute (Consistency.WillNotCorruptState, Cer.Success)]
- [MonoTODO]
+ [MonoTODO ("Not implemented, always returns 0")]
public static int CollectionCount (int generation) {
- throw new NotImplementedException ();
+ return 1;
}
- [MonoTODO]
+ [MonoTODO ("Not implemented")]
public static void AddMemoryPressure (long bytesAllocated) {
- throw new NotImplementedException ();
+
}
- [MonoTODO]
+ [MonoTODO ("Not implemented")]
public static void RemoveMemoryPressure (long bytesAllocated) {
- throw new NotImplementedException ();
}
#endif
}
public void CreateFromUrl_Intranet ()
{
foreach (string url in intranetUrls) {
+ Console.WriteLine ("url: " + url) ;
Zone z = Zone.CreateFromUrl (url);
AssertEquals (url, SecurityZone.Intranet, z.SecurityZone);
}
projects / mono.git / commitdiff