case PlatformID.Unix:
break;
default:
- return; // ignore, cannot run it
+ Assert.Ignore (); // ignore, cannot run it
+ break;
}
var xml = XmlReader.Create (new StringReader (project_xml));
public void ReadLinkAt ()
{
if (!HaveReadlinkAt)
- return;
+ Assert.Ignore ("No ReadlinkAt.");
foreach (string s in Targets) {
CreateLink (s);
public void TryReadLinkAt ()
{
if (!HaveReadlinkAt)
- return;
+ Assert.Ignore ("No ReadlinkAt.");
foreach (string s in Targets) {
CreateLink (s);
public void readlinkat_byte ()
{
if (!HaveReadlinkAt)
- return;
+ Assert.Ignore ("No ReadlinkAt.");
foreach (string s in Targets) {
CreateLink (s);
public void readlinkat_char ()
{
if (!HaveReadlinkAt)
- return;
+ Assert.Ignore ("No ReadlinkAt.");
foreach (string s in Targets) {
CreateLink (s);
public void NamedPipeDefaultPermissionsWork ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
string name = @"Local\MonoTestPipeNPNPW";
public void NamedPipeSetAccessControlFailsWithoutChangePermissionRight ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
string name = @"Local\MonoTestPipeNPSACFWCPR";
void NamedPipePermissionsActuallyWorkSync (string name, bool addDenyEveryone)
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
PipeSecurity security = new PipeSecurity ();
public void NamedPipePermissionsActuallyWorkAsync ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
IAsyncResult waitForConnection;
public void GetLocal ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo local = TimeZoneInfo.Local;
Assert.IsNotNull (local);
Assert.IsTrue (true);
public void DSTInLondon ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
DateTime june01 = new DateTime (2007, 06, 01);
DateTime xmas = new DateTime (2007, 12, 25);
Assert.IsTrue (london.IsDaylightSavingTime (june01), "June 01 is DST in London");
public void DSTTransisions ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
DateTime beforeDST = new DateTime (2007, 03, 25, 0, 59, 59, DateTimeKind.Unspecified);
DateTime startDST = new DateTime (2007, 03, 25, 2, 0, 0, DateTimeKind.Unspecified);
DateTime endDST = new DateTime (2007, 10, 28, 1, 59, 59, DateTimeKind.Unspecified);
public void ConvertFromUTC_ConvertInWinter ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
DateTime utc = new DateTime (2007, 12, 25, 12, 0, 0);
DateTime converted = TimeZoneInfo.ConvertTimeFromUtc (utc, london);
Assert.AreEqual (utc, converted);
public void ConvertFromUtc_ConvertInSummer ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
DateTime utc = new DateTime (2007, 06, 01, 12, 0, 0);
DateTime converted = TimeZoneInfo.ConvertTimeFromUtc (utc, london);
Assert.AreEqual (utc + new TimeSpan (1,0,0), converted);
public void ConvertFromToUtc ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
DateTime utc = DateTime.UtcNow;
Assert.AreEqual (utc.Kind, DateTimeKind.Utc);
DateTime converted = TimeZoneInfo.ConvertTimeFromUtc (utc, london);
public void ConvertToTimeZone ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo.ConvertTime (DateTime.Now, TimeZoneInfo.FindSystemTimeZoneById("Pacific/Auckland"));
}
public void AmbiguousDates ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
Assert.IsFalse (london.IsAmbiguousTime (new DateTime (2007, 10, 28, 1, 0, 0)));
Assert.IsTrue (london.IsAmbiguousTime (new DateTime (2007, 10, 28, 1, 0, 1)));
Assert.IsTrue (london.IsAmbiguousTime (new DateTime (2007, 10, 28, 2, 0, 0)));
public void AmbiguousUTCDates ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
Assert.IsFalse (london.IsAmbiguousTime (new DateTime (2007, 10, 28, 0, 0, 0, DateTimeKind.Utc)));
Assert.IsTrue (london.IsAmbiguousTime (new DateTime (2007, 10, 28, 0, 0, 1, DateTimeKind.Utc)));
Assert.IsTrue (london.IsAmbiguousTime (new DateTime (2007, 10, 28, 0, 59, 59, DateTimeKind.Utc)));
public void NotEmpty ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
global::System.Collections.ObjectModel.ReadOnlyCollection<TimeZoneInfo> systemTZ = TimeZoneInfo.GetSystemTimeZones ();
Assert.IsNotNull(systemTZ, "SystemTZ is null");
Assert.IsFalse (systemTZ.Count == 0, "SystemTZ is empty");
public void ContainsBrussels ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
global::System.Collections.ObjectModel.ReadOnlyCollection<TimeZoneInfo> systemTZ = TimeZoneInfo.GetSystemTimeZones ();
foreach (TimeZoneInfo tz in systemTZ) {
if (tz.Id == "Europe/Brussels")
public void FindBrusselsTZ ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo brussels = TimeZoneInfo.FindSystemTimeZoneById ("Europe/Brussels");
Assert.IsNotNull (brussels);
}
public void OffsetIsCorrectInKinshasa ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo kin = TimeZoneInfo.FindSystemTimeZoneById ("Africa/Kinshasa");
Assert.AreEqual (new TimeSpan (1,0,0), kin.BaseUtcOffset, "BaseUtcOffset in Kinshasa is not +1h");
}
public void OffsetIsCorrectInBrussels ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo brussels = TimeZoneInfo.FindSystemTimeZoneById ("Europe/Brussels");
Assert.AreEqual (new TimeSpan (1,0,0), brussels.BaseUtcOffset, "BaseUtcOffset for Brussels is not +1h");
}
public void NoDSTInKinshasa ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo kin = TimeZoneInfo.FindSystemTimeZoneById ("Africa/Kinshasa");
Assert.IsFalse (kin.SupportsDaylightSavingTime);
}
public void BrusselsSupportsDST ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo brussels = TimeZoneInfo.FindSystemTimeZoneById ("Europe/Brussels");
Assert.IsTrue (brussels.SupportsDaylightSavingTime);
}
public void MelbourneSupportsDST ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo melbourne = TimeZoneInfo.FindSystemTimeZoneById ("Australia/Melbourne");
Assert.IsTrue (melbourne.SupportsDaylightSavingTime);
}
public void RomeAndVaticanSharesTime ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo rome = TimeZoneInfo.FindSystemTimeZoneById ("Europe/Rome");
TimeZoneInfo vatican = TimeZoneInfo.FindSystemTimeZoneById ("Europe/Vatican");
Assert.IsTrue (rome.HasSameRules (vatican));
public void AmbiguousOffsets ()
{
if (Environment.OSVersion.Platform != PlatformID.Unix)
- return;
+ Assert.Ignore ("Not running on Unix.");
TimeZoneInfo brussels = TimeZoneInfo.FindSystemTimeZoneById ("Europe/Brussels");
DateTime date = new DateTime (2007, 10, 28, 2, 30, 00);
Assert.IsTrue (brussels.IsAmbiguousTime (date));
// Check for installed printers, because we need
// to have at least one to test
if (PrinterSettings.InstalledPrinters.Count == 0)
- return;
+ Assert.Ignore ("No printers found.");
PageSettings ps = new PageSettings ();
ps.Color = false;
{
// ensure libgdiplus is built with printing support enabled
if (GDIPlus.RunningOnWindows ())
- return;
+ Assert.Ignore ("Running on Windows.");
Assert.AreEqual (Status.InvalidParameter, GdipGetPostScriptSavePage (IntPtr.Zero), "Missing printing support");
}
public void DefaultValues ()
{
if (!NetPeerTcpBinding.IsPnrpAvailable)
- return; // yes, we actually don't test it.
+ Assert.Ignore ("PNRP is not available."); // yes, we actually don't test it.
var n = new NetPeerTcpBinding ();
Assert.AreEqual (EnvelopeVersion.Soap12, n.EnvelopeVersion, "#1");
public void Constructor1 ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
public void Constructor2 ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("lanmanworkstation");
public void Constructor2_Name_DisplayName ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("workstation");
public void Constructor2_Name_ServiceName ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("lanmanworkstation");
public void Constructor3 ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("lanmanworkstation",
Environment.MachineName);
public void CanPauseAndContinue ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.IsTrue (sc.CanPauseAndContinue, "#1");
public void CanPauseAndContinue_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void CanPauseAndContinue_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("NetDDE", ".");
Assert.IsFalse (sc1.CanPauseAndContinue);
public void CanPauseAndContinue_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void CanPauseAndContinue_Service_OperationNotValid ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("SamSs", ".");
Assert.IsFalse (sc1.CanPauseAndContinue);
public void CanPauseAndContinue_Service_Running ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
public void CanPauseAndContinue_Service_Paused ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void CanPauseAndContinue_Service_Stopped ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void CanShutdown ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.IsTrue (sc.CanShutdown, "#1");
public void CanShutdown_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void CanShutdown_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("NetDDE", ".");
Assert.IsFalse (sc1.CanShutdown);
public void CanShutdown_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void CanShutdown_Service_OperationNotValid ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("SamSs", ".");
Assert.IsFalse (sc1.CanShutdown);
public void CanShutdown_Service_Running ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
public void CanShutdown_Service_Paused ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void CanShutdown_Service_Stopped ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void CanStop ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.IsTrue (sc.CanStop, "#1");
public void CanStop_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void CanStop_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("NetDDE", ".");
Assert.IsFalse (sc1.CanStop);
public void CanStop_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void CanStop_Service_OperationNotValid ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("SamSs", ".");
Assert.IsFalse (sc1.CanStop);
public void CanStop_Service_Running ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#1");
public void CanStop_Service_Paused ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void CanStop_Service_Stopped ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Continue ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Continue_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void Continue_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("NetDDE", ".");
ServiceController sc2 = new ServiceController ("NetDDE", ".");
public void Continue_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void Continue_Service_OperationNotValid ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("SamSs", ".");
ServiceController sc2 = new ServiceController ("SamSs", ".");
public void Continue_Service_Running ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Continue_Service_Stopped ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void DependentServices ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = null;
ServiceController [] dependentServices = null;
public void DependentServices_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("dmserver",
"doesnotexist");
public void DependentServices_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("NetDDE", ".");
ServiceController [] dependentServices = sc.DependentServices;
public void DependentServices_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void DisplayName ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.DisplayName = "workstation";
public void DisplayName_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("dmserver",
"doesnotexist");
public void DisplayName_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("NetDDE", ".");
Assert.AreEqual ("Network DDE", sc.DisplayName);
public void DisplayName_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void DisplayName_ServiceName_Empty ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.DisplayName = "workstation";
public void DisplayName_Value_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.DisplayName = "doesnotexist";
public void DisplayName_Value_Empty ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
Assert.AreEqual (string.Empty, sc.DisplayName, "#A1");
public void DisplayName_Value_Null ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.DisplayName = "Alerter";
public void DisplayName_Value_ServiceName ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.DisplayName = "lanmanworkstation";
public void ExecuteCommand_Device_ControlCodes ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Disk", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void ExecuteCommand_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void ExecuteCommand_Parameter_Incorrect ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void ExecuteCommand_Service_ContinuePending ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void ExecuteCommand_Service_ControlCodes ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void ExecuteCommand_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void ExecuteCommand_Service_Paused ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void ExecuteCommand_Service_PausePending ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void ExecuteCommand_Service_StartPending ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void ExecuteCommand_Service_Stopped ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void ExecuteCommand_Service_StopPending ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule", ".");
Assert.AreEqual (ServiceControllerStatus.Running, sc.Status, "#A");
public void GetDevices ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController [] devices = null;
public void GetDevices_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
try {
ServiceController [] devices = ServiceController.GetDevices ("doesnotexist");
public void GetServices ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController [] services = null;
public void GetServices_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
try {
ServiceController [] services = ServiceController.GetServices ("doesnotexist");
public void MachineName ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.ServiceName = "alerter";
public void MachineName_Empty ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.MachineName = Environment.MachineName;
public void MachineName_Null ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.MachineName = Environment.MachineName;
public void Pause ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Pause_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void Pause_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("NetDDE", ".");
ServiceController sc2 = new ServiceController ("NetDDE", ".");
public void Pause_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void Pause_Service_OperationNotValid ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("SamSs", ".");
ServiceController sc2 = new ServiceController ("SamSs", ".");
public void Pause_Service_Paused ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Pause_Service_Stopped ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Refresh ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = null;
ServiceController [] dependentServices = null;
public void Refresh_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void Refresh_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
sc.Refresh ();
public void Refresh_Service_Paused ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Refresh_Service_Running ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Refresh_Service_Stopped ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Refresh_ServiceName_Empty ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.Refresh ();
public void ServiceName ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.ServiceName = "lanmanworkstation";
public void ServiceName_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("dmserver",
"doesnotexist");
public void ServiceName_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("NetDDE", ".");
Assert.AreEqual ("NetDDE", sc.ServiceName);
public void ServiceName_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void ServiceName_DisplayName_Empty ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.ServiceName = "lanmanworkstation";
public void ServiceName_Value_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.ServiceName = "doesnotexist";
public void ServiceName_Value_Empty ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
Assert.AreEqual (string.Empty, sc.DisplayName, "#A1");
public void ServiceName_Value_Null ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.ServiceName = "lanmanworkstation";
public void ServiceName_Value_DisplayName ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ();
sc.ServiceName = "workstation";
public void ServicesDependedOn ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = null;
ServiceController [] servicesDependedOn = null;
public void ServicesDependedOn_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("dmserver",
"doesnotexist");
public void ServicesDependedOn_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("ClipSrv", ".");
ServiceController [] servicesDependedOn = sc.ServicesDependedOn;
public void ServicesDependedOn_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void ServiceTypeTest ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = null;
public void ServiceType_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("dmserver",
"doesnotexist");
public void ServiceType_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("NetDDE", ".");
Assert.AreEqual (ServiceType.Win32ShareProcess, sc.ServiceType);
public void ServiceType_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void ServiceType_ServiceName_Empty ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = null;
public void Stop ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Stop_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void Stop_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("NetDDE", ".");
ServiceController sc2 = new ServiceController ("NetDDE", ".");
public void Stop_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void Stop_Service_OperationNotValid ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("SamSs", ".");
ServiceController sc2 = new ServiceController ("SamSs", ".");
public void Stop_Service_Paused ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void Stop_Service_Stopped ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void WaitForStatus ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
public void WaitForStatus_Machine_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("Schedule",
"doesnotexist");
public void WaitForStatus_Service_Disabled ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("NetDDE", ".");
ServiceController sc2 = new ServiceController ("NetDDE", ".");
public void WaitForStatus_Service_DoesNotExist ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc = new ServiceController ("doesnotexist", ".");
try {
public void WaitForStatus_Service_OperationNotValid ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("SamSs", ".");
ServiceController sc2 = new ServiceController ("SamSs", ".");
public void WaitForStatus_Timeout ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
ServiceController sc1 = new ServiceController ("Schedule", ".");
ServiceController sc2 = new ServiceController ("Schedule", ".");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
EventLog eventLog = new EventLog ();
Assert.IsFalse (eventLog.EnableRaisingEvents, "#1");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
EventLog eventLog = new EventLog (string.Empty);
Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
EventLog eventLog = new EventLog (string.Empty, ".");
Assert.IsFalse (eventLog.EnableRaisingEvents, "#A1");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monoothersource", "."))
Assert.Ignore ("Event log source 'monoothersource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType != NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType != NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.Exists ("monologtemp", "."))
Assert.Ignore ("Event log 'monologtemp' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType != WIN32_IMPL)
// test can only pass with win32 implementation
- return;
+ Assert.Ignore ("Wrong EventLogImplType.");
using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
if (logKey != null)
{
if (EventLogImplType != WIN32_IMPL)
// test can only pass with win32 implementation
- return;
+ Assert.Ignore ("Wrong EventLogImplType.");
using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
if (logKey != null)
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
string logName = EventLog.LogNameFromSourceName (string.Empty, ".");
Assert.IsNotNull (logName, "#1");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
string logName = EventLog.LogNameFromSourceName (null, ".");
Assert.IsNotNull (logName, "#1");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType != WIN32_IMPL)
// test can only pass with win32 implementation
- return;
+ Assert.Ignore ("Wrong EventLogImplType.");
using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
if (logKey != null)
{
if (EventLogImplType != WIN32_IMPL)
// test can only pass with win32 implementation
- return;
+ Assert.Ignore ("Wrong EventLogImplType.");
using (RegistryKey logKey = FindLogKeyByName ("monotempsource")) {
if (logKey != null)
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
{
if (EventLogImplType == NULL_IMPL)
// test cannot pass with NULL implementation
- return;
+ Assert.Ignore ("No EventLogImplType.");
if (EventLog.SourceExists ("monotempsource", "."))
Assert.Ignore ("Event log source 'monotempsource' should not exist.");
}
}
-#endif
\ No newline at end of file
+#endif
{
if (RunningOnUnix)
// on unix, all characters are allowed
- return;
+ Assert.Ignore ("Running on Unix.");
string systemDir = Environment.GetFolderPath (Environment.SpecialFolder.System);
string exe = "\"" + Path.Combine (systemDir, "calc.exe") + "\"";
{
// Test requires cygwin, so we just bail out for now.
if (Path.DirectorySeparatorChar == '\\')
- return;
+ Assert.Ignore ("Test requires cygwin.");
Process p = new Process ();
p.StartInfo = new ProcessStartInfo ("/bin/sh", "-c \"sleep 2; echo hello\"");
{
int platform = (int) Environment.OSVersion.Platform;
// we are testing on Unix only
- if ((platform != 4) && (platform != 128)) return;
+ if ((platform != 4) && (platform != 128)) Assert.Ignore ("Not running on Unix.");
SerialPort sp = new SerialPort ();
sp.BaudRate = 1234;
var exceptionCatched = false;
// Need at least two addresses.
var ips = Dns.GetHostAddresses (string.Empty);
if (ips.Length < 1)
- return;
+ Assert.Ignore ("This test needs at least two IP addresses.");
var allIps = new IPAddress [ips.Length + 1];
allIps [0] = IPAddress.Loopback;
// Need at least two addresses.
var ips = Dns.GetHostAddresses (string.Empty);
if (ips.Length < 1)
- return;
+ Assert.Ignore ("This test needs at least two IP addresses.");
var allIps = new IPAddress [ips.Length + 1];
allIps [0] = IPAddress.Loopback;
machineAddress = Dns.GetHostAddresses (Dns.GetHostName ());
} catch (SocketException){
// The build hosts sometimes can not resolve the hostname
- return;
+ Assert.Ignore ("Hostname couldn't be resolved.");
}
int port = 61234;
* instead of reporting an error.\r
*/\r
if (req.ResponseUri.DnsSafeHost.Equals ("navigationshilfe1.t-online.de"))\r
- return;\r
+ Assert.Ignore ("Misbehaving DNS server.");\r
\r
Assert.Fail ("Should have raised an exception");\r
} catch (Exception e) {\r
public void PermissionsActuallyWork ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
bool createdNew; SemaphoreSecurity security;
{
// this test is for Windows only
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
// this regpath always exists under windows
RegistryKey k = Registry.CurrentUser
{
// access to registry of remote machines is not implemented on unix
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
RegistryKey hive = RegistryKey.OpenRemoteBaseKey (
RegistryHive.CurrentUser, Environment.MachineName);
{
// access to registry of remote machines is not implemented on unix
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
RegistryKey hive = RegistryKey.OpenRemoteBaseKey (
RegistryHive.CurrentUser, Environment.MachineName);
{
// Not supported on Unix
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
string subKeyName = Guid.NewGuid ().ToString ();
try {
{
// Not supported on Unix
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
string subKeyName = Guid.NewGuid ().ToString ();
try {
public void Handle ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
string subKeyName = Guid.NewGuid ().ToString ();
RegistryKey subkey = null;
{
// access to registry of remote machines is not implemented on unix
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
RegistryKey hive = RegistryKey.OpenRemoteBaseKey (
RegistryHive.CurrentUser, Environment.MachineName);
{
// access to registry of remote machines is not implemented on unix
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
try {
RegistryKey.OpenRemoteBaseKey (RegistryHive.CurrentUser,
public void GetSortKey ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// AE == \u00C6
AssertSortKey ("#1", new byte [] {0xE, 2, 0xE, 0x21, 1, 1,
public void GetSortKeyIgnoreWidth ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertSortKey ("#i1", new byte [] {
0xE, 2, 1, 1, 0x13, 1, 1, 0}, "\uFF21");
public void GetSortKeyDiacritical ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertSortKey ("#i1", new byte [] {
0xE, 0x21, 1, 0xE, 1, 1, 1, 0}, "e\u0301");
public void GetSortKeyIgnoreNonSpaceKana ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertSortKey ("#i1", new byte [] {
0x22, 0x1A, 1, 1, 1, 0xFF, 2, 0xFF, 0xFF, 1, 0},
public void GetSortKeySpecialWeight ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertSortKey ("#i1", new byte [] {
0x22, 0xA, 0x22, 2, 1, 1, 1, 0xFF, 2, 0xFF, 0xFF, 1, 0},
public void GetSortKeyLevel5 ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// shift weight
AssertSortKeyLevel5 ("#8", new byte [] {
public void FrenchSort ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// invariant
AssertSortKey ("#inv-1", new byte [] {0xE, 0xA, 0xE, 0x7C, 0xE, 0x99, 0xE, 0x21, 1, 2, 0x12, 1, 1, 1, 0}, "c\u00F4te");
public void GetSortKeyThai ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertSortKey ("#i1", new byte [] {
0x1E, 7, 0x1F, 0x28, 1, 3, 3, 1, 1, 1, 0},
public void GetSortKeyCzechTailoring ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertSortKey ("#i1", new byte [] {
0xE, 0xA, 0xE, 0x2C, 1, 1, 1, 1, 0},
public void GetSortKeyHungarianTailoring ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertSortKey ("#1", new byte [] {
0xE, 0xE, 1, 1, 0x1A, 1, 1, 0},
public void CustomCJKTable ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertSortKey ("#1", new byte [] {
0x9E, 9, 0x9E, 0x11, 1, 1, 1, 1, 0},
public void CultureSensitiveCompare ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertCompare ("#1", -1, "1", "2");
AssertCompare ("#2", 1, "A", "a");
public void CompareSpecialWeight ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// Japanese (in invariant)
// BUG in .NET 2.0 : half-width kana should be bigger.
public void IndexOfChar ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertIndexOf ("#1", -1, "ABC", '1');
AssertIndexOf ("#2", 2, "ABCABC", 'c', CompareOptions.IgnoreCase);
public void IndexOfCharMSBug ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertIndexOf ("#1", 0, "\u00E6", 'a');
}
public void LastIndexOfChar ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertLastIndexOf ("#1", -1, "ABC", '1');
AssertLastIndexOf ("#2", 5, "ABCABC", 'c', CompareOptions.IgnoreCase);
public void LastIndexOfCharMSBug ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertIndexOf ("#1", 0, "\u00E6", 'a');
}
public void IsPrefix ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertIsPrefix ("#1", false, "ABC", "c", CompareOptions.IgnoreCase);
AssertIsPrefix ("#2", false, "BC", "c", CompareOptions.IgnoreCase);
public void IsPrefixSpecialWeight ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// Japanese (in invariant)
AssertIsPrefix ("#1", false, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
public void IsSuffix ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertIsSuffix ("#1", true, "ABC", "c", CompareOptions.IgnoreCase);
AssertIsSuffix ("#2", true, "BC", "c", CompareOptions.IgnoreCase);
public void IsSuffixMSBug ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertIsSuffix ("#1", true, "\u00E6", "e", CompareOptions.None);
}
public void IndexOfString ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertIndexOf ("#0", 0, "", "", CompareOptions.None);
AssertIndexOf ("#1", -1, "ABC", "1", CompareOptions.None);
public void IndexOfSpecialWeight ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// Japanese (in invariant)
AssertIndexOf ("#1", -1, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
public void LastIndexOfString ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertLastIndexOf ("#1", -1, "ABC", "1", CompareOptions.None);
AssertLastIndexOf ("#2", 5, "ABCABC", "c", CompareOptions.IgnoreCase);
public void LastIndexOfStringDotnetWeird ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
AssertLastIndexOf ("#8", 0, "\u00E6", "ae", CompareOptions.None);
public void LastIndexOfSpecialWeight ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// Japanese (in invariant)
AssertLastIndexOf ("#1", -1, "\u30D1\u30FC\u30B9", "\uFF8A\uFF9F\uFF70\uFF7D");
public void LastIndexOfOrdinalString ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
AssertLastIndexOf ("#1", -1, "ABC", "1", CompareOptions.Ordinal);
AssertLastIndexOf ("#2", 5, "ABCABC", "C", CompareOptions.Ordinal);
public void OrdinalIgnoreCaseCompare ()
{
if (!doTest)
- return;
+ Assert.Ignore ("Test is disabled.");
// matches
// BUG in .NET 2.0 : see GetSortKey() test (mentioned above).
// The test doesn't work if the current culture is already set
if (orig_culture != CultureInfo.InvariantCulture)
- return;
+ Assert.Ignore ("The test doesn't work if the current culture is already set.");
/* Phase 0 - warm up */
new Thread (ThreadWithoutChange).Start ();
public void WindowsSystem32_76191 ()
{
if (RunningOnUnix)
- return;
+ Assert.Ignore ("Running on Unix.");
Directory.SetCurrentDirectory (@"C:\WINDOWS\system32");
WindowsParentFullName ("C:", "C:\\WINDOWS");
// Linux-like platforms but mono-on-windows
// doesn't set the NotDotNet category
if (!RunningOnUnix) {
- return;
+ Assert.Ignore ("Not running on Unix.");
}
Symlink_helper ();
public void EnumerateFilesListSymlinks ()\r
{\r
if (!RunningOnUnix)\r
- return;\r
+ Assert.Ignore ("Not running on Unix.");\r
\r
var afile = Path.Combine (TempFolder, "afile.src");\r
var bfile = Path.Combine (TempFolder, "bfile.src");\r
public void ExistsAccessDenied ()\r
{\r
if (!RunningOnUnix)\r
- return; // this test does not work on Windows.\r
+ Assert.Ignore ("Not running on Unix."); // this test does not work on Windows.\r
\r
string path = TempFolder + DSC + "ExistsAccessDenied";\r
\r
{\r
if (!RunningOnUnix)\r
// on Windows, backslash is used as directory separator\r
- return;\r
+ Assert.Ignore ("Not running on Unix.");\r
\r
string dir = Path.Combine (TempFolder, @"sub\dir");\r
Directory.CreateDirectory (dir);\r
{\r
if (!RunningOnUnix)\r
// on Windows, backslash is used as directory separator\r
- return;\r
+ Assert.Ignore ("Not running on Unix.");\r
\r
string file = Path.Combine (TempFolder, @"doc\temp1.file");\r
File.Create (file).Close ();\r
public void GetFullPath_Unix ()
{
if (Windows)
- return;
+ Assert.Ignore ("Running on Windows.");
string root = "/";
string [,] test = new string [,] {
public void GetFullPath_Windows ()
{
if (!Windows)
- return;
+ Assert.Ignore ("Not running on Windows.");
string root = "C:\\";
string [,] test = new string [,] {
// http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
int platform = (int) Environment.OSVersion.Platform;
if ((platform == 4) || (platform == 128) || (platform == 6))
- return;
+ Assert.Ignore ("Running on Unix.");
string curdir = Directory.GetCurrentDirectory ();
try {
// http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
int platform = (int) Environment.OSVersion.Platform;
if ((platform == 4) || (platform == 128) || (platform == 6))
- return;
+ Assert.Ignore ("Running on Unix.");
string curdir = Directory.GetCurrentDirectory ();
try {
// http://www.mono-project.com/FAQ:_Technical#How_to_detect_the_execution_platform_.3F
int platform = (int) Environment.OSVersion.Platform;
if ((platform == 4) || (platform == 128) || (platform == 6))
- return;
+ Assert.Ignore ("Running on Unix.");
Assert.AreEqual (@"C:\Windows\dir", Path.GetFullPath (@"C:\Windows\System32\..\dir"), "1");
Assert.AreEqual (@"C:\dir", Path.GetFullPath (@"C:\Windows\System32\..\..\dir"), "2");
[Test]
public void Reachability () {
if (GC.MaxGeneration == 0) /*Boehm doesn't handle ephemerons */
- return;
+ Assert.Ignore ("Not working on Boehm.");
var cwt = new ConditionalWeakTable <object,object> ();
List<object> keepAlive;
List<WeakReference> keys;
[Test]
public void InsertStress () {
if (GC.MaxGeneration == 0) /*Boehm doesn't handle ephemerons */
- return;
+ Assert.Ignore ("Not working on Boehm.");
var cwt = new ConditionalWeakTable <object,object> ();
var a = new object ();
[Test]
public void OldGenStress () {
if (GC.MaxGeneration == 0) /*Boehm doesn't handle ephemerons */
- return;
+ Assert.Ignore ("Not working on Boehm.");
var cwt = new ConditionalWeakTable <object,object>[1];
List<object> k = null;
List<WeakReference> res, res2;
public void FinalizableObjectsThatRetainDeadKeys ()
{
if (GC.MaxGeneration == 0) /*Boehm doesn't handle ephemerons */
- return;
+ Assert.Ignore ("Not working on Boehm.");
lock (_lock1) {
var cwt = new ConditionalWeakTable <object,object> ();
ThreadStart dele = () => { FillWithFinalizable (cwt); };
public void OldGenKeysMakeNewGenObjectsReachable ()
{
if (GC.MaxGeneration == 0) /*Boehm doesn't handle ephemerons */
- return;
+ Assert.Ignore ("Not working on Boehm.");
ConditionalWeakTable<object, Val> table = new ConditionalWeakTable<object, Val>();
List<Key> keys = new List<Key>();
{
// some test runners (e.g. Touch.Unit) will execute this on the main thread and that would lock them
if (!Thread.CurrentThread.IsBackground)
- return;
+ Assert.Ignore ("Current thread is not running in the background.");
var a = new Scheduler ("a");
var b = new Scheduler ("b");
}
}
-#endif
\ No newline at end of file
+#endif
AccessControlType.Allow);
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
string dirpath = Path.Combine (Path.GetTempPath (), Path.GetRandomFileName ());
public void PermissionsActuallyWork ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
bool createdNew; EventWaitHandleSecurity security;
{
FileSecurity security;
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
string path = Path.GetTempFileName ();
{
FileSecurity security;
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
string path = Path.GetTempFileName ();
{
FileSecurity security;
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
string path = Path.GetTempFileName ();
public void FailsForNonexistantMutex ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
new MutexSecurity (@"Local\NonexistantMutex", AccessControlSections.Access);
public void SucceedsForExistingMutex ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
bool createdNew;
public void CanSetAndGetMutexSecurity ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
MutexAccessRule rule; SecurityIdentifier sid;
public void PermissionsActuallyWork ()
{
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
bool createdNew; MutexSecurity security;
RegistrySecurity security;
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
try {
RegistrySecurity security;
if (PlatformID.Win32NT != Environment.OSVersion.Platform) {
- Assert.Ignore (); return;
+ Assert.Ignore ();
}
try {
{
// remove g_warning from being show during unit tests
if (IsPosix)
- return;
+ Assert.Ignore ("Running on Unix.");
WindowsIdentity wi = WindowsIdentity.GetCurrent ();
WindowsPrincipal wp = new WindowsPrincipal (wi);
public void RedirectedTest ()
{
if (Console.IsErrorRedirected) {
- // Assert.Inconclusive ();
- return;
+ Assert.Ignore ("The error output stream of the console is redirected.");
}
Console.SetError (TextWriter.Null);
public void Kind ()
{
if (DateTime.Now == DateTime.UtcNow)
- return; // This test does not make sense.
+ Assert.Ignore (); // This test does not make sense.
if (TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.UtcNow)
!= TimeZone.CurrentTimeZone.GetUtcOffset (DateTime.Now))
- return; // In this case it does not satisfy the test premises.
+ Assert.Ignore (); // In this case it does not satisfy the test premises.
Assert.AreEqual (DateTimeKind.Local, DateTime.Now.Kind, "#A1");
Assert.AreEqual (DateTimeKind.Local, DateTime.Today.Kind, "#A2");
// if the method is not present, e.g. on MS.NET, skip this test
if (next == null)
- return;
+ Assert.Ignore ("The JKiss method is not present, e.g. on MS.NET.");
// ensure we match the original JKISS random stream
// first 64KB but without checking every value (one each KB)
}
}
}
-}
\ No newline at end of file
+}
DateTime dst_start_utc = tz.GetDaylightChanges(2007).Start.ToUniversalTime ();
if (dst_start_utc == DateTime.MinValue)
- return;
+ Assert.Ignore ("Couldn't get beginning of daylight saving time in 2007.");
Assert.IsTrue (tz.ToLocalTime (dst_start_utc.Subtract (new TimeSpan (0, 1, 0))) < tz.ToLocalTime (dst_start_utc), "0:1:59 < 0:3:00");
Assert.IsTrue (tz.ToLocalTime (dst_start_utc) < tz.ToLocalTime (dst_start_utc.Add (new TimeSpan (0, 1, 0))), "0:3:00 < 0:3:01");
Assert.IsTrue (tz.ToLocalTime (dst_start_utc.Add (new TimeSpan (0, 1, 0))) < tz.ToLocalTime (dst_start_utc.Add (new TimeSpan (0, 59, 0))), "0:3:01 < 0:3:59");
projects / mono.git / commitdiff