Spell check sweep

.gitattributes

@@ -5,10 +5,10 @@
 .gitattributes export-ignore
 .gitignore     export-ignore
 
-# Resharper DotSettings files are in Unix Format
+# ReSharper DotSettings files are in Unix Format
 *.DotSettings text eol=lf
 
-# Monodevelop on Linux uses CRLF for these files
+# MonoDevelop on Linux uses CRLF for these files
 *.sln	text	eol=crlf
 packages/repositories.config	text	eol=crlf
 

CHANGES.md

@@ -12,7 +12,7 @@ and `ApartmentState` not being properly applied to tests in all cases.
  * 1346 NullReferenceException when [TestFixtureSource] refers to data in a generic class.
  * 1473 Allow Is.Ordered to Compare Null Values
  * 1899 Constraint Throws.Exception does not catch exception with async lambdas
- * 1905 SetupFixture without namespace will make assembly-level Parallelable attribute useless
+ * 1905 SetupFixture without namespace will make assembly-level Parallelizable attribute useless
  * 2091 When a native exception of corrupted state is thrown, nunit test thread crashes and the nunit-console process hangs
  * 2102 NUnitLite incorrectly reports Win 10 OS name
  * 2271 When CollectionAssert.AreEqual do compare each element, it will ignore the IEquatable of the element too
@@ -108,7 +108,7 @@ that test fixtures will be run.
  * 2251 Randomizer.NextGuid()
  * 2253 Parallelizable(ParallelScope.Fixtures) doesn't work on a TestFixture
  * 2254 EqualTo on ValueTuple with Nullable unexpected
- * 2261 When an assembly is marked with ParallelScope.None and there are Parallelizable tests Nunit hangs
+ * 2261 When an assembly is marked with ParallelScope.None and there are Parallelizable tests NUnit hangs
  * 2269 Parallelizable and NonParallelizable attributes on setup and teardown silently ignored
  * 2276 Intermittent test failures in Travic CI: TestContextTests
  * 2281 Add type constraint for Throws and any method requiring Exception
@@ -132,7 +132,7 @@ that test fixtures will be run.
 
 ### NUnit 3.7.1 - June 6, 2017
 
-This is a hotfix release that addresses occasional hangs when using test parallization
+This is a hotfix release that addresses occasional hangs when using test parallelization
 and fixes crashes in NCrunch prior to version 3.9.
 
 #### Issues Resolved

nuget/nunitlite/nunitlite.nuspec

@@ -21,7 +21,7 @@ Supported platforms:
 How to use this package:
 
 1. Create a console application for your tests and delete the generated class containing Main().
-2. Install the NUnitLite package, which creates a new Main() as well as adding a reference to NUnitLite. This will also bring in the NUnit package, which adds a reference to the nunit framework to your project.
+2. Install the NUnitLite package, which creates a new Main() as well as adding a reference to NUnitLite. This will also bring in the NUnit package, which adds a reference to the NUnit framework to your project.
 3. Add your tests to the test project and simply start the project to execute them.</description>
     <language>en-US</language>
     <tags>test unit testing tdd framework fluent assert device phone embedded</tags>

src/NUnitFramework/framework/Api/FrameworkController.cs

@@ -54,7 +54,7 @@ public class FrameworkController : LongLivedMarshalByRefObject
     {
         private const string LOG_FILE_FORMAT = "InternalTrace.{0}.{1}.log";
 
-        // Pre-loaded test assembly, if passed in constructor
+        // Preloaded test assembly, if passed in constructor
         private Assembly _testAssembly;
 
         #region Constructors

src/NUnitFramework/framework/Api/NUnitTestAssemblyRunner.cs

@@ -367,7 +367,7 @@ private void CreateTestExecutionContext(ITestListener listener)
         }
 
         /// <summary>
-        /// Handle the the Completed event for the top level work item
+        /// Handle the Completed event for the top level work item
         /// </summary>
         private void OnRunCompleted(object sender, EventArgs e)
         {

src/NUnitFramework/framework/AssertionHelper.cs

@@ -440,7 +440,7 @@ public BinarySerializableConstraint BinarySerializable
 
 #if !NETSTANDARD1_6
         /// <summary>
-        /// Returns a constraint that tests whether an object graph is serializable in xml format.
+        /// Returns a constraint that tests whether an object graph is serializable in XML format.
         /// </summary>
         public XmlSerializableConstraint XmlSerializable
         {

src/NUnitFramework/framework/Attributes/CultureAttribute.cs

@@ -1,4 +1,4 @@
-// ***********************************************************************
+// ***********************************************************************
 // Copyright (c) 2007 Charlie Poole, Rob Prouse
 //
 // Permission is hereby granted, free of charge, to any person obtaining
@@ -47,7 +47,7 @@ public class CultureAttribute : IncludeExcludeAttribute, IApplyToTest
         /// <summary>
         /// Constructor taking one or more cultures
         /// </summary>
-        /// <param name="cultures">Comma-deliminted list of cultures</param>
+        /// <param name="cultures">Comma-delimited list of cultures</param>
         public CultureAttribute(string cultures) : base(cultures) { }
 
         #region IApplyToTest members

src/NUnitFramework/framework/Attributes/ExplicitAttribute.cs

@@ -29,7 +29,7 @@ namespace NUnit.Framework
 {
     /// <summary>
     /// ExplicitAttribute marks a test or test fixture so that it will
-    /// only be run if explicitly executed from the gui or command line
+    /// only be run if explicitly executed from the GUI or command line
     /// or if it is included by use of a filter. The test will not be
     /// run simply because an enclosing suite is run.
     /// </summary>

src/NUnitFramework/framework/Attributes/NonTestAssemblyAttribute.cs

@@ -1,4 +1,4 @@
-// ***********************************************************************
+// ***********************************************************************
 // Copyright (c) 2016 Charlie Poole, Rob Prouse
 //
 // Permission is hereby granted, free of charge, to any person obtaining
@@ -28,7 +28,7 @@ namespace NUnit.Framework
 {
     /// <summary>
     /// The NonTestAssemblyAttribute may be used by third-party frameworks
-    /// or other software that references the nunit framework but does not
+    /// or other software that references the NUnit framework but does not
     /// contain tests. Applying the attribute indicates that the assembly
     /// is not a test assembly and may prevent errors if certain runners
     /// attempt to load the assembly. Note that recognition of the attribute

src/NUnitFramework/framework/Compatibility/System.Collections.Concurrent/ConcurrentQueue.cs

@@ -160,7 +160,7 @@ public bool TryDequeue (out T result)
 					if (oldHead == oldTail) {
 						// This should be false then
 						if (oldNext != null) {
-							// If not then the linked list is mal formed, update tail
+							// If not then the linked list is malformed, update tail
 							Interlocked.CompareExchange (ref tail, oldNext, oldTail);
 							continue;
 						}
@@ -318,7 +318,7 @@ public void CopyTo (T[] array, int index)
 			if (index < 0)
 				throw new ArgumentOutOfRangeException ("index");
 			if (index >= array.Length)
-				throw new ArgumentException ("index is equals or greather than array length", "index");
+				throw new ArgumentException ("The index is greater than or equal to the array length", "index");
 
 			IEnumerator<T> e = InternalGetEnumerator ();
 			int i = index;

src/NUnitFramework/framework/Constraints/CollectionTally.cs

@@ -1,4 +1,4 @@
-// ***********************************************************************
+// ***********************************************************************
 // Copyright (c) 2010 Charlie Poole, Rob Prouse
 //
 // Permission is hereby granted, free of charge, to any person obtaining
@@ -49,7 +49,7 @@ public CollectionTallyResult()
 
         private readonly NUnitEqualityComparer comparer;
 
-        /// <summary>The result of the comparision between the two collections.</summary>
+        /// <summary>The result of the comparison between the two collections.</summary>
         public CollectionTallyResult Result
         {
             get
@@ -107,4 +107,4 @@ public void TryRemove(IEnumerable c)
                 TryRemove(o);
         }
     }
-}
+}

src/NUnitFramework/framework/Constraints/ConstraintBuilder.cs

@@ -136,7 +136,7 @@ public void Push(IConstraint constraint)
             /// As a side effect, the constraint's Builder
             /// field is set to null.
             /// </summary>
-            /// <returns>The topmost contraint on the stack</returns>
+            /// <returns>The topmost constraint on the stack</returns>
             public IConstraint Pop()
             {
                 IConstraint constraint = stack.Pop();

src/NUnitFramework/framework/Constraints/ConstraintExpression.cs

@@ -61,7 +61,7 @@ public ConstraintExpression()
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ConstraintExpression"/>
-        /// class passing in a ConstraintBuilder, which may be pre-populated.
+        /// class passing in a ConstraintBuilder, which may be prepopulated.
         /// </summary>
         /// <param name="builder">The builder.</param>
         public ConstraintExpression(ConstraintBuilder builder)
@@ -473,7 +473,7 @@ public BinarySerializableConstraint BinarySerializable
 
 #if !NETSTANDARD1_6
         /// <summary>
-        /// Returns a constraint that tests whether an object graph is serializable in xml format.
+        /// Returns a constraint that tests whether an object graph is serializable in XML format.
         /// </summary>
         public XmlSerializableConstraint XmlSerializable
         {

src/NUnitFramework/framework/Constraints/FloatingPointNumerics.cs

@@ -102,7 +102,7 @@ private struct DoubleLongUnion
         ///   <para>
         ///     Floating point values can only represent a finite subset of natural numbers.
         ///     For example, the values 2.00000000 and 2.00000024 can be stored in a float,
-        ///     but nothing inbetween them.
+        ///     but nothing in between them.
         ///   </para>
         ///   <para>
         ///     This comparison will count how many possible floating point values are between
@@ -154,7 +154,7 @@ public static bool AreAlmostEqualUlps(float left, float right, int maxUlps)
         ///   <para>
         ///     Double precision floating point values can only represent a limited series of
         ///     natural numbers. For example, the values 2.0000000000000000 and 2.0000000000000004
-        ///     can be stored in a double, but nothing inbetween them.
+        ///     can be stored in a double, but nothing in between them.
         ///   </para>
         ///   <para>
         ///     This comparison will count how many possible double precision floating point

src/NUnitFramework/framework/Constraints/XmlSerializableConstraint.cs

@@ -30,7 +30,7 @@ namespace NUnit.Framework.Constraints
 {
     /// <summary>
     /// XmlSerializableConstraint tests whether 
-    /// an object is serializable in xml format.
+    /// an object is serializable in XML format.
     /// </summary>
     public class XmlSerializableConstraint : Constraint
     {
@@ -41,7 +41,7 @@ public class XmlSerializableConstraint : Constraint
         /// </summary>
         public override string Description
         {
-            get { return "xml serializable"; }
+            get { return "XML serializable"; }
         }
 
         /// <summary>

src/NUnitFramework/framework/Interfaces/AssertionResult.cs

@@ -1,4 +1,4 @@
-using System;
+using System;
 using System.Collections.Generic;
 using System.Text;
 
@@ -25,7 +25,7 @@ public AssertionResult(AssertionStatus status, string message, string stackTrace
         /// <summary>The message produced by the assertion, or null</summary>
         public string Message { get; private set; }
 
-        /// <summary>The stacktrace associated with the assertion, or null</summary>
+        /// <summary>The stack trace associated with the assertion, or null</summary>
         public string StackTrace { get; private set; }
 
         /// <summary>

src/NUnitFramework/framework/Interfaces/ITestCaseData.cs

@@ -28,7 +28,7 @@ namespace NUnit.Framework.Interfaces
 {
     /// <summary>
     /// The ITestCaseData interface is implemented by a class
-    /// that is able to return complete testcases for use by
+    /// that is able to return complete test cases for use by
     /// a parameterized test method.
     /// </summary>
     public interface ITestCaseData : ITestData

src/NUnitFramework/framework/Interfaces/ITestResult.cs

@@ -1,4 +1,4 @@
-// ***********************************************************************
+// ***********************************************************************
 // Copyright (c) 2010 Charlie Poole, Rob Prouse
 //
 // Permission is hereby granted, free of charge, to any person obtaining
@@ -90,7 +90,7 @@ string Message
         }
 
         /// <summary>
-        /// Gets any stacktrace associated with an
+        /// Gets any stack trace associated with an
         /// error or failure. Not available in
         /// the Compact Framework 1.0.
         /// </summary>

src/NUnitFramework/framework/Interfaces/ITypeInfo.cs

@@ -1,4 +1,4 @@
-// ***********************************************************************
+// ***********************************************************************
 // Copyright (c) 2015 Charlie Poole, Rob Prouse
 //
 // Permission is hereby granted, free of charge, to any person obtaining
@@ -65,7 +65,7 @@ public interface ITypeInfo : IReflectionInfo
         Assembly Assembly { get; }
 
         /// <summary>
-        /// Gets the Namespace of the Type
+        /// Gets the namespace of the Type
         /// </summary>
         string Namespace { get; }
 

src/NUnitFramework/framework/Interfaces/TNode.cs

@@ -203,7 +203,7 @@ public void AddAttribute(string name, string value)
         }
 
         /// <summary>
-        /// Finds a single descendant of this node matching an xpath
+        /// Finds a single descendant of this node matching an XPath
         /// specification. The format of the specification is
         /// limited to what is needed by NUnit and its tests.
         /// </summary>
@@ -219,7 +219,7 @@ public TNode SelectSingleNode(string xpath)
         }
 
         /// <summary>
-        /// Finds all descendants of this node matching an xpath
+        /// Finds all descendants of this node matching an XPath
         /// specification. The format of the specification is
         /// limited to what is needed by NUnit and its tests.
         /// </summary>

src/NUnitFramework/framework/Internal/Builders/NUnitTestCaseBuilder.cs

@@ -68,7 +68,7 @@ public TestMethod BuildTestMethod(IMethodInfo method, Test parentSuite, TestCase
             // original MethodInfo, so we don't use it here.
             string prefix = testMethod.Method.TypeInfo.FullName;
 
-            // Needed to give proper fullname to test in a parameterized fixture.
+            // Needed to give proper full name to test in a parameterized fixture.
             // Without this, the arguments to the fixture are not included.
             if (parentSuite != null)
                 prefix = parentSuite.FullName;

src/NUnitFramework/framework/Internal/Builders/PairwiseStrategy.cs

@@ -1,4 +1,4 @@
-// ***********************************************************************
+// ***********************************************************************
 // Copyright (c) 2008 Charlie Poole, Rob Prouse
 //
 // Permission is hereby granted, free of charge, to any person obtaining
@@ -284,10 +284,10 @@ public bool IsTupleCovered( FeatureTuple tuple )
         /// </para>
         /// <para>Maximizing test coverage</para>
         /// <para>
-        /// To maximize tests coverage, the algorithm walks thru the list of mutable
+        /// To maximize tests coverage, the algorithm walks through the list of mutable
         /// dimensions (mutable dimension is a dimension that are not included in
         /// the previously selected tuple). Then for every dimension, the algorithm
-        /// walks thru the list of features and checks if this feature provides
+        /// walks through the list of features and checks if this feature provides
         /// better coverage than randomly selected feature, and if yes keeps this
         /// feature.
         /// </para>

src/NUnitFramework/framework/Internal/Commands/ConstructFixtureCommand.cs

@@ -47,7 +47,7 @@ public ConstructFixtureCommand(TestCommand innerCommand)
 
                 if (typeInfo != null)
                 {
-                    // Use pre-constructed fixture if available, otherwise construct it
+                    // Use preconstructed fixture if available, otherwise construct it
                     if (!typeInfo.IsStaticClass)
                     {
                         context.TestObject = Test.Fixture ?? typeInfo.Construct(((TestSuite)Test).Arguments);

src/NUnitFramework/framework/Internal/ConstraintUtils.cs

@@ -26,7 +26,7 @@
 namespace NUnit.Framework.Internal
 {
     /// <summary>
-    /// Provides methods to support consistent checking for constaints methods.
+    /// Provides methods to support consistent checking in constraints.
     /// </summary>
     internal static class ConstraintUtils
     {

src/NUnitFramework/framework/Internal/Execution/EventPump.cs

@@ -78,7 +78,7 @@ public class EventPump : IDisposable
         private Thread _pumpThread;
 
         /// <summary>
-        /// The current state of the eventpump
+        /// The current state of the event pump
         /// </summary>
         private int _pumpState = (int)EventPumpState.Stopped;
 

src/NUnitFramework/framework/Internal/Execution/MainThreadWorkItemDispatcher.cs

@@ -28,7 +28,7 @@ namespace NUnit.Framework.Internal.Execution
     /// <summary>
     /// MainThreadWorkItemDispatcher handles execution of WorkItems by
     /// directly executing them on the main thread. This is different
-    /// from the SimpleWorkItemDispatcher where the workitem is dispatched
+    /// from the SimpleWorkItemDispatcher where the work item is dispatched
     /// onto its own thread.
     /// </summary>
     public class MainThreadWorkItemDispatcher : IWorkItemDispatcher

src/NUnitFramework/framework/Internal/Execution/SimpleWorkItem.cs

@@ -104,7 +104,7 @@ private TestCommand MakeTestCommand()
                         command = new TestActionCommand(command, action); ;
 
                 // Try to locate the parent fixture. In current implementations, the test method 
-                // is either one or two levels levels below the TestFixture - if this changes, 
+                // is either one or two levels below the TestFixture - if this changes, 
                 // so should the following code.
                 TestFixture parentFixture = Test.Parent as TestFixture ?? Test.Parent?.Parent as TestFixture;
 

src/NUnitFramework/framework/Internal/Execution/WorkItem.cs

@@ -514,7 +514,7 @@ private ParallelExecutionStrategy GetExecutionStrategy()
         {
             // If there is no fixture and so nothing to do but dispatch
             // grandchildren we run directly. This saves time that would
-            // otherwise be spent enqueuing and dequeing items.
+            // otherwise be spent enqueuing and dequeuing items.
             if (Test.TypeInfo == null)
                 return ParallelExecutionStrategy.Direct;
 

src/NUnitFramework/framework/Internal/Randomizer.cs

@@ -506,7 +506,7 @@ public T NextEnum<T>()
         /// <summary>
         /// Default characters for random functions.
         /// </summary>
-        /// <remarks>Default characters are the English alphabet (uppercase &amp; lowercase), arabic numerals, and underscore</remarks>
+        /// <remarks>Default characters are the English alphabet (uppercase &amp; lowercase), Arabic numerals, and underscore</remarks>
         public const string DefaultStringChars = "abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNOPQRSTUVWXYZ0123456789_";
 
         private const int DefaultStringLength = 25;