diff --git a/src/System.ObjectModel/src/System/Collections/ObjectModel/ObservableCollection.cs b/src/System.ObjectModel/src/System/Collections/ObjectModel/ObservableCollection.cs
index f74a2c8c7bef..7dac6ec2f3f7 100644
--- a/src/System.ObjectModel/src/System/Collections/ObjectModel/ObservableCollection.cs
+++ b/src/System.ObjectModel/src/System/Collections/ObjectModel/ObservableCollection.cs
@@ -27,6 +27,9 @@ public class ObservableCollection<T> : Collection<T>, INotifyCollectionChanged,
         [NonSerialized]
         private int _blockReentrancyCount;
 
+        [NonSerialized]
+        private bool _skipRaisingEvents;
+
         /// <summary>
         /// Initializes a new instance of ObservableCollection that is empty and has default initial capacity.
         /// </summary>
@@ -121,9 +124,95 @@ protected override void RemoveItem(int index)
 
             base.RemoveItem(index);
 
-            OnCountPropertyChanged();
-            OnIndexerPropertyChanged();
-            OnCollectionChanged(NotifyCollectionChangedAction.Remove, removedItem, index);
+            if (!_skipRaisingEvents)
+            {
+                OnCountPropertyChanged();
+                OnIndexerPropertyChanged();
+                OnCollectionChanged(NotifyCollectionChangedAction.Remove, removedItem, index);
+            }
+        }
+
+        /// <summary>
+        /// Called by base class Collection&lt;T&gt; when a count of items is removed from the list;
+        /// raises a CollectionChanged event to any listeners.
+        /// </summary>
+        protected override void RemoveItemsRange(int index, int count)
+        {
+            CheckReentrancy();
+
+            T[] removedItems = null;
+
+            bool ignore = _skipRaisingEvents;
+            if (!ignore)
+            {
+                _skipRaisingEvents = true;
+
+                if (count > 0)
+                {
+                    removedItems = new T[count];
+                    for (int i = 0; i < count; i++)
+                    {
+                        removedItems[i] = this[index + i];
+                    }
+                }
+            }
+
+            try
+            {
+                base.RemoveItemsRange(index, count);
+            }
+            finally
+            {
+                if (!ignore)
+                {
+                    _skipRaisingEvents = false;
+                }
+            }
+
+            if (count > 0 && !_skipRaisingEvents)
+            {
+                OnCountPropertyChanged();
+                OnIndexerPropertyChanged();
+                OnCollectionChanged(NotifyCollectionChangedAction.Remove, removedItems, index);
+            }
+        }
+
+        /// <summary>
+        /// Called by base class Collection&lt;T&gt; when a collection of items is added to list;
+        /// raises a CollectionChanged event to any listeners.
+        /// </summary>
+        protected override void ReplaceItemsRange(int index, int count, IEnumerable<T> collection)
+        {
+            CheckReentrancy();
+
+            _skipRaisingEvents = true;
+
+            T[] itemsToReplace = new T[count - index];
+            for (int i = index; i < count; i++)
+            {
+                itemsToReplace[i] = this[i];
+            }
+
+            try
+            {
+                base.ReplaceItemsRange(index, count, collection);
+            }
+            finally
+            {
+                _skipRaisingEvents = false;
+            }
+
+            if (!_skipRaisingEvents)
+            {
+                IList newItems = collection is IList list ? list : new List<T>(collection);
+
+                if (newItems.Count > 0)
+                {
+                    OnCountPropertyChanged();
+                    OnIndexerPropertyChanged();
+                    OnCollectionChanged(NotifyCollectionChangedAction.Replace, itemsToReplace, newItems, index);
+                }
+            }
         }
 
         /// <summary>
@@ -135,9 +224,51 @@ protected override void InsertItem(int index, T item)
             CheckReentrancy();
             base.InsertItem(index, item);
 
-            OnCountPropertyChanged();
-            OnIndexerPropertyChanged();
-            OnCollectionChanged(NotifyCollectionChangedAction.Add, item, index);
+            if (!_skipRaisingEvents)
+            {
+                OnCountPropertyChanged();
+                OnIndexerPropertyChanged();
+                OnCollectionChanged(NotifyCollectionChangedAction.Add, item, index);
+            }
+        }
+
+        /// <summary>
+        /// Called by base class Collection&lt;T&gt; when a collection of items is added to list;
+        /// raises a CollectionChanged event to any listeners.
+        /// </summary>
+        protected override void InsertItemsRange(int index, IEnumerable<T> collection)
+        {
+            CheckReentrancy();
+
+            bool ignore = _skipRaisingEvents;
+            if (!ignore)
+            {
+                _skipRaisingEvents = true;
+            }
+
+            try
+            {
+                base.InsertItemsRange(index, collection);
+            }
+            finally
+            {
+                if (!ignore)
+                {
+                    _skipRaisingEvents = false;
+                }
+            }
+
+            if (!_skipRaisingEvents)
+            {
+                IList newItems = collection is IList list ? list : new List<T>(collection);
+
+                if (newItems.Count > 0)
+                {
+                    OnCountPropertyChanged();
+                    OnIndexerPropertyChanged();
+                    OnCollectionChanged(NotifyCollectionChangedAction.Add, newItems, index);
+                }
+            }
         }
 
         /// <summary>
@@ -265,6 +396,14 @@ private void OnCollectionChanged(NotifyCollectionChangedAction action, object it
             OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, item, index));
         }
 
+        /// <summary>
+        /// Helper to raise CollectionChanged event to any listeners
+        /// </summary>
+        private void OnCollectionChanged(NotifyCollectionChangedAction action, IList items, int index)
+        {
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, items, index));
+        }
+
         /// <summary>
         /// Helper to raise CollectionChanged event to any listeners
         /// </summary>
@@ -281,6 +420,14 @@ private void OnCollectionChanged(NotifyCollectionChangedAction action, object ol
             OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, newItem, oldItem, index));
         }
 
+        /// <summary>
+        /// Helper to raise CollectionChanged event to any listeners
+        /// </summary>
+        private void OnCollectionChanged(NotifyCollectionChangedAction action, IList oldItems, IList newItems, int index)
+        {
+            OnCollectionChanged(new NotifyCollectionChangedEventArgs(action, newItems, oldItems, index));
+        }
+
         /// <summary>
         /// Helper to raise CollectionChanged event with action == Reset to any listeners
         /// </summary>
diff --git a/src/System.ObjectModel/tests/Configurations.props b/src/System.ObjectModel/tests/Configurations.props
index 2bc19ff4170e..63b0f12fe5de 100644
--- a/src/System.ObjectModel/tests/Configurations.props
+++ b/src/System.ObjectModel/tests/Configurations.props
@@ -3,6 +3,8 @@
     <BuildConfigurations>
       netstandard;
       netcoreapp;
+      uap;
+      uapaot;
     </BuildConfigurations>
   </PropertyGroup>
 </Project>
\ No newline at end of file
diff --git a/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_MethodTests.netcoreapp.cs b/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_MethodTests.netcoreapp.cs
new file mode 100644
index 000000000000..f15d3c3c463f
--- /dev/null
+++ b/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_MethodTests.netcoreapp.cs
@@ -0,0 +1,269 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System.Linq;
+using Xunit;
+
+namespace System.Collections.ObjectModel.Tests
+{
+    public partial class ObservableCollection_MethodTests
+    {
+        [Fact]
+        public static void InsertRange_NotifyCollectionChanged_Beginning_Test()
+        {
+            int[] dataToInsert = new int[] { 1, 2, 3, 4, 5 };
+            int[] initialData = new int[] { 10, 11, 12, 13 };
+            int eventCounter = 0;
+            ObservableCollection<int> collection = new ObservableCollection<int>(initialData);
+            collection.CollectionChanged += (o, e) => eventCounter++;
+
+            collection.InsertRange(0, dataToInsert);
+
+            Assert.Equal(dataToInsert.Length + initialData.Length, collection.Count);
+            Assert.Equal(1, eventCounter);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(dataToInsert, collectionAssertion.AsSpan(0, 5).ToArray());
+            Assert.Equal(initialData, collectionAssertion.AsSpan(5).ToArray());
+        }
+
+        [Fact]
+        public static void InsertRange_NotifyCollectionChanged_Middle_Test()
+        {
+            int[] dataToInsert = new int[] { 1, 2, 3, 4, 5 };
+            int[] initialData = new int[] { 10, 11, 12, 13 };
+            int eventCounter = 0;
+            ObservableCollection<int> collection = new ObservableCollection<int>(initialData);
+            collection.CollectionChanged += (o, e) => eventCounter++;
+
+            collection.InsertRange(2, dataToInsert);
+
+            Assert.Equal(dataToInsert.Length + initialData.Length, collection.Count);
+            Assert.Equal(1, eventCounter);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(initialData.AsSpan(0, 2).ToArray(), collectionAssertion.AsSpan(0, 2).ToArray());
+            Assert.Equal(dataToInsert, collectionAssertion.AsSpan(2, 5).ToArray());
+            Assert.Equal(initialData.AsSpan(2, 2).ToArray(), collectionAssertion.AsSpan(7, 2).ToArray());
+        }
+
+        [Fact]
+        public static void InsertRange_NotifyCollectionChanged_End_Test()
+        {
+            int[] dataToInsert = new int[] { 1, 2, 3, 4, 5 };
+            int[] initialData = new int[] { 10, 11, 12, 13 };
+            int eventCounter = 0;
+            ObservableCollection<int> collection = new ObservableCollection<int>(initialData);
+            collection.CollectionChanged += (o, e) => eventCounter++;
+
+            collection.InsertRange(4, dataToInsert);
+
+            Assert.Equal(dataToInsert.Length + initialData.Length, collection.Count);
+            Assert.Equal(1, eventCounter);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(initialData, collectionAssertion.AsSpan(0, 4).ToArray());
+            Assert.Equal(dataToInsert, collectionAssertion.AsSpan(4).ToArray());
+        }
+
+        [Fact]
+        public static void AddRange_NotifyCollectionChanged_Test()
+        {
+            int[] dataToInsert = new int[] { 1, 2, 3, 4, 5 };
+            int[] initialData = new int[] { 10, 11, 12, 13 };
+            int eventCounter = 0;
+            ObservableCollection<int> collection = new ObservableCollection<int>(initialData);
+            collection.CollectionChanged += (o, e) => eventCounter++;
+
+            collection.AddRange(dataToInsert);
+
+            Assert.Equal(dataToInsert.Length + initialData.Length, collection.Count);
+            Assert.Equal(1, eventCounter);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(initialData, collectionAssertion.AsSpan(0, 4).ToArray());
+            Assert.Equal(dataToInsert, collectionAssertion.AsSpan(4).ToArray());
+        }
+
+        [Fact]
+        public static void AddRange_NotifyCollectionChanged_EventArgs_Test()
+        {
+            int[] dataToAdd = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+            int[] actualDataAdded = new int[0];
+            ObservableCollection<int> collection = new ObservableCollection<int>();
+            collection.CollectionChanged += (o, e) => actualDataAdded = e.NewItems.Cast<int>().ToArray();
+
+            collection.AddRange(dataToAdd);
+
+            Assert.Equal(dataToAdd, actualDataAdded);
+        }
+
+        [Fact]
+        public static void InsertRange_NotifyCollectionChanged_EventArgs_Test()
+        {
+            int[] dataToAdd = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+            int[] actualDataAdded = new int[0];
+            ObservableCollection<int> collection = new ObservableCollection<int>();
+            collection.CollectionChanged += (o, e) => actualDataAdded = e.NewItems.Cast<int>().ToArray();
+
+            collection.InsertRange(0, dataToAdd);
+
+            Assert.Equal(dataToAdd, actualDataAdded);
+        }
+
+        [Fact]
+        public static void InsertRange_NotifyCollectionChanged_EventArgs_Middle_Test()
+        {
+            int[] dataToAdd = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+            int[] actualDataAdded = new int[0];
+            ObservableCollection<int> collection = new ObservableCollection<int>();
+            for (int i = 0; i < 4; i++)
+            {
+                collection.Add(i);
+            }
+
+            collection.CollectionChanged += (o, e) => actualDataAdded = e.NewItems.Cast<int>().ToArray();
+            collection.InsertRange(2, dataToAdd);
+
+            Assert.Equal(dataToAdd, actualDataAdded);
+        }
+
+        [Fact]
+        public static void InsertRange_NotifyCollectionChanged_EventArgs_End_Test()
+        {
+            int[] dataToAdd = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+            int[] actualDataAdded = new int[0];
+            ObservableCollection<int> collection = new ObservableCollection<int>();
+            for (int i = 0; i < 4; i++)
+            {
+                collection.Add(i);
+            }
+
+            collection.CollectionChanged += (o, e) => actualDataAdded = e.NewItems.Cast<int>().ToArray();
+            collection.InsertRange(4, dataToAdd);
+
+            Assert.Equal(dataToAdd, actualDataAdded);
+        }
+
+        [Fact]
+        public static void RemoveRange_NotifyCollectionChanged_FirstTwo_Test()
+        {
+            int[] initialData = new int[] { 10, 11, 12, 13 };
+            int itemsToRemove = 2;
+            int eventCounter = 0;
+            ObservableCollection<int> collection = new ObservableCollection<int>(initialData);
+            collection.CollectionChanged += (o, e) => eventCounter++;
+
+            collection.RemoveRange(0, itemsToRemove);
+
+            Assert.Equal(initialData.Length - itemsToRemove, collection.Count);
+            Assert.Equal(1, eventCounter);
+            Assert.Equal(initialData.AsSpan(2).ToArray(), collection.ToArray());
+        }
+
+        [Fact]
+        public static void RemoveRange_NotifyCollectionChanged_MiddleTwo_Test()
+        {
+            int[] initialData = new int[] { 10, 11, 12, 13 };
+            int itemsToRemove = 2;
+            int eventCounter = 0;
+            ObservableCollection<int> collection = new ObservableCollection<int>(initialData);
+            collection.CollectionChanged += (o, e) => eventCounter++;
+
+            collection.RemoveRange(1, itemsToRemove);
+
+            Assert.Equal(initialData.Length - itemsToRemove, collection.Count);
+            Assert.Equal(1, eventCounter);
+            Assert.Equal(initialData[0], collection[0]);
+            Assert.Equal(initialData[3], collection[1]);
+        }
+
+        [Fact]
+        public static void RemoveRange_NotifyCollectionChanged_LastTwo_Test()
+        {
+            int[] initialData = new int[] { 10, 11, 12, 13 };
+            int itemsToRemove = 2;
+            int eventCounter = 0;
+            ObservableCollection<int> collection = new ObservableCollection<int>(initialData);
+            collection.CollectionChanged += (o, e) => eventCounter++;
+
+            collection.RemoveRange(2, itemsToRemove);
+
+            Assert.Equal(initialData.Length - itemsToRemove, collection.Count);
+            Assert.Equal(1, eventCounter);
+            Assert.Equal(initialData.AsSpan(0, 2).ToArray(), collection.ToArray());
+        }
+
+        [Fact]
+        public static void RemoveRange_NotifyCollectionChanged_IntMaxValueOverflow_Test()
+        {
+            int count = 500;
+            ObservableCollection<int> collection = new ObservableCollection<int>();
+            for (int i = 0; i < count; i++)
+            {
+                collection.Add(i);
+            }
+
+            Assert.Throws<ArgumentException>(() => collection.RemoveRange(collection.Count - 2, int.MaxValue));
+        }
+
+        [Fact]
+        public static void RemoveRange_NotifyCollectionChanged_EventArgs_IndexOfZero_Test()
+        {
+            int[] initialData = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+            int[] actualDataRemoved = new int[0];
+            int numberOfItemsToRemove = 4;
+            ObservableCollection<int> collection = new ObservableCollection<int>();
+            foreach (int item in initialData)
+            {
+                collection.Add(item);
+            }
+
+            collection.CollectionChanged += (o, e) => actualDataRemoved = e.OldItems.Cast<int>().ToArray();
+            collection.RemoveRange(0, numberOfItemsToRemove);
+
+            Assert.Equal(initialData.Length - numberOfItemsToRemove, collection.Count);
+            Assert.Equal(initialData.AsSpan(0, numberOfItemsToRemove).ToArray(), actualDataRemoved);
+        }
+
+        [Fact]
+        public static void RemoveRange_NotifyCollectionChanged_EventArgs_IndexMiddle_Test()
+        {
+            int[] initialData = new int[] { 1, 2, 3, 4, 5, 6, 7, 8 };
+            int[] actualDataRemoved = new int[0];
+            int numberOfItemsToRemove = 4;
+            int startIndex = 3;
+            ObservableCollection<int> collection = new ObservableCollection<int>();
+            foreach (int item in initialData)
+            {
+                collection.Add(item);
+            }
+
+            collection.CollectionChanged += (o, e) => actualDataRemoved = e.OldItems.Cast<int>().ToArray();
+            collection.RemoveRange(startIndex, numberOfItemsToRemove);
+
+            Assert.Equal(initialData.Length - numberOfItemsToRemove, collection.Count);
+            Assert.Equal(initialData.AsSpan(startIndex, numberOfItemsToRemove).ToArray(), actualDataRemoved);
+        }
+
+        [Fact]
+        public static void ReplaceRange_NotifyCollectionChanged_Test()
+        {
+            int[] initialData = new int[] { 10, 11, 12, 13 };
+            int[] dataToReplace = new int[] { 3, 8 };
+            int eventCounter = 0;
+            ObservableCollection<int> collection = new ObservableCollection<int>(initialData);
+            collection.CollectionChanged += (o, e) => eventCounter++;
+
+            collection.ReplaceRange(0, 2, dataToReplace);
+
+            Assert.Equal(initialData.Length, collection.Count);
+            Assert.Equal(1, eventCounter);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(dataToReplace, collectionAssertion.AsSpan(0, 2).ToArray());
+            Assert.Equal(initialData.AsSpan(2, 2).ToArray(), collectionAssertion.AsSpan(2, 2).ToArray());
+        }
+    }
+}
diff --git a/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_MethodsTest.cs b/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_MethodsTest.cs
index 6f03a97cc190..bb291a98a3e4 100644
--- a/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_MethodsTest.cs
+++ b/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_MethodsTest.cs
@@ -14,7 +14,7 @@ namespace System.Collections.ObjectModel.Tests
     /// that the CollectionChanged events and eventargs are fired and populated
     /// properly.
     /// </summary>
-    public static class PublicMethodsTest
+    public partial class PublicMethodsTest
     {
         /// <summary>
         /// Tests that is possible to Add an item to the collection.
diff --git a/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_SkipCollectionChangedTests.netcoreapp.cs b/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_SkipCollectionChangedTests.netcoreapp.cs
new file mode 100644
index 000000000000..9a9b1c6f2120
--- /dev/null
+++ b/src/System.ObjectModel/tests/ObservableCollection/ObservableCollection_SkipCollectionChangedTests.netcoreapp.cs
@@ -0,0 +1,126 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Xunit;
+
+namespace System.ObjectModel.Tests.ObservableCollection
+{
+    public class ObservableCollection_SkipCollectionChangedTests
+    {
+        [Fact]
+        public void SkipCollectionChanged_AddRange_Test()
+        {
+            int collectionChangedCounter = 0;
+            NonNullObservableCollection<string> collection = new NonNullObservableCollection<string>();
+            collection.Add("1");
+            collection.Add("2");
+            collection.Add("3");
+            collection.CollectionChanged += (s, e) => collectionChangedCounter++;
+
+            Assert.Throws<ArgumentNullException>(() => collection.AddRange(new string[1]));
+            Assert.Equal(0, collectionChangedCounter);
+
+            collection.Add("4");
+            Assert.Equal(1, collectionChangedCounter);
+        }
+
+        [Fact]
+        public void SkipCollectionChanged_InsertRange_Test()
+        {
+            int collectionChangedCounter = 0;
+            NonNullObservableCollection<string> collection = new NonNullObservableCollection<string>();
+            collection.Add("1");
+            collection.Add("2");
+            collection.Add("3");
+            collection.CollectionChanged += (s, e) => collectionChangedCounter++;
+
+            Assert.Throws<ArgumentNullException>(() => collection.InsertRange(0, new string[1]));
+            Assert.Equal(0, collectionChangedCounter);
+
+            collection.Add("4");
+            Assert.Equal(1, collectionChangedCounter);
+        }
+
+        [Fact]
+        public void SkipCollectionChanged_RemoveRange_Test()
+        {
+            int collectionChangedCounter = 0;
+            NonNullObservableCollection<string> collection = new NonNullObservableCollection<string>();
+            collection.Add("1");
+            collection.Add("2");
+            collection.Add("3");
+            collection.CollectionChanged += (s, e) => collectionChangedCounter++;
+
+            collection.RemoveRange(0, 2);
+            Assert.Equal(1, collectionChangedCounter);
+
+            collection.Add("1");
+            Assert.Equal(2, collectionChangedCounter);
+        }
+
+        [Fact]
+        public void SkipCollectionChanged_RemoveRange_NoEventsRaised_Test()
+        {
+            int collectionChangedCounter = 0;
+            NonNullObservableCollection<string> collection = new NonNullObservableCollection<string>();
+            collection.Add("1");
+            collection.Add("2");
+            collection.Add("3");
+            collection.CollectionChanged += (s, e) => collectionChangedCounter++;
+
+            collection.RemoveRange(0, 0);
+
+            Assert.Equal(0, collectionChangedCounter);
+        }
+
+        [Fact]
+        public void SkipCollectionChanged_ReplaceRange_Test()
+        {
+            int collectionChangedCounter = 0;
+            NonNullObservableCollection<string> collection = new NonNullObservableCollection<string>();
+            collection.Add("1");
+            collection.Add("2");
+            collection.Add("3");
+            collection.CollectionChanged += (s, e) => collectionChangedCounter++;
+
+            Assert.Throws<ArgumentNullException>(() => collection.ReplaceRange(0, 2, new string[1]));
+            Assert.Equal(0, collectionChangedCounter);
+
+            collection.Add("1");
+            Assert.Equal(1, collectionChangedCounter);
+        }
+
+        [Fact]
+        public void SkipCollectionChanged_ReplaceRange_Empty_Test()
+        {
+            int collectionChangedCounter = 0;
+            NonNullObservableCollection<string> collection = new NonNullObservableCollection<string>();
+            collection.Add("1");
+            collection.Add("2");
+            collection.Add("3");
+            collection.CollectionChanged += (s, e) => collectionChangedCounter++;
+
+            collection.ReplaceRange(0, 0, new string[0]);
+            Assert.Equal(0, collectionChangedCounter);
+
+            collection.Add("1");
+            Assert.Equal(1, collectionChangedCounter);
+        }
+
+        public class NonNullObservableCollection<T> : ObservableCollection<T>
+        {
+
+            public NonNullObservableCollection() : base() { }
+            public NonNullObservableCollection(List<T> list) : base(list) { }
+
+            protected override void InsertItem(int index, T item)
+            {
+                if (item == null)
+                {
+                    throw new ArgumentNullException();
+                }
+
+                base.InsertItem(index, item);
+            }
+        }
+    }
+}
diff --git a/src/System.ObjectModel/tests/System.ObjectModel.Tests.csproj b/src/System.ObjectModel/tests/System.ObjectModel.Tests.csproj
index 7682226ac131..89419f88be3d 100644
--- a/src/System.ObjectModel/tests/System.ObjectModel.Tests.csproj
+++ b/src/System.ObjectModel/tests/System.ObjectModel.Tests.csproj
@@ -22,6 +22,10 @@
     <Compile Include="$(CommonTestPath)\System\Collections\IDictionaryTest.cs">
       <Link>Common\System\CollectionsIDictionaryTest.cs</Link>
     </Compile>
+    <Compile Include="ObservableCollection\ObservableCollection_ConstructorAndPropertyTests.cs" />
+    <Compile Include="ObservableCollection\ObservableCollection_MethodsTest.cs" />
+    <Compile Include="ObservableCollection\ObservableCollection_ReentrancyTests.cs" />
+    <Compile Include="ObservableCollection\ObservableCollection_Serialization.cs" />
     <Compile Include="System\Collections\ObjectModel\KeyedCollectionTests.cs" />
     <Compile Include="System\Collections\Specialized\NotifyCollectionChangedEventArgsTests.cs" />
     <Compile Include="System\ComponentModel\DataErrorsChangedEventArgsTests.cs" />
@@ -32,9 +36,6 @@
     <Compile Include="KeyedCollection\TestMethods.cs" />
     <Compile Include="KeyedCollection\ConcreteTestClasses.cs" />
     <Compile Include="KeyedCollection\Utils.cs" />
-    <Compile Include="ObservableCollection\ObservableCollection_ConstructorAndPropertyTests.cs" />
-    <Compile Include="ObservableCollection\ObservableCollection_MethodsTest.cs" />
-    <Compile Include="ObservableCollection\ObservableCollection_ReentrancyTests.cs" />
     <Compile Include="ReadOnlyDictionary\ReadOnlyDictionaryTests.cs" />
     <Compile Include="ReadOnlyObservableCollection\ReadOnlyObservableCollection_EventsTests.cs" />
     <Compile Include="ReadOnlyObservableCollection\ReadOnlyObservableCollectionTests.cs" />
@@ -43,17 +44,18 @@
     </Compile>
   </ItemGroup>
   <ItemGroup Condition="'$(TargetGroup)'=='netcoreapp'">
+    <Compile Include="ObservableCollection\ObservableCollection_MethodTests.netcoreapp.cs" />    
+    <Compile Include="ObservableCollection\ObservableCollection_SkipCollectionChangedTests.netcoreapp.cs" />
     <Compile Include="KeyedCollection\TestMethods.netcoreapp.cs" />
     <Compile Include="System\Collections\ObjectModel\KeyedCollectionTests.netcoreapp.cs" />
     <Compile Include="System\Windows\Markup\ValueSerializerAttributeTests.cs" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="KeyedCollection\Serialization.cs" />
-    <Compile Include="ObservableCollection\ObservableCollection_Serialization.cs" />
     <Compile Include="ReadOnlyDictionary\ReadOnlyDictionary_SerializationTests.cs" />
     <Compile Include="ReadOnlyObservableCollection\ReadOnlyObservableCollection_SerializationTests.cs" />
     <Compile Include="$(CommonTestPath)\System\Runtime\Serialization\Formatters\BinaryFormatterHelpers.cs">
       <Link>Common\System\Runtime\Serialization\Formatters\BinaryFormatterHelpers.cs</Link>
     </Compile>
   </ItemGroup>
-</Project>
\ No newline at end of file
+</Project>
diff --git a/src/System.Runtime/ref/System.Runtime.cs b/src/System.Runtime/ref/System.Runtime.cs
index 2646e062652b..694759465fd0 100644
--- a/src/System.Runtime/ref/System.Runtime.cs
+++ b/src/System.Runtime/ref/System.Runtime.cs
@@ -4034,6 +4034,7 @@ public Collection(System.Collections.Generic.IList<T> list) { }
         bool System.Collections.IList.IsReadOnly { get { throw null; } }
         object System.Collections.IList.this[int index] { get { throw null; } set { } }
         public void Add(T item) { }
+        public void AddRange(System.Collections.Generic.IEnumerable<T> collection) { }
         public void Clear() { }
         protected virtual void ClearItems() { }
         public bool Contains(T item) { throw null; }
@@ -4042,9 +4043,15 @@ public void CopyTo(T[] array, int index) { }
         public int IndexOf(T item) { throw null; }
         public void Insert(int index, T item) { }
         protected virtual void InsertItem(int index, T item) { }
-        public bool Remove(T item) { throw null; }
+        protected virtual void InsertItemsRange(int index, System.Collections.Generic.IEnumerable<T> collection) { }
+        public void InsertRange(int index, System.Collections.Generic.IEnumerable<T> collection) { }            
+        public bool Remove(T item) { throw null; }     
         public void RemoveAt(int index) { }
         protected virtual void RemoveItem(int index) { }
+        protected virtual void RemoveItemsRange(int index, int count) { }
+        public void RemoveRange(int index, int count) { }
+        protected virtual void ReplaceItemsRange(int index, int count, System.Collections.Generic.IEnumerable<T> collection) { }
+        public void ReplaceRange(int index, int count, System.Collections.Generic.IEnumerable<T> collection) { }
         protected virtual void SetItem(int index, T item) { }
         void System.Collections.ICollection.CopyTo(System.Array array, int index) { }
         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() { throw null; }
diff --git a/src/System.Runtime/tests/System.Runtime.Tests.csproj b/src/System.Runtime/tests/System.Runtime.Tests.csproj
index 812406b043d9..53a45b1ba1de 100644
--- a/src/System.Runtime/tests/System.Runtime.Tests.csproj
+++ b/src/System.Runtime/tests/System.Runtime.Tests.csproj
@@ -72,6 +72,7 @@
     <Compile Include="System\ByteTests.cs" />
     <Compile Include="System\CharTests.cs" />
     <Compile Include="System\CLSCompliantAttributeTests.cs" />
+    <Compile Include="System\Collections\ObjectModel\CollectionTests.cs" />
     <Compile Include="System\DateTimeTests.cs" />
     <Compile Include="System\DateTimeOffsetTests.cs" />
     <Compile Include="System\DBNullTests.cs" />
@@ -155,7 +156,6 @@
     <Compile Include="System\AppContext\AppContext.Switch.Validation.cs" />
     <Compile Include="System\Collections\Generic\KeyNotFoundExceptionTests.cs" />
     <Compile Include="System\Collections\Generic\KeyValuePairTests.cs" />
-    <Compile Include="System\Collections\ObjectModel\CollectionTests.cs" />
     <Compile Include="System\Collections\ObjectModel\CollectionTestBase.cs" />
     <Compile Include="System\Collections\ObjectModel\ReadOnlyCollectionTests.cs" />
     <Compile Include="System\ComponentModel\DefaultValueAttributeTests.cs" />
@@ -234,6 +234,7 @@
     <Compile Include="System\ExitCodeTests.Unix.cs" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetGroup)' != 'netfx' And '$(TargetGroup)' != 'netstandard'">
+    <Compile Include="System\Collections\ObjectModel\CollectionTests.netcoreapp.cs" />
     <Compile Include="System\HashCodeTests.netcoreapp.cs" />
     <Compile Include="Helpers.netcoreapp.cs" />
     <Compile Include="System\ActivatorTests.netcoreapp.cs" />
@@ -271,7 +272,7 @@
     <Compile Include="System\ComponentModel\DefaultValueAttributeTests.netcoreapp.cs" />
     <Compile Include="System\Reflection\BindingFlagsDoNotWrap.netcoreapp.cs" />
     <Compile Include="System\Reflection\InvokeRefReturn.netcoreapp.cs" />
-    <Compile Include="System\Reflection\IsCollectibleTests.cs" Condition="'$(TargetGroup)' != 'uapaot'"/><!-- missing method 'AssemblyLoadContext..ctor(bool) -->
+    <Compile Include="System\Reflection\IsCollectibleTests.cs" Condition="'$(TargetGroup)' != 'uapaot'" /><!-- missing method 'AssemblyLoadContext..ctor(bool) -->
     <Compile Include="System\Reflection\MethodBaseTests.netcoreapp.cs" />
     <Compile Include="System\Reflection\SignatureTypes.netcoreapp.cs" />
     <Compile Include="System\Reflection\TypeDelegatorTests.netcoreapp.cs" />
diff --git a/src/System.Runtime/tests/System/Collections/ObjectModel/CollectionTests.cs b/src/System.Runtime/tests/System/Collections/ObjectModel/CollectionTests.cs
index 4e1fb2f82eb0..0961f2b8812f 100644
--- a/src/System.Runtime/tests/System/Collections/ObjectModel/CollectionTests.cs
+++ b/src/System.Runtime/tests/System/Collections/ObjectModel/CollectionTests.cs
@@ -1,22 +1,13 @@
-// Licensed to the .NET Foundation under one or more agreements.
+// Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System;
-using System.Collections;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using Xunit;
 
 namespace System.Collections.ObjectModel.Tests
 {
-    /// <summary>
-    /// Since <see cref="Collection{T}"/> is just a wrapper base class around an <see cref="IList{T}"/>,
-    /// we just verify that the underlying list is what we expect, validate that the calls which
-    /// we expect are forwarded to the underlying list, and verify that the exceptions we expect
-    /// are thrown.
-    /// </summary>
-    public class CollectionTests : CollectionTestBase
+    public partial class CollectionTests : CollectionTestBase
     {
         private static readonly Collection<int> s_empty = new Collection<int>();
 
diff --git a/src/System.Runtime/tests/System/Collections/ObjectModel/CollectionTests.netcoreapp.cs b/src/System.Runtime/tests/System/Collections/ObjectModel/CollectionTests.netcoreapp.cs
new file mode 100644
index 000000000000..940af6773626
--- /dev/null
+++ b/src/System.Runtime/tests/System/Collections/ObjectModel/CollectionTests.netcoreapp.cs
@@ -0,0 +1,424 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Xunit;
+
+namespace System.Collections.ObjectModel.Tests
+{
+    /// <summary>
+    /// Since <see cref="Collection{T}"/> is just a wrapper base class around an <see cref="IList{T}"/>,
+    /// we just verify that the underlying list is what we expect, validate that the calls which
+    /// we expect are forwarded to the underlying list, and verify that the exceptions we expect
+    /// are thrown.
+    /// </summary>
+    public partial class CollectionTests : CollectionTestBase
+    {
+        [Fact]
+        public void Collection_AddRange_ToEmpty_Test()
+        {
+            int[] expected = new[] { 1, 2, 3, 4 };
+            Collection<int> collection = new Collection<int>();
+
+            collection.AddRange(expected);
+
+            Assert.NotNull(collection);
+            Assert.Equal(expected.Length, collection.Count);
+            Assert.Equal(expected, collection.ToArray());
+        }
+
+        [Fact]
+        public void Collection_AddRange_ToExisting_Test()
+        {
+            int[] initial = new int[] { 1, 2, 3, 4 };
+            int[] dataToInsert = new int[] { 5, 6, 7, 8 };
+            Collection<int> collection = new Collection<int>();
+            for (int i = 0; i < initial.Length; i++)
+                collection.Add(initial[i]);
+
+            collection.AddRange(dataToInsert);
+
+            Assert.NotNull(collection);
+            Assert.Equal(initial.Length + dataToInsert.Length, collection.Count);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(initial, collectionAssertion.AsSpan(0, 4).ToArray());
+            Assert.Equal(dataToInsert, collectionAssertion.AsSpan(4, 4).ToArray());
+        }
+
+        [Fact]
+        public void Collection_AddRange_Empty_Test()
+        {
+            int[] expected = new int[0];
+            Collection<int> collection = new Collection<int>();
+
+            collection.AddRange(expected);
+
+            Assert.NotNull(collection);
+            Assert.Equal(expected.Length, collection.Count);
+        }
+
+        [Fact]
+        public void Collection_AddRange_Null_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            Exception ex = Assert.Throws<ArgumentNullException>(() => collection.AddRange(null));
+        }
+
+        [Fact]
+        public void Collection_AddRange_ReadOnly_Test()
+        {
+            int[] expected = new int[] { 1, 2, 3, 4 };
+            int[] baseCollection = new int[] { 5, 6, 7, 8 };
+            Collection<int> collection = new Collection<int>(baseCollection);
+
+            Exception ex = Assert.Throws<NotSupportedException>(() => collection.AddRange(expected));
+        }
+
+        [Fact]
+        public void Collection_InsertRange_Beginning_Test()
+        {
+            int[] expected = new int[] { 1, 2, 3, 4, 5 };
+            int[] originalCollection = new int[] { 10, 11, 12, 13 };
+            List<int> baseCollection = new List<int>(originalCollection);
+
+            int expectedLength = expected.Length + originalCollection.Length;
+            Collection<int> collection = new Collection<int>(baseCollection);
+
+            collection.InsertRange(0, expected);
+
+            Assert.NotNull(collection);
+            Assert.Equal(expectedLength, collection.Count);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(expected, collectionAssertion.AsSpan(0, 5).ToArray());
+            Assert.Equal(originalCollection, collectionAssertion.AsSpan(5, 4).ToArray());
+        }
+
+        [Fact]
+        public void Collection_InsertRange_End_Test()
+        {
+            int[] expected = new int[] { 1, 2, 3, 4, 5 };
+            int[] originalCollection = new int[] { 10, 11, 12, 13 };
+            List<int> baseCollection = new List<int>(originalCollection);
+
+            int expectedLength = expected.Length + originalCollection.Length;
+            Collection<int> collection = new Collection<int>(baseCollection);
+
+            collection.InsertRange(expected.Length - 1, expected);
+
+            Assert.NotNull(collection);
+            Assert.Equal(expectedLength, collection.Count);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(originalCollection, collectionAssertion.AsSpan(0, 4).ToArray());
+            Assert.Equal(expected, collectionAssertion.AsSpan(4, 5).ToArray());
+        }
+
+        [Fact]
+        public void Collection_InsertRange_Middle_Test()
+        {
+            int[] expected = new int[] { 1, 2, 3, 4, 5 };
+            int[] originalCollection = new int[] { 10, 11, 12, 13 };
+            List<int> baseCollection = new List<int>(originalCollection);
+
+            int expectedLength = expected.Length + originalCollection.Length;
+            Collection<int> collection = new Collection<int>(baseCollection);
+
+            collection.InsertRange(2, expected);
+
+            Assert.NotNull(collection);
+            Assert.Equal(expectedLength, collection.Count);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(originalCollection.AsSpan(0, 2).ToArray(), collectionAssertion.AsSpan(0, 2).ToArray());
+            Assert.Equal(expected, collectionAssertion.AsSpan(2, 5).ToArray());
+            Assert.Equal(originalCollection.AsSpan(2, 2).ToArray(), collectionAssertion.AsSpan(7, 2).ToArray());
+        }
+
+        [Fact]
+        public void Collection_InsertRange_Empty_Test()
+        {
+            List<int> baseCollection = new List<int>(new[] { 10, 11, 12, 13 });
+            Collection<int> collection = new Collection<int>(baseCollection);
+
+            collection.InsertRange(0, new int[0]);
+
+            Assert.NotNull(collection);
+            Assert.Equal(baseCollection.Count, collection.Count);
+            Assert.Equal(baseCollection, collection.ToArray());
+        }
+
+        [Fact]
+        public void Collection_InsertRange_Null_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            Exception ex = Assert.Throws<ArgumentNullException>(() => collection.InsertRange(0, null));
+        }
+
+        [Fact]
+        public void Collection_InsertRange_ReadOnly_Test()
+        {
+            int[] expected = new int[] { 1, 2, 3, 4 };
+            int[] baseCollection = new int[] { 5, 6, 7, 8 };
+            Collection<int> collection = new Collection<int>(baseCollection);
+
+            Exception ex = Assert.Throws<NotSupportedException>(() => collection.InsertRange(0, expected));
+        }
+
+        [Fact]
+        public void Collection_InsertRange_IndexLessThan0_Test()
+        {
+            int[] expected = new int[] { 1, 2, 3, 4 };
+            Collection<int> collection = new Collection<int>();
+            Exception ex = Assert.Throws<ArgumentOutOfRangeException>(() => collection.InsertRange(-1, expected));
+        }
+
+        [Fact]
+        public void Collection_InsertRange_IndexGreaterThanCount_Test()
+        {
+            int[] expected = new int[] { 1, 2, 3, 4 };
+            Collection<int> collection = new Collection<int>();
+            Exception ex = Assert.Throws<ArgumentOutOfRangeException>(() => collection.InsertRange(10, expected));
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_Overflow_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+            collection.Add(3);
+
+            Assert.Throws<ArgumentException>(() => collection.RemoveRange(0, 4));
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_IntMaxValueOverflow_Test()
+        {
+            var count = 500;
+            Collection<int> collection = new Collection<int>();
+            for (int i = 0; i < count; i++)
+            {
+                collection.Add(i);
+            }
+
+            Assert.Throws<ArgumentException>(() => collection.RemoveRange(collection.Count - 2, int.MaxValue));
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_CountIsZero_Test()
+        {
+            int[] expected = new int[] { 1, 2, 3, 4, 5 };
+            Collection<int> collection = new Collection<int>();
+            for (int i = 0; i < expected.Length; i++)
+            {
+                collection.Add(expected[i]);
+            }
+
+            collection.RemoveRange(0, 0);
+
+            Assert.NotNull(collection);
+            Assert.Equal(expected.Length, collection.Count);
+            Assert.Equal(expected, collection.ToArray());
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_CountIsLessThanZero_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+
+            Assert.Throws<ArgumentOutOfRangeException>(() => collection.RemoveRange(0, -1));
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_All_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+            collection.Add(3);
+
+            collection.RemoveRange(0, 3);
+
+            Assert.NotNull(collection);
+            Assert.Equal(0, collection.Count);
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_FirstTwoItems_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+            collection.Add(3);
+
+            collection.RemoveRange(0, 2);
+
+            Assert.NotNull(collection);
+            Assert.Equal(1, collection.Count);
+            Assert.Equal(3, collection[0]);
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_LastTwoItems_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+            collection.Add(3);
+
+            collection.RemoveRange(1, 2);
+
+            Assert.NotNull(collection);
+            Assert.Equal(1, collection.Count);
+            Assert.Equal(1, collection[0]);
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_ZeroItems_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+            collection.Add(3);
+
+            collection.RemoveRange(0, 0);
+
+            Assert.NotNull(collection);
+            Assert.Equal(3, collection.Count);
+            Assert.Equal(1, collection[0]);
+            Assert.Equal(2, collection[1]);
+            Assert.Equal(3, collection[2]);
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_IndexLessThanZero_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+            collection.Add(3);
+
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveRange(-1, 3));
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_IndexGreaterThanCollection_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+            collection.Add(3);
+
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => collection.RemoveRange(4, 3));
+        }
+
+        [Fact]
+        public void Collection_RemoveRange_ReadOnly_Test()
+        {
+            Collection<int> collection = new Collection<int>(new int[] { 1, 2, 3 });
+
+            Assert.Throws<NotSupportedException>(() => collection.RemoveRange(0, 2));
+        }
+
+        [Fact]
+        public void Collection_ReplaceRange_FirstTwo_Test()
+        {
+            int[] initial = new int[] { 1, 2, 3, 4 };
+            int[] replace = new int[] { 5, 6, 7, 8 };
+            Collection<int> collection = new Collection<int>();
+            foreach (var item in initial)
+                collection.Add(item);
+
+            collection.ReplaceRange(0, 2, replace);
+
+            Assert.NotNull(collection);
+            Assert.Equal(initial.Length + 2, collection.Count);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(replace, collectionAssertion.AsSpan(0, 4).ToArray());
+            Assert.Equal(initial.AsSpan(2, 2).ToArray(), collectionAssertion.AsSpan(4, 2).ToArray());
+        }
+
+        [Fact]
+        public void Collection_ReplaceRange_LastTwo_Test()
+        {
+            int[] initial = new int[] { 1, 2, 3, 4 };
+            int[] replace = new int[] { 5, 6, 7, 8 };
+            Collection<int> collection = new Collection<int>();
+            foreach (var item in initial)
+                collection.Add(item);
+
+            collection.ReplaceRange(2, 2, replace);
+
+            Assert.NotNull(collection);
+            Assert.Equal(initial.Length + 2, collection.Count);
+
+            int[] collectionAssertion = collection.ToArray();
+            Assert.Equal(initial.AsSpan(0, 2).ToArray(), collectionAssertion.AsSpan(0, 2).ToArray());
+            Assert.Equal(replace.AsSpan(0, 4).ToArray(), collectionAssertion.AsSpan(2, 4).ToArray());
+        }
+
+        [Fact]
+        public void Collection_ReplaceRange_MiddleTwo_Test()
+        {
+            int[] initial = new int[] { 1, 2, 3, 4 };
+            int[] replace = new int[] { 5, 6, 7, 8 };
+            Collection<int> collection = new Collection<int>();
+            foreach (var item in initial)
+                collection.Add(item);
+
+            collection.ReplaceRange(1, 2, replace);
+
+            Assert.NotNull(collection);
+            Assert.Equal(initial.Length + 2, collection.Count);
+
+            Assert.Equal(initial[0], collection[0]);
+            Assert.Equal(replace, collection.ToArray().AsSpan(1, 4).ToArray());
+            Assert.Equal(initial[3], collection[5]);
+        }
+
+        [Fact]
+        public void Collection_ReplaceRange_NullCollection_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+
+            Assert.Throws<ArgumentNullException>(() => collection.ReplaceRange(0, 2, null));
+        }
+
+        [Fact]
+        public void Collection_ReplaceRange_ReadOnly_Test()
+        {
+            Collection<int> collection = new Collection<int>(new int[] { 1, 2, 3 });
+            Assert.Throws<NotSupportedException>(() => collection.ReplaceRange(0, 2, new int[] { 4, 5 }));
+        }
+
+        [Fact]
+        public void Collection_ReplaceRange_IndexLessThanZero_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => collection.ReplaceRange(-2, 2, new int[] { 1, 2 }));
+        }
+
+        [Fact]
+        public void Collection_ReplaceRange_IndexGreaterThanCount_Test()
+        {
+            Collection<int> collection = new Collection<int>();
+            collection.Add(1);
+            collection.Add(2);
+
+            AssertExtensions.Throws<ArgumentOutOfRangeException>("index", () => collection.ReplaceRange(4, 2, new int[] { 1, 2 }));
+        }
+    }
+}