Ubuntu One Windows Installer

Merge lp:~mandel/ubuntuone-windows-installer/remove_rubish into lp:ubuntuone-windows-installer/beta

  1. remove_rubish
  2. Merge into beta
Proposed by Manuel de la Peña
Status: Merged
Merged at revision: 115
Proposed branch: lp:~mandel/ubuntuone-windows-installer/remove_rubish
Merge into: lp:ubuntuone-windows-installer/beta
Prerequisite: lp:~mandel/ubuntuone-windows-installer/performance_improve
Diff against target: 12899 lines (+289/-12081)
41 files modified
src/Canonical.UbuntuOne.Client/Canonical.UbuntuOne.Client.csproj (+1/-0)
src/Canonical.UbuntuOne.Client/Preferences/IPreferencesDialogPresenter.cs (+0/-5)
src/Canonical.UbuntuOne.Client/Preferences/LoadPreferencesStartupTask.cs (+146/-0)
src/Canonical.UbuntuOne.Client/Preferences/PreferencesDialogPresenter.cs (+9/-27)
src/Canonical.UbuntuOne.Client/objects.xml (+5/-1)
src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj (+1/-1)
src/Canonical.UbuntuOne.Common/Utils/ApplicationWrapper.cs (+17/-0)
src/Canonical.UbuntuOne.Common/Utils/ConfigurationLocator.cs (+0/-305)
src/Canonical.UbuntuOne.Common/Utils/IApplication.cs (+7/-0)
src/Canonical.UbuntuOne.Common/Utils/IStartupTask.cs (+32/-0)
src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj (+1/-0)
src/Canonical.UbuntuOne.ProcessDispatcher/IPipeListener.cs (+1/-3)
src/Canonical.UbuntuOne.ProcessDispatcher/JsonMessageProcessor.cs (+1/-1)
src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamerFactory.cs (+1/-1)
src/Canonical.UbuntuOne.ProcessDispatcher/PipeListener.cs (+1/-1)
src/Canonical.UbuntuOne.ProcessDispatcher/PipeListeningStartupTask.cs (+45/-0)
src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs (+1/-1)
src/Canonical.UbuntuOne.ProcessDispatcher/objects.xml (+6/-0)
src/UbuntuOneClient.Tests/ProgramFixture.cs (+0/-5)
src/UbuntuOneClient/Program.cs (+4/-15)
src/UbuntuOneClient/objects.xml (+10/-6)
tools/NUnit/NUnitFitTests.html (+0/-277)
tools/NUnit/NUnitTests.config (+0/-84)
tools/NUnit/NUnitTests.nunit (+0/-14)
tools/NUnit/agent.conf (+0/-4)
tools/NUnit/agent.log.conf (+0/-18)
tools/NUnit/fit-license.txt (+0/-342)
tools/NUnit/framework/nunit.framework.xml (+0/-10228)
tools/NUnit/launcher.log.conf (+0/-18)
tools/NUnit/license.txt (+0/-15)
tools/NUnit/nunit-agent-x86.exe.config (+0/-76)
tools/NUnit/nunit-agent.exe.config (+0/-76)
tools/NUnit/nunit-console-x86.exe.config (+0/-76)
tools/NUnit/nunit-console.exe.config (+0/-76)
tools/NUnit/nunit-x86.exe.config (+0/-91)
tools/NUnit/nunit.exe.config (+0/-91)
tools/NUnit/pnunit-agent.exe.config (+0/-77)
tools/NUnit/pnunit-launcher.exe.config (+0/-77)
tools/NUnit/runFile.exe.config (+0/-43)
tools/NUnit/runpnunit.bat (+0/-2)
tools/NUnit/test.conf (+0/-24)
To merge this branch: bzr merge lp:~mandel/ubuntuone-windows-installer/remove_rubish
Reviewer Review Type Date Requested Status
Ubuntu One hackers Pending
Review via email: mp+38841@code.launchpad.net

Description of the change

Refactored ugly code that was added in desperate moments.

To post a comment you must log in.

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk
1=== modified file 'src/Canonical.UbuntuOne.Client/Canonical.UbuntuOne.Client.csproj'
2--- src/Canonical.UbuntuOne.Client/Canonical.UbuntuOne.Client.csproj 2010-10-19 14:28:37 +0000
3+++ src/Canonical.UbuntuOne.Client/Canonical.UbuntuOne.Client.csproj 2010-10-19 14:28:38 +0000
4@@ -91,6 +91,7 @@
5 <Compile Include="Preferences\IPreferencesDialogPresenter.cs" />
6 <Compile Include="Preferences\IPreferencesManager.cs" />
7 <Compile Include="Preferences\IPreferencesView.cs" />
8+ <Compile Include="Preferences\LoadPreferencesStartupTask.cs" />
9 <Compile Include="Preferences\PreferencesDialogPresenter.cs" />
10 <Compile Include="Properties\AssemblyInfo.cs" />
11 <Compile Include="SyncDaemonClient.cs" />
12
13=== modified file 'src/Canonical.UbuntuOne.Client/Preferences/IPreferencesDialogPresenter.cs'
14--- src/Canonical.UbuntuOne.Client/Preferences/IPreferencesDialogPresenter.cs 2010-10-19 14:28:37 +0000
15+++ src/Canonical.UbuntuOne.Client/Preferences/IPreferencesDialogPresenter.cs 2010-10-19 14:28:38 +0000
16@@ -31,10 +31,5 @@
17 /// Updates the preferences that the user will use in the application.
18 /// </summary>
19 void UpdatePreferences();
20-
21- /// <summary>
22- /// Allows to load the preferences in the application so that they are used.
23- /// </summary>
24- void LoadPreferences();
25 }
26 }
27
28=== added file 'src/Canonical.UbuntuOne.Client/Preferences/LoadPreferencesStartupTask.cs'
29--- src/Canonical.UbuntuOne.Client/Preferences/LoadPreferencesStartupTask.cs 1970-01-01 00:00:00 +0000
30+++ src/Canonical.UbuntuOne.Client/Preferences/LoadPreferencesStartupTask.cs 2010-10-19 14:28:38 +0000
31@@ -0,0 +1,146 @@
32+/*
33+ * Copyright 2010 Canonical Ltd.
34+ *
35+ * This file is part of UbuntuOne on Windows.
36+ *
37+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify
38+ * it under the terms of the GNU Lesser General Public License version
39+ * as published by the Free Software Foundation.
40+ *
41+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
42+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
43+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
44+ * GNU Lesser General Public License for more details.
45+ *
46+ * You should have received a copy of the GNU Lesser General Public License
47+ * along with UbuntuOne for Windows. If not, see <http://www.gnu.org/licenses/>.
48+ *
49+ * Authors: Manuel de la Peña <manuel.delapena@canonical.com>
50+ */
51+using System;
52+using System.IO;
53+using Canonical.Ubuntu.SSO;
54+using Canonical.UbuntuOne.Common;
55+using Canonical.UbuntuOne.Common.Utils;
56+using log4net;
57+
58+namespace Canonical.UbuntuOne.Client.Preferences
59+{
60+ /// <summary>
61+ /// Task that will ensure that the preferences are loaded at boot time.
62+ /// </summary>
63+ public class LoadPreferencesStartupTask : IStartupTask
64+ {
65+ #region Variables
66+
67+ private ISSOCredentialsProvider _ssoProvider;
68+ private const string EventName = "PreferencesStartupLoad";
69+ private const string ApplicationName = "UbuntuOne";
70+ private ILog _logger;
71+ private readonly object _loggerLock = new object();
72+
73+ #endregion
74+
75+ #region DI properties
76+
77+ /// <summary>
78+ /// Gets and sets the logger used by the class.
79+ /// </summary>
80+ internal ILog Logger
81+ {
82+ get
83+ {
84+ if (_logger == null)
85+ {
86+ lock (_loggerLock)
87+ {
88+ _logger = LogManager.GetLogger(typeof(PreferencesDialogPresenter));
89+ }
90+ }
91+ return _logger;
92+ }
93+ set { _logger = value; }
94+ }
95+
96+ /// <summary>
97+ /// Gets and sets the provider that will return the credentials used in ubuntu one.
98+ /// </summary>
99+ public ISSOCredentialsProvider SSOCredentialsProvider
100+ {
101+ get { return _ssoProvider; }
102+ set
103+ {
104+ if (value == null) return;
105+ _ssoProvider = value;
106+ _ssoProvider.OnCredentialsFound += OnCredentialsFound;
107+ _ssoProvider.OnCredentialsError += OnCredentialsError;
108+ _ssoProvider.OnCredetialsDenied += OnCredentialsDenied;
109+ }
110+ }
111+
112+ /// <summary>
113+ /// Gets and sets the preferences manager used to ensure that the user has its preferences
114+ /// stored.
115+ /// </summary>
116+ public IPreferencesManager PreferencesManager { get; set; }
117+
118+ /// <summary>
119+ /// Gets the sync daemon that is used to perform the sync operations.
120+ /// </summary>
121+ public ISyncDaemon SyncDaemon { get; set; }
122+
123+ /// <summary>
124+ /// Gets and sets the message box used to send messages to the user.
125+ /// </summary>
126+ public IMessageBox MessageBox { get; set; }
127+
128+ #endregion
129+
130+ #region Helpers
131+
132+ /// <summary>
133+ /// Helper method executed when the provider did return new credentials.
134+ /// </summary>
135+ /// <param name="sender"></param>
136+ /// <param name="args"></param>
137+ private void OnCredentialsFound(object sender, CredentialsFoundEventArgs args)
138+ {
139+ // check if the credentials are for us
140+ if (args.ApplicationName != EventName) return;
141+ Logger.Info("Got the UbuntuOne credentials!");
142+ var oneDir = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments),
143+ "UbuntuOne");
144+ // ensure that the path can be handled by the python code
145+ oneDir = oneDir.Replace("\\", "\\\\");
146+ // call the ISyncService to perform the manual sync
147+
148+ SyncDaemon.EnableManualSyncAutoExecution(
149+ oneDir,
150+ args.Credentials["Token"],
151+ args.Credentials["TokenSecret"],
152+ args.Credentials["ConsumerKey"],
153+ args.Credentials["ConsumerSecret"],
154+ (int)PreferencesManager.AutoSyncFrequency);
155+ }
156+
157+ private void OnCredentialsDenied(object sender, CredentialsDeniedEventArgs args)
158+ {
159+
160+ MessageBox.ShowWarning("You need to login to be able to sync your files.");
161+ }
162+
163+ private void OnCredentialsError(object sender, CredentialsErrorEventArgs args)
164+ {
165+ MessageBox.ShowError("An error courred when trying to retrieve your credentials.");
166+ }
167+
168+ #endregion
169+
170+ public void Exeucte()
171+ {
172+ if (PreferencesManager.IsAutoSyncEnable)
173+ // we get the credentials, because we have register an action to the credetials aquired, we do nothing besides this
174+ SSOCredentialsProvider.LoginToGetCredentials(EventName, ApplicationName);
175+ }
176+ }
177+}
178
179=== modified file 'src/Canonical.UbuntuOne.Client/Preferences/PreferencesDialogPresenter.cs'
180--- src/Canonical.UbuntuOne.Client/Preferences/PreferencesDialogPresenter.cs 2010-10-19 14:28:37 +0000
181+++ src/Canonical.UbuntuOne.Client/Preferences/PreferencesDialogPresenter.cs 2010-10-19 14:28:38 +0000
182@@ -18,10 +18,8 @@
183 */
184 using System;
185 using System.IO;
186-using System.ServiceModel;
187 using Canonical.Ubuntu.SSO;
188 using Canonical.UbuntuOne.Common;
189-using Canonical.UbuntuOne.Common.Net;
190 using log4net;
191
192 namespace Canonical.UbuntuOne.Client.Preferences
193@@ -36,8 +34,8 @@
194 private ISSOCredentialsProvider _ssoProvider;
195 private ILog _logger;
196 private readonly object _loggerLock = new object();
197- private static string EventName = "UbuntuOneAutoManualSync";
198- private static string ApplicationName = "UbuntuOne";
199+ private const string EventName = "UbuntuOneAutoManualSync";
200+ private const string ApplicationName = "UbuntuOne";
201
202 #endregion
203
204@@ -77,15 +75,9 @@
205 public IPreferencesManager PreferencesManager { get; set; }
206
207 /// <summary>
208- /// Gets and sets the channel factory that can be used to create communication objects that are used to
209- /// interact with the sync daemon.
210- /// </summary>
211- public ChannelFactory<ISyncDaemon> SyncDaemonChannelFactory { get; set; }
212-
213- /// <summary>
214- /// Gets and sets the service caller that is used to do the house keeping when calling a service.
215- /// </summary>
216- public IServiceCaller ServiceCaller { get; set; }
217+ /// Gets the sync daemon that is used to perform the sync operations.
218+ /// </summary>
219+ public ISyncDaemon SyncDaemon { get; set; }
220
221 /// <summary>
222 /// Gets and sets the provider that will return the credentials used in ubuntu one.
223@@ -129,16 +121,13 @@
224 oneDir = oneDir.Replace("\\", "\\\\");
225 // call the ISyncService to perform the manual sync
226
227- var syncServiceChannel = SyncDaemonChannelFactory.CreateChannel();
228- ServiceCaller.SaveProxyCall(
229- () => syncServiceChannel.EnableManualSyncAutoExecution(
230+ SyncDaemon.EnableManualSyncAutoExecution(
231 oneDir,
232 args.Credentials["Token"],
233 args.Credentials["TokenSecret"],
234 args.Credentials["ConsumerKey"],
235 args.Credentials["ConsumerSecret"],
236- (int)PreferencesManager.AutoSyncFrequency),
237- (ICommunicationObject)syncServiceChannel);
238+ (int)PreferencesManager.AutoSyncFrequency);
239 }
240
241 private void OnCredentialsDenied(object sender, CredentialsDeniedEventArgs args)
242@@ -151,6 +140,7 @@
243 {
244 MessageBox.ShowError("An error courred when trying to retrieve your credentials.");
245 }
246+
247 #endregion
248
249 public void Show()
250@@ -174,18 +164,10 @@
251 else
252 {
253 // we call to disable the autosync, the service knows what to do
254- var syncServiceChannel = SyncDaemonChannelFactory.CreateChannel();
255- ServiceCaller.SaveProxyCall(syncServiceChannel.DisableManualSyncAutoExecution,
256- (ICommunicationObject)syncServiceChannel);
257+ SyncDaemon.DisableManualSyncAutoExecution();
258 }
259 PreferencesManager.Save();
260 }
261
262- public void LoadPreferences()
263- {
264- if(PreferencesManager.IsAutoSyncEnable)
265- // we get the credentials, because we have register an action to the credetials aquired, we do nothing besides this
266- SSOCredentialsProvider.LoginToGetCredentials(EventName, ApplicationName);
267- }
268 }
269 }
270
271=== modified file 'src/Canonical.UbuntuOne.Client/objects.xml'
272--- src/Canonical.UbuntuOne.Client/objects.xml 2010-10-19 14:28:37 +0000
273+++ src/Canonical.UbuntuOne.Client/objects.xml 2010-10-19 14:28:38 +0000
274@@ -9,5 +9,9 @@
275 <object id="PreferencesDialogPresenter"
276 type="Canonical.UbuntuOne.Client.Preferences.PreferencesDialogPresenter, Canonical.UbuntuOne.Client"
277 autowire="autodetect"/>
278-
279+
280+ <object id="LoadPreferencesStartupTask"
281+ type="Canonical.UbuntuOne.Client.Preferences.LoadPreferencesStartupTask, Canonical.UbuntuOne.Client"
282+ autowire="autodetect"/>
283+
284 </objects>
285\ No newline at end of file
286
287=== modified file 'src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj'
288--- src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj 2010-10-19 14:28:37 +0000
289+++ src/Canonical.UbuntuOne.Common/Canonical.UbuntuOne.Common.csproj 2010-10-19 14:28:38 +0000
290@@ -107,7 +107,6 @@
291 <Compile Include="Threading\WpfDispatcher.cs" />
292 <Compile Include="Utils\ApplicationLocatorException.cs" />
293 <Compile Include="Utils\ApplicationWrapper.cs" />
294- <Compile Include="Utils\ConfigurationLocator.cs" />
295 <Compile Include="Utils\Constants.cs" />
296 <Compile Include="Utils\Explorer.cs" />
297 <Compile Include="Utils\ExplorerException.cs" />
298@@ -117,6 +116,7 @@
299 <Compile Include="IMessageBox.cs" />
300 <Compile Include="IProcessManager.cs" />
301 <Compile Include="IProcessManagerFactory.cs" />
302+ <Compile Include="Utils\IStartupTask.cs" />
303 <Compile Include="Utils\IWebbrowser.cs" />
304 <Compile Include="ProcessManagementException.cs" />
305 <Compile Include="ProcessManager.cs" />
306
307=== modified file 'src/Canonical.UbuntuOne.Common/Utils/ApplicationWrapper.cs'
308--- src/Canonical.UbuntuOne.Common/Utils/ApplicationWrapper.cs 2010-09-08 08:24:05 +0000
309+++ src/Canonical.UbuntuOne.Common/Utils/ApplicationWrapper.cs 2010-10-19 14:28:38 +0000
310@@ -17,6 +17,7 @@
311 *
312 * Authors: Manuel de la Peña <manuel.delapena@canonical.com>
313 */
314+using System.Collections.Generic;
315 using System.Windows;
316
317 namespace Canonical.UbuntuOne.Common.Utils
318@@ -37,16 +38,32 @@
319 public ApplicationWrapper()
320 {
321 _app = new Application();
322+ StartupTasks = new List<IStartupTask>();
323 }
324
325 #region Implementation of IApplication
326
327 /// <summary>
328+ /// Gets and sets the tasks that will be executed in sequencial
329+ /// order during the start up of the application.
330+ /// </summary>
331+ public IList<IStartupTask> StartupTasks { get; set; }
332+
333+ /// <summary>
334 /// Allows to start the application using the passed window.
335 /// </summary>
336 /// <param name="startWindow">The main window of the application.</param>
337 public void Run(Window startWindow)
338 {
339+ // execute the actions that need to be performed before the app is started.
340+ if (StartupTasks != null)
341+ {
342+ foreach (var startupTask in StartupTasks)
343+ {
344+ startupTask.Exeucte();
345+ }
346+ }
347+
348 _app.Run(startWindow);
349 }
350
351
352=== removed file 'src/Canonical.UbuntuOne.Common/Utils/ConfigurationLocator.cs'
353--- src/Canonical.UbuntuOne.Common/Utils/ConfigurationLocator.cs 2010-10-19 14:28:37 +0000
354+++ src/Canonical.UbuntuOne.Common/Utils/ConfigurationLocator.cs 1970-01-01 00:00:00 +0000
355@@ -1,305 +0,0 @@
356-/*
357- * Copyright 2010 Canonical Ltd.
358- *
359- * This file is part of UbuntuOne on Windows.
360- *
361- * UbuntuOne on Windows is free software: you can redistribute it and/or modify
362- * it under the terms of the GNU Lesser General Public License version
363- * as published by the Free Software Foundation.
364- *
365- * Ubuntu One on Windows is distributed in the hope that it will be useful,
366- * but WITHOUT ANY WARRANTY; without even the implied warranty of
367- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
368- * GNU Lesser General Public License for more details.
369- *
370- * You should have received a copy of the GNU Lesser General Public License
371- * along with UbuntuOne for Windows. If not, see <http://www.gnu.org/licenses/>.
372- *
373- * Authors: Manuel de la Peña <manuel.delapena@canonical.com>
374- */
375-using System;
376-using System.IO;
377-using System.Security.Principal;
378-using Canonical.UbuntuOne.ProcessDispatcher;
379-using log4net;
380-
381-namespace Canonical.UbuntuOne.Common.Utils
382-{
383- /// <summary>
384- /// This class allow to find the configuration to be used in the application accodring to the user that started the
385- /// process. This allows to point to different configurations that will ensure that there are no service collitions
386- /// by usint the users name space.
387- /// </summary>
388- public class ConfigurationLocator
389- {
390- #region Variables
391-
392- private const string UserToken = "$username$";
393- private const string ConfigFolder = "Config";
394- private const string DaemonAppConfigName = "Canonical.UbuntuOne.ProcessDispatcher.exe.config";
395- private const string UserAppConfigName = "UbuntuOneClient.exe.config";
396- private const string Log4NetConfig = "log4net.config";
397- private const string BehavioursConfig = "serviceModel.behaviours.config";
398- private const string BindingsConfig = "serviceModel.bindings.config";
399- private const string ServicesConfig = "serviceModel.services.config";
400- private const string ClientConfig = "serviceModel.client.config";
401- private string _userConfigPath;
402- private readonly object _userConfigPathLock = new object();
403- private readonly object _loggerLock = new object();
404- private ILog _logger;
405-
406- #endregion
407-
408- #region Properties
409-
410- /// <summary>
411- /// Allows to get and set the logger that will be used.
412- /// </summary>
413- internal ILog Logger
414- {
415- get
416- {
417- if (_logger == null)
418- {
419- lock (_loggerLock)
420- {
421- _logger = LogManager.GetLogger(typeof(ConfigurationLocator));
422- }
423- }
424- return _logger;
425- }
426- set
427- {
428- _logger = value;
429- }
430- }
431-
432- /// <summary>
433- /// Gets the path to be used to store the users configuration.
434- /// </summary>
435- private string UserDaemonConfigPath
436- {
437- get
438- {
439- if (_userConfigPath == null)
440- {
441- lock (_userConfigPathLock)
442- {
443- _userConfigPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
444- _userConfigPath = Path.Combine(_userConfigPath, "UbuntuOne");
445- _userConfigPath = Path.Combine(_userConfigPath, "Daemon");
446- }
447- }
448- return _userConfigPath;
449- }
450- }
451-
452- private string UserClientConfigPath
453- {
454- get
455- {
456- if (_userConfigPath == null)
457- {
458- lock (_userConfigPathLock)
459- {
460- _userConfigPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
461- _userConfigPath = Path.Combine(_userConfigPath, "UbuntuOne");
462- _userConfigPath = Path.Combine(_userConfigPath, "Client");
463- }
464- }
465- return _userConfigPath;
466- }
467- }
468- /// <summary>
469- /// Gets and sets the application locator that will be used to find the location of the
470- /// root configuration.
471- /// </summary>
472- public IApplicationLocator ApplicationLocator { get; set; }
473-
474- #endregion
475-
476- #region Constructors
477-
478- /// <summary>
479- /// Creates a new configuration locator with the default app locator.
480- /// </summary>
481- public ConfigurationLocator()
482- : this(new UbuntuOneApplicationLocator())
483- {
484-
485- }
486-
487- /// <summary>
488- /// Creates a new configuration locator with a pass app locator.
489- /// </summary>
490- /// <param name="applicationLocator">The object that will return the path to known applications.</param>
491- public ConfigurationLocator(IApplicationLocator applicationLocator)
492- {
493- ApplicationLocator = applicationLocator;
494- }
495-
496- #endregion
497-
498- #region Helpers
499-
500- /// <summary>
501- /// Returns if the configuration for the current user daemon is present.
502- /// </summary>
503- /// <returns>A flag stating if the configuraton is present.</returns>
504- private bool IsDaemonConfigurationPresent()
505- {
506- // the configuration is store per user in his location to
507- // ensure that he is the only one using it
508- return Directory.Exists(UserDaemonConfigPath)
509- && File.Exists(Path.Combine(UserDaemonConfigPath, DaemonAppConfigName))
510- && Directory.Exists(Path.Combine(UserDaemonConfigPath, ConfigFolder));
511- }
512-
513- /// <summary>
514- /// Returns if the configuration for the current user client is present
515- /// </summary>
516- /// <returns>A flag stating if the configuration is present.</returns>
517- private bool IsClientConfigurationPresent()
518- {
519- return Directory.Exists(UserClientConfigPath)
520- && File.Exists(Path.Combine(UserClientConfigPath, UserAppConfigName))
521- && Directory.Exists(Path.Combine(UserClientConfigPath, ConfigFolder));
522- }
523-
524- /// <summary>
525- /// Methods that updates all the urls in the services named pipes so that they are ersonalized
526- /// for the current user.
527- /// </summary>
528- private void UpdateDaemonServicesConfiguration()
529- {
530- var servicesFullPath = Path.Combine(UserDaemonConfigPath, ConfigFolder);
531- servicesFullPath = Path.Combine(servicesFullPath, ServicesConfig);
532- string userConfig;
533- using (var fileReader = new StreamReader(new FileStream(servicesFullPath, FileMode.Open)))
534- {
535- userConfig = fileReader.ReadToEnd();
536- }
537- userConfig = userConfig.Replace(UserToken, WindowsIdentity.GetCurrent().Name);
538- File.Delete(servicesFullPath);
539- using (var fileWriter = new StreamWriter(new FileStream(servicesFullPath, FileMode.CreateNew)))
540- {
541- fileWriter.Write(userConfig);
542- }
543- }
544-
545- /// <summary>
546- /// Updates the clients configurations so that the clients uses the correct named pipes.
547- /// </summary>
548- private void UpdateClientConfiguration()
549- {
550- var clientsFullPath = Path.Combine(UserClientConfigPath, ConfigFolder);
551- clientsFullPath = Path.Combine(clientsFullPath, ClientConfig);
552- string userConfig;
553- using(var fileReader = new StreamReader(new FileStream(clientsFullPath, FileMode.Open)))
554- {
555- userConfig = fileReader.ReadToEnd();
556- }
557- userConfig = userConfig.Replace(UserToken, WindowsIdentity.GetCurrent().Name);
558- File.Delete(clientsFullPath);
559- using(var fileWriter = new StreamWriter(new FileStream(clientsFullPath, FileMode.CreateNew)))
560- {
561- fileWriter.Write(userConfig);
562- }
563- }
564-
565- /// <summary>
566- /// Method that copies all the configuration that is deployed by the msi to the users config location.
567- /// </summary>
568- private void CopyDaemonRootConfiguration()
569- {
570- if (!Directory.Exists(UserDaemonConfigPath))
571- {
572- Logger.DebugFormat("Creating dir {0}", UserDaemonConfigPath);
573- Directory.CreateDirectory(UserDaemonConfigPath);
574- }
575- // we need to copy the info from the root path
576- var daemonPath = ApplicationLocator.GetApplicationPath(Constants.U1DaemonAppName);
577- File.Copy(Path.Combine(daemonPath, DaemonAppConfigName), Path.Combine(UserDaemonConfigPath, DaemonAppConfigName));
578- // we copy the config files for log4net and the service model
579- var userConfigFolderPath = Path.Combine(UserDaemonConfigPath, ConfigFolder);
580- if (!Directory.Exists(userConfigFolderPath))
581- {
582- Logger.DebugFormat("Create dir {0}", userConfigFolderPath);
583- Directory.CreateDirectory(userConfigFolderPath);
584- }
585- var rootConfigFolderPath = Path.Combine(daemonPath, ConfigFolder);
586- File.Copy(Path.Combine(rootConfigFolderPath, Log4NetConfig), Path.Combine(userConfigFolderPath, Log4NetConfig));
587- File.Copy(Path.Combine(rootConfigFolderPath, BehavioursConfig), Path.Combine(userConfigFolderPath, BehavioursConfig));
588- File.Copy(Path.Combine(rootConfigFolderPath, BindingsConfig), Path.Combine(userConfigFolderPath, BindingsConfig));
589- File.Copy(Path.Combine(rootConfigFolderPath, ServicesConfig), Path.Combine(userConfigFolderPath, ServicesConfig));
590- }
591-
592- private void CopyClietnRootConfiguration()
593- {
594- if (!Directory.Exists(UserClientConfigPath))
595- {
596- Logger.DebugFormat("Creating dir {0}", UserClientConfigPath);
597- Directory.CreateDirectory(UserClientConfigPath);
598- }
599- // we need to copy the info from the root path
600- var clientPath = ApplicationLocator.GetApplicationPath(Constants.U1ClientAppName);
601- File.Copy(Path.Combine(clientPath, UserAppConfigName), Path.Combine(UserClientConfigPath, UserAppConfigName));
602- // we copy the config files for log4net and the service model
603- var userConfigFolderPath = Path.Combine(UserClientConfigPath, ConfigFolder);
604- if (!Directory.Exists(userConfigFolderPath))
605- {
606- Logger.DebugFormat("Create dir {0}", userConfigFolderPath);
607- Directory.CreateDirectory(userConfigFolderPath);
608- }
609- var rootConfigFolderPath = Path.Combine(clientPath, ConfigFolder);
610- File.Copy(Path.Combine(rootConfigFolderPath, Log4NetConfig), Path.Combine(userConfigFolderPath, Log4NetConfig));
611- File.Copy(Path.Combine(rootConfigFolderPath, BindingsConfig), Path.Combine(userConfigFolderPath, BindingsConfig));
612- File.Copy(Path.Combine(rootConfigFolderPath, ClientConfig), Path.Combine(userConfigFolderPath, ClientConfig));
613- }
614-
615- #endregion
616-
617-
618-
619- ///<summary>
620- /// Returns the path with the configuration to be used for the dameon for the current user.
621- ///</summary>
622- ///<returns>The path to the configuration to be used by the current user when running the daemon.</returns>
623- public string GetCurrentUserDaemonConfiguration()
624- {
625- if (!IsDaemonConfigurationPresent())
626- {
627- Logger.Info("The users config does not exist!");
628- // we copy the root configuration
629- CopyDaemonRootConfiguration();
630- // we update the name pipe so that the use the current user name as part of the path
631- UpdateDaemonServicesConfiguration();
632- }
633- var appConfigPath = Path.Combine(UserDaemonConfigPath, DaemonAppConfigName);
634- Logger.InfoFormat("The config path is {0}", appConfigPath);
635- return appConfigPath;
636- }
637-
638- /// <summary>
639- /// Returns the path with the configuration to be used for the client for the current user.
640- /// </summary>
641- /// <returns>The path to the configuration to use.</returns>
642- public string GetCurrentUserClientConfiguration()
643- {
644- if (!IsClientConfigurationPresent())
645- {
646- Logger.Info("The users config does not exist!");
647- // we copy the root configuration
648- CopyClietnRootConfiguration();
649- // we update the name pipe so that the use the current user name as part of the path
650- UpdateClientConfiguration();
651- }
652- var appConfigPath = Path.Combine(UserClientConfigPath, UserAppConfigName);
653- Logger.InfoFormat("The config path is {0}", appConfigPath);
654- return appConfigPath;
655-
656- return null;
657- }
658-
659- }
660-}
661
662=== modified file 'src/Canonical.UbuntuOne.Common/Utils/IApplication.cs'
663--- src/Canonical.UbuntuOne.Common/Utils/IApplication.cs 2010-09-08 08:24:05 +0000
664+++ src/Canonical.UbuntuOne.Common/Utils/IApplication.cs 2010-10-19 14:28:38 +0000
665@@ -17,6 +17,7 @@
666 *
667 * Authors: Manuel de la Peña <manuel.delapena@canonical.com>
668 */
669+using System.Collections.Generic;
670 using System.Windows;
671
672 namespace Canonical.UbuntuOne.Common.Utils
673@@ -27,6 +28,12 @@
674 public interface IApplication
675 {
676 /// <summary>
677+ /// Gets and sets the tasks that will be executed in sequencial
678+ /// order during the start up of the application.
679+ /// </summary>
680+ IList<IStartupTask> StartupTasks { get; set; }
681+
682+ /// <summary>
683 /// Allows to start the application using the passed window.
684 /// </summary>
685 /// <param name="startWindow">The main window of the application.</param>
686
687=== added file 'src/Canonical.UbuntuOne.Common/Utils/IStartupTask.cs'
688--- src/Canonical.UbuntuOne.Common/Utils/IStartupTask.cs 1970-01-01 00:00:00 +0000
689+++ src/Canonical.UbuntuOne.Common/Utils/IStartupTask.cs 2010-10-19 14:28:38 +0000
690@@ -0,0 +1,32 @@
691+/*
692+ * Copyright 2010 Canonical Ltd.
693+ *
694+ * This file is part of UbuntuOne on Windows.
695+ *
696+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify
697+ * it under the terms of the GNU Lesser General Public License version
698+ * as published by the Free Software Foundation.
699+ *
700+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
701+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
702+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
703+ * GNU Lesser General Public License for more details.
704+ *
705+ * You should have received a copy of the GNU Lesser General Public License
706+ * along with UbuntuOne for Windows. If not, see <http://www.gnu.org/licenses/>.
707+ *
708+ * Authors: Manuel de la Peña <manuel.delapena@canonical.com>
709+ */
710+namespace Canonical.UbuntuOne.Common.Utils
711+{
712+ /// <summary>
713+ /// Interface to be implemented by those objects that are executed when an application is started.
714+ /// </summary>
715+ public interface IStartupTask
716+ {
717+ /// <summary>
718+ /// Method to be executed at start up.
719+ /// </summary>
720+ void Exeucte();
721+ }
722+}
723
724=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj'
725--- src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj 2010-10-19 14:28:37 +0000
726+++ src/Canonical.UbuntuOne.ProcessDispatcher/Canonical.UbuntuOne.ProcessDispatcher.csproj 2010-10-19 14:28:38 +0000
727@@ -101,6 +101,7 @@
728 <Compile Include="JsonPipeStreamerFactory.cs" />
729 <Compile Include="PipeListener.cs" />
730 <Compile Include="PipeListenerException.cs" />
731+ <Compile Include="PipeListeningStartupTask.cs" />
732 <Compile Include="SyncDaemonWindowsService.cs">
733 </Compile>
734 <Compile Include="CallerContext.cs" />
735
736=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/IPipeListener.cs'
737--- src/Canonical.UbuntuOne.ProcessDispatcher/IPipeListener.cs 2010-10-19 14:28:37 +0000
738+++ src/Canonical.UbuntuOne.ProcessDispatcher/IPipeListener.cs 2010-10-19 14:28:38 +0000
739@@ -1,8 +1,6 @@
740-using System;
741-
742 namespace Canonical.UbuntuOne.ProcessDispatcher
743 {
744- public interface IPipeListener
745+ internal interface IPipeListener
746 {
747 /// <summary>
748 /// Gets if the pipe listener is indeed listening to the pipe.
749
750=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/JsonMessageProcessor.cs'
751--- src/Canonical.UbuntuOne.ProcessDispatcher/JsonMessageProcessor.cs 2010-10-19 14:28:37 +0000
752+++ src/Canonical.UbuntuOne.ProcessDispatcher/JsonMessageProcessor.cs 2010-10-19 14:28:38 +0000
753@@ -26,7 +26,7 @@
754 /// <summary>
755 /// Message processor that works with json messages from python.
756 /// </summary>
757- public class JsonMessageProcessor : IMessageProcessor
758+ internal class JsonMessageProcessor : IMessageProcessor
759 {
760 #region DI Properties
761
762
763=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamerFactory.cs'
764--- src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamerFactory.cs 2010-10-19 14:28:37 +0000
765+++ src/Canonical.UbuntuOne.ProcessDispatcher/JsonPipeStreamerFactory.cs 2010-10-19 14:28:38 +0000
766@@ -22,7 +22,7 @@
767 /// <summary>
768 /// PipeStreamerFactory that creates streamers that use json for communication.
769 /// </summary>
770- public class JsonPipeStreamerFactory : IPipeStreamerFactory
771+ internal class JsonPipeStreamerFactory : IPipeStreamerFactory
772 {
773 #region Implementation of IPipeStreamerFactory
774
775
776=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/PipeListener.cs'
777--- src/Canonical.UbuntuOne.ProcessDispatcher/PipeListener.cs 2010-10-19 14:28:37 +0000
778+++ src/Canonical.UbuntuOne.ProcessDispatcher/PipeListener.cs 2010-10-19 14:28:38 +0000
779@@ -30,7 +30,7 @@
780 /// from the python code and will perform an operation for each messages
781 /// that has been recived.
782 /// </summary>
783- public class PipeListener : IPipeListener
784+ internal class PipeListener : IPipeListener
785 {
786 #region Helper strcut
787
788
789=== added file 'src/Canonical.UbuntuOne.ProcessDispatcher/PipeListeningStartupTask.cs'
790--- src/Canonical.UbuntuOne.ProcessDispatcher/PipeListeningStartupTask.cs 1970-01-01 00:00:00 +0000
791+++ src/Canonical.UbuntuOne.ProcessDispatcher/PipeListeningStartupTask.cs 2010-10-19 14:28:38 +0000
792@@ -0,0 +1,45 @@
793+/*
794+ * Copyright 2010 Canonical Ltd.
795+ *
796+ * This file is part of UbuntuOne on Windows.
797+ *
798+ * UbuntuOne on Windows is free software: you can redistribute it and/or modify
799+ * it under the terms of the GNU Lesser General Public License version
800+ * as published by the Free Software Foundation.
801+ *
802+ * Ubuntu One on Windows is distributed in the hope that it will be useful,
803+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
804+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
805+ * GNU Lesser General Public License for more details.
806+ *
807+ * You should have received a copy of the GNU Lesser General Public License
808+ * along with UbuntuOne for Windows. If not, see <http://www.gnu.org/licenses/>.
809+ *
810+ * Authors: Manuel de la Peña <manuel.delapena@canonical.com>
811+ */
812+using System;
813+using System.Security.Principal;
814+using Canonical.UbuntuOne.Common.Utils;
815+
816+namespace Canonical.UbuntuOne.ProcessDispatcher
817+{
818+ /// <summary>
819+ /// Start up taks that takes care of ensuring that we will be listening to messages from python.
820+ /// </summary>
821+ public class PipeListeningStartupTask : IStartupTask
822+ {
823+ #region DI properties
824+
825+ /// <summary>
826+ /// Gets and sets the listener that is used to receive messages from python.
827+ /// </summary>
828+ internal IPipeListener PipeListener { get; set; }
829+
830+ #endregion
831+
832+ public void Exeucte()
833+ {
834+ PipeListener.StartListening(string.Format("PythonMessages{0}", WindowsIdentity.GetCurrent().Name));
835+ }
836+ }
837+}
838
839=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs'
840--- src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs 2010-10-19 14:28:37 +0000
841+++ src/Canonical.UbuntuOne.ProcessDispatcher/SyncDaemonService.cs 2010-10-19 14:28:38 +0000
842@@ -433,7 +433,7 @@
843 UseShellExecute = false,
844 RedirectStandardOutput = false,
845 RedirectStandardError = false,
846- CreateNoWindow = false
847+ CreateNoWindow = true
848 }
849 };
850 sync.Start();
851
852=== modified file 'src/Canonical.UbuntuOne.ProcessDispatcher/objects.xml'
853--- src/Canonical.UbuntuOne.ProcessDispatcher/objects.xml 2010-10-19 14:28:37 +0000
854+++ src/Canonical.UbuntuOne.ProcessDispatcher/objects.xml 2010-10-19 14:28:38 +0000
855@@ -84,4 +84,10 @@
856 value="5"/>
857 </object>
858
859+ <object id="PipeListeningStartupTask"
860+ type="Canonical.UbuntuOne.ProcessDispatcher.PipeListeningStartupTask, Canonical.UbuntuOne.ProcessDispatcher"
861+ autowire="autodetect" >
862+ <property name="PipeListener"
863+ ref="PipeListener"/>
864+ </object>
865 </objects>
866\ No newline at end of file
867
868=== modified file 'src/UbuntuOneClient.Tests/ProgramFixture.cs'
869--- src/UbuntuOneClient.Tests/ProgramFixture.cs 2010-10-19 14:28:37 +0000
870+++ src/UbuntuOneClient.Tests/ProgramFixture.cs 2010-10-19 14:28:38 +0000
871@@ -42,8 +42,6 @@
872 private IApplication _app;
873 private MockRepository _mocks;
874 private Program _program;
875- private IPreferencesDialogPresenter _preferencesDialogPresenter;
876- private IPipeListener _pipeListener;
877
878 #endregion
879
880@@ -56,14 +54,11 @@
881 _updater = _mocks.StrictMock<IUpdater>();
882 _notifyIcon = _mocks.StrictMock<INotificationIconView>();
883 _app = _mocks.StrictMock<IApplication>();
884- _pipeListener = _mocks.DynamicMock<IPipeListener>();
885- _preferencesDialogPresenter = _mocks.StrictMock<IPreferencesDialogPresenter>();
886 _program = new Program
887 {
888 NotifyIcon = _notifyIcon,
889 Updater = _updater,
890 Application = _app,
891- PreferencesDialogPresenter = _preferencesDialogPresenter
892 };
893 }
894
895
896=== modified file 'src/UbuntuOneClient/Program.cs'
897--- src/UbuntuOneClient/Program.cs 2010-10-19 14:28:37 +0000
898+++ src/UbuntuOneClient/Program.cs 2010-10-19 14:28:38 +0000
899@@ -42,7 +42,6 @@
900 private INotificationIconView _notifyIcon;
901 private readonly object _notifyIconLock = new object();
902 private Thread _updatesThread;
903- private static readonly ConfigurationLocator _configLocator = new ConfigurationLocator();
904
905 #region DI Properties for testability
906
907@@ -94,16 +93,6 @@
908 /// </summary>
909 internal IApplication Application { get; set; }
910
911- /// <summary>
912- /// Allows to get and set the presenter that knows how to deal with the settings.
913- /// </summary>
914- internal IPreferencesDialogPresenter PreferencesDialogPresenter { get; set; }
915-
916- /// <summary>
917- /// Gets and sets the listener that will be used to listen to messages from the python code.
918- /// </summary>
919- internal IPipeListener PipeListener { get; set; }
920-
921 #endregion
922
923 #region Helper methods
924@@ -140,10 +129,7 @@
925 // that way we will not stop the execution of the application while we chec the rss feed.
926 _updatesThread = new Thread(CheckForUpdates);
927 _updatesThread.Start();
928- // we are goign to load the current settings
929- // TODO: using the presenter here is very ugly.
930- PreferencesDialogPresenter.LoadPreferences();
931- PipeListener.StartListening(string.Format("PythonMessages{0}", WindowsIdentity.GetCurrent().Name));
932+
933 // we do not worry about looping to allow the other thread to finish, we no that app should take longer
934 Application.Run(NotifyIcon as Window);
935
936@@ -174,6 +160,9 @@
937
938 ObjectsContainer.Initialize(new SpringContainer());
939 var program = ObjectsContainer.GetImplementationOf<Program>();
940+ // HACK: This should be done by the IoC and not manually
941+ program.Application.StartupTasks.Add(ObjectsContainer.GetImplementationOf<PipeListeningStartupTask>());
942+ program.Application.StartupTasks.Add(ObjectsContainer.GetImplementationOf<LoadPreferencesStartupTask>());
943 program.StartApplication();
944
945 }
946
947=== modified file 'src/UbuntuOneClient/objects.xml'
948--- src/UbuntuOneClient/objects.xml 2010-10-19 14:28:37 +0000
949+++ src/UbuntuOneClient/objects.xml 2010-10-19 14:28:38 +0000
950@@ -46,19 +46,23 @@
951 <property name="RSSFeed"
952 value="http://s3.amazonaws.com/u1wintest/rss"/>
953 </object>
954-
955+
956 <object id="Application"
957- type="UbuntuOneClient.ApplicationWrapper, UbuntuOneClient" />
958+ type="UbuntuOneClient.ApplicationWrapper, UbuntuOneClient" >
959+ <property name="StartupTasks">
960+ <list element-type="Canonical.UbuntuOne.Common.Utils.IStartupTask, Canonical.UbuntuOne.Common">
961+ <value>1</value>
962+ <ref object="PipeListeningStartupTask"/> <!-- task that ensures that we listen to messages from python-->
963+ <ref object="LoadPreferencesStartupTask"/> <!-- Load the preferences -->
964+ </list>
965+ </property>
966+ </object>
967
968 <object id="Program"
969 type="UbuntuOneClient.Program, UbuntuOneClient"
970 autowire="autodetect" >
971 <property name="Application"
972 ref="Application" />
973- <property name="PreferencesDialogPresenter"
974- ref="PreferencesDialogPresenter" />
975- <property name="PipeListener"
976- ref="PipeListener" />
977 </object>
978
979 <!-- ############################################################### -->
980
981=== removed directory 'tools/NUnit'
982=== removed file 'tools/NUnit/Logo.ico'
983Binary files tools/NUnit/Logo.ico 2010-10-19 14:28:37 +0000 and tools/NUnit/Logo.ico 1970-01-01 00:00:00 +0000 differ
984=== removed file 'tools/NUnit/NUnitFitTests.html'
985--- tools/NUnit/NUnitFitTests.html 2010-10-19 14:28:37 +0000
986+++ tools/NUnit/NUnitFitTests.html 1970-01-01 00:00:00 +0000
987@@ -1,277 +0,0 @@
988-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
989-<html>
990- <body>
991- <h1>NUnit Acceptance Tests</h1>
992- <p>
993- Developers love self-referential programs! Hence, NUnit has always run all it's
994- own tests, even those that are not really unit tests.
995- <p>Now, beginning with NUnit 2.4, NUnit has top-level tests using Ward Cunningham's
996- FIT framework. At this time, the tests are pretty rudimentary, but it's a start
997- and it's a framework for doing more.
998- <h2>Running the Tests</h2>
999- <p>Open a console or shell window and navigate to the NUnit bin directory, which
1000- contains this file. To run the test under Microsoft .Net, enter the command
1001- <pre> runFile NUnitFitTests.html TestResults.html .</pre>
1002- To run it under Mono, enter
1003- <pre> mono runFile.exe NUnitFitTests.html TestResults.html .</pre>
1004- Note the space and dot at the end of each command. The results of your test
1005- will be in TestResults.html in the same directory.
1006- <h2>Platform and CLR Version</h2>
1007- <table BORDER cellSpacing="0" cellPadding="5">
1008- <tr>
1009- <td colspan="2">NUnit.Fixtures.PlatformInfo</td>
1010- </tr>
1011- </table>
1012- <h2>Verify Unit Tests</h2>
1013- <p>
1014- Load and run the NUnit unit tests, verifying that the results are as expected.
1015- When these tests are run on different platforms, different numbers of tests may
1016- be skipped, so the values for Skipped and Run tests are informational only.
1017- <p>
1018- The number of tests in each assembly should be constant across all platforms -
1019- any discrepancy usually means that one of the test source files was not
1020- compiled on the platform. There should be no failures and no tests ignored.
1021- <p><b>Note:</b>
1022- At the moment, the nunit.extensions.tests assembly is failing because the
1023- fixture doesn't initialize addins in the test domain.
1024- <p>
1025- <table BORDER cellSpacing="0" cellPadding="5">
1026- <tr>
1027- <td colspan="6">NUnit.Fixtures.AssemblyRunner</td>
1028- </tr>
1029- <tr>
1030- <td>Assembly</td>
1031- <td>Tests()</td>
1032- <td>Run()</td>
1033- <td>Skipped()</td>
1034- <td>Ignored()</td>
1035- <td>Failures()</td>
1036- </tr>
1037- <tr>
1038- <td>nunit.framework.tests.dll</td>
1039- <td>397</td>
1040- <td>&nbsp;</td>
1041- <td>&nbsp;</td>
1042- <td>0</td>
1043- <td>0</td>
1044- </tr>
1045- <tr>
1046- <td>nunit.core.tests.dll</td>
1047- <td>355</td>
1048- <td>&nbsp;</td>
1049- <td>&nbsp;</td>
1050- <td>0</td>
1051- <td>0</td>
1052- </tr>
1053- <tr>
1054- <td>nunit.util.tests.dll</td>
1055- <td>238</td>
1056- <td>&nbsp;</td>
1057- <td>&nbsp;</td>
1058- <td>0</td>
1059- <td>0</td>
1060- </tr>
1061- <tr>
1062- <td>nunit.mocks.tests.dll</td>
1063- <td>43</td>
1064- <td>&nbsp;</td>
1065- <td>&nbsp;</td>
1066- <td>0</td>
1067- <td>0</td>
1068- </tr>
1069- <tr>
1070- <td>nunit.extensions.tests.dll</td>
1071- <td>5</td>
1072- <td>&nbsp;</td>
1073- <td>&nbsp;</td>
1074- <td>0</td>
1075- <td>0</td>
1076- </tr>
1077- <tr>
1078- <td>nunit-console.tests.dll</td>
1079- <td>40</td>
1080- <td>&nbsp;</td>
1081- <td>&nbsp;</td>
1082- <td>0</td>
1083- <td>0</td>
1084- </tr>
1085- <tr>
1086- <td>nunit.uikit.tests.dll</td>
1087- <td>34</td>
1088- <td>&nbsp;</td>
1089- <td>&nbsp;</td>
1090- <td>0</td>
1091- <td>0</td>
1092- </tr>
1093- <tr>
1094- <td>nunit-gui.tests.dll</td>
1095- <td>15</td>
1096- <td>&nbsp;</td>
1097- <td>&nbsp;</td>
1098- <td>0</td>
1099- <td>0</td>
1100- </tr>
1101- <tr>
1102- <td>nunit.fixtures.tests.dll</td>
1103- <td>6</td>
1104- <td>&nbsp;</td>
1105- <td>&nbsp;</td>
1106- <td>0</td>
1107- <td>0</td>
1108- </tr>
1109- </table>
1110- <h2>Code Snippet Tests</h2>
1111- <p>
1112- These tests create a test assembly from a snippet of code and then load and run
1113- the tests that it contains, verifying that the structure of the loaded tests is
1114- as expected and that the number of tests run, skipped, ignored or failed is
1115- correct.
1116- <p>
1117- <table BORDER cellSpacing="0" cellPadding="5">
1118- <tr>
1119- <td colspan="6">NUnit.Fixtures.SnippetRunner</td>
1120- </tr>
1121- <tr>
1122- <td>Code</td>
1123- <td>Tree()</td>
1124- <td>Run()</td>
1125- <td>Skipped()</td>
1126- <td>Ignored()</td>
1127- <td>Failures()</td>
1128- </tr>
1129- <tr>
1130- <td><pre>public class TestClass
1131-{
1132-}</pre>
1133- </td>
1134- <td>EMPTY</td>
1135- <td>0</td>
1136- <td>0</td>
1137- <td>0</td>
1138- <td>0</td>
1139- </tr>
1140- <tr>
1141- <td><pre>using NUnit.Framework;
1142-
1143-[TestFixture]
1144-public class TestClass
1145-{
1146-}</pre>
1147- </td>
1148- <td>TestClass</td>
1149- <td>0</td>
1150- <td>0</td>
1151- <td>0</td>
1152- <td>0</td>
1153- </tr>
1154- <tr>
1155- <td><pre>using NUnit.Framework;
1156-
1157-[TestFixture]
1158-public class TestClass
1159-{
1160- [Test]
1161- public void T1() { }
1162- [Test]
1163- public void T2() { }
1164- [Test]
1165- public void T3() { }
1166-}</pre>
1167- </td>
1168- <td><pre>TestClass
1169-&gt;T1
1170-&gt;T2
1171-&gt;T3</pre>
1172- </td>
1173- <td>3</td>
1174- <td>0</td>
1175- <td>0</td>
1176- <td>0</td>
1177- </tr>
1178- <tr>
1179- <td><pre>using NUnit.Framework;
1180-
1181-[TestFixture]
1182-public class TestClass1
1183-{
1184- [Test]
1185- public void T1() { }
1186-}
1187-
1188-[TestFixture]
1189-public class TestClass2
1190-{
1191- [Test]
1192- public void T2() { }
1193- [Test]
1194- public void T3() { }
1195-}</pre>
1196- </td>
1197- <td><pre>TestClass1
1198-&gt;T1
1199-TestClass2
1200-&gt;T2
1201-&gt;T3</pre>
1202- </td>
1203- <td>3</td>
1204- <td>0</td>
1205- <td>0</td>
1206- <td>0</td>
1207- </tr>
1208- <tr>
1209- <td><pre>using NUnit.Framework;
1210-
1211-[TestFixture]
1212-public class TestClass
1213-{
1214- [Test]
1215- public void T1() { }
1216- [Test, Ignore]
1217- public void T2() { }
1218- [Test]
1219- public void T3() { }
1220-}</pre>
1221- </td>
1222- <td><pre>TestClass
1223-&gt;T1
1224-&gt;T2
1225-&gt;T3</pre>
1226- </td>
1227- <td>2</td>
1228- <td>0</td>
1229- <td>1</td>
1230- <td>0</td>
1231- </tr>
1232- <tr>
1233- <td><pre>using NUnit.Framework;
1234-
1235-[TestFixture]
1236-public class TestClass
1237-{
1238- [Test]
1239- public void T1() { }
1240- [Test, Explicit]
1241- public void T2() { }
1242- [Test]
1243- public void T3() { }
1244-}</pre>
1245- </td>
1246- <td><pre>TestClass
1247-&gt;T1
1248-&gt;T2
1249-&gt;T3</pre>
1250- </td>
1251- <td>2</td>
1252- <td>1</td>
1253- <td>0</td>
1254- <td>0</td>
1255- </tr>
1256- </table>
1257- <h2>Summary Information</h2>
1258- <table BORDER cellSpacing="0" cellPadding="5">
1259- <tr>
1260- <td colspan="2">fit.Summary</td>
1261- </tr>
1262- </table>
1263- </body>
1264-</html>
1265
1266=== removed file 'tools/NUnit/NUnitTests.config'
1267--- tools/NUnit/NUnitTests.config 2010-10-19 14:28:37 +0000
1268+++ tools/NUnit/NUnitTests.config 1970-01-01 00:00:00 +0000
1269@@ -1,84 +0,0 @@
1270-<?xml version="1.0" encoding="utf-8" ?>
1271-<configuration>
1272-<!--
1273- This is the configuration file for the NUnitTests.nunit test project. You may
1274- need to create a similar configuration file for your own test project.
1275- -->
1276-
1277-<!--
1278- The <NUnit> section is only needed if you want to use a non-default value
1279- for any of the settings. It is commented out below. If you are going to use
1280- it, you must deifne the NUnit section group and the sections you need.
1281-
1282- The syntax shown here works for most runtimes. If NUnit fails at startup, you
1283- can try specifying the name of the assembly containing the NameValueSectionHandler:
1284-
1285- <section name="TestCaseBuilder" type="System.Configuration.NameValueSectionHandler, System" />
1286-
1287- If that fails, try the fully qualified name of the assembly:
1288-
1289- <section name="TestCaseBuilder" type="System.Configuration.NameValueSectionHandler, System,
1290- Version=2.0.50727.832, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
1291-
1292- Unfortunately, this last approach makes your config file non-portable across runtimes.
1293- -->
1294-
1295-<!--
1296- <configSections>
1297- <sectionGroup name="NUnit">
1298- <section name="TestCaseBuilder" type="System.Configuration.NameValueSectionHandler"/>
1299- <section name="TestRunner" type="System.Configuration.NameValueSectionHandler"/>
1300- </sectionGroup>
1301- </configSections>
1302- -->
1303-
1304- <appSettings>
1305- <!-- User application and configured property settings go here.-->
1306- <!-- Example: <add key="settingName" value="settingValue"/> -->
1307- <add key="test.setting" value="54321" />
1308- </appSettings>
1309-
1310-<!-- Sample NUnit section group showing all default values -->
1311-<!--
1312- <NUnit>
1313- <TestCaseBuilder>
1314- <add key="OldStyleTestCases" value="false" />
1315- </TestCaseBuilder>
1316- <TestRunner>
1317- <add key="ApartmentState" value="MTA" />
1318- <add key="ThreadPriority" value="Normal" />
1319- </TestRunner>
1320- </NUnit>
1321--->
1322-
1323- <!--
1324- The following <runtime> section allows running nunit tests under
1325- .NET 1.0 by redirecting assemblies. The appliesTo attribute
1326- causes the section to be ignored except under .NET 1.0.
1327- -->
1328- <runtime>
1329- <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"
1330- appliesTo="v1.0.3705">
1331- <dependentAssembly>
1332- <assemblyIdentity name="System" publicKeyToken="b77a5c561934e089" culture="" />
1333- <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
1334- </dependentAssembly>
1335- <dependentAssembly>
1336- <assemblyIdentity name="System.Data" publicKeyToken="b77a5c561934e089" culture="" />
1337- <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
1338- </dependentAssembly>
1339- <dependentAssembly>
1340- <assemblyIdentity name="System.Drawing" publicKeyToken="b03f5f7f11d50a3a" culture="" />
1341- <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
1342- </dependentAssembly>
1343- <dependentAssembly>
1344- <assemblyIdentity name="System.Windows.Forms" publicKeyToken="b77a5c561934e089" culture="" />
1345- <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
1346- </dependentAssembly>
1347- <dependentAssembly>
1348- <assemblyIdentity name="System.Xml" publicKeyToken="b77a5c561934e089" culture="" />
1349- <bindingRedirect oldVersion="1.0.5000.0" newVersion="1.0.3300.0" />
1350- </dependentAssembly>
1351- </assemblyBinding>
1352- </runtime>
1353-</configuration>
1354
1355=== removed file 'tools/NUnit/NUnitTests.nunit'
1356--- tools/NUnit/NUnitTests.nunit 2010-10-19 14:28:37 +0000
1357+++ tools/NUnit/NUnitTests.nunit 1970-01-01 00:00:00 +0000
1358@@ -1,14 +0,0 @@
1359-<NUnitProject>
1360- <Settings appbase="."/>
1361- <Config name="Default" binpath="lib;tests;framework" runtimeFramework="v2.0">
1362- <assembly path="tests/nunit.framework.tests.dll" />
1363- <assembly path="tests/nunit.core.tests.dll" />
1364- <assembly path="tests/nunit.util.tests.dll" />
1365- <assembly path="tests/nunit.mocks.tests.dll" />
1366- <assembly path="tests/nunit-console.tests.dll" />
1367- <assembly path="tests/nunit.uiexception.tests.dll" />
1368- <assembly path="tests/nunit.uikit.tests.dll" />
1369- <assembly path="tests/nunit-gui.tests.dll" />
1370- <assembly path="tests/nunit.fixtures.tests.dll" />
1371- </Config>
1372-</NUnitProject>
1373
1374=== removed file 'tools/NUnit/agent.conf'
1375--- tools/NUnit/agent.conf 2010-10-19 14:28:37 +0000
1376+++ tools/NUnit/agent.conf 1970-01-01 00:00:00 +0000
1377@@ -1,4 +0,0 @@
1378-<AgentConfig>
1379- <Port>8080</Port>
1380- <PathToAssemblies>.</PathToAssemblies>
1381-</AgentConfig>
1382\ No newline at end of file
1383
1384=== removed file 'tools/NUnit/agent.log.conf'
1385--- tools/NUnit/agent.log.conf 2010-10-19 14:28:37 +0000
1386+++ tools/NUnit/agent.log.conf 1970-01-01 00:00:00 +0000
1387@@ -1,18 +0,0 @@
1388-<log4net>
1389- <!-- A1 is set to be a ConsoleAppender -->
1390- <appender name="A1" type="log4net.Appender.ConsoleAppender">
1391-
1392- <!-- A1 uses PatternLayout -->
1393- <layout type="log4net.Layout.PatternLayout">
1394- <!-- Print the date in ISO 8601 format -->
1395- <conversionPattern value="%-5level %logger - %message%newline" />
1396- </layout>
1397- </appender>
1398-
1399- <!-- Set root logger level to DEBUG and its only appender to A1 -->
1400- <root>
1401- <level value="DEBUG" />
1402- <appender-ref ref="A1" />
1403- </root>
1404-
1405-</log4net>
1406
1407=== removed file 'tools/NUnit/fit-license.txt'
1408--- tools/NUnit/fit-license.txt 2010-10-19 14:28:37 +0000
1409+++ tools/NUnit/fit-license.txt 1970-01-01 00:00:00 +0000
1410@@ -1,342 +0,0 @@
1411-
1412-
1413- GNU GENERAL PUBLIC LICENSE
1414- Version 2, June 1991
1415-
1416- Copyright (C) 1989, 1991 Free Software Foundation, Inc.
1417- 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1418- Everyone is permitted to copy and distribute verbatim copies
1419- of this license document, but changing it is not allowed.
1420-
1421- Preamble
1422-
1423- The licenses for most software are designed to take away your
1424-freedom to share and change it. By contrast, the GNU General Public
1425-License is intended to guarantee your freedom to share and change free
1426-software--to make sure the software is free for all its users. This
1427-General Public License applies to most of the Free Software
1428-Foundation's software and to any other program whose authors commit to
1429-using it. (Some other Free Software Foundation software is covered by
1430-the GNU Library General Public License instead.) You can apply it to
1431-your programs, too.
1432-
1433- When we speak of free software, we are referring to freedom, not
1434-price. Our General Public Licenses are designed to make sure that you
1435-have the freedom to distribute copies of free software (and charge for
1436-this service if you wish), that you receive source code or can get it
1437-if you want it, that you can change the software or use pieces of it
1438-in new free programs; and that you know you can do these things.
1439-
1440- To protect your rights, we need to make restrictions that forbid
1441-anyone to deny you these rights or to ask you to surrender the rights.
1442-These restrictions translate to certain responsibilities for you if you
1443-distribute copies of the software, or if you modify it.
1444-
1445- For example, if you distribute copies of such a program, whether
1446-gratis or for a fee, you must give the recipients all the rights that
1447-you have. You must make sure that they, too, receive or can get the
1448-source code. And you must show them these terms so they know their
1449-rights.
1450-
1451- We protect your rights with two steps: (1) copyright the software, and
1452-(2) offer you this license which gives you legal permission to copy,
1453-distribute and/or modify the software.
1454-
1455- Also, for each author's protection and ours, we want to make certain
1456-that everyone understands that there is no warranty for this free
1457-software. If the software is modified by someone else and passed on, we
1458-want its recipients to know that what they have is not the original, so
1459-that any problems introduced by others will not reflect on the original
1460-authors' reputations.
1461-
1462- Finally, any free program is threatened constantly by software
1463-patents. We wish to avoid the danger that redistributors of a free
1464-program will individually obtain patent licenses, in effect making the
1465-program proprietary. To prevent this, we have made it clear that any
1466-patent must be licensed for everyone's free use or not licensed at all.
1467-
1468- The precise terms and conditions for copying, distribution and
1469-modification follow.
1470-
1471- GNU GENERAL PUBLIC LICENSE
1472- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
1473-
1474- 0. This License applies to any program or other work which contains
1475-a notice placed by the copyright holder saying it may be distributed
1476-under the terms of this General Public License. The "Program", below,
1477-refers to any such program or work, and a "work based on the Program"
1478-means either the Program or any derivative work under copyright law:
1479-that is to say, a work containing the Program or a portion of it,
1480-either verbatim or with modifications and/or translated into another
1481-language. (Hereinafter, translation is included without limitation in
1482-the term "modification".) Each licensee is addressed as "you".
1483-
1484-Activities other than copying, distribution and modification are not
1485-covered by this License; they are outside its scope. The act of
1486-running the Program is not restricted, and the output from the Program
1487-is covered only if its contents constitute a work based on the
1488-Program (independent of having been made by running the Program).
1489-Whether that is true depends on what the Program does.
1490-
1491- 1. You may copy and distribute verbatim copies of the Program's
1492-source code as you receive it, in any medium, provided that you
1493-conspicuously and appropriately publish on each copy an appropriate
1494-copyright notice and disclaimer of warranty; keep intact all the
1495-notices that refer to this License and to the absence of any warranty;
1496-and give any other recipients of the Program a copy of this License
1497-along with the Program.
1498-
1499-You may charge a fee for the physical act of transferring a copy, and
1500-you may at your option offer warranty protection in exchange for a fee.
1501-
1502- 2. You may modify your copy or copies of the Program or any portion
1503-of it, thus forming a work based on the Program, and copy and
1504-distribute such modifications or work under the terms of Section 1
1505-above, provided that you also meet all of these conditions:
1506-
1507- a) You must cause the modified files to carry prominent notices
1508- stating that you changed the files and the date of any change.
1509-
1510- b) You must cause any work that you distribute or publish, that in
1511- whole or in part contains or is derived from the Program or any
1512- part thereof, to be licensed as a whole at no charge to all third
1513- parties under the terms of this License.
1514-
1515- c) If the modified program normally reads commands interactively
1516- when run, you must cause it, when started running for such
1517- interactive use in the most ordinary way, to print or display an
1518- announcement including an appropriate copyright notice and a
1519- notice that there is no warranty (or else, saying that you provide
1520- a warranty) and that users may redistribute the program under
1521- these conditions, and telling the user how to view a copy of this
1522- License. (Exception: if the Program itself is interactive but
1523- does not normally print such an announcement, your work based on
1524- the Program is not required to print an announcement.)
1525-
1526-These requirements apply to the modified work as a whole. If
1527-identifiable sections of that work are not derived from the Program,
1528-and can be reasonably considered independent and separate works in
1529-themselves, then this License, and its terms, do not apply to those
1530-sections when you distribute them as separate works. But when you
1531-distribute the same sections as part of a whole which is a work based
1532-on the Program, the distribution of the whole must be on the terms of
1533-this License, whose permissions for other licensees extend to the
1534-entire whole, and thus to each and every part regardless of who wrote it.
1535-
1536-Thus, it is not the intent of this section to claim rights or contest
1537-your rights to work written entirely by you; rather, the intent is to
1538-exercise the right to control the distribution of derivative or
1539-collective works based on the Program.
1540-
1541-In addition, mere aggregation of another work not based on the Program
1542-with the Program (or with a work based on the Program) on a volume of
1543-a storage or distribution medium does not bring the other work under
1544-the scope of this License.
1545-
1546- 3. You may copy and distribute the Program (or a work based on it,
1547-under Section 2) in object code or executable form under the terms of
1548-Sections 1 and 2 above provided that you also do one of the following:
1549-
1550- a) Accompany it with the complete corresponding machine-readable
1551- source code, which must be distributed under the terms of Sections
1552- 1 and 2 above on a medium customarily used for software interchange; or,
1553-
1554- b) Accompany it with a written offer, valid for at least three
1555- years, to give any third party, for a charge no more than your
1556- cost of physically performing source distribution, a complete
1557- machine-readable copy of the corresponding source code, to be
1558- distributed under the terms of Sections 1 and 2 above on a medium
1559- customarily used for software interchange; or,
1560-
1561- c) Accompany it with the information you received as to the offer
1562- to distribute corresponding source code. (This alternative is
1563- allowed only for noncommercial distribution and only if you
1564- received the program in object code or executable form with such
1565- an offer, in accord with Subsection b above.)
1566-
1567-The source code for a work means the preferred form of the work for
1568-making modifications to it. For an executable work, complete source
1569-code means all the source code for all modules it contains, plus any
1570-associated interface definition files, plus the scripts used to
1571-control compilation and installation of the executable. However, as a
1572-special exception, the source code distributed need not include
1573-anything that is normally distributed (in either source or binary
1574-form) with the major components (compiler, kernel, and so on) of the
1575-operating system on which the executable runs, unless that component
1576-itself accompanies the executable.
1577-
1578-If distribution of executable or object code is made by offering
1579-access to copy from a designated place, then offering equivalent
1580-access to copy the source code from the same place counts as
1581-distribution of the source code, even though third parties are not
1582-compelled to copy the source along with the object code.
1583-
1584- 4. You may not copy, modify, sublicense, or distribute the Program
1585-except as expressly provided under this License. Any attempt
1586-otherwise to copy, modify, sublicense or distribute the Program is
1587-void, and will automatically terminate your rights under this License.
1588-However, parties who have received copies, or rights, from you under
1589-this License will not have their licenses terminated so long as such
1590-parties remain in full compliance.
1591-
1592- 5. You are not required to accept this License, since you have not
1593-signed it. However, nothing else grants you permission to modify or
1594-distribute the Program or its derivative works. These actions are
1595-prohibited by law if you do not accept this License. Therefore, by
1596-modifying or distributing the Program (or any work based on the
1597-Program), you indicate your acceptance of this License to do so, and
1598-all its terms and conditions for copying, distributing or modifying
1599-the Program or works based on it.
1600-
1601- 6. Each time you redistribute the Program (or any work based on the
1602-Program), the recipient automatically receives a license from the
1603-original licensor to copy, distribute or modify the Program subject to
1604-these terms and conditions. You may not impose any further
1605-restrictions on the recipients' exercise of the rights granted herein.
1606-You are not responsible for enforcing compliance by third parties to
1607-this License.
1608-
1609- 7. If, as a consequence of a court judgment or allegation of patent
1610-infringement or for any other reason (not limited to patent issues),
1611-conditions are imposed on you (whether by court order, agreement or
1612-otherwise) that contradict the conditions of this License, they do not
1613-excuse you from the conditions of this License. If you cannot
1614-distribute so as to satisfy simultaneously your obligations under this
1615-License and any other pertinent obligations, then as a consequence you
1616-may not distribute the Program at all. For example, if a patent
1617-license would not permit royalty-free redistribution of the Program by
1618-all those who receive copies directly or indirectly through you, then
1619-the only way you could satisfy both it and this License would be to
1620-refrain entirely from distribution of the Program.
1621-
1622-If any portion of this section is held invalid or unenforceable under
1623-any particular circumstance, the balance of the section is intended to
1624-apply and the section as a whole is intended to apply in other
1625-circumstances.
1626-
1627-It is not the purpose of this section to induce you to infringe any
1628-patents or other property right claims or to contest validity of any
1629-such claims; this section has the sole purpose of protecting the
1630-integrity of the free software distribution system, which is
1631-implemented by public license practices. Many people have made
1632-generous contributions to the wide range of software distributed
1633-through that system in reliance on consistent application of that
1634-system; it is up to the author/donor to decide if he or she is willing
1635-to distribute software through any other system and a licensee cannot
1636-impose that choice.
1637-
1638-This section is intended to make thoroughly clear what is believed to
1639-be a consequence of the rest of this License.
1640-
1641- 8. If the distribution and/or use of the Program is restricted in
1642-certain countries either by patents or by copyrighted interfaces, the
1643-original copyright holder who places the Program under this License
1644-may add an explicit geographical distribution limitation excluding
1645-those countries, so that distribution is permitted only in or among
1646-countries not thus excluded. In such case, this License incorporates
1647-the limitation as if written in the body of this License.
1648-
1649- 9. The Free Software Foundation may publish revised and/or new versions
1650-of the General Public License from time to time. Such new versions will
1651-be similar in spirit to the present version, but may differ in detail to
1652-address new problems or concerns.
1653-
1654-Each version is given a distinguishing version number. If the Program
1655-specifies a version number of this License which applies to it and "any
1656-later version", you have the option of following the terms and conditions
1657-either of that version or of any later version published by the Free
1658-Software Foundation. If the Program does not specify a version number of
1659-this License, you may choose any version ever published by the Free Software
1660-Foundation.
1661-
1662- 10. If you wish to incorporate parts of the Program into other free
1663-programs whose distribution conditions are different, write to the author
1664-to ask for permission. For software which is copyrighted by the Free
1665-Software Foundation, write to the Free Software Foundation; we sometimes
1666-make exceptions for this. Our decision will be guided by the two goals
1667-of preserving the free status of all derivatives of our free software and
1668-of promoting the sharing and reuse of software generally.
1669-
1670- NO WARRANTY
1671-
1672- 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
1673-FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
1674-OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
1675-PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
1676-OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
1677-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
1678-TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
1679-PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
1680-REPAIR OR CORRECTION.
1681-
1682- 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
1683-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
1684-REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
1685-INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
1686-OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
1687-TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
1688-YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
1689-PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
1690-POSSIBILITY OF SUCH DAMAGES.
1691-
1692- END OF TERMS AND CONDITIONS
1693-
1694- How to Apply These Terms to Your New Programs
1695-
1696- If you develop a new program, and you want it to be of the greatest
1697-possible use to the public, the best way to achieve this is to make it
1698-free software which everyone can redistribute and change under these terms.
1699-
1700- To do so, attach the following notices to the program. It is safest
1701-to attach them to the start of each source file to most effectively
1702-convey the exclusion of warranty; and each file should have at least
1703-the "copyright" line and a pointer to where the full notice is found.
1704-
1705- <one line to give the program's name and a brief idea of what it does.>
1706- Copyright (C) <year> <name of author>
1707-
1708- This program is free software; you can redistribute it and/or modify
1709- it under the terms of the GNU General Public License as published by
1710- the Free Software Foundation; either version 2 of the License, or
1711- (at your option) any later version.
1712-
1713- This program is distributed in the hope that it will be useful,
1714- but WITHOUT ANY WARRANTY; without even the implied warranty of
1715- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1716- GNU General Public License for more details.
1717-
1718- You should have received a copy of the GNU General Public License
1719- along with this program; if not, write to the Free Software
1720- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
1721-
1722-
1723-Also add information on how to contact you by electronic and paper mail.
1724-
1725-If the program is interactive, make it output a short notice like this
1726-when it starts in an interactive mode:
1727-
1728- Gnomovision version 69, Copyright (C) year name of author
1729- Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
1730- This is free software, and you are welcome to redistribute it
1731- under certain conditions; type `show c' for details.
1732-
1733-The hypothetical commands `show w' and `show c' should show the appropriate
1734-parts of the General Public License. Of course, the commands you use may
1735-be called something other than `show w' and `show c'; they could even be
1736-mouse-clicks or menu items--whatever suits your program.
1737-
1738-You should also get your employer (if you work as a programmer) or your
1739-school, if any, to sign a "copyright disclaimer" for the program, if
1740-necessary. Here is a sample; alter the names:
1741-
1742- Yoyodyne, Inc., hereby disclaims all copyright interest in the program
1743- `Gnomovision' (which makes passes at compilers) written by James Hacker.
1744-
1745- <signature of Ty Coon>, 1 April 1989
1746- Ty Coon, President of Vice
1747-
1748-This General Public License does not permit incorporating your program into
1749-proprietary programs. If your program is a subroutine library, you may
1750-consider it more useful to permit linking proprietary applications with the
1751-library. If this is what you want to do, use the GNU Library General
1752-Public License instead of this License.
1753\ No newline at end of file
1754
1755=== removed directory 'tools/NUnit/framework'
1756=== removed file 'tools/NUnit/framework/nunit.framework.dll'
1757Binary files tools/NUnit/framework/nunit.framework.dll 2010-10-19 14:28:37 +0000 and tools/NUnit/framework/nunit.framework.dll 1970-01-01 00:00:00 +0000 differ
1758=== removed file 'tools/NUnit/framework/nunit.framework.xml'
1759--- tools/NUnit/framework/nunit.framework.xml 2010-10-19 14:28:37 +0000
1760+++ tools/NUnit/framework/nunit.framework.xml 1970-01-01 00:00:00 +0000
1761@@ -1,10228 +0,0 @@
1762-<?xml version="1.0"?>
1763-<doc>
1764- <assembly>
1765- <name>nunit.framework</name>
1766- </assembly>
1767- <members>
1768- <member name="T:NUnit.Framework.Constraints.BinaryConstraint">
1769- <summary>
1770- BinaryConstraint is the abstract base of all constraints
1771- that combine two other constraints in some fashion.
1772- </summary>
1773- </member>
1774- <member name="T:NUnit.Framework.Constraints.Constraint">
1775- <summary>
1776- The Constraint class is the base of all built-in constraints
1777- within NUnit. It provides the operator overloads used to combine
1778- constraints.
1779- </summary>
1780- </member>
1781- <member name="T:NUnit.Framework.Constraints.IResolveConstraint">
1782- <summary>
1783- The IConstraintExpression interface is implemented by all
1784- complete and resolvable constraints and expressions.
1785- </summary>
1786- </member>
1787- <member name="M:NUnit.Framework.Constraints.IResolveConstraint.Resolve">
1788- <summary>
1789- Return the top-level constraint for this expression
1790- </summary>
1791- <returns></returns>
1792- </member>
1793- <member name="F:NUnit.Framework.Constraints.Constraint.UNSET">
1794- <summary>
1795- Static UnsetObject used to detect derived constraints
1796- failing to set the actual value.
1797- </summary>
1798- </member>
1799- <member name="F:NUnit.Framework.Constraints.Constraint.actual">
1800- <summary>
1801- The actual value being tested against a constraint
1802- </summary>
1803- </member>
1804- <member name="F:NUnit.Framework.Constraints.Constraint.displayName">
1805- <summary>
1806- The display name of this Constraint for use by ToString()
1807- </summary>
1808- </member>
1809- <member name="F:NUnit.Framework.Constraints.Constraint.argcnt">
1810- <summary>
1811- Argument fields used by ToString();
1812- </summary>
1813- </member>
1814- <member name="F:NUnit.Framework.Constraints.Constraint.builder">
1815- <summary>
1816- The builder holding this constraint
1817- </summary>
1818- </member>
1819- <member name="M:NUnit.Framework.Constraints.Constraint.#ctor">
1820- <summary>
1821- Construct a constraint with no arguments
1822- </summary>
1823- </member>
1824- <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object)">
1825- <summary>
1826- Construct a constraint with one argument
1827- </summary>
1828- </member>
1829- <member name="M:NUnit.Framework.Constraints.Constraint.#ctor(System.Object,System.Object)">
1830- <summary>
1831- Construct a constraint with two arguments
1832- </summary>
1833- </member>
1834- <member name="M:NUnit.Framework.Constraints.Constraint.SetBuilder(NUnit.Framework.Constraints.ConstraintBuilder)">
1835- <summary>
1836- Sets the ConstraintBuilder holding this constraint
1837- </summary>
1838- </member>
1839- <member name="M:NUnit.Framework.Constraints.Constraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">
1840- <summary>
1841- Write the failure message to the MessageWriter provided
1842- as an argument. The default implementation simply passes
1843- the constraint and the actual value to the writer, which
1844- then displays the constraint description and the value.
1845-
1846- Constraints that need to provide additional details,
1847- such as where the error occured can override this.
1848- </summary>
1849- <param name="writer">The MessageWriter on which to display the message</param>
1850- </member>
1851- <member name="M:NUnit.Framework.Constraints.Constraint.Matches(System.Object)">
1852- <summary>
1853- Test whether the constraint is satisfied by a given value
1854- </summary>
1855- <param name="actual">The value to be tested</param>
1856- <returns>True for success, false for failure</returns>
1857- </member>
1858- <member name="M:NUnit.Framework.Constraints.Constraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
1859- <summary>
1860- Test whether the constraint is satisfied by an
1861- ActualValueDelegate that returns the value to be tested.
1862- The default implementation simply evaluates the delegate
1863- but derived classes may override it to provide for delayed
1864- processing.
1865- </summary>
1866- <param name="del">An ActualValueDelegate</param>
1867- <returns>True for success, false for failure</returns>
1868- </member>
1869- <member name="M:NUnit.Framework.Constraints.Constraint.Matches``1(``0@)">
1870- <summary>
1871- Test whether the constraint is satisfied by a given reference.
1872- The default implementation simply dereferences the value but
1873- derived classes may override it to provide for delayed processing.
1874- </summary>
1875- <param name="actual">A reference to the value to be tested</param>
1876- <returns>True for success, false for failure</returns>
1877- </member>
1878- <member name="M:NUnit.Framework.Constraints.Constraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
1879- <summary>
1880- Write the constraint description to a MessageWriter
1881- </summary>
1882- <param name="writer">The writer on which the description is displayed</param>
1883- </member>
1884- <member name="M:NUnit.Framework.Constraints.Constraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
1885- <summary>
1886- Write the actual value for a failing constraint test to a
1887- MessageWriter. The default implementation simply writes
1888- the raw value of actual, leaving it to the writer to
1889- perform any formatting.
1890- </summary>
1891- <param name="writer">The writer on which the actual value is displayed</param>
1892- </member>
1893- <member name="M:NUnit.Framework.Constraints.Constraint.ToString">
1894- <summary>
1895- Default override of ToString returns the constraint DisplayName
1896- followed by any arguments within angle brackets.
1897- </summary>
1898- <returns></returns>
1899- </member>
1900- <member name="M:NUnit.Framework.Constraints.Constraint.GetStringRepresentation">
1901- <summary>
1902- Returns the string representation of this constraint
1903- </summary>
1904- </member>
1905- <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseAnd(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
1906- <summary>
1907- This operator creates a constraint that is satisfied only if both
1908- argument constraints are satisfied.
1909- </summary>
1910- </member>
1911- <member name="M:NUnit.Framework.Constraints.Constraint.op_BitwiseOr(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
1912- <summary>
1913- This operator creates a constraint that is satisfied if either
1914- of the argument constraints is satisfied.
1915- </summary>
1916- </member>
1917- <member name="M:NUnit.Framework.Constraints.Constraint.op_LogicalNot(NUnit.Framework.Constraints.Constraint)">
1918- <summary>
1919- This operator creates a constraint that is satisfied if the
1920- argument constraint is not satisfied.
1921- </summary>
1922- </member>
1923- <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32)">
1924- <summary>
1925- Returns a DelayedConstraint with the specified delay time.
1926- </summary>
1927- <param name="delayInMilliseconds">The delay in milliseconds.</param>
1928- <returns></returns>
1929- </member>
1930- <member name="M:NUnit.Framework.Constraints.Constraint.After(System.Int32,System.Int32)">
1931- <summary>
1932- Returns a DelayedConstraint with the specified delay time
1933- and polling interval.
1934- </summary>
1935- <param name="delayInMilliseconds">The delay in milliseconds.</param>
1936- <param name="pollingInterval">The interval at which to test the constraint.</param>
1937- <returns></returns>
1938- </member>
1939- <member name="P:NUnit.Framework.Constraints.Constraint.DisplayName">
1940- <summary>
1941- The display name of this Constraint for use by ToString().
1942- The default value is the name of the constraint with
1943- trailing "Constraint" removed. Derived classes may set
1944- this to another name in their constructors.
1945- </summary>
1946- </member>
1947- <member name="P:NUnit.Framework.Constraints.Constraint.And">
1948- <summary>
1949- Returns a ConstraintExpression by appending And
1950- to the current constraint.
1951- </summary>
1952- </member>
1953- <member name="P:NUnit.Framework.Constraints.Constraint.With">
1954- <summary>
1955- Returns a ConstraintExpression by appending And
1956- to the current constraint.
1957- </summary>
1958- </member>
1959- <member name="P:NUnit.Framework.Constraints.Constraint.Or">
1960- <summary>
1961- Returns a ConstraintExpression by appending Or
1962- to the current constraint.
1963- </summary>
1964- </member>
1965- <member name="T:NUnit.Framework.Constraints.Constraint.UnsetObject">
1966- <summary>
1967- Class used to detect any derived constraints
1968- that fail to set the actual value in their
1969- Matches override.
1970- </summary>
1971- </member>
1972- <member name="F:NUnit.Framework.Constraints.BinaryConstraint.left">
1973- <summary>
1974- The first constraint being combined
1975- </summary>
1976- </member>
1977- <member name="F:NUnit.Framework.Constraints.BinaryConstraint.right">
1978- <summary>
1979- The second constraint being combined
1980- </summary>
1981- </member>
1982- <member name="M:NUnit.Framework.Constraints.BinaryConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
1983- <summary>
1984- Construct a BinaryConstraint from two other constraints
1985- </summary>
1986- <param name="left">The first constraint</param>
1987- <param name="right">The second constraint</param>
1988- </member>
1989- <member name="T:NUnit.Framework.Constraints.AndConstraint">
1990- <summary>
1991- AndConstraint succeeds only if both members succeed.
1992- </summary>
1993- </member>
1994- <member name="M:NUnit.Framework.Constraints.AndConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
1995- <summary>
1996- Create an AndConstraint from two other constraints
1997- </summary>
1998- <param name="left">The first constraint</param>
1999- <param name="right">The second constraint</param>
2000- </member>
2001- <member name="M:NUnit.Framework.Constraints.AndConstraint.Matches(System.Object)">
2002- <summary>
2003- Apply both member constraints to an actual value, succeeding
2004- succeeding only if both of them succeed.
2005- </summary>
2006- <param name="actual">The actual value</param>
2007- <returns>True if the constraints both succeeded</returns>
2008- </member>
2009- <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2010- <summary>
2011- Write a description for this contraint to a MessageWriter
2012- </summary>
2013- <param name="writer">The MessageWriter to receive the description</param>
2014- </member>
2015- <member name="M:NUnit.Framework.Constraints.AndConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
2016- <summary>
2017- Write the actual value for a failing constraint test to a
2018- MessageWriter. The default implementation simply writes
2019- the raw value of actual, leaving it to the writer to
2020- perform any formatting.
2021- </summary>
2022- <param name="writer">The writer on which the actual value is displayed</param>
2023- </member>
2024- <member name="T:NUnit.Framework.Constraints.OrConstraint">
2025- <summary>
2026- OrConstraint succeeds if either member succeeds
2027- </summary>
2028- </member>
2029- <member name="M:NUnit.Framework.Constraints.OrConstraint.#ctor(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
2030- <summary>
2031- Create an OrConstraint from two other constraints
2032- </summary>
2033- <param name="left">The first constraint</param>
2034- <param name="right">The second constraint</param>
2035- </member>
2036- <member name="M:NUnit.Framework.Constraints.OrConstraint.Matches(System.Object)">
2037- <summary>
2038- Apply the member constraints to an actual value, succeeding
2039- succeeding as soon as one of them succeeds.
2040- </summary>
2041- <param name="actual">The actual value</param>
2042- <returns>True if either constraint succeeded</returns>
2043- </member>
2044- <member name="M:NUnit.Framework.Constraints.OrConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2045- <summary>
2046- Write a description for this contraint to a MessageWriter
2047- </summary>
2048- <param name="writer">The MessageWriter to receive the description</param>
2049- </member>
2050- <member name="T:NUnit.Framework.Constraints.CollectionConstraint">
2051- <summary>
2052- CollectionConstraint is the abstract base class for
2053- constraints that operate on collections.
2054- </summary>
2055- </member>
2056- <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor">
2057- <summary>
2058- Construct an empty CollectionConstraint
2059- </summary>
2060- </member>
2061- <member name="M:NUnit.Framework.Constraints.CollectionConstraint.#ctor(System.Object)">
2062- <summary>
2063- Construct a CollectionConstraint
2064- </summary>
2065- <param name="arg"></param>
2066- </member>
2067- <member name="M:NUnit.Framework.Constraints.CollectionConstraint.IsEmpty(System.Collections.IEnumerable)">
2068- <summary>
2069- Determines whether the specified enumerable is empty.
2070- </summary>
2071- <param name="enumerable">The enumerable.</param>
2072- <returns>
2073- <c>true</c> if the specified enumerable is empty; otherwise, <c>false</c>.
2074- </returns>
2075- </member>
2076- <member name="M:NUnit.Framework.Constraints.CollectionConstraint.Matches(System.Object)">
2077- <summary>
2078- Test whether the constraint is satisfied by a given value
2079- </summary>
2080- <param name="actual">The value to be tested</param>
2081- <returns>True for success, false for failure</returns>
2082- </member>
2083- <member name="M:NUnit.Framework.Constraints.CollectionConstraint.doMatch(System.Collections.IEnumerable)">
2084- <summary>
2085- Protected method to be implemented by derived classes
2086- </summary>
2087- <param name="collection"></param>
2088- <returns></returns>
2089- </member>
2090- <member name="T:NUnit.Framework.Constraints.CollectionItemsEqualConstraint">
2091- <summary>
2092- CollectionItemsEqualConstraint is the abstract base class for all
2093- collection constraints that apply some notion of item equality
2094- as a part of their operation.
2095- </summary>
2096- </member>
2097- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor">
2098- <summary>
2099- Construct an empty CollectionConstraint
2100- </summary>
2101- </member>
2102- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.#ctor(System.Object)">
2103- <summary>
2104- Construct a CollectionConstraint
2105- </summary>
2106- <param name="arg"></param>
2107- </member>
2108- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IComparer)">
2109- <summary>
2110- Flag the constraint to use the supplied IComparer object.
2111- </summary>
2112- <param name="comparer">The IComparer object to use.</param>
2113- <returns>Self.</returns>
2114- </member>
2115- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
2116- <summary>
2117- Flag the constraint to use the supplied IComparer object.
2118- </summary>
2119- <param name="comparer">The IComparer object to use.</param>
2120- <returns>Self.</returns>
2121- </member>
2122- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Comparison{``0})">
2123- <summary>
2124- Flag the constraint to use the supplied Comparison object.
2125- </summary>
2126- <param name="comparer">The IComparer object to use.</param>
2127- <returns>Self.</returns>
2128- </member>
2129- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using(System.Collections.IEqualityComparer)">
2130- <summary>
2131- Flag the constraint to use the supplied IEqualityComparer object.
2132- </summary>
2133- <param name="comparer">The IComparer object to use.</param>
2134- <returns>Self.</returns>
2135- </member>
2136- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
2137- <summary>
2138- Flag the constraint to use the supplied IEqualityComparer object.
2139- </summary>
2140- <param name="comparer">The IComparer object to use.</param>
2141- <returns>Self.</returns>
2142- </member>
2143- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.ItemsEqual(System.Object,System.Object)">
2144- <summary>
2145- Compares two collection members for equality
2146- </summary>
2147- </member>
2148- <member name="M:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.Tally(System.Collections.IEnumerable)">
2149- <summary>
2150- Return a new CollectionTally for use in making tests
2151- </summary>
2152- <param name="c">The collection to be included in the tally</param>
2153- </member>
2154- <member name="P:NUnit.Framework.Constraints.CollectionItemsEqualConstraint.IgnoreCase">
2155- <summary>
2156- Flag the constraint to ignore case and return self.
2157- </summary>
2158- </member>
2159- <member name="T:NUnit.Framework.Constraints.EmptyCollectionConstraint">
2160- <summary>
2161- EmptyCollectionConstraint tests whether a collection is empty.
2162- </summary>
2163- </member>
2164- <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.doMatch(System.Collections.IEnumerable)">
2165- <summary>
2166- Check that the collection is empty
2167- </summary>
2168- <param name="collection"></param>
2169- <returns></returns>
2170- </member>
2171- <member name="M:NUnit.Framework.Constraints.EmptyCollectionConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2172- <summary>
2173- Write the constraint description to a MessageWriter
2174- </summary>
2175- <param name="writer"></param>
2176- </member>
2177- <member name="T:NUnit.Framework.Constraints.UniqueItemsConstraint">
2178- <summary>
2179- UniqueItemsConstraint tests whether all the items in a
2180- collection are unique.
2181- </summary>
2182- </member>
2183- <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.doMatch(System.Collections.IEnumerable)">
2184- <summary>
2185- Check that all items are unique.
2186- </summary>
2187- <param name="actual"></param>
2188- <returns></returns>
2189- </member>
2190- <member name="M:NUnit.Framework.Constraints.UniqueItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2191- <summary>
2192- Write a description of this constraint to a MessageWriter
2193- </summary>
2194- <param name="writer"></param>
2195- </member>
2196- <member name="T:NUnit.Framework.Constraints.CollectionContainsConstraint">
2197- <summary>
2198- CollectionContainsConstraint is used to test whether a collection
2199- contains an expected object as a member.
2200- </summary>
2201- </member>
2202- <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.#ctor(System.Object)">
2203- <summary>
2204- Construct a CollectionContainsConstraint
2205- </summary>
2206- <param name="expected"></param>
2207- </member>
2208- <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.doMatch(System.Collections.IEnumerable)">
2209- <summary>
2210- Test whether the expected item is contained in the collection
2211- </summary>
2212- <param name="actual"></param>
2213- <returns></returns>
2214- </member>
2215- <member name="M:NUnit.Framework.Constraints.CollectionContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2216- <summary>
2217- Write a descripton of the constraint to a MessageWriter
2218- </summary>
2219- <param name="writer"></param>
2220- </member>
2221- <member name="T:NUnit.Framework.Constraints.CollectionEquivalentConstraint">
2222- <summary>
2223- CollectionEquivalentCOnstraint is used to determine whether two
2224- collections are equivalent.
2225- </summary>
2226- </member>
2227- <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.#ctor(System.Collections.IEnumerable)">
2228- <summary>
2229- Construct a CollectionEquivalentConstraint
2230- </summary>
2231- <param name="expected"></param>
2232- </member>
2233- <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.doMatch(System.Collections.IEnumerable)">
2234- <summary>
2235- Test whether two collections are equivalent
2236- </summary>
2237- <param name="actual"></param>
2238- <returns></returns>
2239- </member>
2240- <member name="M:NUnit.Framework.Constraints.CollectionEquivalentConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2241- <summary>
2242- Write a description of this constraint to a MessageWriter
2243- </summary>
2244- <param name="writer"></param>
2245- </member>
2246- <member name="T:NUnit.Framework.Constraints.CollectionSubsetConstraint">
2247- <summary>
2248- CollectionSubsetConstraint is used to determine whether
2249- one collection is a subset of another
2250- </summary>
2251- </member>
2252- <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.#ctor(System.Collections.IEnumerable)">
2253- <summary>
2254- Construct a CollectionSubsetConstraint
2255- </summary>
2256- <param name="expected">The collection that the actual value is expected to be a subset of</param>
2257- </member>
2258- <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.doMatch(System.Collections.IEnumerable)">
2259- <summary>
2260- Test whether the actual collection is a subset of
2261- the expected collection provided.
2262- </summary>
2263- <param name="actual"></param>
2264- <returns></returns>
2265- </member>
2266- <member name="M:NUnit.Framework.Constraints.CollectionSubsetConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2267- <summary>
2268- Write a description of this constraint to a MessageWriter
2269- </summary>
2270- <param name="writer"></param>
2271- </member>
2272- <member name="T:NUnit.Framework.Constraints.CollectionOrderedConstraint">
2273- <summary>
2274- CollectionOrderedConstraint is used to test whether a collection is ordered.
2275- </summary>
2276- </member>
2277- <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.#ctor">
2278- <summary>
2279- Construct a CollectionOrderedConstraint
2280- </summary>
2281- </member>
2282- <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using(System.Collections.IComparer)">
2283- <summary>
2284- Modifies the constraint to use an IComparer and returns self.
2285- </summary>
2286- </member>
2287- <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
2288- <summary>
2289- Modifies the constraint to use an IComparer&lt;T&gt; and returns self.
2290- </summary>
2291- </member>
2292- <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.Using``1(System.Comparison{``0})">
2293- <summary>
2294- Modifies the constraint to use a Comparison&lt;T&gt; and returns self.
2295- </summary>
2296- </member>
2297- <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.By(System.String)">
2298- <summary>
2299- Modifies the constraint to test ordering by the value of
2300- a specified property and returns self.
2301- </summary>
2302- </member>
2303- <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.doMatch(System.Collections.IEnumerable)">
2304- <summary>
2305- Test whether the collection is ordered
2306- </summary>
2307- <param name="actual"></param>
2308- <returns></returns>
2309- </member>
2310- <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2311- <summary>
2312- Write a description of the constraint to a MessageWriter
2313- </summary>
2314- <param name="writer"></param>
2315- </member>
2316- <member name="M:NUnit.Framework.Constraints.CollectionOrderedConstraint.GetStringRepresentation">
2317- <summary>
2318- Returns the string representation of the constraint.
2319- </summary>
2320- <returns></returns>
2321- </member>
2322- <member name="P:NUnit.Framework.Constraints.CollectionOrderedConstraint.Descending">
2323- <summary>
2324- If used performs a reverse comparison
2325- </summary>
2326- </member>
2327- <member name="T:NUnit.Framework.Constraints.ComparisonConstraint">
2328- <summary>
2329- Abstract base class for constraints that compare values to
2330- determine if one is greater than, equal to or less than
2331- the other.
2332- </summary>
2333- </member>
2334- <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.expected">
2335- <summary>
2336- The value against which a comparison is to be made
2337- </summary>
2338- </member>
2339- <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.ltOK">
2340- <summary>
2341- If true, less than returns success
2342- </summary>
2343- </member>
2344- <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.eqOK">
2345- <summary>
2346- if true, equal returns success
2347- </summary>
2348- </member>
2349- <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.gtOK">
2350- <summary>
2351- if true, greater than returns success
2352- </summary>
2353- </member>
2354- <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.predicate">
2355- <summary>
2356- The predicate used as a part of the description
2357- </summary>
2358- </member>
2359- <member name="F:NUnit.Framework.Constraints.ComparisonConstraint.comparer">
2360- <summary>
2361- ComparisonAdapter to be used in making the comparison
2362- </summary>
2363- </member>
2364- <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.#ctor(System.Object,System.Boolean,System.Boolean,System.Boolean,System.String)">
2365- <summary>
2366- Initializes a new instance of the <see cref="T:ComparisonConstraint"/> class.
2367- </summary>
2368- <param name="value">The value against which to make a comparison.</param>
2369- <param name="ltOK">if set to <c>true</c> less succeeds.</param>
2370- <param name="eqOK">if set to <c>true</c> equal succeeds.</param>
2371- <param name="gtOK">if set to <c>true</c> greater succeeds.</param>
2372- <param name="predicate">String used in describing the constraint.</param>
2373- </member>
2374- <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Matches(System.Object)">
2375- <summary>
2376- Test whether the constraint is satisfied by a given value
2377- </summary>
2378- <param name="actual">The value to be tested</param>
2379- <returns>True for success, false for failure</returns>
2380- </member>
2381- <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2382- <summary>
2383- Write the constraint description to a MessageWriter
2384- </summary>
2385- <param name="writer">The writer on which the description is displayed</param>
2386- </member>
2387- <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using(System.Collections.IComparer)">
2388- <summary>
2389- Modifies the constraint to use an IComparer and returns self
2390- </summary>
2391- </member>
2392- <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
2393- <summary>
2394- Modifies the constraint to use an IComparer&lt;T&gt; and returns self
2395- </summary>
2396- </member>
2397- <member name="M:NUnit.Framework.Constraints.ComparisonConstraint.Using``1(System.Comparison{``0})">
2398- <summary>
2399- Modifies the constraint to use a Comparison&lt;T&gt; and returns self
2400- </summary>
2401- </member>
2402- <member name="T:NUnit.Framework.Constraints.GreaterThanConstraint">
2403- <summary>
2404- Tests whether a value is greater than the value supplied to its constructor
2405- </summary>
2406- </member>
2407- <member name="M:NUnit.Framework.Constraints.GreaterThanConstraint.#ctor(System.Object)">
2408- <summary>
2409- Initializes a new instance of the <see cref="T:GreaterThanConstraint"/> class.
2410- </summary>
2411- <param name="expected">The expected value.</param>
2412- </member>
2413- <member name="T:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint">
2414- <summary>
2415- Tests whether a value is greater than or equal to the value supplied to its constructor
2416- </summary>
2417- </member>
2418- <member name="M:NUnit.Framework.Constraints.GreaterThanOrEqualConstraint.#ctor(System.Object)">
2419- <summary>
2420- Initializes a new instance of the <see cref="T:GreaterThanOrEqualConstraint"/> class.
2421- </summary>
2422- <param name="expected">The expected value.</param>
2423- </member>
2424- <member name="T:NUnit.Framework.Constraints.LessThanConstraint">
2425- <summary>
2426- Tests whether a value is less than the value supplied to its constructor
2427- </summary>
2428- </member>
2429- <member name="M:NUnit.Framework.Constraints.LessThanConstraint.#ctor(System.Object)">
2430- <summary>
2431- Initializes a new instance of the <see cref="T:LessThanConstraint"/> class.
2432- </summary>
2433- <param name="expected">The expected value.</param>
2434- </member>
2435- <member name="T:NUnit.Framework.Constraints.LessThanOrEqualConstraint">
2436- <summary>
2437- Tests whether a value is less than or equal to the value supplied to its constructor
2438- </summary>
2439- </member>
2440- <member name="M:NUnit.Framework.Constraints.LessThanOrEqualConstraint.#ctor(System.Object)">
2441- <summary>
2442- Initializes a new instance of the <see cref="T:LessThanOrEqualConstraint"/> class.
2443- </summary>
2444- <param name="expected">The expected value.</param>
2445- </member>
2446- <member name="T:NUnit.Framework.Constraints.ActualValueDelegate">
2447- <summary>
2448- Delegate used to delay evaluation of the actual value
2449- to be used in evaluating a constraint
2450- </summary>
2451- </member>
2452- <member name="T:NUnit.Framework.Constraints.ConstraintBuilder">
2453- <summary>
2454- ConstraintBuilder maintains the stacks that are used in
2455- processing a ConstraintExpression. An OperatorStack
2456- is used to hold operators that are waiting for their
2457- operands to be reognized. a ConstraintStack holds
2458- input constraints as well as the results of each
2459- operator applied.
2460- </summary>
2461- </member>
2462- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.#ctor">
2463- <summary>
2464- Initializes a new instance of the <see cref="T:ConstraintBuilder"/> class.
2465- </summary>
2466- </member>
2467- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.ConstraintOperator)">
2468- <summary>
2469- Appends the specified operator to the expression by first
2470- reducing the operator stack and then pushing the new
2471- operator on the stack.
2472- </summary>
2473- <param name="op">The operator to push.</param>
2474- </member>
2475- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Append(NUnit.Framework.Constraints.Constraint)">
2476- <summary>
2477- Appends the specified constraint to the expresson by pushing
2478- it on the constraint stack.
2479- </summary>
2480- <param name="constraint">The constraint to push.</param>
2481- </member>
2482- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.SetTopOperatorRightContext(System.Object)">
2483- <summary>
2484- Sets the top operator right context.
2485- </summary>
2486- <param name="rightContext">The right context.</param>
2487- </member>
2488- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ReduceOperatorStack(System.Int32)">
2489- <summary>
2490- Reduces the operator stack until the topmost item
2491- precedence is greater than or equal to the target precedence.
2492- </summary>
2493- <param name="targetPrecedence">The target precedence.</param>
2494- </member>
2495- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.Resolve">
2496- <summary>
2497- Resolves this instance, returning a Constraint. If the builder
2498- is not currently in a resolvable state, an exception is thrown.
2499- </summary>
2500- <returns>The resolved constraint</returns>
2501- </member>
2502- <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.IsResolvable">
2503- <summary>
2504- Gets a value indicating whether this instance is resolvable.
2505- </summary>
2506- <value>
2507- <c>true</c> if this instance is resolvable; otherwise, <c>false</c>.
2508- </value>
2509- </member>
2510- <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack">
2511- <summary>
2512- OperatorStack is a type-safe stack for holding ConstraintOperators
2513- </summary>
2514- </member>
2515- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
2516- <summary>
2517- Initializes a new instance of the <see cref="T:OperatorStack"/> class.
2518- </summary>
2519- <param name="builder">The builder.</param>
2520- </member>
2521- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Push(NUnit.Framework.Constraints.ConstraintOperator)">
2522- <summary>
2523- Pushes the specified operator onto the stack.
2524- </summary>
2525- <param name="op">The op.</param>
2526- </member>
2527- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Pop">
2528- <summary>
2529- Pops the topmost operator from the stack.
2530- </summary>
2531- <returns></returns>
2532- </member>
2533- <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Empty">
2534- <summary>
2535- Gets a value indicating whether this <see cref="T:OpStack"/> is empty.
2536- </summary>
2537- <value><c>true</c> if empty; otherwise, <c>false</c>.</value>
2538- </member>
2539- <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.OperatorStack.Top">
2540- <summary>
2541- Gets the topmost operator without modifying the stack.
2542- </summary>
2543- <value>The top.</value>
2544- </member>
2545- <member name="T:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack">
2546- <summary>
2547- ConstraintStack is a type-safe stack for holding Constraints
2548- </summary>
2549- </member>
2550- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
2551- <summary>
2552- Initializes a new instance of the <see cref="T:ConstraintStack"/> class.
2553- </summary>
2554- <param name="builder">The builder.</param>
2555- </member>
2556- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Push(NUnit.Framework.Constraints.Constraint)">
2557- <summary>
2558- Pushes the specified constraint. As a side effect,
2559- the constraint's builder field is set to the
2560- ConstraintBuilder owning this stack.
2561- </summary>
2562- <param name="constraint">The constraint.</param>
2563- </member>
2564- <member name="M:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Pop">
2565- <summary>
2566- Pops this topmost constrait from the stack.
2567- As a side effect, the constraint's builder
2568- field is set to null.
2569- </summary>
2570- <returns></returns>
2571- </member>
2572- <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Empty">
2573- <summary>
2574- Gets a value indicating whether this <see cref="T:ConstraintStack"/> is empty.
2575- </summary>
2576- <value><c>true</c> if empty; otherwise, <c>false</c>.</value>
2577- </member>
2578- <member name="P:NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack.Top">
2579- <summary>
2580- Gets the topmost constraint without modifying the stack.
2581- </summary>
2582- <value>The topmost constraint</value>
2583- </member>
2584- <member name="T:NUnit.Framework.Constraints.EmptyConstraint">
2585- <summary>
2586- EmptyConstraint tests a whether a string or collection is empty,
2587- postponing the decision about which test is applied until the
2588- type of the actual argument is known.
2589- </summary>
2590- </member>
2591- <member name="M:NUnit.Framework.Constraints.EmptyConstraint.Matches(System.Object)">
2592- <summary>
2593- Test whether the constraint is satisfied by a given value
2594- </summary>
2595- <param name="actual">The value to be tested</param>
2596- <returns>True for success, false for failure</returns>
2597- </member>
2598- <member name="M:NUnit.Framework.Constraints.EmptyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2599- <summary>
2600- Write the constraint description to a MessageWriter
2601- </summary>
2602- <param name="writer">The writer on which the description is displayed</param>
2603- </member>
2604- <member name="T:NUnit.Framework.Constraints.EqualConstraint">
2605- <summary>
2606- EqualConstraint is able to compare an actual value with the
2607- expected value provided in its constructor. Two objects are
2608- considered equal if both are null, or if both have the same
2609- value. NUnit has special semantics for some object types.
2610- </summary>
2611- </member>
2612- <member name="F:NUnit.Framework.Constraints.EqualConstraint.clipStrings">
2613- <summary>
2614- If true, strings in error messages will be clipped
2615- </summary>
2616- </member>
2617- <member name="F:NUnit.Framework.Constraints.EqualConstraint.comparer">
2618- <summary>
2619- NUnitEqualityComparer used to test equality.
2620- </summary>
2621- </member>
2622- <member name="M:NUnit.Framework.Constraints.EqualConstraint.#ctor(System.Object)">
2623- <summary>
2624- Initializes a new instance of the <see cref="T:NUnit.Framework.Constraints.EqualConstraint"/> class.
2625- </summary>
2626- <param name="expected">The expected value.</param>
2627- </member>
2628- <member name="M:NUnit.Framework.Constraints.EqualConstraint.Within(System.Object)">
2629- <summary>
2630- Flag the constraint to use a tolerance when determining equality.
2631- </summary>
2632- <param name="amount">Tolerance value to be used</param>
2633- <returns>Self.</returns>
2634- </member>
2635- <member name="M:NUnit.Framework.Constraints.EqualConstraint.Comparer(System.Collections.IComparer)">
2636- <summary>
2637- Flag the constraint to use the supplied IComparer object.
2638- </summary>
2639- <param name="comparer">The IComparer object to use.</param>
2640- <returns>Self.</returns>
2641- </member>
2642- <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IComparer)">
2643- <summary>
2644- Flag the constraint to use the supplied IComparer object.
2645- </summary>
2646- <param name="comparer">The IComparer object to use.</param>
2647- <returns>Self.</returns>
2648- </member>
2649- <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
2650- <summary>
2651- Flag the constraint to use the supplied IComparer object.
2652- </summary>
2653- <param name="comparer">The IComparer object to use.</param>
2654- <returns>Self.</returns>
2655- </member>
2656- <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Comparison{``0})">
2657- <summary>
2658- Flag the constraint to use the supplied Comparison object.
2659- </summary>
2660- <param name="comparer">The IComparer object to use.</param>
2661- <returns>Self.</returns>
2662- </member>
2663- <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using(System.Collections.IEqualityComparer)">
2664- <summary>
2665- Flag the constraint to use the supplied IEqualityComparer object.
2666- </summary>
2667- <param name="comparer">The IComparer object to use.</param>
2668- <returns>Self.</returns>
2669- </member>
2670- <member name="M:NUnit.Framework.Constraints.EqualConstraint.Using``1(System.Collections.Generic.IEqualityComparer{``0})">
2671- <summary>
2672- Flag the constraint to use the supplied IEqualityComparer object.
2673- </summary>
2674- <param name="comparer">The IComparer object to use.</param>
2675- <returns>Self.</returns>
2676- </member>
2677- <member name="M:NUnit.Framework.Constraints.EqualConstraint.Matches(System.Object)">
2678- <summary>
2679- Test whether the constraint is satisfied by a given value
2680- </summary>
2681- <param name="actual">The value to be tested</param>
2682- <returns>True for success, false for failure</returns>
2683- </member>
2684- <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteMessageTo(NUnit.Framework.Constraints.MessageWriter)">
2685- <summary>
2686- Write a failure message. Overridden to provide custom
2687- failure messages for EqualConstraint.
2688- </summary>
2689- <param name="writer">The MessageWriter to write to</param>
2690- </member>
2691- <member name="M:NUnit.Framework.Constraints.EqualConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2692- <summary>
2693- Write description of this constraint
2694- </summary>
2695- <param name="writer">The MessageWriter to write to</param>
2696- </member>
2697- <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionDifferences(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">
2698- <summary>
2699- Display the failure information for two collections that did not match.
2700- </summary>
2701- <param name="writer">The MessageWriter on which to display</param>
2702- <param name="expected">The expected collection.</param>
2703- <param name="actual">The actual collection</param>
2704- <param name="depth">The depth of this failure in a set of nested collections</param>
2705- </member>
2706- <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayCollectionTypesAndSizes(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32)">
2707- <summary>
2708- Displays a single line showing the types and sizes of the expected
2709- and actual collections or arrays. If both are identical, the value is
2710- only shown once.
2711- </summary>
2712- <param name="writer">The MessageWriter on which to display</param>
2713- <param name="expected">The expected collection or array</param>
2714- <param name="actual">The actual collection or array</param>
2715- <param name="indent">The indentation level for the message line</param>
2716- </member>
2717- <member name="M:NUnit.Framework.Constraints.EqualConstraint.DisplayFailurePoint(NUnit.Framework.Constraints.MessageWriter,System.Collections.ICollection,System.Collections.ICollection,System.Int32,System.Int32)">
2718- <summary>
2719- Displays a single line showing the point in the expected and actual
2720- arrays at which the comparison failed. If the arrays have different
2721- structures or dimensions, both values are shown.
2722- </summary>
2723- <param name="writer">The MessageWriter on which to display</param>
2724- <param name="expected">The expected array</param>
2725- <param name="actual">The actual array</param>
2726- <param name="failurePoint">Index of the failure point in the underlying collections</param>
2727- <param name="indent">The indentation level for the message line</param>
2728- </member>
2729- <member name="P:NUnit.Framework.Constraints.EqualConstraint.IgnoreCase">
2730- <summary>
2731- Flag the constraint to ignore case and return self.
2732- </summary>
2733- </member>
2734- <member name="P:NUnit.Framework.Constraints.EqualConstraint.NoClip">
2735- <summary>
2736- Flag the constraint to suppress string clipping
2737- and return self.
2738- </summary>
2739- </member>
2740- <member name="P:NUnit.Framework.Constraints.EqualConstraint.AsCollection">
2741- <summary>
2742- Flag the constraint to compare arrays as collections
2743- and return self.
2744- </summary>
2745- </member>
2746- <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ulps">
2747- <summary>
2748- Switches the .Within() modifier to interpret its tolerance as
2749- a distance in representable values (see remarks).
2750- </summary>
2751- <returns>Self.</returns>
2752- <remarks>
2753- Ulp stands for "unit in the last place" and describes the minimum
2754- amount a given value can change. For any integers, an ulp is 1 whole
2755- digit. For floating point values, the accuracy of which is better
2756- for smaller numbers and worse for larger numbers, an ulp depends
2757- on the size of the number. Using ulps for comparison of floating
2758- point results instead of fixed tolerances is safer because it will
2759- automatically compensate for the added inaccuracy of larger numbers.
2760- </remarks>
2761- </member>
2762- <member name="P:NUnit.Framework.Constraints.EqualConstraint.Percent">
2763- <summary>
2764- Switches the .Within() modifier to interpret its tolerance as
2765- a percentage that the actual values is allowed to deviate from
2766- the expected value.
2767- </summary>
2768- <returns>Self</returns>
2769- </member>
2770- <member name="P:NUnit.Framework.Constraints.EqualConstraint.Days">
2771- <summary>
2772- Causes the tolerance to be interpreted as a TimeSpan in days.
2773- </summary>
2774- <returns>Self</returns>
2775- </member>
2776- <member name="P:NUnit.Framework.Constraints.EqualConstraint.Hours">
2777- <summary>
2778- Causes the tolerance to be interpreted as a TimeSpan in hours.
2779- </summary>
2780- <returns>Self</returns>
2781- </member>
2782- <member name="P:NUnit.Framework.Constraints.EqualConstraint.Minutes">
2783- <summary>
2784- Causes the tolerance to be interpreted as a TimeSpan in minutes.
2785- </summary>
2786- <returns>Self</returns>
2787- </member>
2788- <member name="P:NUnit.Framework.Constraints.EqualConstraint.Seconds">
2789- <summary>
2790- Causes the tolerance to be interpreted as a TimeSpan in seconds.
2791- </summary>
2792- <returns>Self</returns>
2793- </member>
2794- <member name="P:NUnit.Framework.Constraints.EqualConstraint.Milliseconds">
2795- <summary>
2796- Causes the tolerance to be interpreted as a TimeSpan in milliseconds.
2797- </summary>
2798- <returns>Self</returns>
2799- </member>
2800- <member name="P:NUnit.Framework.Constraints.EqualConstraint.Ticks">
2801- <summary>
2802- Causes the tolerance to be interpreted as a TimeSpan in clock ticks.
2803- </summary>
2804- <returns>Self</returns>
2805- </member>
2806- <member name="T:NUnit.Framework.Constraints.SameAsConstraint">
2807- <summary>
2808- SameAsConstraint tests whether an object is identical to
2809- the object passed to its constructor
2810- </summary>
2811- </member>
2812- <member name="M:NUnit.Framework.Constraints.SameAsConstraint.#ctor(System.Object)">
2813- <summary>
2814- Initializes a new instance of the <see cref="T:SameAsConstraint"/> class.
2815- </summary>
2816- <param name="expected">The expected object.</param>
2817- </member>
2818- <member name="M:NUnit.Framework.Constraints.SameAsConstraint.Matches(System.Object)">
2819- <summary>
2820- Test whether the constraint is satisfied by a given value
2821- </summary>
2822- <param name="actual">The value to be tested</param>
2823- <returns>True for success, false for failure</returns>
2824- </member>
2825- <member name="M:NUnit.Framework.Constraints.SameAsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2826- <summary>
2827- Write the constraint description to a MessageWriter
2828- </summary>
2829- <param name="writer">The writer on which the description is displayed</param>
2830- </member>
2831- <member name="T:NUnit.Framework.Constraints.StringConstraint">
2832- <summary>
2833- StringConstraint is the abstract base for constraints
2834- that operate on strings. It supports the IgnoreCase
2835- modifier for string operations.
2836- </summary>
2837- </member>
2838- <member name="F:NUnit.Framework.Constraints.StringConstraint.expected">
2839- <summary>
2840- The expected value
2841- </summary>
2842- </member>
2843- <member name="F:NUnit.Framework.Constraints.StringConstraint.caseInsensitive">
2844- <summary>
2845- Indicates whether tests should be case-insensitive
2846- </summary>
2847- </member>
2848- <member name="M:NUnit.Framework.Constraints.StringConstraint.#ctor(System.String)">
2849- <summary>
2850- Constructs a StringConstraint given an expected value
2851- </summary>
2852- <param name="expected">The expected value</param>
2853- </member>
2854- <member name="P:NUnit.Framework.Constraints.StringConstraint.IgnoreCase">
2855- <summary>
2856- Modify the constraint to ignore case in matching.
2857- </summary>
2858- </member>
2859- <member name="T:NUnit.Framework.Constraints.EmptyStringConstraint">
2860- <summary>
2861- EmptyStringConstraint tests whether a string is empty.
2862- </summary>
2863- </member>
2864- <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.Matches(System.Object)">
2865- <summary>
2866- Test whether the constraint is satisfied by a given value
2867- </summary>
2868- <param name="actual">The value to be tested</param>
2869- <returns>True for success, false for failure</returns>
2870- </member>
2871- <member name="M:NUnit.Framework.Constraints.EmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2872- <summary>
2873- Write the constraint description to a MessageWriter
2874- </summary>
2875- <param name="writer">The writer on which the description is displayed</param>
2876- </member>
2877- <member name="T:NUnit.Framework.Constraints.NullOrEmptyStringConstraint">
2878- <summary>
2879- NullEmptyStringConstraint tests whether a string is either null or empty.
2880- </summary>
2881- </member>
2882- <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.#ctor">
2883- <summary>
2884- Constructs a new NullOrEmptyStringConstraint
2885- </summary>
2886- </member>
2887- <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.Matches(System.Object)">
2888- <summary>
2889- Test whether the constraint is satisfied by a given value
2890- </summary>
2891- <param name="actual">The value to be tested</param>
2892- <returns>True for success, false for failure</returns>
2893- </member>
2894- <member name="M:NUnit.Framework.Constraints.NullOrEmptyStringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2895- <summary>
2896- Write the constraint description to a MessageWriter
2897- </summary>
2898- <param name="writer">The writer on which the description is displayed</param>
2899- </member>
2900- <member name="T:NUnit.Framework.Constraints.SubstringConstraint">
2901- <summary>
2902- SubstringConstraint can test whether a string contains
2903- the expected substring.
2904- </summary>
2905- </member>
2906- <member name="M:NUnit.Framework.Constraints.SubstringConstraint.#ctor(System.String)">
2907- <summary>
2908- Initializes a new instance of the <see cref="T:SubstringConstraint"/> class.
2909- </summary>
2910- <param name="expected">The expected.</param>
2911- </member>
2912- <member name="M:NUnit.Framework.Constraints.SubstringConstraint.Matches(System.Object)">
2913- <summary>
2914- Test whether the constraint is satisfied by a given value
2915- </summary>
2916- <param name="actual">The value to be tested</param>
2917- <returns>True for success, false for failure</returns>
2918- </member>
2919- <member name="M:NUnit.Framework.Constraints.SubstringConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2920- <summary>
2921- Write the constraint description to a MessageWriter
2922- </summary>
2923- <param name="writer">The writer on which the description is displayed</param>
2924- </member>
2925- <member name="T:NUnit.Framework.Constraints.StartsWithConstraint">
2926- <summary>
2927- StartsWithConstraint can test whether a string starts
2928- with an expected substring.
2929- </summary>
2930- </member>
2931- <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.#ctor(System.String)">
2932- <summary>
2933- Initializes a new instance of the <see cref="T:StartsWithConstraint"/> class.
2934- </summary>
2935- <param name="expected">The expected string</param>
2936- </member>
2937- <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.Matches(System.Object)">
2938- <summary>
2939- Test whether the constraint is matched by the actual value.
2940- This is a template method, which calls the IsMatch method
2941- of the derived class.
2942- </summary>
2943- <param name="actual"></param>
2944- <returns></returns>
2945- </member>
2946- <member name="M:NUnit.Framework.Constraints.StartsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2947- <summary>
2948- Write the constraint description to a MessageWriter
2949- </summary>
2950- <param name="writer">The writer on which the description is displayed</param>
2951- </member>
2952- <member name="T:NUnit.Framework.Constraints.EndsWithConstraint">
2953- <summary>
2954- EndsWithConstraint can test whether a string ends
2955- with an expected substring.
2956- </summary>
2957- </member>
2958- <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.#ctor(System.String)">
2959- <summary>
2960- Initializes a new instance of the <see cref="T:EndsWithConstraint"/> class.
2961- </summary>
2962- <param name="expected">The expected string</param>
2963- </member>
2964- <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.Matches(System.Object)">
2965- <summary>
2966- Test whether the constraint is matched by the actual value.
2967- This is a template method, which calls the IsMatch method
2968- of the derived class.
2969- </summary>
2970- <param name="actual"></param>
2971- <returns></returns>
2972- </member>
2973- <member name="M:NUnit.Framework.Constraints.EndsWithConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2974- <summary>
2975- Write the constraint description to a MessageWriter
2976- </summary>
2977- <param name="writer">The writer on which the description is displayed</param>
2978- </member>
2979- <member name="T:NUnit.Framework.Constraints.RegexConstraint">
2980- <summary>
2981- RegexConstraint can test whether a string matches
2982- the pattern provided.
2983- </summary>
2984- </member>
2985- <member name="M:NUnit.Framework.Constraints.RegexConstraint.#ctor(System.String)">
2986- <summary>
2987- Initializes a new instance of the <see cref="T:RegexConstraint"/> class.
2988- </summary>
2989- <param name="pattern">The pattern.</param>
2990- </member>
2991- <member name="M:NUnit.Framework.Constraints.RegexConstraint.Matches(System.Object)">
2992- <summary>
2993- Test whether the constraint is satisfied by a given value
2994- </summary>
2995- <param name="actual">The value to be tested</param>
2996- <returns>True for success, false for failure</returns>
2997- </member>
2998- <member name="M:NUnit.Framework.Constraints.RegexConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
2999- <summary>
3000- Write the constraint description to a MessageWriter
3001- </summary>
3002- <param name="writer">The writer on which the description is displayed</param>
3003- </member>
3004- <member name="T:NUnit.Framework.Constraints.TypeConstraint">
3005- <summary>
3006- TypeConstraint is the abstract base for constraints
3007- that take a Type as their expected value.
3008- </summary>
3009- </member>
3010- <member name="F:NUnit.Framework.Constraints.TypeConstraint.expectedType">
3011- <summary>
3012- The expected Type used by the constraint
3013- </summary>
3014- </member>
3015- <member name="M:NUnit.Framework.Constraints.TypeConstraint.#ctor(System.Type)">
3016- <summary>
3017- Construct a TypeConstraint for a given Type
3018- </summary>
3019- <param name="type"></param>
3020- </member>
3021- <member name="M:NUnit.Framework.Constraints.TypeConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
3022- <summary>
3023- Write the actual value for a failing constraint test to a
3024- MessageWriter. TypeConstraints override this method to write
3025- the name of the type.
3026- </summary>
3027- <param name="writer">The writer on which the actual value is displayed</param>
3028- </member>
3029- <member name="T:NUnit.Framework.Constraints.ExactTypeConstraint">
3030- <summary>
3031- ExactTypeConstraint is used to test that an object
3032- is of the exact type provided in the constructor
3033- </summary>
3034- </member>
3035- <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.#ctor(System.Type)">
3036- <summary>
3037- Construct an ExactTypeConstraint for a given Type
3038- </summary>
3039- <param name="type">The expected Type.</param>
3040- </member>
3041- <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.Matches(System.Object)">
3042- <summary>
3043- Test that an object is of the exact type specified
3044- </summary>
3045- <param name="actual">The actual value.</param>
3046- <returns>True if the tested object is of the exact type provided, otherwise false.</returns>
3047- </member>
3048- <member name="M:NUnit.Framework.Constraints.ExactTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3049- <summary>
3050- Write the description of this constraint to a MessageWriter
3051- </summary>
3052- <param name="writer">The MessageWriter to use</param>
3053- </member>
3054- <member name="T:NUnit.Framework.Constraints.InstanceOfTypeConstraint">
3055- <summary>
3056- InstanceOfTypeConstraint is used to test that an object
3057- is of the same type provided or derived from it.
3058- </summary>
3059- </member>
3060- <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.#ctor(System.Type)">
3061- <summary>
3062- Construct an InstanceOfTypeConstraint for the type provided
3063- </summary>
3064- <param name="type">The expected Type</param>
3065- </member>
3066- <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.Matches(System.Object)">
3067- <summary>
3068- Test whether an object is of the specified type or a derived type
3069- </summary>
3070- <param name="actual">The object to be tested</param>
3071- <returns>True if the object is of the provided type or derives from it, otherwise false.</returns>
3072- </member>
3073- <member name="M:NUnit.Framework.Constraints.InstanceOfTypeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3074- <summary>
3075- Write a description of this constraint to a MessageWriter
3076- </summary>
3077- <param name="writer">The MessageWriter to use</param>
3078- </member>
3079- <member name="T:NUnit.Framework.Constraints.AssignableFromConstraint">
3080- <summary>
3081- AssignableFromConstraint is used to test that an object
3082- can be assigned from a given Type.
3083- </summary>
3084- </member>
3085- <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.#ctor(System.Type)">
3086- <summary>
3087- Construct an AssignableFromConstraint for the type provided
3088- </summary>
3089- <param name="type"></param>
3090- </member>
3091- <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.Matches(System.Object)">
3092- <summary>
3093- Test whether an object can be assigned from the specified type
3094- </summary>
3095- <param name="actual">The object to be tested</param>
3096- <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>
3097- </member>
3098- <member name="M:NUnit.Framework.Constraints.AssignableFromConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3099- <summary>
3100- Write a description of this constraint to a MessageWriter
3101- </summary>
3102- <param name="writer">The MessageWriter to use</param>
3103- </member>
3104- <member name="T:NUnit.Framework.Constraints.AssignableToConstraint">
3105- <summary>
3106- AssignableToConstraint is used to test that an object
3107- can be assigned to a given Type.
3108- </summary>
3109- </member>
3110- <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.#ctor(System.Type)">
3111- <summary>
3112- Construct an AssignableToConstraint for the type provided
3113- </summary>
3114- <param name="type"></param>
3115- </member>
3116- <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.Matches(System.Object)">
3117- <summary>
3118- Test whether an object can be assigned to the specified type
3119- </summary>
3120- <param name="actual">The object to be tested</param>
3121- <returns>True if the object can be assigned a value of the expected Type, otherwise false.</returns>
3122- </member>
3123- <member name="M:NUnit.Framework.Constraints.AssignableToConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3124- <summary>
3125- Write a description of this constraint to a MessageWriter
3126- </summary>
3127- <param name="writer">The MessageWriter to use</param>
3128- </member>
3129- <member name="T:NUnit.Framework.Constraints.ContainsConstraint">
3130- <summary>
3131- ContainsConstraint tests a whether a string contains a substring
3132- or a collection contains an object. It postpones the decision of
3133- which test to use until the type of the actual argument is known.
3134- This allows testing whether a string is contained in a collection
3135- or as a substring of another string using the same syntax.
3136- </summary>
3137- </member>
3138- <member name="M:NUnit.Framework.Constraints.ContainsConstraint.#ctor(System.Object)">
3139- <summary>
3140- Initializes a new instance of the <see cref="T:ContainsConstraint"/> class.
3141- </summary>
3142- <param name="expected">The expected.</param>
3143- </member>
3144- <member name="M:NUnit.Framework.Constraints.ContainsConstraint.Matches(System.Object)">
3145- <summary>
3146- Test whether the constraint is satisfied by a given value
3147- </summary>
3148- <param name="actual">The value to be tested</param>
3149- <returns>True for success, false for failure</returns>
3150- </member>
3151- <member name="M:NUnit.Framework.Constraints.ContainsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3152- <summary>
3153- Write the constraint description to a MessageWriter
3154- </summary>
3155- <param name="writer">The writer on which the description is displayed</param>
3156- </member>
3157- <member name="P:NUnit.Framework.Constraints.ContainsConstraint.IgnoreCase">
3158- <summary>
3159- Flag the constraint to ignore case and return self.
3160- </summary>
3161- </member>
3162- <member name="T:NUnit.Framework.Constraints.PropertyExistsConstraint">
3163- <summary>
3164- PropertyExistsConstraint tests that a named property
3165- exists on the object provided through Match.
3166-
3167- Originally, PropertyConstraint provided this feature
3168- in addition to making optional tests on the vaue
3169- of the property. The two constraints are now separate.
3170- </summary>
3171- </member>
3172- <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.#ctor(System.String)">
3173- <summary>
3174- Initializes a new instance of the <see cref="T:PropertyExistConstraint"/> class.
3175- </summary>
3176- <param name="name">The name of the property.</param>
3177- </member>
3178- <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.Matches(System.Object)">
3179- <summary>
3180- Test whether the property exists for a given object
3181- </summary>
3182- <param name="actual">The object to be tested</param>
3183- <returns>True for success, false for failure</returns>
3184- </member>
3185- <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3186- <summary>
3187- Write the constraint description to a MessageWriter
3188- </summary>
3189- <param name="writer">The writer on which the description is displayed</param>
3190- </member>
3191- <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
3192- <summary>
3193- Write the actual value for a failing constraint test to a
3194- MessageWriter.
3195- </summary>
3196- <param name="writer">The writer on which the actual value is displayed</param>
3197- </member>
3198- <member name="M:NUnit.Framework.Constraints.PropertyExistsConstraint.GetStringRepresentation">
3199- <summary>
3200- Returns the string representation of the constraint.
3201- </summary>
3202- <returns></returns>
3203- </member>
3204- <member name="T:NUnit.Framework.Constraints.PropertyConstraint">
3205- <summary>
3206- PropertyConstraint extracts a named property and uses
3207- its value as the actual value for a chained constraint.
3208- </summary>
3209- </member>
3210- <member name="T:NUnit.Framework.Constraints.PrefixConstraint">
3211- <summary>
3212- Abstract base class used for prefixes
3213- </summary>
3214- </member>
3215- <member name="F:NUnit.Framework.Constraints.PrefixConstraint.baseConstraint">
3216- <summary>
3217- The base constraint
3218- </summary>
3219- </member>
3220- <member name="M:NUnit.Framework.Constraints.PrefixConstraint.#ctor(NUnit.Framework.Constraints.IResolveConstraint)">
3221- <summary>
3222- Construct given a base constraint
3223- </summary>
3224- <param name="resolvable"></param>
3225- </member>
3226- <member name="M:NUnit.Framework.Constraints.PropertyConstraint.#ctor(System.String,NUnit.Framework.Constraints.Constraint)">
3227- <summary>
3228- Initializes a new instance of the <see cref="T:PropertyConstraint"/> class.
3229- </summary>
3230- <param name="name">The name.</param>
3231- <param name="baseConstraint">The constraint to apply to the property.</param>
3232- </member>
3233- <member name="M:NUnit.Framework.Constraints.PropertyConstraint.Matches(System.Object)">
3234- <summary>
3235- Test whether the constraint is satisfied by a given value
3236- </summary>
3237- <param name="actual">The value to be tested</param>
3238- <returns>True for success, false for failure</returns>
3239- </member>
3240- <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3241- <summary>
3242- Write the constraint description to a MessageWriter
3243- </summary>
3244- <param name="writer">The writer on which the description is displayed</param>
3245- </member>
3246- <member name="M:NUnit.Framework.Constraints.PropertyConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
3247- <summary>
3248- Write the actual value for a failing constraint test to a
3249- MessageWriter. The default implementation simply writes
3250- the raw value of actual, leaving it to the writer to
3251- perform any formatting.
3252- </summary>
3253- <param name="writer">The writer on which the actual value is displayed</param>
3254- </member>
3255- <member name="M:NUnit.Framework.Constraints.PropertyConstraint.GetStringRepresentation">
3256- <summary>
3257- Returns the string representation of the constraint.
3258- </summary>
3259- <returns></returns>
3260- </member>
3261- <member name="T:NUnit.Framework.Constraints.NotConstraint">
3262- <summary>
3263- NotConstraint negates the effect of some other constraint
3264- </summary>
3265- </member>
3266- <member name="M:NUnit.Framework.Constraints.NotConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
3267- <summary>
3268- Initializes a new instance of the <see cref="T:NotConstraint"/> class.
3269- </summary>
3270- <param name="baseConstraint">The base constraint to be negated.</param>
3271- </member>
3272- <member name="M:NUnit.Framework.Constraints.NotConstraint.Matches(System.Object)">
3273- <summary>
3274- Test whether the constraint is satisfied by a given value
3275- </summary>
3276- <param name="actual">The value to be tested</param>
3277- <returns>True for if the base constraint fails, false if it succeeds</returns>
3278- </member>
3279- <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3280- <summary>
3281- Write the constraint description to a MessageWriter
3282- </summary>
3283- <param name="writer">The writer on which the description is displayed</param>
3284- </member>
3285- <member name="M:NUnit.Framework.Constraints.NotConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
3286- <summary>
3287- Write the actual value for a failing constraint test to a MessageWriter.
3288- </summary>
3289- <param name="writer">The writer on which the actual value is displayed</param>
3290- </member>
3291- <member name="T:NUnit.Framework.Constraints.AllItemsConstraint">
3292- <summary>
3293- AllItemsConstraint applies another constraint to each
3294- item in a collection, succeeding if they all succeed.
3295- </summary>
3296- </member>
3297- <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
3298- <summary>
3299- Construct an AllItemsConstraint on top of an existing constraint
3300- </summary>
3301- <param name="itemConstraint"></param>
3302- </member>
3303- <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.Matches(System.Object)">
3304- <summary>
3305- Apply the item constraint to each item in the collection,
3306- failing if any item fails.
3307- </summary>
3308- <param name="actual"></param>
3309- <returns></returns>
3310- </member>
3311- <member name="M:NUnit.Framework.Constraints.AllItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3312- <summary>
3313- Write a description of this constraint to a MessageWriter
3314- </summary>
3315- <param name="writer"></param>
3316- </member>
3317- <member name="T:NUnit.Framework.Constraints.SomeItemsConstraint">
3318- <summary>
3319- SomeItemsConstraint applies another constraint to each
3320- item in a collection, succeeding if any of them succeeds.
3321- </summary>
3322- </member>
3323- <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
3324- <summary>
3325- Construct a SomeItemsConstraint on top of an existing constraint
3326- </summary>
3327- <param name="itemConstraint"></param>
3328- </member>
3329- <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.Matches(System.Object)">
3330- <summary>
3331- Apply the item constraint to each item in the collection,
3332- succeeding if any item succeeds.
3333- </summary>
3334- <param name="actual"></param>
3335- <returns></returns>
3336- </member>
3337- <member name="M:NUnit.Framework.Constraints.SomeItemsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3338- <summary>
3339- Write a description of this constraint to a MessageWriter
3340- </summary>
3341- <param name="writer"></param>
3342- </member>
3343- <member name="T:NUnit.Framework.Constraints.NoItemConstraint">
3344- <summary>
3345- NoItemConstraint applies another constraint to each
3346- item in a collection, failing if any of them succeeds.
3347- </summary>
3348- </member>
3349- <member name="M:NUnit.Framework.Constraints.NoItemConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
3350- <summary>
3351- Construct a SomeItemsConstraint on top of an existing constraint
3352- </summary>
3353- <param name="itemConstraint"></param>
3354- </member>
3355- <member name="M:NUnit.Framework.Constraints.NoItemConstraint.Matches(System.Object)">
3356- <summary>
3357- Apply the item constraint to each item in the collection,
3358- failing if any item fails.
3359- </summary>
3360- <param name="actual"></param>
3361- <returns></returns>
3362- </member>
3363- <member name="M:NUnit.Framework.Constraints.NoItemConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3364- <summary>
3365- Write a description of this constraint to a MessageWriter
3366- </summary>
3367- <param name="writer"></param>
3368- </member>
3369- <member name="T:NUnit.Framework.Constraints.Numerics">
3370- <summary>
3371- The Numerics class contains common operations on numeric values.
3372- </summary>
3373- </member>
3374- <member name="M:NUnit.Framework.Constraints.Numerics.IsNumericType(System.Object)">
3375- <summary>
3376- Checks the type of the object, returning true if
3377- the object is a numeric type.
3378- </summary>
3379- <param name="obj">The object to check</param>
3380- <returns>true if the object is a numeric type</returns>
3381- </member>
3382- <member name="M:NUnit.Framework.Constraints.Numerics.IsFloatingPointNumeric(System.Object)">
3383- <summary>
3384- Checks the type of the object, returning true if
3385- the object is a floating point numeric type.
3386- </summary>
3387- <param name="obj">The object to check</param>
3388- <returns>true if the object is a floating point numeric type</returns>
3389- </member>
3390- <member name="M:NUnit.Framework.Constraints.Numerics.IsFixedPointNumeric(System.Object)">
3391- <summary>
3392- Checks the type of the object, returning true if
3393- the object is a fixed point numeric type.
3394- </summary>
3395- <param name="obj">The object to check</param>
3396- <returns>true if the object is a fixed point numeric type</returns>
3397- </member>
3398- <member name="M:NUnit.Framework.Constraints.Numerics.AreEqual(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance@)">
3399- <summary>
3400- Test two numeric values for equality, performing the usual numeric
3401- conversions and using a provided or default tolerance. If the tolerance
3402- provided is Empty, this method may set it to a default tolerance.
3403- </summary>
3404- <param name="expected">The expected value</param>
3405- <param name="actual">The actual value</param>
3406- <param name="tolerance">A reference to the tolerance in effect</param>
3407- <returns>True if the values are equal</returns>
3408- </member>
3409- <member name="M:NUnit.Framework.Constraints.Numerics.Compare(System.Object,System.Object)">
3410- <summary>
3411- Compare two numeric values, performing the usual numeric conversions.
3412- </summary>
3413- <param name="expected">The expected value</param>
3414- <param name="actual">The actual value</param>
3415- <returns>The relationship of the values to each other</returns>
3416- </member>
3417- <member name="T:NUnit.Framework.Constraints.MessageWriter">
3418- <summary>
3419- MessageWriter is the abstract base for classes that write
3420- constraint descriptions and messages in some form. The
3421- class has separate methods for writing various components
3422- of a message, allowing implementations to tailor the
3423- presentation as needed.
3424- </summary>
3425- </member>
3426- <member name="M:NUnit.Framework.Constraints.MessageWriter.#ctor">
3427- <summary>
3428- Construct a MessageWriter given a culture
3429- </summary>
3430- </member>
3431- <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.String,System.Object[])">
3432- <summary>
3433- Method to write single line message with optional args, usually
3434- written to precede the general failure message.
3435- </summary>
3436- <param name="message">The message to be written</param>
3437- <param name="args">Any arguments used in formatting the message</param>
3438- </member>
3439- <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteMessageLine(System.Int32,System.String,System.Object[])">
3440- <summary>
3441- Method to write single line message with optional args, usually
3442- written to precede the general failure message, at a givel
3443- indentation level.
3444- </summary>
3445- <param name="level">The indentation level of the message</param>
3446- <param name="message">The message to be written</param>
3447- <param name="args">Any arguments used in formatting the message</param>
3448- </member>
3449- <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(NUnit.Framework.Constraints.Constraint)">
3450- <summary>
3451- Display Expected and Actual lines for a constraint. This
3452- is called by MessageWriter's default implementation of
3453- WriteMessageTo and provides the generic two-line display.
3454- </summary>
3455- <param name="constraint">The constraint that failed</param>
3456- </member>
3457- <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object)">
3458- <summary>
3459- Display Expected and Actual lines for given values. This
3460- method may be called by constraints that need more control over
3461- the display of actual and expected values than is provided
3462- by the default implementation.
3463- </summary>
3464- <param name="expected">The expected value</param>
3465- <param name="actual">The actual value causing the failure</param>
3466- </member>
3467- <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayDifferences(System.Object,System.Object,NUnit.Framework.Constraints.Tolerance)">
3468- <summary>
3469- Display Expected and Actual lines for given values, including
3470- a tolerance value on the Expected line.
3471- </summary>
3472- <param name="expected">The expected value</param>
3473- <param name="actual">The actual value causing the failure</param>
3474- <param name="tolerance">The tolerance within which the test was made</param>
3475- </member>
3476- <member name="M:NUnit.Framework.Constraints.MessageWriter.DisplayStringDifferences(System.String,System.String,System.Int32,System.Boolean,System.Boolean)">
3477- <summary>
3478- Display the expected and actual string values on separate lines.
3479- If the mismatch parameter is >=0, an additional line is displayed
3480- line containing a caret that points to the mismatch point.
3481- </summary>
3482- <param name="expected">The expected string value</param>
3483- <param name="actual">The actual string value</param>
3484- <param name="mismatch">The point at which the strings don't match or -1</param>
3485- <param name="ignoreCase">If true, case is ignored in locating the point where the strings differ</param>
3486- <param name="clipping">If true, the strings should be clipped to fit the line</param>
3487- </member>
3488- <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteConnector(System.String)">
3489- <summary>
3490- Writes the text for a connector.
3491- </summary>
3492- <param name="connector">The connector.</param>
3493- </member>
3494- <member name="M:NUnit.Framework.Constraints.MessageWriter.WritePredicate(System.String)">
3495- <summary>
3496- Writes the text for a predicate.
3497- </summary>
3498- <param name="predicate">The predicate.</param>
3499- </member>
3500- <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteExpectedValue(System.Object)">
3501- <summary>
3502- Writes the text for an expected value.
3503- </summary>
3504- <param name="expected">The expected value.</param>
3505- </member>
3506- <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteModifier(System.String)">
3507- <summary>
3508- Writes the text for a modifier
3509- </summary>
3510- <param name="modifier">The modifier.</param>
3511- </member>
3512- <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteActualValue(System.Object)">
3513- <summary>
3514- Writes the text for an actual value.
3515- </summary>
3516- <param name="actual">The actual value.</param>
3517- </member>
3518- <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteValue(System.Object)">
3519- <summary>
3520- Writes the text for a generalized value.
3521- </summary>
3522- <param name="val">The value.</param>
3523- </member>
3524- <member name="M:NUnit.Framework.Constraints.MessageWriter.WriteCollectionElements(System.Collections.ICollection,System.Int32,System.Int32)">
3525- <summary>
3526- Writes the text for a collection value,
3527- starting at a particular point, to a max length
3528- </summary>
3529- <param name="collection">The collection containing elements to write.</param>
3530- <param name="start">The starting point of the elements to write</param>
3531- <param name="max">The maximum number of elements to write</param>
3532- </member>
3533- <member name="P:NUnit.Framework.Constraints.MessageWriter.MaxLineLength">
3534- <summary>
3535- Abstract method to get the max line length
3536- </summary>
3537- </member>
3538- <member name="T:NUnit.Framework.Constraints.MsgUtils">
3539- <summary>
3540- Static methods used in creating messages
3541- </summary>
3542- </member>
3543- <member name="F:NUnit.Framework.Constraints.MsgUtils.ELLIPSIS">
3544- <summary>
3545- Static string used when strings are clipped
3546- </summary>
3547- </member>
3548- <member name="M:NUnit.Framework.Constraints.MsgUtils.GetTypeRepresentation(System.Object)">
3549- <summary>
3550- Returns the representation of a type as used in NUnitLite.
3551- This is the same as Type.ToString() except for arrays,
3552- which are displayed with their declared sizes.
3553- </summary>
3554- <param name="obj"></param>
3555- <returns></returns>
3556- </member>
3557- <member name="M:NUnit.Framework.Constraints.MsgUtils.EscapeControlChars(System.String)">
3558- <summary>
3559- Converts any control characters in a string
3560- to their escaped representation.
3561- </summary>
3562- <param name="s">The string to be converted</param>
3563- <returns>The converted string</returns>
3564- </member>
3565- <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesAsString(System.Int32[])">
3566- <summary>
3567- Return the a string representation for a set of indices into an array
3568- </summary>
3569- <param name="indices">Array of indices for which a string is needed</param>
3570- </member>
3571- <member name="M:NUnit.Framework.Constraints.MsgUtils.GetArrayIndicesFromCollectionIndex(System.Collections.ICollection,System.Int32)">
3572- <summary>
3573- Get an array of indices representing the point in a collection or
3574- array corresponding to a single int index into the collection.
3575- </summary>
3576- <param name="collection">The collection to which the indices apply</param>
3577- <param name="index">Index in the collection</param>
3578- <returns>Array of indices</returns>
3579- </member>
3580- <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipString(System.String,System.Int32,System.Int32)">
3581- <summary>
3582- Clip a string to a given length, starting at a particular offset, returning the clipped
3583- string with ellipses representing the removed parts
3584- </summary>
3585- <param name="s">The string to be clipped</param>
3586- <param name="maxStringLength">The maximum permitted length of the result string</param>
3587- <param name="clipStart">The point at which to start clipping</param>
3588- <returns>The clipped string</returns>
3589- </member>
3590- <member name="M:NUnit.Framework.Constraints.MsgUtils.ClipExpectedAndActual(System.String@,System.String@,System.Int32,System.Int32)">
3591- <summary>
3592- Clip the expected and actual strings in a coordinated fashion,
3593- so that they may be displayed together.
3594- </summary>
3595- <param name="expected"></param>
3596- <param name="actual"></param>
3597- <param name="maxDisplayLength"></param>
3598- <param name="mismatch"></param>
3599- </member>
3600- <member name="M:NUnit.Framework.Constraints.MsgUtils.FindMismatchPosition(System.String,System.String,System.Int32,System.Boolean)">
3601- <summary>
3602- Shows the position two strings start to differ. Comparison
3603- starts at the start index.
3604- </summary>
3605- <param name="expected">The expected string</param>
3606- <param name="actual">The actual string</param>
3607- <param name="istart">The index in the strings at which comparison should start</param>
3608- <param name="ignoreCase">Boolean indicating whether case should be ignored</param>
3609- <returns>-1 if no mismatch found, or the index where mismatch found</returns>
3610- </member>
3611- <member name="T:NUnit.Framework.Constraints.PathConstraint">
3612- <summary>
3613- PathConstraint serves as the abstract base of constraints
3614- that operate on paths and provides several helper methods.
3615- </summary>
3616- </member>
3617- <member name="F:NUnit.Framework.Constraints.PathConstraint.expected">
3618- <summary>
3619- The expected path used in the constraint
3620- </summary>
3621- </member>
3622- <member name="F:NUnit.Framework.Constraints.PathConstraint.caseInsensitive">
3623- <summary>
3624- Flag indicating whether a caseInsensitive comparison should be made
3625- </summary>
3626- </member>
3627- <member name="M:NUnit.Framework.Constraints.PathConstraint.#ctor(System.String)">
3628- <summary>
3629- Construct a PathConstraint for a give expected path
3630- </summary>
3631- <param name="expected">The expected path</param>
3632- </member>
3633- <member name="M:NUnit.Framework.Constraints.PathConstraint.GetStringRepresentation">
3634- <summary>
3635- Returns the string representation of this constraint
3636- </summary>
3637- </member>
3638- <member name="M:NUnit.Framework.Constraints.PathConstraint.Canonicalize(System.String)">
3639- <summary>
3640- Canonicalize the provided path
3641- </summary>
3642- <param name="path"></param>
3643- <returns>The path in standardized form</returns>
3644- </member>
3645- <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePath(System.String,System.String)">
3646- <summary>
3647- Test whether two paths are the same
3648- </summary>
3649- <param name="path1">The first path</param>
3650- <param name="path2">The second path</param>
3651- <returns></returns>
3652- </member>
3653- <member name="M:NUnit.Framework.Constraints.PathConstraint.IsSamePathOrUnder(System.String,System.String)">
3654- <summary>
3655- Test whether one path is the same as or under another path
3656- </summary>
3657- <param name="path1">The first path - supposed to be the parent path</param>
3658- <param name="path2">The second path - supposed to be the child path</param>
3659- <returns></returns>
3660- </member>
3661- <member name="P:NUnit.Framework.Constraints.PathConstraint.IgnoreCase">
3662- <summary>
3663- Modifies the current instance to be case-insensitve
3664- and returns it.
3665- </summary>
3666- </member>
3667- <member name="P:NUnit.Framework.Constraints.PathConstraint.RespectCase">
3668- <summary>
3669- Modifies the current instance to be case-sensitve
3670- and returns it.
3671- </summary>
3672- </member>
3673- <member name="T:NUnit.Framework.Constraints.SamePathConstraint">
3674- <summary>
3675- Summary description for SamePathConstraint.
3676- </summary>
3677- </member>
3678- <member name="M:NUnit.Framework.Constraints.SamePathConstraint.#ctor(System.String)">
3679- <summary>
3680- Initializes a new instance of the <see cref="T:SamePathConstraint"/> class.
3681- </summary>
3682- <param name="expected">The expected path</param>
3683- </member>
3684- <member name="M:NUnit.Framework.Constraints.SamePathConstraint.Matches(System.Object)">
3685- <summary>
3686- Test whether the constraint is satisfied by a given value
3687- </summary>
3688- <param name="actual">The value to be tested</param>
3689- <returns>True for success, false for failure</returns>
3690- </member>
3691- <member name="M:NUnit.Framework.Constraints.SamePathConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3692- <summary>
3693- Write the constraint description to a MessageWriter
3694- </summary>
3695- <param name="writer">The writer on which the description is displayed</param>
3696- </member>
3697- <member name="T:NUnit.Framework.Constraints.SamePathOrUnderConstraint">
3698- <summary>
3699- SamePathOrUnderConstraint tests that one path is under another
3700- </summary>
3701- </member>
3702- <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.#ctor(System.String)">
3703- <summary>
3704- Initializes a new instance of the <see cref="T:SamePathOrUnderConstraint"/> class.
3705- </summary>
3706- <param name="expected">The expected path</param>
3707- </member>
3708- <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.Matches(System.Object)">
3709- <summary>
3710- Test whether the constraint is satisfied by a given value
3711- </summary>
3712- <param name="actual">The value to be tested</param>
3713- <returns>True for success, false for failure</returns>
3714- </member>
3715- <member name="M:NUnit.Framework.Constraints.SamePathOrUnderConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3716- <summary>
3717- Write the constraint description to a MessageWriter
3718- </summary>
3719- <param name="writer">The writer on which the description is displayed</param>
3720- </member>
3721- <member name="T:NUnit.Framework.Constraints.EmptyDirectoryContraint">
3722- <summary>
3723- EmptyDirectoryConstraint is used to test that a directory is empty
3724- </summary>
3725- </member>
3726- <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.Matches(System.Object)">
3727- <summary>
3728- Test whether the constraint is satisfied by a given value
3729- </summary>
3730- <param name="actual">The value to be tested</param>
3731- <returns>True for success, false for failure</returns>
3732- </member>
3733- <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3734- <summary>
3735- Write the constraint description to a MessageWriter
3736- </summary>
3737- <param name="writer">The writer on which the description is displayed</param>
3738- </member>
3739- <member name="M:NUnit.Framework.Constraints.EmptyDirectoryContraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
3740- <summary>
3741- Write the actual value for a failing constraint test to a
3742- MessageWriter. The default implementation simply writes
3743- the raw value of actual, leaving it to the writer to
3744- perform any formatting.
3745- </summary>
3746- <param name="writer">The writer on which the actual value is displayed</param>
3747- </member>
3748- <member name="T:NUnit.Framework.Constraints.SubDirectoryConstraint">
3749- <summary>
3750- SubDirectoryConstraint is used to test that one directory is a subdirectory of another.
3751- </summary>
3752- </member>
3753- <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.#ctor(System.IO.DirectoryInfo)">
3754- <summary>
3755- Initializes a new instance of the <see cref="T:SubDirectoryConstraint"/> class.
3756- </summary>
3757- <param name="dirInfo">The dir info.</param>
3758- </member>
3759- <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.Matches(System.Object)">
3760- <summary>
3761- Test whether the constraint is satisfied by a given value
3762- </summary>
3763- <param name="actual">The value to be tested</param>
3764- <returns>True for success, false for failure</returns>
3765- </member>
3766- <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3767- <summary>
3768- Write the constraint description to a MessageWriter
3769- </summary>
3770- <param name="writer">The writer on which the description is displayed</param>
3771- </member>
3772- <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.BuildDirectoryList(System.IO.DirectoryInfo)">
3773- <summary>
3774- Builds a list of DirectoryInfo objects, recursing where necessary
3775- </summary>
3776- <param name="StartingDirectory">directory to recurse</param>
3777- <returns>list of DirectoryInfo objects from the top level</returns>
3778- </member>
3779- <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.IsDirectoryOnPath(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
3780- <summary>
3781- private method to determine whether a directory is within the path
3782- </summary>
3783- <param name="ParentDirectory">top-level directory to search</param>
3784- <param name="SearchDirectory">directory to search for</param>
3785- <returns>true if found, false if not</returns>
3786- </member>
3787- <member name="M:NUnit.Framework.Constraints.SubDirectoryConstraint.DirectoriesEqual(System.IO.DirectoryInfo,System.IO.DirectoryInfo)">
3788- <summary>
3789- Method to compare two DirectoryInfo objects
3790- </summary>
3791- <param name="expected">first directory to compare</param>
3792- <param name="actual">second directory to compare</param>
3793- <returns>true if equivalent, false if not</returns>
3794- </member>
3795- <member name="T:NUnit.Framework.Constraints.ThrowsConstraint">
3796- <summary>
3797- ThrowsConstraint is used to test the exception thrown by
3798- a delegate by applying a constraint to it.
3799- </summary>
3800- </member>
3801- <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.#ctor(NUnit.Framework.Constraints.Constraint)">
3802- <summary>
3803- Initializes a new instance of the <see cref="T:ThrowsConstraint"/> class,
3804- using a constraint to be applied to the exception.
3805- </summary>
3806- <param name="baseConstraint">A constraint to apply to the caught exception.</param>
3807- </member>
3808- <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(System.Object)">
3809- <summary>
3810- Executes the code of the delegate and captures any exception.
3811- If a non-null base constraint was provided, it applies that
3812- constraint to the exception.
3813- </summary>
3814- <param name="actual">A delegate representing the code to be tested</param>
3815- <returns>True if an exception is thrown and the constraint succeeds, otherwise false</returns>
3816- </member>
3817- <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.Matches(NUnit.Framework.Constraints.ActualValueDelegate)">
3818- <summary>
3819- Converts an ActualValueDelegate to a TestDelegate
3820- before calling the primary overload.
3821- </summary>
3822- <param name="del"></param>
3823- <returns></returns>
3824- </member>
3825- <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3826- <summary>
3827- Write the constraint description to a MessageWriter
3828- </summary>
3829- <param name="writer">The writer on which the description is displayed</param>
3830- </member>
3831- <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
3832- <summary>
3833- Write the actual value for a failing constraint test to a
3834- MessageWriter. The default implementation simply writes
3835- the raw value of actual, leaving it to the writer to
3836- perform any formatting.
3837- </summary>
3838- <param name="writer">The writer on which the actual value is displayed</param>
3839- </member>
3840- <member name="M:NUnit.Framework.Constraints.ThrowsConstraint.GetStringRepresentation">
3841- <summary>
3842- Returns the string representation of this constraint
3843- </summary>
3844- </member>
3845- <member name="P:NUnit.Framework.Constraints.ThrowsConstraint.ActualException">
3846- <summary>
3847- Get the actual exception thrown - used by Assert.Throws.
3848- </summary>
3849- </member>
3850- <member name="T:NUnit.Framework.Constraints.ThrowsNothingConstraint">
3851- <summary>
3852- ThrowsNothingConstraint tests that a delegate does not
3853- throw an exception.
3854- </summary>
3855- </member>
3856- <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.Matches(System.Object)">
3857- <summary>
3858- Test whether the constraint is satisfied by a given value
3859- </summary>
3860- <param name="actual">The value to be tested</param>
3861- <returns>True if no exception is thrown, otherwise false</returns>
3862- </member>
3863- <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3864- <summary>
3865- Write the constraint description to a MessageWriter
3866- </summary>
3867- <param name="writer">The writer on which the description is displayed</param>
3868- </member>
3869- <member name="M:NUnit.Framework.Constraints.ThrowsNothingConstraint.WriteActualValueTo(NUnit.Framework.Constraints.MessageWriter)">
3870- <summary>
3871- Write the actual value for a failing constraint test to a
3872- MessageWriter. The default implementation simply writes
3873- the raw value of actual, leaving it to the writer to
3874- perform any formatting.
3875- </summary>
3876- <param name="writer">The writer on which the actual value is displayed</param>
3877- </member>
3878- <member name="T:NUnit.Framework.Constraints.RangeConstraint">
3879- <summary>
3880- RangeConstraint tests whethe two values are within a
3881- specified range.
3882- </summary>
3883- </member>
3884- <member name="M:NUnit.Framework.Constraints.RangeConstraint.#ctor(System.IComparable,System.IComparable)">
3885- <summary>
3886- Initializes a new instance of the <see cref="T:RangeConstraint"/> class.
3887- </summary>
3888- <param name="from">From.</param>
3889- <param name="to">To.</param>
3890- </member>
3891- <member name="M:NUnit.Framework.Constraints.RangeConstraint.Matches(System.Object)">
3892- <summary>
3893- Test whether the constraint is satisfied by a given value
3894- </summary>
3895- <param name="actual">The value to be tested</param>
3896- <returns>True for success, false for failure</returns>
3897- </member>
3898- <member name="M:NUnit.Framework.Constraints.RangeConstraint.WriteDescriptionTo(NUnit.Framework.Constraints.MessageWriter)">
3899- <summary>
3900- Write the constraint description to a MessageWriter
3901- </summary>
3902- <param name="writer">The writer on which the description is displayed</param>
3903- </member>
3904- <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using(System.Collections.IComparer)">
3905- <summary>
3906- Modifies the constraint to use an IComparer and returns self.
3907- </summary>
3908- </member>
3909- <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Collections.Generic.IComparer{``0})">
3910- <summary>
3911- Modifies the constraint to use an IComparer&lt;T&gt; and returns self.
3912- </summary>
3913- </member>
3914- <member name="M:NUnit.Framework.Constraints.RangeConstraint.Using``1(System.Comparison{``0})">
3915- <summary>
3916- Modifies the constraint to use a Comparison&lt;T&gt; and returns self.
3917- </summary>
3918- </member>
3919- <member name="T:NUnit.Framework.Constraints.ConstraintFactory">
3920- <summary>
3921- Helper class with properties and methods that supply
3922- a number of constraints used in Asserts.
3923- </summary>
3924- </member>
3925- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Property(System.String)">
3926- <summary>
3927- Returns a new PropertyConstraintExpression, which will either
3928- test for the existence of the named property on the object
3929- being tested or apply any following constraint to that property.
3930- </summary>
3931- </member>
3932- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute(System.Type)">
3933- <summary>
3934- Returns a new AttributeConstraint checking for the
3935- presence of a particular attribute on an object.
3936- </summary>
3937- </member>
3938- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Attribute``1">
3939- <summary>
3940- Returns a new AttributeConstraint checking for the
3941- presence of a particular attribute on an object.
3942- </summary>
3943- </member>
3944- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EqualTo(System.Object)">
3945- <summary>
3946- Returns a constraint that tests two items for equality
3947- </summary>
3948- </member>
3949- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SameAs(System.Object)">
3950- <summary>
3951- Returns a constraint that tests that two references are the same object
3952- </summary>
3953- </member>
3954- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThan(System.Object)">
3955- <summary>
3956- Returns a constraint that tests whether the
3957- actual value is greater than the suppled argument
3958- </summary>
3959- </member>
3960- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.GreaterThanOrEqualTo(System.Object)">
3961- <summary>
3962- Returns a constraint that tests whether the
3963- actual value is greater than or equal to the suppled argument
3964- </summary>
3965- </member>
3966- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtLeast(System.Object)">
3967- <summary>
3968- Returns a constraint that tests whether the
3969- actual value is greater than or equal to the suppled argument
3970- </summary>
3971- </member>
3972- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThan(System.Object)">
3973- <summary>
3974- Returns a constraint that tests whether the
3975- actual value is less than the suppled argument
3976- </summary>
3977- </member>
3978- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.LessThanOrEqualTo(System.Object)">
3979- <summary>
3980- Returns a constraint that tests whether the
3981- actual value is less than or equal to the suppled argument
3982- </summary>
3983- </member>
3984- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AtMost(System.Object)">
3985- <summary>
3986- Returns a constraint that tests whether the
3987- actual value is less than or equal to the suppled argument
3988- </summary>
3989- </member>
3990- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf(System.Type)">
3991- <summary>
3992- Returns a constraint that tests whether the actual
3993- value is of the exact type supplied as an argument.
3994- </summary>
3995- </member>
3996- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.TypeOf``1">
3997- <summary>
3998- Returns a constraint that tests whether the actual
3999- value is of the exact type supplied as an argument.
4000- </summary>
4001- </member>
4002- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf(System.Type)">
4003- <summary>
4004- Returns a constraint that tests whether the actual value
4005- is of the type supplied as an argument or a derived type.
4006- </summary>
4007- </member>
4008- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOf``1">
4009- <summary>
4010- Returns a constraint that tests whether the actual value
4011- is of the type supplied as an argument or a derived type.
4012- </summary>
4013- </member>
4014- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType(System.Type)">
4015- <summary>
4016- Returns a constraint that tests whether the actual value
4017- is of the type supplied as an argument or a derived type.
4018- </summary>
4019- </member>
4020- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InstanceOfType``1">
4021- <summary>
4022- Returns a constraint that tests whether the actual value
4023- is of the type supplied as an argument or a derived type.
4024- </summary>
4025- </member>
4026- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom(System.Type)">
4027- <summary>
4028- Returns a constraint that tests whether the actual value
4029- is assignable from the type supplied as an argument.
4030- </summary>
4031- </member>
4032- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableFrom``1">
4033- <summary>
4034- Returns a constraint that tests whether the actual value
4035- is assignable from the type supplied as an argument.
4036- </summary>
4037- </member>
4038- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo(System.Type)">
4039- <summary>
4040- Returns a constraint that tests whether the actual value
4041- is assignable from the type supplied as an argument.
4042- </summary>
4043- </member>
4044- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.AssignableTo``1">
4045- <summary>
4046- Returns a constraint that tests whether the actual value
4047- is assignable from the type supplied as an argument.
4048- </summary>
4049- </member>
4050- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EquivalentTo(System.Collections.IEnumerable)">
4051- <summary>
4052- Returns a constraint that tests whether the actual value
4053- is a collection containing the same elements as the
4054- collection supplied as an argument.
4055- </summary>
4056- </member>
4057- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SubsetOf(System.Collections.IEnumerable)">
4058- <summary>
4059- Returns a constraint that tests whether the actual value
4060- is a subset of the collection supplied as an argument.
4061- </summary>
4062- </member>
4063- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Member(System.Object)">
4064- <summary>
4065- Returns a new CollectionContainsConstraint checking for the
4066- presence of a particular object in the collection.
4067- </summary>
4068- </member>
4069- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.Object)">
4070- <summary>
4071- Returns a new CollectionContainsConstraint checking for the
4072- presence of a particular object in the collection.
4073- </summary>
4074- </member>
4075- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Contains(System.String)">
4076- <summary>
4077- Returns a new ContainsConstraint. This constraint
4078- will, in turn, make use of the appropriate second-level
4079- constraint, depending on the type of the actual argument.
4080- This overload is only used if the item sought is a string,
4081- since any other type implies that we are looking for a
4082- collection member.
4083- </summary>
4084- </member>
4085- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringContaining(System.String)">
4086- <summary>
4087- Returns a constraint that succeeds if the actual
4088- value contains the substring supplied as an argument.
4089- </summary>
4090- </member>
4091- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.ContainsSubstring(System.String)">
4092- <summary>
4093- Returns a constraint that succeeds if the actual
4094- value contains the substring supplied as an argument.
4095- </summary>
4096- </member>
4097- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotContain(System.String)">
4098- <summary>
4099- Returns a constraint that fails if the actual
4100- value contains the substring supplied as an argument.
4101- </summary>
4102- </member>
4103- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StartsWith(System.String)">
4104- <summary>
4105- Returns a constraint that succeeds if the actual
4106- value starts with the substring supplied as an argument.
4107- </summary>
4108- </member>
4109- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringStarting(System.String)">
4110- <summary>
4111- Returns a constraint that succeeds if the actual
4112- value starts with the substring supplied as an argument.
4113- </summary>
4114- </member>
4115- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotStartWith(System.String)">
4116- <summary>
4117- Returns a constraint that fails if the actual
4118- value starts with the substring supplied as an argument.
4119- </summary>
4120- </member>
4121- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.EndsWith(System.String)">
4122- <summary>
4123- Returns a constraint that succeeds if the actual
4124- value ends with the substring supplied as an argument.
4125- </summary>
4126- </member>
4127- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringEnding(System.String)">
4128- <summary>
4129- Returns a constraint that succeeds if the actual
4130- value ends with the substring supplied as an argument.
4131- </summary>
4132- </member>
4133- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotEndWith(System.String)">
4134- <summary>
4135- Returns a constraint that fails if the actual
4136- value ends with the substring supplied as an argument.
4137- </summary>
4138- </member>
4139- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.Matches(System.String)">
4140- <summary>
4141- Returns a constraint that succeeds if the actual
4142- value matches the Regex pattern supplied as an argument.
4143- </summary>
4144- </member>
4145- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.StringMatching(System.String)">
4146- <summary>
4147- Returns a constraint that succeeds if the actual
4148- value matches the Regex pattern supplied as an argument.
4149- </summary>
4150- </member>
4151- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.DoesNotMatch(System.String)">
4152- <summary>
4153- Returns a constraint that fails if the actual
4154- value matches the pattern supplied as an argument.
4155- </summary>
4156- </member>
4157- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePath(System.String)">
4158- <summary>
4159- Returns a constraint that tests whether the path provided
4160- is the same as an expected path after canonicalization.
4161- </summary>
4162- </member>
4163- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.SamePathOrUnder(System.String)">
4164- <summary>
4165- Returns a constraint that tests whether the path provided
4166- is the same path or under an expected path after canonicalization.
4167- </summary>
4168- </member>
4169- <member name="M:NUnit.Framework.Constraints.ConstraintFactory.InRange(System.IComparable,System.IComparable)">
4170- <summary>
4171- Returns a constraint that tests whether the actual value falls
4172- within a specified range.
4173- </summary>
4174- </member>
4175- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Not">
4176- <summary>
4177- Returns a ConstraintExpression that negates any
4178- following constraint.
4179- </summary>
4180- </member>
4181- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.No">
4182- <summary>
4183- Returns a ConstraintExpression that negates any
4184- following constraint.
4185- </summary>
4186- </member>
4187- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.All">
4188- <summary>
4189- Returns a ConstraintExpression, which will apply
4190- the following constraint to all members of a collection,
4191- succeeding if all of them succeed.
4192- </summary>
4193- </member>
4194- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Some">
4195- <summary>
4196- Returns a ConstraintExpression, which will apply
4197- the following constraint to all members of a collection,
4198- succeeding if at least one of them succeeds.
4199- </summary>
4200- </member>
4201- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.None">
4202- <summary>
4203- Returns a ConstraintExpression, which will apply
4204- the following constraint to all members of a collection,
4205- succeeding if all of them fail.
4206- </summary>
4207- </member>
4208- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Length">
4209- <summary>
4210- Returns a new ConstraintExpression, which will apply the following
4211- constraint to the Length property of the object being tested.
4212- </summary>
4213- </member>
4214- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Count">
4215- <summary>
4216- Returns a new ConstraintExpression, which will apply the following
4217- constraint to the Count property of the object being tested.
4218- </summary>
4219- </member>
4220- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Message">
4221- <summary>
4222- Returns a new ConstraintExpression, which will apply the following
4223- constraint to the Message property of the object being tested.
4224- </summary>
4225- </member>
4226- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.InnerException">
4227- <summary>
4228- Returns a new ConstraintExpression, which will apply the following
4229- constraint to the InnerException property of the object being tested.
4230- </summary>
4231- </member>
4232- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Null">
4233- <summary>
4234- Returns a constraint that tests for null
4235- </summary>
4236- </member>
4237- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.True">
4238- <summary>
4239- Returns a constraint that tests for True
4240- </summary>
4241- </member>
4242- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.False">
4243- <summary>
4244- Returns a constraint that tests for False
4245- </summary>
4246- </member>
4247- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.NaN">
4248- <summary>
4249- Returns a constraint that tests for NaN
4250- </summary>
4251- </member>
4252- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Empty">
4253- <summary>
4254- Returns a constraint that tests for empty
4255- </summary>
4256- </member>
4257- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Unique">
4258- <summary>
4259- Returns a constraint that tests whether a collection
4260- contains all unique items.
4261- </summary>
4262- </member>
4263- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.BinarySerializable">
4264- <summary>
4265- Returns a constraint that tests whether an object graph is serializable in binary format.
4266- </summary>
4267- </member>
4268- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.XmlSerializable">
4269- <summary>
4270- Returns a constraint that tests whether an object graph is serializable in xml format.
4271- </summary>
4272- </member>
4273- <member name="P:NUnit.Framework.Constraints.ConstraintFactory.Ordered">
4274- <summary>
4275- Returns a constraint that tests whether a collection is ordered
4276- </summary>
4277- </member>
4278- <member name="T:NUnit.Framework.Constraints.ConstraintOperator">
4279- <summary>
4280- The ConstraintOperator class is used internally by a
4281- ConstraintBuilder to represent an operator that
4282- modifies or combines constraints.
4283-
4284- Constraint operators use left and right precedence
4285- values to determine whether the top operator on the
4286- stack should be reduced before pushing a new operator.
4287- </summary>
4288- </member>
4289- <member name="F:NUnit.Framework.Constraints.ConstraintOperator.left_precedence">
4290- <summary>
4291- The precedence value used when the operator
4292- is about to be pushed to the stack.
4293- </summary>
4294- </member>
4295- <member name="F:NUnit.Framework.Constraints.ConstraintOperator.right_precedence">
4296- <summary>
4297- The precedence value used when the operator
4298- is on the top of the stack.
4299- </summary>
4300- </member>
4301- <member name="M:NUnit.Framework.Constraints.ConstraintOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
4302- <summary>
4303- Reduce produces a constraint from the operator and
4304- any arguments. It takes the arguments from the constraint
4305- stack and pushes the resulting constraint on it.
4306- </summary>
4307- <param name="stack"></param>
4308- </member>
4309- <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftContext">
4310- <summary>
4311- The syntax element preceding this operator
4312- </summary>
4313- </member>
4314- <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightContext">
4315- <summary>
4316- The syntax element folowing this operator
4317- </summary>
4318- </member>
4319- <member name="P:NUnit.Framework.Constraints.ConstraintOperator.LeftPrecedence">
4320- <summary>
4321- The precedence value used when the operator
4322- is about to be pushed to the stack.
4323- </summary>
4324- </member>
4325- <member name="P:NUnit.Framework.Constraints.ConstraintOperator.RightPrecedence">
4326- <summary>
4327- The precedence value used when the operator
4328- is on the top of the stack.
4329- </summary>
4330- </member>
4331- <member name="T:NUnit.Framework.Constraints.PrefixOperator">
4332- <summary>
4333- PrefixOperator takes a single constraint and modifies
4334- it's action in some way.
4335- </summary>
4336- </member>
4337- <member name="M:NUnit.Framework.Constraints.PrefixOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
4338- <summary>
4339- Reduce produces a constraint from the operator and
4340- any arguments. It takes the arguments from the constraint
4341- stack and pushes the resulting constraint on it.
4342- </summary>
4343- <param name="stack"></param>
4344- </member>
4345- <member name="M:NUnit.Framework.Constraints.PrefixOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
4346- <summary>
4347- Returns the constraint created by applying this
4348- prefix to another constraint.
4349- </summary>
4350- <param name="constraint"></param>
4351- <returns></returns>
4352- </member>
4353- <member name="T:NUnit.Framework.Constraints.NotOperator">
4354- <summary>
4355- Negates the test of the constraint it wraps.
4356- </summary>
4357- </member>
4358- <member name="M:NUnit.Framework.Constraints.NotOperator.#ctor">
4359- <summary>
4360- Constructs a new NotOperator
4361- </summary>
4362- </member>
4363- <member name="M:NUnit.Framework.Constraints.NotOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
4364- <summary>
4365- Returns a NotConstraint applied to its argument.
4366- </summary>
4367- </member>
4368- <member name="T:NUnit.Framework.Constraints.CollectionOperator">
4369- <summary>
4370- Abstract base for operators that indicate how to
4371- apply a constraint to items in a collection.
4372- </summary>
4373- </member>
4374- <member name="M:NUnit.Framework.Constraints.CollectionOperator.#ctor">
4375- <summary>
4376- Constructs a CollectionOperator
4377- </summary>
4378- </member>
4379- <member name="T:NUnit.Framework.Constraints.AllOperator">
4380- <summary>
4381- Represents a constraint that succeeds if all the
4382- members of a collection match a base constraint.
4383- </summary>
4384- </member>
4385- <member name="M:NUnit.Framework.Constraints.AllOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
4386- <summary>
4387- Returns a constraint that will apply the argument
4388- to the members of a collection, succeeding if
4389- they all succeed.
4390- </summary>
4391- </member>
4392- <member name="T:NUnit.Framework.Constraints.SomeOperator">
4393- <summary>
4394- Represents a constraint that succeeds if any of the
4395- members of a collection match a base constraint.
4396- </summary>
4397- </member>
4398- <member name="M:NUnit.Framework.Constraints.SomeOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
4399- <summary>
4400- Returns a constraint that will apply the argument
4401- to the members of a collection, succeeding if
4402- any of them succeed.
4403- </summary>
4404- </member>
4405- <member name="T:NUnit.Framework.Constraints.NoneOperator">
4406- <summary>
4407- Represents a constraint that succeeds if none of the
4408- members of a collection match a base constraint.
4409- </summary>
4410- </member>
4411- <member name="M:NUnit.Framework.Constraints.NoneOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
4412- <summary>
4413- Returns a constraint that will apply the argument
4414- to the members of a collection, succeeding if
4415- none of them succeed.
4416- </summary>
4417- </member>
4418- <member name="T:NUnit.Framework.Constraints.WithOperator">
4419- <summary>
4420- Represents a constraint that simply wraps the
4421- constraint provided as an argument, without any
4422- further functionality, but which modifes the
4423- order of evaluation because of its precedence.
4424- </summary>
4425- </member>
4426- <member name="M:NUnit.Framework.Constraints.WithOperator.#ctor">
4427- <summary>
4428- Constructor for the WithOperator
4429- </summary>
4430- </member>
4431- <member name="M:NUnit.Framework.Constraints.WithOperator.ApplyPrefix(NUnit.Framework.Constraints.Constraint)">
4432- <summary>
4433- Returns a constraint that wraps its argument
4434- </summary>
4435- </member>
4436- <member name="T:NUnit.Framework.Constraints.SelfResolvingOperator">
4437- <summary>
4438- Abstract base class for operators that are able to reduce to a
4439- constraint whether or not another syntactic element follows.
4440- </summary>
4441- </member>
4442- <member name="T:NUnit.Framework.Constraints.PropOperator">
4443- <summary>
4444- Operator used to test for the presence of a named Property
4445- on an object and optionally apply further tests to the
4446- value of that property.
4447- </summary>
4448- </member>
4449- <member name="M:NUnit.Framework.Constraints.PropOperator.#ctor(System.String)">
4450- <summary>
4451- Constructs a PropOperator for a particular named property
4452- </summary>
4453- </member>
4454- <member name="M:NUnit.Framework.Constraints.PropOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
4455- <summary>
4456- Reduce produces a constraint from the operator and
4457- any arguments. It takes the arguments from the constraint
4458- stack and pushes the resulting constraint on it.
4459- </summary>
4460- <param name="stack"></param>
4461- </member>
4462- <member name="P:NUnit.Framework.Constraints.PropOperator.Name">
4463- <summary>
4464- Gets the name of the property to which the operator applies
4465- </summary>
4466- </member>
4467- <member name="T:NUnit.Framework.Constraints.AttributeOperator">
4468- <summary>
4469- Operator that tests for the presence of a particular attribute
4470- on a type and optionally applies further tests to the attribute.
4471- </summary>
4472- </member>
4473- <member name="M:NUnit.Framework.Constraints.AttributeOperator.#ctor(System.Type)">
4474- <summary>
4475- Construct an AttributeOperator for a particular Type
4476- </summary>
4477- <param name="type">The Type of attribute tested</param>
4478- </member>
4479- <member name="M:NUnit.Framework.Constraints.AttributeOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
4480- <summary>
4481- Reduce produces a constraint from the operator and
4482- any arguments. It takes the arguments from the constraint
4483- stack and pushes the resulting constraint on it.
4484- </summary>
4485- </member>
4486- <member name="T:NUnit.Framework.Constraints.ThrowsOperator">
4487- <summary>
4488- Operator that tests that an exception is thrown and
4489- optionally applies further tests to the exception.
4490- </summary>
4491- </member>
4492- <member name="M:NUnit.Framework.Constraints.ThrowsOperator.#ctor">
4493- <summary>
4494- Construct a ThrowsOperator
4495- </summary>
4496- </member>
4497- <member name="M:NUnit.Framework.Constraints.ThrowsOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
4498- <summary>
4499- Reduce produces a constraint from the operator and
4500- any arguments. It takes the arguments from the constraint
4501- stack and pushes the resulting constraint on it.
4502- </summary>
4503- </member>
4504- <member name="T:NUnit.Framework.Constraints.BinaryOperator">
4505- <summary>
4506- Abstract base class for all binary operators
4507- </summary>
4508- </member>
4509- <member name="M:NUnit.Framework.Constraints.BinaryOperator.Reduce(NUnit.Framework.Constraints.ConstraintBuilder.ConstraintStack)">
4510- <summary>
4511- Reduce produces a constraint from the operator and
4512- any arguments. It takes the arguments from the constraint
4513- stack and pushes the resulting constraint on it.
4514- </summary>
4515- <param name="stack"></param>
4516- </member>
4517- <member name="M:NUnit.Framework.Constraints.BinaryOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
4518- <summary>
4519- Abstract method that produces a constraint by applying
4520- the operator to its left and right constraint arguments.
4521- </summary>
4522- </member>
4523- <member name="P:NUnit.Framework.Constraints.BinaryOperator.LeftPrecedence">
4524- <summary>
4525- Gets the left precedence of the operator
4526- </summary>
4527- </member>
4528- <member name="P:NUnit.Framework.Constraints.BinaryOperator.RightPrecedence">
4529- <summary>
4530- Gets the right precedence of the operator
4531- </summary>
4532- </member>
4533- <member name="T:NUnit.Framework.Constraints.AndOperator">
4534- <summary>
4535- Operator that requires both it's arguments to succeed
4536- </summary>
4537- </member>
4538- <member name="M:NUnit.Framework.Constraints.AndOperator.#ctor">
4539- <summary>
4540- Construct an AndOperator
4541- </summary>
4542- </member>
4543- <member name="M:NUnit.Framework.Constraints.AndOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
4544- <summary>
4545- Apply the operator to produce an AndConstraint
4546- </summary>
4547- </member>
4548- <member name="T:NUnit.Framework.Constraints.OrOperator">
4549- <summary>
4550- Operator that requires at least one of it's arguments to succeed
4551- </summary>
4552- </member>
4553- <member name="M:NUnit.Framework.Constraints.OrOperator.#ctor">
4554- <summary>
4555- Construct an OrOperator
4556- </summary>
4557- </member>
4558- <member name="M:NUnit.Framework.Constraints.OrOperator.ApplyOperator(NUnit.Framework.Constraints.Constraint,NUnit.Framework.Constraints.Constraint)">
4559- <summary>
4560- Apply the operator to produce an OrConstraint
4561- </summary>
4562- </member>
4563- <member name="T:NUnit.Framework.Constraints.ConstraintExpression">
4564- <summary>
4565- ConstraintExpression represents a compound constraint in the
4566- process of being constructed from a series of syntactic elements.
4567-
4568- Individual elements are appended to the expression as they are
4569- reognized. Once an actual Constraint is appended, the expression
4570- returns a resolvable Constraint.
4571- </summary>
4572- </member>
4573- <member name="T:NUnit.Framework.Constraints.ConstraintExpressionBase">
4574- <summary>
4575- ConstraintExpressionBase is the abstract base class for the
4576- generated ConstraintExpression class, which represents a
4577- compound constraint in the process of being constructed
4578- from a series of syntactic elements.
4579-
4580- NOTE: ConstraintExpressionBase is aware of some of its
4581- derived classes, which is an apparent violation of
4582- encapsulation. Ideally, these classes would be a
4583- single class, but they must be separated in order to
4584- allow parts to be generated under .NET 1.x and to
4585- provide proper user feedback in syntactically
4586- aware IDEs.
4587- </summary>
4588- </member>
4589- <member name="F:NUnit.Framework.Constraints.ConstraintExpressionBase.builder">
4590- <summary>
4591- The ConstraintBuilder holding the elements recognized so far
4592- </summary>
4593- </member>
4594- <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor">
4595- <summary>
4596- Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/> class.
4597- </summary>
4598- </member>
4599- <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
4600- <summary>
4601- Initializes a new instance of the <see cref="T:ConstraintExpressionBase"/>
4602- class passing in a ConstraintBuilder, which may be pre-populated.
4603- </summary>
4604- <param name="builder">The builder.</param>
4605- </member>
4606- <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.ToString">
4607- <summary>
4608- Returns a string representation of the expression as it
4609- currently stands. This should only be used for testing,
4610- since it has the side-effect of resolving the expression.
4611- </summary>
4612- <returns></returns>
4613- </member>
4614- <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.ConstraintOperator)">
4615- <summary>
4616- Appends an operator to the expression and returns the
4617- resulting expression itself.
4618- </summary>
4619- </member>
4620- <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.SelfResolvingOperator)">
4621- <summary>
4622- Appends a self-resolving operator to the expression and
4623- returns a new ResolvableConstraintExpression.
4624- </summary>
4625- </member>
4626- <member name="M:NUnit.Framework.Constraints.ConstraintExpressionBase.Append(NUnit.Framework.Constraints.Constraint)">
4627- <summary>
4628- Appends a constraint to the expression and returns that
4629- constraint, which is associated with the current state
4630- of the expression being built.
4631- </summary>
4632- </member>
4633- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor">
4634- <summary>
4635- Initializes a new instance of the <see cref="T:ConstraintExpression"/> class.
4636- </summary>
4637- </member>
4638- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.#ctor(NUnit.Framework.Constraints.ConstraintBuilder)">
4639- <summary>
4640- Initializes a new instance of the <see cref="T:ConstraintExpression"/>
4641- class passing in a ConstraintBuilder, which may be pre-populated.
4642- </summary>
4643- <param name="builder">The builder.</param>
4644- </member>
4645- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Property(System.String)">
4646- <summary>
4647- Returns a new PropertyConstraintExpression, which will either
4648- test for the existence of the named property on the object
4649- being tested or apply any following constraint to that property.
4650- </summary>
4651- </member>
4652- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute(System.Type)">
4653- <summary>
4654- Returns a new AttributeConstraint checking for the
4655- presence of a particular attribute on an object.
4656- </summary>
4657- </member>
4658- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Attribute``1">
4659- <summary>
4660- Returns a new AttributeConstraint checking for the
4661- presence of a particular attribute on an object.
4662- </summary>
4663- </member>
4664- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(NUnit.Framework.Constraints.Constraint)">
4665- <summary>
4666- Returns the constraint provided as an argument - used to allow custom
4667- custom constraints to easily participate in the syntax.
4668- </summary>
4669- </member>
4670- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches``1(System.Predicate{``0})">
4671- <summary>
4672- Returns the constraint provided as an argument - used to allow custom
4673- custom constraints to easily participate in the syntax.
4674- </summary>
4675- </member>
4676- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EqualTo(System.Object)">
4677- <summary>
4678- Returns a constraint that tests two items for equality
4679- </summary>
4680- </member>
4681- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SameAs(System.Object)">
4682- <summary>
4683- Returns a constraint that tests that two references are the same object
4684- </summary>
4685- </member>
4686- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThan(System.Object)">
4687- <summary>
4688- Returns a constraint that tests whether the
4689- actual value is greater than the suppled argument
4690- </summary>
4691- </member>
4692- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.GreaterThanOrEqualTo(System.Object)">
4693- <summary>
4694- Returns a constraint that tests whether the
4695- actual value is greater than or equal to the suppled argument
4696- </summary>
4697- </member>
4698- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtLeast(System.Object)">
4699- <summary>
4700- Returns a constraint that tests whether the
4701- actual value is greater than or equal to the suppled argument
4702- </summary>
4703- </member>
4704- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThan(System.Object)">
4705- <summary>
4706- Returns a constraint that tests whether the
4707- actual value is less than the suppled argument
4708- </summary>
4709- </member>
4710- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.LessThanOrEqualTo(System.Object)">
4711- <summary>
4712- Returns a constraint that tests whether the
4713- actual value is less than or equal to the suppled argument
4714- </summary>
4715- </member>
4716- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AtMost(System.Object)">
4717- <summary>
4718- Returns a constraint that tests whether the
4719- actual value is less than or equal to the suppled argument
4720- </summary>
4721- </member>
4722- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf(System.Type)">
4723- <summary>
4724- Returns a constraint that tests whether the actual
4725- value is of the exact type supplied as an argument.
4726- </summary>
4727- </member>
4728- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.TypeOf``1">
4729- <summary>
4730- Returns a constraint that tests whether the actual
4731- value is of the exact type supplied as an argument.
4732- </summary>
4733- </member>
4734- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf(System.Type)">
4735- <summary>
4736- Returns a constraint that tests whether the actual value
4737- is of the type supplied as an argument or a derived type.
4738- </summary>
4739- </member>
4740- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOf``1">
4741- <summary>
4742- Returns a constraint that tests whether the actual value
4743- is of the type supplied as an argument or a derived type.
4744- </summary>
4745- </member>
4746- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType(System.Type)">
4747- <summary>
4748- Returns a constraint that tests whether the actual value
4749- is of the type supplied as an argument or a derived type.
4750- </summary>
4751- </member>
4752- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InstanceOfType``1">
4753- <summary>
4754- Returns a constraint that tests whether the actual value
4755- is of the type supplied as an argument or a derived type.
4756- </summary>
4757- </member>
4758- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom(System.Type)">
4759- <summary>
4760- Returns a constraint that tests whether the actual value
4761- is assignable from the type supplied as an argument.
4762- </summary>
4763- </member>
4764- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableFrom``1">
4765- <summary>
4766- Returns a constraint that tests whether the actual value
4767- is assignable from the type supplied as an argument.
4768- </summary>
4769- </member>
4770- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo(System.Type)">
4771- <summary>
4772- Returns a constraint that tests whether the actual value
4773- is assignable from the type supplied as an argument.
4774- </summary>
4775- </member>
4776- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.AssignableTo``1">
4777- <summary>
4778- Returns a constraint that tests whether the actual value
4779- is assignable from the type supplied as an argument.
4780- </summary>
4781- </member>
4782- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EquivalentTo(System.Collections.IEnumerable)">
4783- <summary>
4784- Returns a constraint that tests whether the actual value
4785- is a collection containing the same elements as the
4786- collection supplied as an argument.
4787- </summary>
4788- </member>
4789- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SubsetOf(System.Collections.IEnumerable)">
4790- <summary>
4791- Returns a constraint that tests whether the actual value
4792- is a subset of the collection supplied as an argument.
4793- </summary>
4794- </member>
4795- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Member(System.Object)">
4796- <summary>
4797- Returns a new CollectionContainsConstraint checking for the
4798- presence of a particular object in the collection.
4799- </summary>
4800- </member>
4801- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.Object)">
4802- <summary>
4803- Returns a new CollectionContainsConstraint checking for the
4804- presence of a particular object in the collection.
4805- </summary>
4806- </member>
4807- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Contains(System.String)">
4808- <summary>
4809- Returns a new ContainsConstraint. This constraint
4810- will, in turn, make use of the appropriate second-level
4811- constraint, depending on the type of the actual argument.
4812- This overload is only used if the item sought is a string,
4813- since any other type implies that we are looking for a
4814- collection member.
4815- </summary>
4816- </member>
4817- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringContaining(System.String)">
4818- <summary>
4819- Returns a constraint that succeeds if the actual
4820- value contains the substring supplied as an argument.
4821- </summary>
4822- </member>
4823- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.ContainsSubstring(System.String)">
4824- <summary>
4825- Returns a constraint that succeeds if the actual
4826- value contains the substring supplied as an argument.
4827- </summary>
4828- </member>
4829- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StartsWith(System.String)">
4830- <summary>
4831- Returns a constraint that succeeds if the actual
4832- value starts with the substring supplied as an argument.
4833- </summary>
4834- </member>
4835- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringStarting(System.String)">
4836- <summary>
4837- Returns a constraint that succeeds if the actual
4838- value starts with the substring supplied as an argument.
4839- </summary>
4840- </member>
4841- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.EndsWith(System.String)">
4842- <summary>
4843- Returns a constraint that succeeds if the actual
4844- value ends with the substring supplied as an argument.
4845- </summary>
4846- </member>
4847- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringEnding(System.String)">
4848- <summary>
4849- Returns a constraint that succeeds if the actual
4850- value ends with the substring supplied as an argument.
4851- </summary>
4852- </member>
4853- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.Matches(System.String)">
4854- <summary>
4855- Returns a constraint that succeeds if the actual
4856- value matches the Regex pattern supplied as an argument.
4857- </summary>
4858- </member>
4859- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.StringMatching(System.String)">
4860- <summary>
4861- Returns a constraint that succeeds if the actual
4862- value matches the Regex pattern supplied as an argument.
4863- </summary>
4864- </member>
4865- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePath(System.String)">
4866- <summary>
4867- Returns a constraint that tests whether the path provided
4868- is the same as an expected path after canonicalization.
4869- </summary>
4870- </member>
4871- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.SamePathOrUnder(System.String)">
4872- <summary>
4873- Returns a constraint that tests whether the path provided
4874- is the same path or under an expected path after canonicalization.
4875- </summary>
4876- </member>
4877- <member name="M:NUnit.Framework.Constraints.ConstraintExpression.InRange(System.IComparable,System.IComparable)">
4878- <summary>
4879- Returns a constraint that tests whether the actual value falls
4880- within a specified range.
4881- </summary>
4882- </member>
4883- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Not">
4884- <summary>
4885- Returns a ConstraintExpression that negates any
4886- following constraint.
4887- </summary>
4888- </member>
4889- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.No">
4890- <summary>
4891- Returns a ConstraintExpression that negates any
4892- following constraint.
4893- </summary>
4894- </member>
4895- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.All">
4896- <summary>
4897- Returns a ConstraintExpression, which will apply
4898- the following constraint to all members of a collection,
4899- succeeding if all of them succeed.
4900- </summary>
4901- </member>
4902- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Some">
4903- <summary>
4904- Returns a ConstraintExpression, which will apply
4905- the following constraint to all members of a collection,
4906- succeeding if at least one of them succeeds.
4907- </summary>
4908- </member>
4909- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.None">
4910- <summary>
4911- Returns a ConstraintExpression, which will apply
4912- the following constraint to all members of a collection,
4913- succeeding if all of them fail.
4914- </summary>
4915- </member>
4916- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Length">
4917- <summary>
4918- Returns a new ConstraintExpression, which will apply the following
4919- constraint to the Length property of the object being tested.
4920- </summary>
4921- </member>
4922- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Count">
4923- <summary>
4924- Returns a new ConstraintExpression, which will apply the following
4925- constraint to the Count property of the object being tested.
4926- </summary>
4927- </member>
4928- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Message">
4929- <summary>
4930- Returns a new ConstraintExpression, which will apply the following
4931- constraint to the Message property of the object being tested.
4932- </summary>
4933- </member>
4934- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.InnerException">
4935- <summary>
4936- Returns a new ConstraintExpression, which will apply the following
4937- constraint to the InnerException property of the object being tested.
4938- </summary>
4939- </member>
4940- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.With">
4941- <summary>
4942- With is currently a NOP - reserved for future use.
4943- </summary>
4944- </member>
4945- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Null">
4946- <summary>
4947- Returns a constraint that tests for null
4948- </summary>
4949- </member>
4950- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.True">
4951- <summary>
4952- Returns a constraint that tests for True
4953- </summary>
4954- </member>
4955- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.False">
4956- <summary>
4957- Returns a constraint that tests for False
4958- </summary>
4959- </member>
4960- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.NaN">
4961- <summary>
4962- Returns a constraint that tests for NaN
4963- </summary>
4964- </member>
4965- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Empty">
4966- <summary>
4967- Returns a constraint that tests for empty
4968- </summary>
4969- </member>
4970- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Unique">
4971- <summary>
4972- Returns a constraint that tests whether a collection
4973- contains all unique items.
4974- </summary>
4975- </member>
4976- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.BinarySerializable">
4977- <summary>
4978- Returns a constraint that tests whether an object graph is serializable in binary format.
4979- </summary>
4980- </member>
4981- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.XmlSerializable">
4982- <summary>
4983- Returns a constraint that tests whether an object graph is serializable in xml format.
4984- </summary>
4985- </member>
4986- <member name="P:NUnit.Framework.Constraints.ConstraintExpression.Ordered">
4987- <summary>
4988- Returns a constraint that tests whether a collection is ordered
4989- </summary>
4990- </member>
4991- <member name="T:NUnit.Framework.Constraints.BinarySerializableConstraint">
4992- <summary>
4993- BinarySerializableConstraint tests whether
4994- an object is serializable in binary format.
4995- </summary>
4996- </member>
4997- <member name="M:NUnit.Framework.Constraints.BinarySerializableConstraint.Matches(System.Object)">
4998- <summary>
4999- Test whether the constraint is satisfied by a given value
5000- </summary>
The diff has been truncated for viewing.

Subscribers

People subscribed via source and target branches

to all changes: