diff --git a/src/Common/src/Interop/OSX/Interop.CoreFoundation.cs b/src/Common/src/Interop/OSX/Interop.CoreFoundation.cs index e9576c47bde5..befba3511a8d 100644 --- a/src/Common/src/Interop/OSX/Interop.CoreFoundation.cs +++ b/src/Common/src/Interop/OSX/Interop.CoreFoundation.cs @@ -62,7 +62,7 @@ internal static SafeCreateHandle CFStringCreateWithCString(string str) } /// - /// Creates a pointer to an unmanaged CFArray containing the input values. Folows the "Create Rule" where if you create it, you delete it. + /// Creates a pointer to an unmanaged CFArray containing the input values. Follows the "Create Rule" where if you create it, you delete it. /// /// Should be IntPtr.Zero /// The values to put in the array @@ -78,7 +78,7 @@ private static extern SafeCreateHandle CFArrayCreate( IntPtr callbacks); /// - /// Creates a pointer to an unmanaged CFArray containing the input values. Folows the "Create Rule" where if you create it, you delete it. + /// Creates a pointer to an unmanaged CFArray containing the input values. Follows the "Create Rule" where if you create it, you delete it. /// /// The values to put in the array /// The number of values in the array diff --git a/src/Common/src/Microsoft/Win32/SafeHandles/SafeCreateHandle.OSX.cs b/src/Common/src/Microsoft/Win32/SafeHandles/SafeCreateHandle.OSX.cs index 9f3476143fce..5cc4927c10ab 100644 --- a/src/Common/src/Microsoft/Win32/SafeHandles/SafeCreateHandle.OSX.cs +++ b/src/Common/src/Microsoft/Win32/SafeHandles/SafeCreateHandle.OSX.cs @@ -10,7 +10,7 @@ namespace Microsoft.Win32.SafeHandles { /// /// This class is a wrapper around the Create pattern in OS X where - /// if a Create* function is called, the caler must also CFRelease + /// if a Create* function is called, the caller must also CFRelease /// on the same pointer in order to correctly free the memory. /// [System.Security.SecurityCritical] diff --git a/src/Common/src/System/SR.Core.cs b/src/Common/src/System/SR.Core.cs index 15a6dc14d48f..0b80c9a2fdc8 100644 --- a/src/Common/src/System/SR.Core.cs +++ b/src/Common/src/System/SR.Core.cs @@ -38,7 +38,7 @@ private static bool UsingResourceKeys() return false; } - // TODO: Resouce generation tool should be modified to call this version in release build + // TODO: Resource generation tool should be modified to call this version in release build [MethodImpl(MethodImplOptions.NoInlining)] internal static string GetResourceString(string resourceKey) { diff --git a/src/Common/src/System/Threading/Tasks/ForceAsyncAwaiter.cs b/src/Common/src/System/Threading/Tasks/ForceAsyncAwaiter.cs index dd82b9483b2f..d1bd27733c47 100644 --- a/src/Common/src/System/Threading/Tasks/ForceAsyncAwaiter.cs +++ b/src/Common/src/System/Threading/Tasks/ForceAsyncAwaiter.cs @@ -12,7 +12,7 @@ internal static partial class TaskAwaiters /// Returns an awaitable/awaiter that will ensure the continuation is executed /// asynchronously on the thread pool, even if the task is already completed /// by the time the await occurs. Effectively, it is equivalent to awaiting - /// with ConfigureAwait(false) and then queueing the continuation with Task.Run, + /// with ConfigureAwait(false) and then queuing the continuation with Task.Run, /// but it avoids the extra hop if the continuation already executed asynchronously. /// public static ForceAsyncAwaiter ForceAsync(this Task task) diff --git a/src/Common/tests/System/Xml/ModuleCore/cattrbase.cs b/src/Common/tests/System/Xml/ModuleCore/cattrbase.cs index a4e029c3a2fd..59cafd87bc84 100644 --- a/src/Common/tests/System/Xml/ModuleCore/cattrbase.cs +++ b/src/Common/tests/System/Xml/ModuleCore/cattrbase.cs @@ -31,15 +31,15 @@ public class CAttrBase : Attribute private CAttrBase _parent = null; private string _filter; - //Allows Inhertiance (ie: object to determine if ever been set) - private object _priority; //Allows Inhertiance - private object _implemented; //Allows Inhertiance - private object _skipped; //Allows Inhertiance - private object _error; //Allows Inhertiance - private object _security; //Allows Inhertiance - private object _filtercriteria;//Allows Inhertiance - private object[] _languages; //Allows Inhertiance - private object _xml; //Allows Inhertiance + //Allows Inheritance (i.e.: object to determine if ever been set) + private object _priority; //Allows Inheritance + private object _implemented; //Allows Inheritance + private object _skipped; //Allows Inheritance + private object _error; //Allows Inheritance + private object _security; //Allows Inheritance + private object _filtercriteria;//Allows Inheritance + private object[] _languages; //Allows Inheritance + private object _xml; //Allows Inheritance //Constructors public CAttrBase() @@ -420,7 +420,7 @@ public virtual string File public virtual string Files { - //Search Pattern (ie: *.*) + //Search Pattern (i.e.: *.*) get { return _files; } set { _files = value; } } diff --git a/src/Common/tests/System/Xml/ModuleCore/cerror.cs b/src/Common/tests/System/Xml/ModuleCore/cerror.cs index d9d5e0192bb7..0bcb73c4feb7 100644 --- a/src/Common/tests/System/Xml/ModuleCore/cerror.cs +++ b/src/Common/tests/System/Xml/ModuleCore/cerror.cs @@ -33,7 +33,7 @@ static public IError Error s_rIError = value; //Setup the standard c# Console to log to LTM instead... - //ie: Console.WriteLine will automatically log to LTM + //i.e.: Console.WriteLine will automatically log to LTM if (s_rLTMConsole == null) { s_rLTMConsole = new CLTMConsole(); @@ -244,7 +244,7 @@ static public bool Equals(object actual, object expected, string message) try { //Equals is identical to Compare, except that Equals doesn't throw. - //This way if We still want to throw the exception so we get the logging and comapre block + //This way if We still want to throw the exception so we get the logging and compare block //but the test wants to continue to do other things. return CError.Compare(actual, expected, message); } @@ -260,7 +260,7 @@ static public bool Equals(bool equal, string message) try { //Equals is identical to Compare, except that Equals doesn't throw. - //This way if We still want to throw the exception so we get the logging and comapre block + //This way if We still want to throw the exception so we get the logging and compare block //but the test wants to continue to do other things. return CError.Compare(equal, message); } diff --git a/src/Common/tests/System/Xml/ModuleCore/cltmconsole.cs b/src/Common/tests/System/Xml/ModuleCore/cltmconsole.cs index e6f49a8cdcb8..8ca9cd642cc9 100644 --- a/src/Common/tests/System/Xml/ModuleCore/cltmconsole.cs +++ b/src/Common/tests/System/Xml/ModuleCore/cltmconsole.cs @@ -28,17 +28,17 @@ public override void Write(char ch) CError.Write(ch.ToString()); } - //Overlaods - We also implement "string" since its much more effiencent and TextWriter will call this instead + //Overloads - We also implement "string" since its much more efficient and TextWriter will call this instead public override void Write(string strText) { CError.Write(strText); } - //Overlaods - We also implement "string" since its much more effiencent and TextWriter will call this instead + //Overloads - We also implement "string" since its much more efficient and TextWriter will call this instead public override void Write(char[] ch) { //Note: This is a workaround the TextWriter::Write(char[]) that incorrectly - //writes 1 char at a time, which means \r\n is written sperately and then gets fixed + //writes 1 char at a time, which means \r\n is written separately and then gets fixed //up to be two carriage returns! if (ch != null) { diff --git a/src/Common/tests/System/Xml/ModuleCore/cmodinfo.cs b/src/Common/tests/System/Xml/ModuleCore/cmodinfo.cs index 88860b646023..5e05c3b4cd30 100644 --- a/src/Common/tests/System/Xml/ModuleCore/cmodinfo.cs +++ b/src/Common/tests/System/Xml/ModuleCore/cmodinfo.cs @@ -46,9 +46,9 @@ public CModInfo() static internal void Dispose() { //Reset the info. - //Since this is a static class, (to make it simplier to access from anywhere in your code) + //Since this is a static class, (to make it simpler to access from anywhere in your code) //we need to reset this info everytime a test is run - so if you don't select an alias - //the next time it doesn't use the previous alias setting - ie: ProviderInfo doesn't + //the next time it doesn't use the previous alias setting - i.e.: ProviderInfo doesn't //get called when no alias is selected... s_strCommandLine = null; s_hashOptions = null; diff --git a/src/Common/tests/System/Xml/ModuleCore/cparser.cs b/src/Common/tests/System/Xml/ModuleCore/cparser.cs index da9d14f7f7a1..d2fbd6b368b9 100644 --- a/src/Common/tests/System/Xml/ModuleCore/cparser.cs +++ b/src/Common/tests/System/Xml/ModuleCore/cparser.cs @@ -74,7 +74,7 @@ static public MyDict ParseKeywords(string str, Tokens tokens) case PARSE.Keyword: if (tokens.Equal.IndexOf(ch) >= 0) { - //Note: We have a case-insentive hashtable so we don't have to lowercase + //Note: We have a case-insensitive hashtable so we don't have to lowercase key = str.Substring(keyStart, index - keyStart).Trim(); state = PARSE.Equal; } diff --git a/src/Common/tests/System/Xml/ModuleCore/ctestbase.cs b/src/Common/tests/System/Xml/ModuleCore/ctestbase.cs index a04b912f317f..93db326230af 100644 --- a/src/Common/tests/System/Xml/ModuleCore/ctestbase.cs +++ b/src/Common/tests/System/Xml/ModuleCore/ctestbase.cs @@ -60,7 +60,7 @@ public virtual CAttrBase Attribute protected abstract CAttrBase CreateAttribute(); - //Note: These are just a mere convience to access the attribute values + //Note: These are just a mere convenience to access the attribute values //for this particular object. Also note that for non-attribute based //scenarios (dynamic), the attribute class will be created just to hold //the values diff --git a/src/Common/tests/System/Xml/ModuleCore/ctestcase.cs b/src/Common/tests/System/Xml/ModuleCore/ctestcase.cs index 098c571583f0..8e0901188f1e 100644 --- a/src/Common/tests/System/Xml/ModuleCore/ctestcase.cs +++ b/src/Common/tests/System/Xml/ModuleCore/ctestcase.cs @@ -54,7 +54,7 @@ public override tagVARIATION_STATUS Execute() foreach (object child in children) { CTestCase childTc = child as CTestCase; - if (childTc != null) //nested test test case class will be child of a test case + if (childTc != null) //nested test case class will be child of a test case { childTc.Init(); childTc.Execute(); @@ -90,7 +90,7 @@ public override tagVARIATION_STATUS Execute() catch (Exception e) { System.Console.WriteLine(indent + var.Desc); - System.Console.WriteLine("unexpected exception happend:{0}", e.Message); + System.Console.WriteLine("unexpected exception happened:{0}", e.Message); System.Console.WriteLine(e.StackTrace); System.Console.WriteLine(indent + " FAILED"); TestModule.FailCount++; @@ -137,7 +137,7 @@ public void RunVariation(dlgtTestVariation testmethod, Variation curVar) catch (Exception e) { System.Console.WriteLine(indent + curVar.Desc); - System.Console.WriteLine("unexpected exception happend:{0}", e.Message); + System.Console.WriteLine("unexpected exception happened:{0}", e.Message); System.Console.WriteLine(e.StackTrace); System.Console.WriteLine(indent + " FAILED"); TestModule.FailCount++; @@ -178,9 +178,9 @@ public CVariation CurVariation { //Return the current variation: //Note: We do this so that within the variation the user can have access to all the - //atrributes of that particular method. Unlike the TestModule/TestCase which are objects + //attributes of that particular method. Unlike the TestModule/TestCase which are objects //and have properties to reference, the variations are function and don't. Each variation - //could also have multiple atrributes (repeats), so we can't simply use the StackFrame + //could also have multiple attributes (repeats), so we can't simply use the StackFrame //to determine this info... get { return _curvariation; } set { _curvariation = value; } @@ -219,8 +219,8 @@ public virtual tagVARIATION_STATUS ExecuteVariation(int index) } //Before exiting make sure we reset our CurVariation to null, to prevent - //incorrect uses of CurVariation wihtin the TestCase, but not actually a running - //variation. This will only be valid within a fucntion with a //[Variation] attribute... + //incorrect uses of CurVariation within the TestCase, but not actually a running + //variation. This will only be valid within a function with a //[Variation] attribute... _curvariation = null; return (tagVARIATION_STATUS)result; } @@ -248,11 +248,11 @@ public virtual void DetermineVariations() //Default - no sort bool bSort = false; //Normally the reflection Type.GetMethods() api returns the methods in order - //of how thery appear in the code. But it will change that order depending + //of how they appear in the code. But it will change that order depending //upon if there are virtual functions, which are returned first before other //non-virtual functions. Then there are also inherited classes where the - //derived classes methods are returned before the inherted class. So we have - //added the support of specifing an id=x, as an attribute so you can have + //derived classes methods are returned before the inherited class. So we have + //added the support of specifying an id=x, as an attribute so you can have //then sorted and displayed however your see fit. if (bSort) Children.Sort(/*Default sort is based upon IComparable of each item*/); diff --git a/src/Common/tests/System/Xml/ModuleCore/ctestexception.cs b/src/Common/tests/System/Xml/ModuleCore/ctestexception.cs index 0070cfcf8ae3..c25be7364bc4 100644 --- a/src/Common/tests/System/Xml/ModuleCore/ctestexception.cs +++ b/src/Common/tests/System/Xml/ModuleCore/ctestexception.cs @@ -71,7 +71,7 @@ public CTestException(int result, string message) public CTestException(int result, string message, object actual, object expected, Exception inner) : base(message, inner) { - //Note: iResult is the variation result (ie: TEST_PASS, TEST_FAIL, etc...) + //Note: iResult is the variation result (i.e.: TEST_PASS, TEST_FAIL, etc...) //Setup the exception Result = result; Actual = actual; diff --git a/src/Common/tests/System/Xml/ModuleCore/ctestmodule.cs b/src/Common/tests/System/Xml/ModuleCore/ctestmodule.cs index 8b87a67d989a..6191fa04a280 100644 --- a/src/Common/tests/System/Xml/ModuleCore/ctestmodule.cs +++ b/src/Common/tests/System/Xml/ModuleCore/ctestmodule.cs @@ -53,7 +53,7 @@ public CTestModule(string desc, string owner, int version) { _clsid = GetType().ToString(); - //The attribute should take precendence + //The attribute should take precedence if (this.Owner == null) this.Owner = owner; if (this.Version <= 0) @@ -195,11 +195,11 @@ public virtual void DetermineTestCases() bool bSort = false; //Normally the reflection Type.GetMethods() api returns the methods in order - //of how thery appear in the code. But it will change that order depending + //of how they appear in the code. But it will change that order depending //upon if there are virtual functions, which are returned first before other //non-virtual functions. Then there are also many times were people want multiple //source files, so its totally up the compiler on how it pulls in the files (*.cs). - //So we have added the support of specifing an id=x, as an attribute so you can have + //So we have added the support of specifying an id=x, as an attribute so you can have //then sorted and displayed however your see fit. if (bSort) Children.Sort(/*Default sort is based upon IComparable of each item*/); @@ -215,9 +215,9 @@ protected virtual void DetermineFilters() protected virtual string FilterScope(string xpath) { - //Basically we want to allow either simply filtering at the variation node (ie: no scope), + //Basically we want to allow either simply filtering at the variation node (i.e.: no scope), //in which case we'll just add the 'assumed' scope, or allow filtering at any level. - //We also want to be consitent with the XmlDriver in which all filters are predicates only. + //We also want to be consistent with the XmlDriver in which all filters are predicates only. string varfilter = "//Variation[{0}]"; if (xpath != null) { @@ -236,9 +236,9 @@ protected virtual string FilterScope(string xpath) public CTestCase CurTestCase { //Return the current testcase: - //Note: We do this so that within global functions (ie: at the module level) the user can + //Note: We do this so that within global functions (i.e.: at the module level) the user can //have know which testcase/variation were in, without having to pass this state from - //execute arround + //execute around get { return _curtestcase; } set { _curtestcase = value; } } diff --git a/src/Common/tests/System/Xml/ModuleCore/cvariation.cs b/src/Common/tests/System/Xml/ModuleCore/cvariation.cs index 3c28dfb6030c..d07a457f0de0 100644 --- a/src/Common/tests/System/Xml/ModuleCore/cvariation.cs +++ b/src/Common/tests/System/Xml/ModuleCore/cvariation.cs @@ -34,7 +34,7 @@ public CVariation(CTestCase testcase, string desc, string function) : base(function, desc) { //Note: The parent automatically gets setup on AddVariation so we don't - //really need to pass in the testcase, left here for backward compatibilty + //really need to pass in the testcase, left here for backward compatibility //of inherited drivers. } @@ -42,7 +42,7 @@ public CVariation(CTestCase testcase, string desc, TestFunc function) : base(null, desc) { //Note: The parent automatically gets setup on AddVariation so we don't - //really need to pass in the testcase, left here for backward compatibilty + //really need to pass in the testcase, left here for backward compatibility //of inherited drivers. _pfunc = function; } diff --git a/src/Common/tests/System/Xml/ModuleCore/interop.cs b/src/Common/tests/System/Xml/ModuleCore/interop.cs index 1797d4ca643f..ce9d817ab8b2 100644 --- a/src/Common/tests/System/Xml/ModuleCore/interop.cs +++ b/src/Common/tests/System/Xml/ModuleCore/interop.cs @@ -44,7 +44,7 @@ public enum tagERRORLEVEL //////////////////////////////////////////////////////////////////////// public enum tagCONSOLEFLAGS { - CONSOLE_RAW = 0x00000000, //No fixup - Don't use, unless you know the text contains no CR/LF, no Xml reserverd tokens, or no other non-respresentable characters + CONSOLE_RAW = 0x00000000, //No fixup - Don't use, unless you know the text contains no CR/LF, no Xml reserved tokens, or no other non-representable characters CONSOLE_TEXT = 0x00000001, //Default - Automatically fixup CR/LF correctly for log files, fixup xml tokens, etc CONSOLE_XML = 0x00000002, //For Xml - User text is placed into a CDATA section (with no xml fixups) CONSOLE_IGNORE = 0x00000004, //Ignore - User text is placed into ignore tags (can combine this with console_xml as well) diff --git a/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemEventArgs.cs b/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemEventArgs.cs index ed076e2a400c..8df624b6a996 100644 --- a/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemEventArgs.cs +++ b/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemEventArgs.cs @@ -57,7 +57,7 @@ public WatcherChangeTypes ChangeType } /// - /// Gets the fully qualifed path of the affected file or directory. + /// Gets the fully qualified path of the affected file or directory. /// public string FullPath { diff --git a/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Linux.cs b/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Linux.cs index fc22b3c2e6ca..3babb644417a 100644 --- a/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Linux.cs +++ b/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Linux.cs @@ -27,7 +27,7 @@ private void StartRaisingEvents() // Open an inotify file descriptor. Ideally this would be a constrained execution region, but we don't have access to // PrepareConstrainedRegions. We still use a finally block to house the code that opens the handle and stores it in - // hopes of making it as non-interruptable as possible. Ideally the SafeFileHandle would be allocated before the block, + // hopes of making it as non-interruptible as possible. Ideally the SafeFileHandle would be allocated before the block, // but SetHandle is protected and SafeFileHandle is sealed, so we're stuck doing the allocation here. SafeFileHandle handle; try { } finally @@ -189,7 +189,7 @@ private static Interop.Sys.NotifyEvents TranslateFilters(NotifyFilters filters) } // For the Rename event, we'll register for the corresponding move inotify events if the - // caller's NotifyFilters asks for notications related to names. + // caller's NotifyFilters asks for notifications related to names. const NotifyFilters filtersForMoved = NotifyFilters.FileName | NotifyFilters.DirectoryName; @@ -261,7 +261,7 @@ private sealed class RunningInstance /// Mapping from watch descriptor (as returned by inotify_add_watch) to state for /// the associated directory being watched. Events from inotify include only relative /// names, so the watch descriptor in an event must be used to look up the associated - /// directory path in order to conver the relative filename into a full path. + /// directory path in order to convert the relative filename into a full path. /// private readonly Dictionary _wdToPathMap = new Dictionary(); /// diff --git a/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Win32.cs b/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Win32.cs index ba2347bfc9d7..3c923c915d61 100644 --- a/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Win32.cs +++ b/src/System.IO.FileSystem.Watcher/src/System/IO/FileSystemWatcher.Win32.cs @@ -77,7 +77,7 @@ private void StopRaisingEvents() // Close the directory handle. This will cause the async operation to stop processing. // This operation doesn't need to be atomic because the API will deal with a closed // handle appropriately. If we get here while asynchronously waiting on a change notification, - // closing the directory handle should cause ReadDirectoryChangesCallback be be called, + // closing the directory handle should cause ReadDirectoryChangesCallback be called, // cleaning up the operation. Note that it's critical to also null out the handle. If the // handle is currently in use in a P/Invoke, it will have its reference count temporarily // increased, such that the disposal operation won't take effect and close the handle diff --git a/src/System.IO.FileSystem.Watcher/src/System/IO/PatternMatcher.cs b/src/System.IO.FileSystem.Watcher/src/System/IO/PatternMatcher.cs index e6d12fa6cac2..4b9913b54d50 100644 --- a/src/System.IO.FileSystem.Watcher/src/System/IO/PatternMatcher.cs +++ b/src/System.IO.FileSystem.Watcher/src/System/IO/PatternMatcher.cs @@ -167,7 +167,7 @@ public static bool StrictMatchPattern(string expression, string name) // This allows a simple conversion between state number and expression // offset. Each character in the expression can represent one or two // states. * and DOS_STAR generate two states: ExprOffset*2 and - // ExprOffset*2 + 1. All other expreesion characters can produce only + // ExprOffset*2 + 1. All other expression characters can produce only // a single state. Thus ExprOffset = State/2. // // @@ -182,9 +182,9 @@ public static bool StrictMatchPattern(string expression, string name) // DestCount - Next location to put a matching assuming current name char // // NameFinished - Allows one more iteration through the Matches array - // after the name is exhusted (to come *s for example) + // after the name is exhausted (to come *s for example) // - // PreviousDestCount - This is used to prevent entry duplication, see coment + // PreviousDestCount - This is used to prevent entry duplication, see comment // // PreviousMatches - Holds the previous set of matches (the Src array) // @@ -235,7 +235,7 @@ public static bool StrictMatchPattern(string expression, string name) nameFinished = true; // - // if we have already exhasted the expression, C#. Don't + // if we have already exhausted the expression, C#. Don't // continue. // if (previousMatches[matchesCount - 1] == maxState) @@ -360,7 +360,7 @@ public static bool StrictMatchPattern(string expression, string name) { // // We are at a period. We can only match zero - // characters (ie. the epsilon transition). + // characters (i.e. the epsilon transition). // currentMatches[destCount++] = (currentState + 1); continue; @@ -451,10 +451,10 @@ public static bool StrictMatchPattern(string expression, string name) // // Prevent duplication in the destination array. // - // Each of the arrays is montonically increasing and non- + // Each of the arrays is monotonically increasing and non- // duplicating, thus we skip over any source element in the src // array if we just added the same element to the destination - // array. This guarentees non-duplication in the dest. array. + // array. This guarantees non-duplication in the dest. array. // if ((srcCount < matchesCount) && (previousDestCount < destCount)) diff --git a/src/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.Error.cs b/src/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.Error.cs index a8ec7027d7f6..62923235b187 100644 --- a/src/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.Error.cs +++ b/src/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.Error.cs @@ -31,7 +31,7 @@ public static void FileSystemWatcher_Error_File() }; watcher.EnableRaisingEvents = true; - // FSW works by calling ReadDirectoryChanges aynchronously, processing the changes + // FSW works by calling ReadDirectoryChanges asynchronously, processing the changes // in the callback and invoking event handlers from the callback serially. // After it processes all events for a particular callback it calls ReadDirectoryChanges // to queue another overlapped operation. diff --git a/src/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.InternalBufferSize.cs b/src/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.InternalBufferSize.cs index 4779d8a723b2..15ab1f2f2b28 100644 --- a/src/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.InternalBufferSize.cs +++ b/src/System.IO.FileSystem.Watcher/tests/FileSystemWatcher.InternalBufferSize.cs @@ -42,7 +42,7 @@ public static void FileSystemWatcher_InternalBufferSize_File() unblockHandler.Set(); Utility.ExpectEvent(eventOccurred, "error"); - // Update InternalBufferSize to accomadate the data + // Update InternalBufferSize to accommodate the data watcher.InternalBufferSize = watcher.InternalBufferSize * 2; unblockHandler.Reset(); diff --git a/src/System.IO.MemoryMappedFiles/src/Resources/Strings.resx b/src/System.IO.MemoryMappedFiles/src/Resources/Strings.resx index 9357c7090573..624c01678aec 100644 --- a/src/System.IO.MemoryMappedFiles/src/Resources/Strings.resx +++ b/src/System.IO.MemoryMappedFiles/src/Resources/Strings.resx @@ -184,7 +184,7 @@ A positive number is required. - The capacity must be greater than or equal to 0. 0 represents the the size of the file being mapped. + The capacity must be greater than or equal to 0. 0 represents the size of the file being mapped. The size must be greater than or equal to 0. If 0 is specified, the view extends from the specified offset to the end of the file mapping. diff --git a/src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs b/src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs index 344f0d5d0b7c..878cb223d630 100644 --- a/src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs +++ b/src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Unix.cs @@ -11,7 +11,7 @@ public partial class MemoryMappedFile { /// /// Used by the 2 Create factory method groups. A null fileHandle specifies that the - /// memory mapped file should not be associated with an existing file on disk (ie start + /// memory mapped file should not be associated with an existing file on disk (i.e. start /// out empty). /// [SecurityCritical] @@ -188,7 +188,7 @@ private static FileStream CreateSharedBackingObjectUsingMemory( try { - // Unlink the shared memory object immediatley so that it'll go away once all handles + // Unlink the shared memory object immediately so that it'll go away once all handles // to it are closed (as with opened then unlinked files, it'll remain usable via // the open handles even though it's unlinked and can't be opened anew via its name). Interop.CheckIo(Interop.Sys.ShmUnlink(mapName)); diff --git a/src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Windows.cs b/src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Windows.cs index 18848df110c4..3eb02979ecb8 100644 --- a/src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Windows.cs +++ b/src/System.IO.MemoryMappedFiles/src/System/IO/MemoryMappedFiles/MemoryMappedFile.Windows.cs @@ -14,7 +14,7 @@ public partial class MemoryMappedFile { /// /// Used by the 2 Create factory method groups. A null fileHandle specifies that the - /// memory mapped file should not be associated with an exsiting file on disk (ie start + /// memory mapped file should not be associated with an exsiting file on disk (i.e. start /// out empty). /// @@ -87,7 +87,7 @@ private static SafeMemoryMappedFileHandle CreateOrOpenCore( /// either create or open a memory mapped file up to a timeout. CreateFileMapping may fail /// if the file exists and we have non-null security attributes, in which case we need to /// use OpenFileMapping. But, there exists a race condition because the memory mapped file - /// may have closed inbetween the two calls -- hence the loop. + /// may have closed between the two calls -- hence the loop. /// /// The retry/timeout logic increases the wait time each pass through the loop and times /// out in approximately 1.4 minutes. If after retrying, a MMF handle still hasn't been opened, @@ -105,7 +105,7 @@ private static SafeMemoryMappedFileHandle CreateOrOpenCore( int waitRetries = 14; //((2^13)-1)*10ms == approximately 1.4mins int waitSleep = 0; - // keep looping until we've exhausted retries or break as soon we we get valid handle + // keep looping until we've exhausted retries or break as soon we get valid handle while (waitRetries > 0) { // try to create diff --git a/src/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateOrOpen.Tests.cs b/src/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateOrOpen.Tests.cs index cc507c27027b..1157be80c0ee 100644 --- a/src/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateOrOpen.Tests.cs +++ b/src/System.IO.MemoryMappedFiles/tests/MemoryMappedFile.CreateOrOpen.Tests.cs @@ -103,7 +103,7 @@ public void InvalidArgument_Inheritability(HandleInheritability inheritability) /// /// Test various combinations of arguments to CreateOrOpen, validating the created maps each time they're created, - /// focusing on on accesses that don't involve execute permissions. + /// focusing on accesses that don't involve execute permissions. /// [PlatformSpecific(PlatformID.Windows)] [Theory] @@ -164,7 +164,7 @@ public void ValidArgumentCombinations_NonExecute( /// /// Test various combinations of arguments to CreateOrOpen, validating the created maps each time they're created, - /// focusing on on accesses that involve execute permissions. + /// focusing on accesses that involve execute permissions. /// [PlatformSpecific(PlatformID.Windows)] [Theory] diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/CompressionOption.cs b/src/System.IO.Packaging/src/System/IO/Packaging/CompressionOption.cs index 987fdd5f95e1..69636b9b8aa9 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/CompressionOption.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/CompressionOption.cs @@ -23,7 +23,7 @@ public enum CompressionOption : int NotCompressed = -1, /// - /// Compression is optimized for a resonable compromise between size and performance. + /// Compression is optimized for a reasonable compromise between size and performance. /// Normal = 0, diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/ContentType.cs b/src/System.IO.Packaging/src/System/IO/Packaging/ContentType.cs index cc3780f21f40..ef515cd295b2 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/ContentType.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/ContentType.cs @@ -195,7 +195,7 @@ internal bool AreTypeAndSubTypeEqual(ContentType contentType) /// This method does a weak comparison of the content types. We only compare the /// type and subType values in an ASCII case-insensitive manner. /// Parameter and value pairs are not used for the comparison. - /// If you wish to compare the paramters too, then you must get the ParameterValuePairs from + /// If you wish to compare the parameters too, then you must get the ParameterValuePairs from /// both the ContentType objects and compare each parameter entry. /// The allowParameterValuePairs parameter is used to indicate whether the /// comparison is tolerant to parameters being present or no. @@ -471,9 +471,9 @@ private static string ValidateToken(string token) /// Validating if the value of a parameter is either a valid token or a /// valid quoted string /// - /// paramter value string + /// parameter value string /// validate parameter value string - /// If the paramter value is empty + /// If the parameter value is empty private static string ValidateQuotedStringOrToken(string parameterValue) { if (String.IsNullOrEmpty(parameterValue)) diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/InternalRelationshipCollection.cs b/src/System.IO.Packaging/src/System/IO/Packaging/InternalRelationshipCollection.cs index add4bcb915a4..5fdbf2085e17 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/InternalRelationshipCollection.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/InternalRelationshipCollection.cs @@ -43,7 +43,7 @@ IEnumerator IEnumerable.GetEnumerator() } /// - /// Returns an enumertor over all the relationships for a Package or a PackagePart + /// Returns an enumerator over all the relationships for a Package or a PackagePart /// /// IEnumerator IEnumerable.GetEnumerator() @@ -52,7 +52,7 @@ IEnumerator IEnumerable.GetEnumerator( } /// - /// Returns an enumertor over all the relationships for a Package or a PackagePart + /// Returns an enumerator over all the relationships for a Package or a PackagePart /// /// public List.Enumerator GetEnumerator() @@ -522,7 +522,7 @@ internal static void WriteRelationshipsAsXml(XmlWriter writer, IEnumerable 0, - "The partname may not be wellformed"); + "The partname may not be well-formed"); - // Get the parname without the last segment + // Get the partname without the last segment partName = partName.Substring(0, partName.Length - file.Length); partName = Path.Combine(partName, s_relationshipPartSegmentName, file); // Adding the "_rels" segment and the last segment back @@ -303,13 +303,13 @@ public static Uri GetSourcePartUriFromRelationshipPartUri(Uri relationshipPartUr string partNameWithoutExtension = Path.GetFileNameWithoutExtension(path); Debug.Assert((path.Length - partNameWithoutExtension.Length - s_relationshipPartExtensionName.Length - 1) > 0, - "The partname may not be wellformed"); + "The partname may not be well-formed"); //Get the part name without the last segment path = path.Substring(0, path.Length - partNameWithoutExtension.Length - s_relationshipPartExtensionName.Length - 1); Debug.Assert((path.Length - s_relationshipPartSegmentName.Length) > 0, - "The partname may not be wellformed"); + "The partname may not be well-formed"); path = path.Substring(0, path.Length - s_relationshipPartSegmentName.Length); // Removing rels segment path = Path.Combine(path, partNameWithoutExtension); // Adding the last segment without ".rels" extension @@ -486,7 +486,7 @@ private static Exception GetExceptionIfPartUriInvalid(Uri partUri, out string pa if (argumentException != null) return argumentException; - //We test if the URI is wellformed and refined. + //We test if the URI is well-formed and refined. //The relative URI that was passed to us may not be correctly escaped and so we test that. //Also there might be navigation "/../" present in the URI which we need to detect. string wellFormedPartName = @@ -604,7 +604,7 @@ private static string GetStringForPartUriFromAnyUri(Uri partUri) Uri safeUnescapedUri; // Step 1: Get the safe-unescaped form of the URI first. This will unescape all the characters - // that can be safely un-escaped, unreserved characters, unicode characters, etc. + // that can be safely un-escaped, unreserved characters, Unicode characters, etc. if (!partUri.IsAbsoluteUri) { //We assume a well formed part uri has been passed to this method @@ -863,7 +863,7 @@ private bool IsRelationshipUri() { bool result = false; - //exit early if the partUri does not end with the relationship extention + //exit early if the partUri does not end with the relationship extension if (!NormalizedPartUriString.EndsWith(s_relationshipPartUpperCaseExtension, StringComparison.Ordinal)) return false; @@ -916,7 +916,7 @@ private bool IsRelationshipUri() //Returns the normalized string for the part uri. //Currently normalizing the PartUriString consists of only one step - - //1. Take the wellformed and escaped partUri string and case fold to UpperInvariant + //1. Take the well-formed and escaped partUri string and case fold to UpperInvariant private string GetNormalizedPartUriString() { //Case Fold the partUri string to Invariant Upper case (this helps us perform case insensitive comparison) diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/Package.cs b/src/System.IO.Packaging/src/System/IO/Packaging/Package.cs index c9b6afeba6e1..aa365b16d85f 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/Package.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/Package.cs @@ -889,7 +889,7 @@ public static Package Open( if (packageMode == FileMode.Truncate) throw new NotSupportedException(SR.UnsupportedCombinationOfModeAccess); - //Note: FileShare enum is not being verfied at this stage, as we do not interpret the flag in this + //Note: FileShare enum is not being verified at this stage, as we do not interpret the flag in this //code at all and just pass it on to the next layer, where the necessary validation can be //performed. Also, there is no meaningful way to check this parameter at this layer, as the //FileShare enumeration is a set of flags and flags/Bit-fields can be combined using a diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/PackagePart.cs b/src/System.IO.Packaging/src/System/IO/Packaging/PackagePart.cs index b286def6a9c0..b67692902d23 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/PackagePart.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/PackagePart.cs @@ -661,7 +661,7 @@ internal void Close() if (_requestedStreams != null) { //Adding this extra check here to optimize delete operation - //Everytime we delete a part we close it before deleting to + //Every time we delete a part we close it before deleting to //ensure that its deleted in a valid state. However, we do not //need to persist any changes if the part is being deleted. if (!_deleted) diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/PackageRelationshipCollection.cs b/src/System.IO.Packaging/src/System/IO/Packaging/PackageRelationshipCollection.cs index 6f651b50864a..90d9229bf5a5 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/PackageRelationshipCollection.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/PackageRelationshipCollection.cs @@ -130,7 +130,7 @@ internal FilteredEnumerator(IEnumerator enumerator, string #region IEnumerator Methods /// - /// This method keeps moving the enumerator the the next position till + /// This method keeps moving the enumerator the next position till /// a relationship is found with the matching Name /// /// Bool indicating if the enumerator successfully moved to the next position diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/PackageRelationshipSelector.cs b/src/System.IO.Packaging/src/System/IO/Packaging/PackageRelationshipSelector.cs index 9b4b3eb19524..6d8bd5fc16f0 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/PackageRelationshipSelector.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/PackageRelationshipSelector.cs @@ -131,7 +131,7 @@ public string SelectionCriteria /// This method returns the list of selected PackageRelationships as per the /// given criteria, from a part in the Package provided /// - /// Package object from which we get the relationsips + /// Package object from which we get the relationships /// /// If package parameter is null public List Select(Package package) diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/PartBasedPackageProperties.cs b/src/System.IO.Packaging/src/System/IO/Packaging/PartBasedPackageProperties.cs index 85c58d27ca3e..336655ac61c4 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/PartBasedPackageProperties.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/PartBasedPackageProperties.cs @@ -636,7 +636,7 @@ private void ParseCorePropertyPart(PackagePart part) } // This method validates xsi:type="dcterms:W3CDTF" - // The valude of xsi:type is a qualified name. It should have a prefix that matches + // The value of xsi:type is a qualified name. It should have a prefix that matches // the xml namespace (ns) within the scope and the name that matches name // The comparisons should be case-sensitive comparisons internal static void ValidateXsiType(XmlReader reader, Object ns, string name) @@ -654,7 +654,7 @@ internal static void ValidateXsiType(XmlReader reader, Object ns, string name) int index = typeValue.IndexOf(':'); - // The valude of xsi:type is not a qualified name + // The value of xsi:type is not a qualified name if (index == -1) { throw new XmlException(SR.Format(SR.UnknownDCDateTimeXsiType, reader.Name), diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/XmlCompatibilityReader.cs b/src/System.IO.Packaging/src/System/IO/Packaging/XmlCompatibilityReader.cs index 61d3095a07f2..270e0c6a8f34 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/XmlCompatibilityReader.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/XmlCompatibilityReader.cs @@ -118,7 +118,7 @@ public void DeclareNamespaceCompatibility(string newNamespace, string oldNamespa { // if we are mapping what was used as a new namespace to a newer name, // scan the _newNamespaces dictionary and update the entries. We collect - // a list to avoid updating the dictonary during enumeration. + // a list to avoid updating the dictionary during enumeration. List keysToUpdate = new List(); foreach (KeyValuePair pair in _namespaceMap) diff --git a/src/System.IO.Packaging/src/System/IO/Packaging/ZipPackage.cs b/src/System.IO.Packaging/src/System/IO/Packaging/ZipPackage.cs index 1d36582b8365..e3c3b64d3d11 100644 --- a/src/System.IO.Packaging/src/System/IO/Packaging/ZipPackage.cs +++ b/src/System.IO.Packaging/src/System/IO/Packaging/ZipPackage.cs @@ -109,7 +109,7 @@ protected override PackagePart GetPartCore(Uri partUri) // underlying package by some other means, and the user wants to // access the updated part. This is currently not possible as the // underlying zip i/o layer does not allow for FileShare.ReadWrite. - // 2. Also, its not a straighforward task to determine if a new part was + // 2. Also, its not a straightforward task to determine if a new part was // added as we need to look for atomic as well as interleaved parts and // this has to be done in a case sensitive manner. So, effectively // we will have to go through the entire list of zip items to determine @@ -292,7 +292,7 @@ protected override void Dispose(bool disposing) /// /// File path to the container. /// Container is opened in the specified mode if possible - /// Container is opened with the speficied access if possible + /// Container is opened with the specified access if possible /// Container is opened with the specified share if possible internal ZipPackage(string path, FileMode packageFileMode, FileAccess packageFileAccess, FileShare share) @@ -556,7 +556,7 @@ static private CompressionOption GetCompressionOptionFromZipFileInfo(ZipArchiveE /// /// ExtensionComparer - /// The Extensions are stored in the Default Dicitonary in their original form, + /// The Extensions are stored in the Default Dictionary in their original form, /// however they are compared in a normalized manner. /// Equivalence for extensions in the content type stream, should follow /// the same rules as extensions of partnames. Also, by the time this code is invoked, @@ -568,8 +568,8 @@ private sealed class ExtensionEqualityComparer : IEqualityComparer { bool IEqualityComparer.Equals(string extensionA, string extensionB) { - Debug.Assert(extensionA != null, "extenstion should not be null"); - Debug.Assert(extensionB != null, "extenstion should not be null"); + Debug.Assert(extensionA != null, "extension should not be null"); + Debug.Assert(extensionB != null, "extension should not be null"); //Important Note: any change to this should be made in accordance //with the rules for comparing/normalizing partnames. @@ -580,7 +580,7 @@ bool IEqualityComparer.Equals(string extensionA, string extensionB) int IEqualityComparer.GetHashCode(string extension) { - Debug.Assert(extension != null, "extenstion should not be null"); + Debug.Assert(extension != null, "extension should not be null"); //Important Note: any change to this should be made in accordance //with the rules for comparing/normalizing partnames. diff --git a/src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.Windows.cs b/src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.Windows.cs index 6b3ff7390dbb..2a0e6afe75c8 100644 --- a/src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.Windows.cs +++ b/src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeClientStream.Windows.cs @@ -18,7 +18,7 @@ namespace System.IO.Pipes public sealed partial class NamedPipeClientStream : PipeStream { // Waits for a pipe instance to become available. This method may return before WaitForConnection is called - // on the server end, but WaitForConnection will not return until we have returned. Any data writen to the + // on the server end, but WaitForConnection will not return until we have returned. Any data written to the // pipe by us after we have connected but before the server has called WaitForConnection will be available // to the server after it calls WaitForConnection. [SecurityCritical] diff --git a/src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs b/src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs index d60d4e6807f0..057f4afb9738 100644 --- a/src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs +++ b/src/System.IO.Pipes/src/System/IO/Pipes/NamedPipeServerStream.cs @@ -68,7 +68,7 @@ public NamedPipeServerStream(String pipeName, PipeDirection direction, int maxNu /// Win32 note: this gets used for dwPipeMode. CreateNamedPipe allows you to specify PIPE_TYPE_BYTE/MESSAGE /// and PIPE_READMODE_BYTE/MESSAGE independently, but this sets type and readmode to match. /// - /// PipeOption enum: None, Asynchronous, or Writethrough + /// PipeOption enum: None, Asynchronous, or Write-through /// Win32 note: this gets passed in with dwOpenMode to CreateNamedPipe. Asynchronous corresponds to /// FILE_FLAG_OVERLAPPED option. PipeOptions enum doesn't expose FIRST_PIPE_INSTANCE option because /// this sets that automatically based on the number of instances specified. diff --git a/src/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs b/src/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs index b91d954fca9a..574b9a5bbffc 100644 --- a/src/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs +++ b/src/System.IO.Pipes/tests/NamedPipeTests/NamedPipeTest.Specific.cs @@ -35,7 +35,7 @@ public async Task ConnectToNonExistentServer_Throws_TimeoutException() var ctx = new CancellationTokenSource(); Assert.Throws(() => client.Connect(60)); // 60 to be over internal 50 interval await Assert.ThrowsAsync(() => client.ConnectAsync(50)); - await Assert.ThrowsAsync(() => client.ConnectAsync(60, ctx.Token)); // testing Token overload; ctx is not cancelled in this test + await Assert.ThrowsAsync(() => client.ConnectAsync(60, ctx.Token)); // testing Token overload; ctx is not canceled in this test } } diff --git a/src/System.IO.Pipes/tests/PipeTest.Read.cs b/src/System.IO.Pipes/tests/PipeTest.Read.cs index 2354b896c5a5..f09e17230e72 100644 --- a/src/System.IO.Pipes/tests/PipeTest.Read.cs +++ b/src/System.IO.Pipes/tests/PipeTest.Read.cs @@ -287,7 +287,7 @@ public async Task AsyncReadWriteChain_ReadWrite(int iterations, int writeBufferS using (ServerClientPair pair = CreateServerClientPair()) { - // Repeatedly and asynchronously write to the writeable pipe and read from the readable pipe, + // Repeatedly and asynchronously write to the writable pipe and read from the readable pipe, // verifying that the correct data made it through. for (int iter = 0; iter < iterations; iter++) { diff --git a/src/System.IO.UnmanagedMemoryStream/src/System/IO/UnmanagedMemoryAccessor.cs b/src/System.IO.UnmanagedMemoryStream/src/System/IO/UnmanagedMemoryAccessor.cs index 01a21533205b..a15fda8c960d 100644 --- a/src/System.IO.UnmanagedMemoryStream/src/System/IO/UnmanagedMemoryAccessor.cs +++ b/src/System.IO.UnmanagedMemoryStream/src/System/IO/UnmanagedMemoryAccessor.cs @@ -699,7 +699,7 @@ public UInt64 ReadUInt64(Int64 position) // ************** Write Methods ****************/ - // The following 13 WriteXXX methods write a value of type XXX into unmanaged memory at 'positon'. + // The following 13 WriteXXX methods write a value of type XXX into unmanaged memory at 'position'. // The bounds of the unmanaged memory are checked against to ensure that there is enough // space after 'position' to write a value of type XXX. XXX can be a bool, byte, char, decimal, // double, short, int, long, sbyte, float, ushort, uint, or ulong. @@ -1249,7 +1249,7 @@ private byte InternalReadByte(Int64 position) [System.Security.SecuritySafeCritical] // auto-generated private void InternalWrite(Int64 position, byte value) { - Debug.Assert(CanWrite, "UMA not writeable"); + Debug.Assert(CanWrite, "UMA not writable"); Debug.Assert(position >= 0, "position less than 0"); Debug.Assert(position <= _capacity - sizeof(byte), "position is greater than capacity - sizeof(byte)"); diff --git a/src/System.IO.UnmanagedMemoryStream/src/System/IO/UnmanagedMemoryStream.cs b/src/System.IO.UnmanagedMemoryStream/src/System/IO/UnmanagedMemoryStream.cs index e9f9fdc3de48..e1f30d799025 100644 --- a/src/System.IO.UnmanagedMemoryStream/src/System/IO/UnmanagedMemoryStream.cs +++ b/src/System.IO.UnmanagedMemoryStream/src/System/IO/UnmanagedMemoryStream.cs @@ -29,7 +29,7 @@ namespace System.IO * * It may become necessary to add in some sort of * DeallocationMode enum, specifying whether we unmap a section of memory, - * call free, run a user-provided delegate to free the memory, etc etc. + * call free, run a user-provided delegate to free the memory, etc. * We'll suggest user write a subclass of UnmanagedMemoryStream that uses * a SafeHandle subclass to hold onto the memory. * Check for problems when using this in the negative parts of a @@ -62,7 +62,7 @@ namespace System.IO * a. a race condition in WriteX that could have allowed a thread to * read from unzeroed memory was fixed * b. memory region cannot be expanded beyond _capacity; in other - * words, a UMS creator is saying a writeable UMS is safe to + * words, a UMS creator is saying a writable UMS is safe to * write to anywhere in the memory range up to _capacity, specified * in the ctor. Even if the caller doesn't specify a capacity, then * length is used as the capacity. @@ -497,7 +497,7 @@ public override int Read([In, Out] byte[] buffer, int offset, int count) /// Buffer to read the bytes to. /// Starting index in the buffer. /// Maximum number of bytes to read. - /// Token that can be used to cancell this operation. + /// Token that can be used to cancel this operation. /// Task that can be used to access the number of bytes actually read. public override Task ReadAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) { @@ -574,7 +574,7 @@ public override int ReadByte() } /// - /// Advanced the Position to specifice location in the stream. + /// Advanced the Position to specific location in the stream. /// /// Offset from the loc parameter. /// Origin for the offset parameter. @@ -742,7 +742,7 @@ public override void Write(byte[] buffer, int offset, int count) /// Buffer that will be written. /// Starting index in the buffer. /// Number of bytes to write. - /// Token that can be used to cancell the operation. + /// Token that can be used to cancel the operation. /// Task that can be awaited public override Task WriteAsync(Byte[] buffer, Int32 offset, Int32 count, CancellationToken cancellationToken) { diff --git a/src/System.IO.UnmanagedMemoryStream/tests/UmsTests.cs b/src/System.IO.UnmanagedMemoryStream/tests/UmsTests.cs index 3b4cc7ec3f64..a2e716b68259 100644 --- a/src/System.IO.UnmanagedMemoryStream/tests/UmsTests.cs +++ b/src/System.IO.UnmanagedMemoryStream/tests/UmsTests.cs @@ -234,7 +234,7 @@ public static void CopyToTest() Assert.Throws(() => ums.CopyTo(destination)); } - // copying to non-writeable stream should throw + // copying to non-writable stream should throw using (var manager = new UmsManager(FileAccess.Read, testData)) { UnmanagedMemoryStream ums = manager.Stream; @@ -307,7 +307,7 @@ public static async Task CopyToAsyncTest() await Assert.ThrowsAsync(() => ums.CopyToAsync(destination)); } - // cpoying to non-writeable stream should throw + // copying to non-writable stream should throw using (var manager = new UmsManager(FileAccess.Read, testData)) { UnmanagedMemoryStream ums = manager.Stream; diff --git a/src/System.IO/src/System/IO/BinaryReader.cs b/src/System.IO/src/System/IO/BinaryReader.cs index e0139da3ada0..4c8a6d638b03 100644 --- a/src/System.IO/src/System/IO/BinaryReader.cs +++ b/src/System.IO/src/System/IO/BinaryReader.cs @@ -451,7 +451,7 @@ private int InternalReadOneChar() if (_charBytes == null) { - _charBytes = new byte[MaxCharBytesSize]; //REVIEW: We need atmost 2 bytes/char here? + _charBytes = new byte[MaxCharBytesSize]; //REVIEW: We need at most 2 bytes/char here? } if (_singleChar == null) { diff --git a/src/System.IO/src/System/IO/BufferedStream.cs b/src/System.IO/src/System/IO/BufferedStream.cs index f16f6d1a3b9d..b2b7af9fd35a 100644 --- a/src/System.IO/src/System/IO/BufferedStream.cs +++ b/src/System.IO/src/System/IO/BufferedStream.cs @@ -257,7 +257,7 @@ public override void Flush() { // If the underlying stream is not seekable AND we have something in the read buffer, then FlushRead would throw. // We can either throw away the buffer resulting in data loss (!) or ignore the Flush. - // (We cannot throw becasue it would be a breaking change.) We opt into ignoring the Flush in that situation. + // (We cannot throw because it would be a breaking change.) We opt into ignoring the Flush in that situation. if (!_stream.CanSeek) return; @@ -308,7 +308,7 @@ private async Task FlushAsyncInternal(CancellationToken cancellationToken) if (_readPos < _readLen) { // If the underlying stream is not seekable AND we have something in the read buffer, then FlushRead would throw. - // We can either throw away the buffer resulting in date loss (!) or ignore the Flush. (We cannot throw becasue it + // We can either throw away the buffer resulting in date loss (!) or ignore the Flush. (We cannot throw because it // would be a breaking change.) We opt into ignoring the Flush in that situation. if (!_stream.CanSeek) return; @@ -548,7 +548,7 @@ public override Task ReadAsync(byte[] buffer, int offset, int count, Cancel Exception error; bytesFromBuffer = ReadFromBuffer(buffer, offset, count, out error); - // If we satistied enough data from the buffer, we can complete synchronously. + // If we satisfied enough data from the buffer, we can complete synchronously. // Reading again for more data may cause us to block if we're using a device with no clear end of file, // such as a serial port or pipe. If we blocked here and this code was used with redirected pipes for a // process's standard output, this can lead to deadlocks involving two processes. diff --git a/src/System.IO/src/System/IO/MemoryStream.cs b/src/System.IO/src/System/IO/MemoryStream.cs index 6aecc256e038..1d125422246a 100644 --- a/src/System.IO/src/System/IO/MemoryStream.cs +++ b/src/System.IO/src/System/IO/MemoryStream.cs @@ -9,7 +9,7 @@ namespace System.IO { - // A MemoryStream represents a Stream in memory (ie, it has no backing store). + // A MemoryStream represents a Stream in memory (i.e, it has no backing store). // This stream may reduce the need for temporary buffers and files in // an application. // @@ -33,7 +33,7 @@ public class MemoryStream : Stream private bool _isOpen; // Is this stream open or closed? // In V2, if we get support for arrays of more than 2 GB worth of elements, - // consider removing this constraing, or setting it to Int64.MaxValue. + // consider removing this constraint, or setting it to Int64.MaxValue. private const int MemStreamMaxLength = int.MaxValue; public MemoryStream() @@ -467,7 +467,7 @@ public override int ReadByte() public override Task CopyToAsync(Stream destination, int bufferSize, CancellationToken cancellationToken) { - // This implementation offers beter performance compared to the base class version. + // This implementation offers better performance compared to the base class version. // The parameter checks must be in sync with the base version: if (destination == null) @@ -496,7 +496,7 @@ public override Task CopyToAsync(Stream destination, int bufferSize, Cancellatio } // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Read() or Write() which a subclass might have overriden. + // since it does not call through to Read() or Write() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Read/Write) when we are not sure. if (GetType() != typeof(MemoryStream)) diff --git a/src/System.IO/src/System/IO/StreamReader.cs b/src/System.IO/src/System/IO/StreamReader.cs index 1db8aaca3746..8042b1fb5aec 100644 --- a/src/System.IO/src/System/IO/StreamReader.cs +++ b/src/System.IO/src/System/IO/StreamReader.cs @@ -584,7 +584,7 @@ internal virtual int ReadBuffer() _isBlocked = (_byteLen < _byteBuffer.Length); // Check for preamble before detect encoding. This is not to override the - // user suppplied Encoding for the one we implicitly detect. The user could + // user supplied Encoding for the one we implicitly detect. The user could // customize the encoding which we will loose, such as ThrowOnError on UTF8 if (IsPreamble()) { @@ -690,7 +690,7 @@ private int ReadBuffer(char[] userBuffer, int userOffset, int desiredChars, out _isBlocked = (_byteLen < _byteBuffer.Length); // Check for preamble before detect encoding. This is not to override the - // user suppplied Encoding for the one we implicitly detect. The user could + // user supplied Encoding for the one we implicitly detect. The user could // customize the encoding which we will loose, such as ThrowOnError on UTF8 // Note: we don't need to recompute readToUserBuffer optimization as IsPreamble // doesn't change the encoding or affect _maxCharsPerBuffer @@ -797,7 +797,7 @@ public override string ReadLine() public override Task ReadLineAsync() { // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Read() which a subclass might have overriden. + // since it does not call through to Read() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Read) when we are not sure. if (GetType() != typeof(StreamReader)) @@ -885,7 +885,7 @@ private async Task ReadLineAsyncInternal() public override Task ReadToEndAsync() { // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Read() which a subclass might have overriden. + // since it does not call through to Read() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Read) when we are not sure. if (GetType() != typeof(StreamReader)) @@ -937,7 +937,7 @@ public override Task ReadAsync(char[] buffer, int index, int count) } // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Read() which a subclass might have overriden. + // since it does not call through to Read() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Read) when we are not sure. if (GetType() != typeof(StreamReader)) @@ -976,7 +976,7 @@ internal override async Task ReadAsyncInternal(char[] buffer, int index, in while (count > 0) { - // n is the characeters avaialbe in _charBuffer + // n is the characters available in _charBuffer int n = CharLen_Prop - CharPos_Prop; // charBuffer is empty, let's read from the stream @@ -1055,7 +1055,7 @@ internal override async Task ReadAsyncInternal(char[] buffer, int index, in IsBlocked_Prop = (ByteLen_Prop < tmpByteBuffer.Length); // Check for preamble before detect encoding. This is not to override the - // user suppplied Encoding for the one we implicitly detect. The user could + // user supplied Encoding for the one we implicitly detect. The user could // customize the encoding which we will loose, such as ThrowOnError on UTF8 // Note: we don't need to recompute readToUserBuffer optimization as IsPreamble // doesn't change the encoding or affect _maxCharsPerBuffer @@ -1144,7 +1144,7 @@ public override Task ReadBlockAsync(char[] buffer, int index, int count) } // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Read() which a subclass might have overriden. + // since it does not call through to Read() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Read) when we are not sure. if (GetType() != typeof(StreamReader)) @@ -1297,7 +1297,7 @@ private async Task ReadBufferAsync() IsBlocked_Prop = (ByteLen_Prop < tmpByteBuffer.Length); // Check for preamble before detect encoding. This is not to override the - // user suppplied Encoding for the one we implicitly detect. The user could + // user supplied Encoding for the one we implicitly detect. The user could // customize the encoding which we will loose, such as ThrowOnError on UTF8 if (IsPreamble()) { diff --git a/src/System.IO/src/System/IO/StreamWriter.cs b/src/System.IO/src/System/IO/StreamWriter.cs index 1e31ca6846cd..c7c012613f32 100644 --- a/src/System.IO/src/System/IO/StreamWriter.cs +++ b/src/System.IO/src/System/IO/StreamWriter.cs @@ -425,7 +425,7 @@ public override void Write(string value) public override Task WriteAsync(char value) { // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Write() which a subclass might have overriden. + // since it does not call through to Write() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Write) when we are not sure. if (GetType() != typeof(StreamWriter)) @@ -492,7 +492,7 @@ private static async Task WriteAsyncInternal(StreamWriter _this, char value, public override Task WriteAsync(string value) { // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Write() which a subclass might have overriden. + // since it does not call through to Write() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Write) when we are not sure. if (GetType() != typeof(StreamWriter)) @@ -602,7 +602,7 @@ public override Task WriteAsync(char[] buffer, int index, int count) } // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Write() which a subclass might have overriden. + // since it does not call through to Write() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Write) when we are not sure. if (GetType() != typeof(StreamWriter)) @@ -688,7 +688,7 @@ private static async Task WriteAsyncInternal(StreamWriter _this, char[] buffer, public override Task WriteLineAsync() { // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Write() which a subclass might have overriden. + // since it does not call through to Write() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Write) when we are not sure. if (GetType() != typeof(StreamWriter)) @@ -713,7 +713,7 @@ public override Task WriteLineAsync() public override Task WriteLineAsync(char value) { // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Write() which a subclass might have overriden. + // since it does not call through to Write() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Write) when we are not sure. if (GetType() != typeof(StreamWriter)) @@ -738,7 +738,7 @@ public override Task WriteLineAsync(char value) public override Task WriteLineAsync(string value) { // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Write() which a subclass might have overriden. + // since it does not call through to Write() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Write) when we are not sure. if (GetType() != typeof(StreamWriter)) @@ -780,7 +780,7 @@ public override Task WriteLineAsync(char[] buffer, int index, int count) } // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Write() which a subclass might have overriden. + // since it does not call through to Write() which a subclass might have overridden. // To be safe we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Write) when we are not sure. if (GetType() != typeof(StreamWriter)) @@ -805,7 +805,7 @@ public override Task WriteLineAsync(char[] buffer, int index, int count) public override Task FlushAsync() { // If we have been inherited into a subclass, the following implementation could be incorrect - // since it does not call through to Flush() which a subclass might have overriden. To be safe + // since it does not call through to Flush() which a subclass might have overridden. To be safe // we will only use this implementation in cases where we know it is safe to do so, // and delegate to our base class (which will call into Flush) when we are not sure. if (GetType() != typeof(StreamWriter)) diff --git a/src/System.Text.Encoding.CodePages/src/System/Text/EUCJPEncoding.cs b/src/System.Text.Encoding.CodePages/src/System/Text/EUCJPEncoding.cs index 84fe6575cce1..f3ce363409e5 100644 --- a/src/System.Text.Encoding.CodePages/src/System/Text/EUCJPEncoding.cs +++ b/src/System.Text.Encoding.CodePages/src/System/Text/EUCJPEncoding.cs @@ -33,7 +33,7 @@ // // Regarding Normalization: // Forms KC & KD are precluded because of things like halfwidth Katakana that has compatibility mappings -// Form D is precluded because of 0x00a8, which changes to space + dierises. +// Form D is precluded because of 0x00a8, which changes to space + dieresis. // // I think that IsAlwaysNormalized should probably return true for form C (but not certain) // diff --git a/src/System.Text.Encoding.CodePages/src/System/Text/ISCIIEncoding.cs b/src/System.Text.Encoding.CodePages/src/System/Text/ISCIIEncoding.cs index 2a82d1203215..b8c7009d7fda 100644 --- a/src/System.Text.Encoding.CodePages/src/System/Text/ISCIIEncoding.cs +++ b/src/System.Text.Encoding.CodePages/src/System/Text/ISCIIEncoding.cs @@ -183,7 +183,7 @@ public override unsafe int GetBytes(char* chars, int charCount, byte* bytes, int continue; } - // See if its outside of the Indic script Range range + // See if its outside of the Indic script range if ((ch < IndicBegin) || (ch > IndicEnd)) { // See if its a ZWJ or ZWNJ and if we has bLastVirama; diff --git a/src/System.Text.Encoding.CodePages/src/System/Text/ISO2022Encoding.cs b/src/System.Text.Encoding.CodePages/src/System/Text/ISO2022Encoding.cs index 3cf9041e1146..1f28c4cc50ce 100644 --- a/src/System.Text.Encoding.CodePages/src/System/Text/ISO2022Encoding.cs +++ b/src/System.Text.Encoding.CodePages/src/System/Text/ISO2022Encoding.cs @@ -17,7 +17,7 @@ // IsAlwaysNormalized ??? // Regarding Normalization for ISO-2022-JP (50220, 50221, 50222), its the same rules as EUCJP // Forms KC & KD are precluded because of things like halfwidth Katakana that has compatibility mappings -// Form D is precluded because of 0x00a8, which changes to space + dierises. +// Form D is precluded because of 0x00a8, which changes to space + dieresis. // // Note: I think that IsAlwaysNormalized should probably return true for form C for Japanese 20932 based CPs. // @@ -27,7 +27,7 @@ // IsAlwaysNormalized ??? // Regarding Normalization for ISO-2022-CN (50227, 50229) & HZ-GB2312 (52936) I think is similar to the Japanese case. // Forms KC & KD are precluded because of things like halfwidth Katakana that has compatibility mappings -// Form D is precluded because of 0x00a8, which changes to space + dierises. +// Form D is precluded because of 0x00a8, which changes to space + dieresis. // // Note: I think that IsAlwaysNormalized should probably return true for form C for Chinese 20936 based CPs. // @@ -1041,7 +1041,7 @@ private unsafe int GetCharsCP5022xJP(byte* bytes, int byteCount, // MLang treated JIS 0208 '*' lead byte like a single halfwidth katakana // escape, so use 0x8e00 as katakana lead byte and keep same trail byte. // 0x2a lead byte range is normally unused in JIS 0208, so shouldn't have - // any wierd compatibility issues. + // any weird compatibility issues. if ((b2Bytes == true) && ((iBytes & 0xff00) == 0x2a00)) { iBytes = (ushort)(iBytes & 0xff); diff --git a/src/System.Text.Encoding.CodePages/src/System/Text/SBCSCodePageEncoding.cs b/src/System.Text.Encoding.CodePages/src/System/Text/SBCSCodePageEncoding.cs index fb34999b74e8..1c7d0b87d01c 100644 --- a/src/System.Text.Encoding.CodePages/src/System/Text/SBCSCodePageEncoding.cs +++ b/src/System.Text.Encoding.CodePages/src/System/Text/SBCSCodePageEncoding.cs @@ -957,7 +957,7 @@ public override int GetMaxCharCount(int byteCount) return (int)charCount; } - // True if and only if the encoding only uses single byte code points. (Ie, ASCII, 1252, etc) + // True if and only if the encoding only uses single byte code points. (i.e. ASCII, 1252, etc) public override bool IsSingleByte { get diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Bits.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Bits.cs index f2f1da76e9bf..1f0f6cc5b59b 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Bits.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Bits.cs @@ -44,7 +44,7 @@ public static bool ExactlyOne(uint num) /// - /// Compute the 1-based position of the least sigificant bit that is set, and return it (return 0 if no bits are set). + /// Compute the 1-based position of the least significant bit that is set, and return it (return 0 if no bits are set). /// (e.g. 0x1001100 will return 3, since the 3rd bit is set). /// public static int LeastPosition(uint num) diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/BufferBuilder.cs b/src/System.Xml.ReaderWriter/src/System/Xml/BufferBuilder.cs index d8aabd58afd1..4867edb487ff 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/BufferBuilder.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/BufferBuilder.cs @@ -18,11 +18,11 @@ namespace System.Xml // BufferBuilder is a replacement for StringBuilder for cases when large strings can occur. // StringBuilder stores the string that is being built in one large chunk of memory. If it needs more memory, // it allocates a new chunk of double size and copies the data into it. This results in bad perf and - // memory constumption in case the string is very large (>85kB). Large objects are allocated on Large Object + // memory consumption in case the string is very large (>85kB). Large objects are allocated on Large Object // Heap and are not freed by GC as fast as smaller objects. // // BufferBuilder uses a StringBuilder as long as the stored string is smaller that 64kB. If the final string - // should be bigger that that, it stores the data in a list of char[] arrays. A StringBuilder object still needs to be + // should be bigger than that, it stores the data in a list of char[] arrays. A StringBuilder object still needs to be // used in order to create the final string in ToString methods, but this is ok since at that point // we already know the resulting string length and we can initialize the StringBuilder with the correct // capacity. diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/CharEntityEncoderFallback.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/CharEntityEncoderFallback.cs index 5a482cf780a2..9a9766d7dc81 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/CharEntityEncoderFallback.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/CharEntityEncoderFallback.cs @@ -145,7 +145,7 @@ public override bool Fallback(char charUnknownHigh, char charUnknownLow, int ind public override char GetNextChar() { // The protocol using GetNextChar() and MovePrevious() called by Encoder is not well documented. - // Here we have to to signal to Encoder that the previous read was last character. Only AFTER we can + // Here we have to signal to Encoder that the previous read was last character. Only AFTER we can // mark ourself as done (-1). Otherwise MovePrevious() can still be called, but -1 is already incorrectly set // and return false from MovePrevious(). Then Encoder swallowing the rest of the bytes. if (_charEntityIndex == _charEntity.Length) diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/DtdProcessing.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/DtdProcessing.cs index 0cb0d796526e..74c8bdf1a86a 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/DtdProcessing.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/DtdProcessing.cs @@ -4,7 +4,7 @@ namespace System.Xml { - // DtdProcessing enumerations speficies how will an XmlReader handle DTDs in the XML document. + // DtdProcessing enumerations specifies how will an XmlReader handle DTDs in the XML document. // // Prohibit The XmlReader will throw an exception when it finds a '' character. If WriteEndElement is called and no other characters have been - // output, then the '>' character can be be overwritten with the shortcut syntax " />". + // output, then the '>' character can be overwritten with the shortcut syntax " />". contentPos = bufPos; } diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlTextReaderImpl.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlTextReaderImpl.cs index 7bd7b87d2700..928cd738a266 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlTextReaderImpl.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlTextReaderImpl.cs @@ -112,7 +112,7 @@ private enum IncrementalReadState #region Later Init Fileds - //later init means in the construction stage, do not opend filestream and do not read any data from Stream/TextReader + //later init means in the construction stage, do not open filestream and do not read any data from Stream/TextReader //the purpose is to make the Create of XmlReader do not block on IO. private class LaterInitParam { @@ -253,7 +253,7 @@ private enum InitInputType // Outer XmlReader exposed to the user - either XmlTextReader or XmlTextReaderImpl (when created via XmlReader.Create). // Virtual methods called from within XmlTextReaderImpl must be called on the outer reader so in case the user overrides - // some of the XmlTextReader methods we will call the overriden version. + // some of the XmlTextReader methods we will call the overridden version. private XmlReader _outerReader; @@ -4232,7 +4232,7 @@ private void ParseAttributeValueSlow(int curPos, char quoteChar, NodeData attr) case '<': Throw(pos, SR.Xml_BadAttributeChar, XmlException.BuildCharExceptionArgs('<', '\0')); break; - // entity referece + // entity reference case '&': if (pos - _ps.charPos > 0) { @@ -5351,7 +5351,7 @@ private bool ParseCDataOrComment(XmlNodeType type, out int outStartPos, out int pos++; } - // posibbly end of comment or cdata section + // possibly end of comment or cdata section if (chars[pos] == stopChar) { if (chars[pos + 1] == stopChar) @@ -6890,7 +6890,7 @@ private void RegisterEntity(IDtdEntityInfo entity) _ps.entity = entity; _ps.entityId = _nextEntityId++; - // register entity for recursion checkes + // register entity for recursion checks if (entity != null) { if (_currentEntities == null) @@ -7521,7 +7521,7 @@ private bool UriEqual(Uri uri1, string uri1Str, string uri2Str, XmlResolver reso /// /// This method should be called every time the reader is about to consume some number of - /// characters from the input. It will count it agains the security counters and + /// characters from the input. It will count it against the security counters and /// may throw if some of the security limits are exceeded. /// /// Number of characters to be consumed. diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlTextReaderImplAsync.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlTextReaderImplAsync.cs index 32ac9f8decd6..d5727034db81 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlTextReaderImplAsync.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlTextReaderImplAsync.cs @@ -2658,7 +2658,7 @@ private async Task ParseAttributeValueSlowAsync(int curPos, char quoteChar, Node case '<': Throw(pos, SR.Xml_BadAttributeChar, XmlException.BuildCharExceptionArgs('<', '\0')); break; - // entity referece + // entity reference case '&': if (pos - _ps.charPos > 0) { @@ -4009,7 +4009,7 @@ private async Task> ParseCDataOrCommentTupleAsync(Xml pos++; } - // posibbly end of comment or cdata section + // possibly end of comment or cdata section if (chars[pos] == stopChar) { if (chars[pos + 1] == stopChar) diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlUtf8RawTextWriter.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlUtf8RawTextWriter.cs index 3f56fea39723..7e1f2bef6a57 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlUtf8RawTextWriter.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlUtf8RawTextWriter.cs @@ -244,7 +244,7 @@ internal override void StartElementContent() // StartElementContent is always called; therefore, in order to allow shortcut syntax, we save the // position of the '>' character. If WriteEndElement is called and no other characters have been - // output, then the '>' character can be be overwritten with the shortcut syntax " />". + // output, then the '>' character can be overwritten with the shortcut syntax " />". contentPos = bufPos; } diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWellformedWriter.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWellformedWriter.cs index c710138d937e..319a1d8c6949 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWellformedWriter.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWellformedWriter.cs @@ -1755,7 +1755,7 @@ private void PushNamespaceImplicit(string prefix, string ns) } // PushNamespaceExplicit is called when a namespace declaration is written out; - // It returs true if the namespace declaration should we written out, false if it should be omited (if OmitDuplicateNamespaceDeclarations is true) + // It returns true if the namespace declaration should we written out, false if it should be omitted (if OmitDuplicateNamespaceDeclarations is true) private bool PushNamespaceExplicit(string prefix, string ns) { bool writeItOut = true; @@ -2189,7 +2189,7 @@ private static Exception InvalidCharsException(string name, int badCharIndex) return new ArgumentException(SR.Format(SR.Xml_InvalidNameCharsDetail, args)); } - // This method translates speficic state transition errors in more friendly error messages + // This method translates specific state transition errors in more friendly error messages private void ThrowInvalidStateTransition(Token token, State currentState) { string wrongTokenMessage = SR.Format(SR.Xml_WrongToken, tokenName[(int)token], GetStateName(currentState)); diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWellformedWriterHelpers.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWellformedWriterHelpers.cs index a4ee7e890f6d..2e5ff81cf2f1 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWellformedWriterHelpers.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWellformedWriterHelpers.cs @@ -385,7 +385,7 @@ internal void Replay(XmlWriter writer) } } - // This method trims whitespaces from the beginnig and the end of the string and cached writer events + // This method trims whitespaces from the beginning and the end of the string and cached writer events internal void Trim() { // if only one string value -> trim the write spaces directly diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWriter.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWriter.cs index eb3636001ad1..19f1203dbebe 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWriter.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWriter.cs @@ -48,7 +48,7 @@ public abstract partial class XmlWriter : IDisposable // Constants private const int WriteNodeBufferSize = 1024; - // Returns the settings describing the features of the the writer. Returns null for V1 XmlWriters (XmlTextWriter). + // Returns the settings describing the features of the writer. Returns null for V1 XmlWriters (XmlTextWriter). public virtual XmlWriterSettings Settings { get @@ -62,7 +62,7 @@ public virtual XmlWriterSettings Settings public abstract void WriteStartDocument(); - //Writes out the XML declaration with the version "1.0" and the speficied standalone attribute. + //Writes out the XML declaration with the version "1.0" and the specified standalone attribute. public abstract void WriteStartDocument(bool standalone); diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWriterAsync.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWriterAsync.cs index a018c6c13f2d..28d8ed8d9435 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWriterAsync.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Core/XmlWriterAsync.cs @@ -27,7 +27,7 @@ public virtual Task WriteStartDocumentAsync() throw NotImplemented.ByDesign; } - //Writes out the XML declaration with the version "1.0" and the speficied standalone attribute. + //Writes out the XML declaration with the version "1.0" and the specified standalone attribute. public virtual Task WriteStartDocumentAsync(bool standalone) { diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Schema/DtdParser.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Schema/DtdParser.cs index d4995233f35a..de50a9bbea07 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Schema/DtdParser.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Schema/DtdParser.cs @@ -2936,13 +2936,13 @@ private string GetValue() private string GetValueWithStrippedSpaces() { Debug.Assert(_curPos == 0 || _chars[_curPos - 1] == '"' || _chars[_curPos - 1] == '\''); - // We cannot StripSpaces directly in the buffer - we need the original value inthe buffer intact so that the internal subset value is correct + // We cannot StripSpaces directly in the buffer - we need the original value in the buffer intact so that the internal subset value is correct string val = (_stringBuilder.Length == 0) ? new string(_chars, _tokenStartPos, _curPos - _tokenStartPos - 1) : _stringBuilder.ToString(); return StripSpaces(val); } // - // Parsing buffer maintainance methods + // Parsing buffer maintenance methods // private int ReadData() { diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Schema/SchemaEntity.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Schema/SchemaEntity.cs index 9ad74800a692..3acdfbcf717f 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Schema/SchemaEntity.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Schema/SchemaEntity.cs @@ -15,7 +15,7 @@ internal sealed class SchemaEntity : IDtdEntityInfo private String _text; // Text for internal entity private XmlQualifiedName _ndata = XmlQualifiedName.Empty; // NDATA identifier private int _lineNumber; // line number - private int _linePosition; // character postion + private int _linePosition; // character position private bool _isParameter; // parameter entity flag private bool _isExternal; // external entity flag private bool _parsingInProgress; // whether entity is being parsed (DtdParser infinite recursion check) diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/Schema/XmlUntypedStringConverter.cs b/src/System.Xml.ReaderWriter/src/System/Xml/Schema/XmlUntypedStringConverter.cs index 61150fab1a13..2ee6bdf37911 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/Schema/XmlUntypedStringConverter.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/Schema/XmlUntypedStringConverter.cs @@ -44,7 +44,7 @@ internal class XmlUntypedStringConverter private static readonly string s_untypedStringTypeName = "xdt:untypedAtomic"; - // Static convertor instance + // Static converter instance internal static XmlUntypedStringConverter Instance = new XmlUntypedStringConverter(true); private XmlUntypedStringConverter(bool listsAllowed) diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/XmlCharType.cs b/src/System.Xml.ReaderWriter/src/System/Xml/XmlCharType.cs index a84cc0b15466..5e77c397adb4 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/XmlCharType.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/XmlCharType.cs @@ -1038,7 +1038,7 @@ unsafe internal struct XmlCharType byte* s_CharData = (byte*)GCHandle.Alloc(s_xmlCharTypeData, GCHandleType.Pinned).AddrOfPinnedObject(); // we never free this memory. we avoid allocate this memory in the managed heap and pinning it to reduce - // the presure on the GC + // the pressure on the GC for (int i = 0; i < 256; i++) { s_PageIndexes[i] = (IntPtr)(s_CharData + s_Indexes[i]); diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/XmlConvert.cs b/src/System.Xml.ReaderWriter/src/System/Xml/XmlConvert.cs index 46c49e9c0b52..0dee5ad0f00a 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/XmlConvert.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/XmlConvert.cs @@ -520,12 +520,12 @@ public static bool IsNCNameSurrogatePair(char lowChar, char highChar) #endif - // Value convertors: + // Value converters: // // String representation of Base types in XML (xsd) sometimes differ from // one common language runtime offer and for all types it has to be locale independent. // o -- means that XmlConvert pass through to common language runtime converter with InvariantInfo FormatInfo - // x -- means we doing something special to make a convertion. + // x -- means we doing something special to make a conversion. // // From: To: Bol Chr SBy Byt I16 U16 I32 U32 I64 U64 Sgl Dbl Dec Dat Tim Str uid // ------------------------------------------------------------------------------ diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/XmlNameTable.cs b/src/System.Xml.ReaderWriter/src/System/Xml/XmlNameTable.cs index 8ef8f4a16617..fa376333cb28 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/XmlNameTable.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/XmlNameTable.cs @@ -33,7 +33,7 @@ public abstract class XmlNameTable /// /// /// Creates a new atom for the characters at the specified range - /// of chararacters in the specified string. + /// of characters in the specified string. /// public abstract String Add(char[] array, int offset, int length); diff --git a/src/System.Xml.ReaderWriter/src/System/Xml/XmlNamespaceManager.cs b/src/System.Xml.ReaderWriter/src/System/Xml/XmlNamespaceManager.cs index be4f85f11b3a..033b008c7c1e 100644 --- a/src/System.Xml.ReaderWriter/src/System/Xml/XmlNamespaceManager.cs +++ b/src/System.Xml.ReaderWriter/src/System/Xml/XmlNamespaceManager.cs @@ -142,7 +142,7 @@ public virtual void AddNamespace(string prefix, string uri) } else { - // othewise link + // otherwise link previousDeclIndex = declIndex; } } diff --git a/src/System.Xml.ReaderWriter/tests/Readers/NameTable/TCRecordNameTableAdd.cs b/src/System.Xml.ReaderWriter/tests/Readers/NameTable/TCRecordNameTableAdd.cs index 3f00ed3613a5..80617e1702a1 100644 --- a/src/System.Xml.ReaderWriter/tests/Readers/NameTable/TCRecordNameTableAdd.cs +++ b/src/System.Xml.ReaderWriter/tests/Readers/NameTable/TCRecordNameTableAdd.cs @@ -110,7 +110,7 @@ public override void AddChildren() // for function Variation_17 { - this.AddChild(new CVariation(Variation_17) { Attribute = new Variation("Add new string, get object using permutations of upper & lowecase, should be null") { Pri = 0 } }); + this.AddChild(new CVariation(Variation_17) { Attribute = new Variation("Add new string, get object using permutations of upper & lowercase, should be null") { Pri = 0 } }); } diff --git a/src/System.Xml.ReaderWriter/tests/Readers/NameTable/XmlNameTable.cs b/src/System.Xml.ReaderWriter/tests/Readers/NameTable/XmlNameTable.cs index b6a67a442817..78068c206278 100644 --- a/src/System.Xml.ReaderWriter/tests/Readers/NameTable/XmlNameTable.cs +++ b/src/System.Xml.ReaderWriter/tests/Readers/NameTable/XmlNameTable.cs @@ -943,7 +943,7 @@ public int Variation_16() } - [Variation("Add new string, get object using permutations of upper & lowecase, should be null", Pri = 0)] + [Variation("Add new string, get object using permutations of upper & lowercase, should be null", Pri = 0)] public int Variation_17() { ReloadSource(); diff --git a/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/CRWFactory.cs b/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/CRWFactory.cs index 4d7b550e7423..dad064c476af 100644 --- a/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/CRWFactory.cs +++ b/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/CRWFactory.cs @@ -34,8 +34,8 @@ public override int Init(object o) } /// - /// We will basically create two seperate spec files and call the below method - /// for each of the spec file seperately. + /// We will basically create two separate spec files and call the below method + /// for each of the spec file separately. /// //[XmlDriverScenario("XmlReader", "ReaderCreateSpec.xml")] //[XmlDriverScenario("XmlWriter", "WriterCreateSpec.xml")] @@ -47,7 +47,7 @@ public override int ExecuteVariation(CXmlDriverParam param) CError.WriteLine(this.CurVariation.Desc); CFactory f = null; string factoryToInvoke = param.SelectExistingValue("DriverFunction"); - switch (factoryToInvoke) //seperates whether to call Reader or Writer + switch (factoryToInvoke) //separates whether to call Reader or Writer { case "XmlReader": f = new CReaderFactory(); diff --git a/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/CXmlDriverEngine.cs b/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/CXmlDriverEngine.cs index 92689533f559..cf41e06fd162 100644 --- a/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/CXmlDriverEngine.cs +++ b/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/CXmlDriverEngine.cs @@ -93,7 +93,7 @@ protected virtual void DetermineTestCases() { _parseError = null; - // get controll file + // get control file string cmdSpecFile = null; if (CModCmdLine.CmdLine.ContainsKey(CMD_SPEC_LTM_KEY)) cmdSpecFile = (string)CModCmdLine.CmdLine[CMD_SPEC_LTM_KEY]; @@ -418,7 +418,7 @@ private static void MergeElements(XElement res, XElement parent, XElement child) private static XElement MergeSections(XElement parent, XElement child) { - // check inheritace rules + // check inheritance rules XAttribute attr = child.Attribute("Inheritance"); string Inheritance = ""; if (attr != null) diff --git a/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/ReaderFactory.cs b/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/ReaderFactory.cs index 47b45179dc1a..0e8e7e98df86 100644 --- a/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/ReaderFactory.cs +++ b/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/ReaderFactory.cs @@ -168,10 +168,10 @@ protected void TestReader() if (!IsVariationValid) { - //Invalid Case didnt throw exception. + //Invalid Case didn't throw exception. pstate = TestState.Error; DumpVariationInfo(); - throw new CTestFailedException("Invalid Variation didnt throw exception"); + throw new CTestFailedException("Invalid Variation didn't throw exception"); } else { @@ -253,7 +253,7 @@ protected void CreateReader(ReadThru readThru) { // Assumption is that the Create method doesn't throw NullReferenceException and // it is not the goal of this framework to test if they are thrown anywhere. - // but if they are thrown thats a problem and they shouldnt be caught but exposed. + // but if they are thrown that's a problem and they shouldn't be caught but exposed. try { switch (readThru) diff --git a/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/WriterFactory.cs b/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/WriterFactory.cs index 2918660b5068..2578ff1c8404 100644 --- a/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/WriterFactory.cs +++ b/src/System.Xml.ReaderWriter/tests/Writers/RwFactory/WriterFactory.cs @@ -127,10 +127,10 @@ protected void TestWriter() WriteNodes(); if (!IsVariationValid) { - //Invalid Case didnt throw exception. + //Invalid Case didn't throw exception. pstate = TestState.Error; DumpVariationInfo(); - throw new CTestFailedException("Invalid Variation didnt throw exception"); + throw new CTestFailedException("Invalid Variation didn't throw exception"); } else { @@ -212,7 +212,7 @@ protected void CreateWriter(WriteThru writeThru) { // Assumption is that the Create method doesn't throw NullReferenceException and // it is not the goal of this framework to test if they are thrown anywhere. - // but if they are thrown thats a problem and they shouldnt be caught but exposed. + // but if they are thrown that's a problem and they shouldn't be caught but exposed. Log("Writing thru : " + writeThru); @@ -286,7 +286,7 @@ protected void SetupSettings() _settings.OmitXmlDeclaration = Boolean.Parse(ReadFilterCriteria("OmitXmlDeclaration", true)); - //Reading Writer Type to determing encoding and if the writer type is binary writer. + //Reading Writer Type to determine encoding and if the writer type is binary writer. string wt = ReadFilterCriteria("WriterType", true); if (wt == "TextWriter" || wt == "XmlDocumentWriter") { diff --git a/src/System.Xml.ReaderWriter/tests/XmlConvert/ToTypeTests.cs b/src/System.Xml.ReaderWriter/tests/XmlConvert/ToTypeTests.cs index afec55e77335..b1e591f3f382 100644 --- a/src/System.Xml.ReaderWriter/tests/XmlConvert/ToTypeTests.cs +++ b/src/System.Xml.ReaderWriter/tests/XmlConvert/ToTypeTests.cs @@ -610,7 +610,7 @@ public int ToType40() dt = dt.AddTicks(9999999); span = TimeZoneInfo.Local.GetUtcOffset(dt); expDateTime = String.Format("0001-01-01T23:59:59.9999999{0:+0#;-0#}:{1:00}", span.Hours, span.Minutes); - CError.Compare(XmlConvert.ToString(dt), expDateTime, "milisecs"); + CError.Compare(XmlConvert.ToString(dt), expDateTime, "millisecs"); dt = new DateTime(2002, 12, 30, 23, 15, 55); span = TimeZoneInfo.Local.GetUtcOffset(dt); @@ -674,7 +674,7 @@ public int ToType43() expDateTime = (TimeZoneInfo.Local.GetUtcOffset(dt).Hours < 0) ? String.Format("0001-01-01T23:59:59.9999999-0{0}:00", Math.Abs(TimeZoneInfo.Local.GetUtcOffset(dt).Hours)) : String.Format("0001-01-01T23:59:59.9999999+0{0}:00", Math.Abs(TimeZoneInfo.Local.GetUtcOffset(dt).Hours)); - CError.Equals(XmlConvert.ToString(dt, XmlDateTimeSerializationMode.Local), expDateTime, "milisecs"); + CError.Equals(XmlConvert.ToString(dt, XmlDateTimeSerializationMode.Local), expDateTime, "millisecs"); // new 05/2002 dt = new DateTime(2002, 12, 30, 23, 15, 55); @@ -926,7 +926,7 @@ public int ToType56() dto = new DateTimeOffset(1, 1, 1, 23, 59, 59, TimeSpan.Zero); dto = dto.AddTicks(9999999); - CError.Equals(XmlConvert.ToString(dto), "0001-01-01T23:59:59.9999999Z", "milisecs"); + CError.Equals(XmlConvert.ToString(dto), "0001-01-01T23:59:59.9999999Z", "millisecs"); dto = new DateTimeOffset(2002, 12, 30, 23, 15, 55, TimeSpan.Zero); CError.Equals(XmlConvert.ToString(dto), "2002-12-30T23:15:55Z", "datetimeOffset4"); diff --git a/src/System.Xml.ReaderWriter/tests/XmlConvert/VerifyNameTests1.cs b/src/System.Xml.ReaderWriter/tests/XmlConvert/VerifyNameTests1.cs index 2c55f6341af0..be8289cf48f2 100644 --- a/src/System.Xml.ReaderWriter/tests/XmlConvert/VerifyNameTests1.cs +++ b/src/System.Xml.ReaderWriter/tests/XmlConvert/VerifyNameTests1.cs @@ -37,7 +37,7 @@ public override void AddChildren() AddChild(new CVariation(v4) { Attribute = new Variation("VerifyXmlChars.Name with two colons") { Params = new object[] { 5, false } } }); AddChild(new CVariation(v5) { Attribute = new Variation("VerifyPublicId.multiple non letter characters with :") { Params = new object[] { 6, false } } }); AddChild(new CVariation(v5) { Attribute = new Variation("VerifyWhitespace.multiple non letter characters with :") { Params = new object[] { 7, true } } }); - AddChild(new CVariation(v5) { Attribute = new Variation("VerifyName.multiple non letter characterse with :") { Params = new object[] { 2, false } } }); + AddChild(new CVariation(v5) { Attribute = new Variation("VerifyName.multiple non letter characters with :") { Params = new object[] { 2, false } } }); AddChild(new CVariation(v5) { Attribute = new Variation("VerifyNCName.multiple non letter characters with :") { Params = new object[] { 3, true } } }); AddChild(new CVariation(v5) { Attribute = new Variation("VerifyXmlChars.multiple non letter characters with :") { Params = new object[] { 5, false } } }); AddChild(new CVariation(v5) { Attribute = new Variation("VerifyNMTOKEN.multiple non letter characters with :") { Params = new object[] { 1, false } } }); diff --git a/src/System.Xml.ReaderWriter/tests/XmlReaderLib/ReadValue.cs b/src/System.Xml.ReaderWriter/tests/XmlReaderLib/ReadValue.cs index e2e75cc79dec..49b68e396a28 100644 --- a/src/System.Xml.ReaderWriter/tests/XmlReaderLib/ReadValue.cs +++ b/src/System.Xml.ReaderWriter/tests/XmlReaderLib/ReadValue.cs @@ -74,7 +74,7 @@ public int TestReadValuePri0() } } - CError.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didnt read 5 chars"); + CError.Compare(DataReader.ReadValueChunk(buffer, 0, 5), 5, "Didn't read 5 chars"); CError.Compare("value", new string(buffer), "Strings don't match"); return TEST_PASS; diff --git a/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCAttributeXmlDeclaration.cs b/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCAttributeXmlDeclaration.cs index 7ee13bdea849..dbef04bc0168 100644 --- a/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCAttributeXmlDeclaration.cs +++ b/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCAttributeXmlDeclaration.cs @@ -26,7 +26,7 @@ public override void AddChildren() // for function TAXmlDecl_3 { - this.AddChild(new CVariation(TAXmlDecl_3) { Attribute = new Variation("MoveToFirstAttribute/MoveToNextAttribute succesive calls") }); + this.AddChild(new CVariation(TAXmlDecl_3) { Attribute = new Variation("MoveToFirstAttribute/MoveToNextAttribute successive calls") }); } diff --git a/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCInvalidXML.cs b/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCInvalidXML.cs index 4880949b0374..dde67b385cbf 100644 --- a/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCInvalidXML.cs +++ b/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCInvalidXML.cs @@ -56,7 +56,7 @@ public override void AddChildren() // for function InvalidCommentCharacters { - this.AddChild(new CVariation(InvalidCommentCharacters) { Attribute = new Variation("For non-wellformed XMLs, check for the line info in the error message") }); + this.AddChild(new CVariation(InvalidCommentCharacters) { Attribute = new Variation("For non-well-formed XMLs, check for the line info in the error message") }); } diff --git a/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCLinePos.cs b/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCLinePos.cs index ea8e61302dc6..84faa310b469 100644 --- a/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCLinePos.cs +++ b/src/System.Xml.ReaderWriter/tests/XmlReaderLib/TCLinePos.cs @@ -110,7 +110,7 @@ public override void AddChildren() // for function TestLinePos21 { - this.AddChild(new CVariation(TestLinePos21) { Attribute = new Variation("LineNumber/LinePos after ReadBase64 succesive calls") }); + this.AddChild(new CVariation(TestLinePos21) { Attribute = new Variation("LineNumber/LinePos after ReadBase64 successive calls") }); }