Add some additional micro benchmark coverage for immutable collections.

src/benchmarks/micro/libraries/System.Collections/AddRemove/AddRemoveSteadyState.cs

@@ -4,6 +4,7 @@
 
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Extensions;
 using MicroBenchmarks;
@@ -20,6 +21,8 @@ public class Add_Remove_SteadyState<T> // serialized producer/consumer throughpu
         private ConcurrentStack<T> _concurrentStack;
         private Queue<T> _queue;
         private Stack<T> _stack;
+        private ImmutableQueue<T> _immutableQueue;
+        private ImmutableStack<T> _immutableStack;
 
         [Params(Utils.DefaultCollectionSize)]
         public int Count;
@@ -73,5 +76,23 @@ public void Stack()
             T item = _stack.Pop();
             _stack.Push(item);
         }
+
+        [GlobalSetup(Target = nameof(ImmutableQueue))]
+        public void SetupImmutableQueue() => _immutableQueue = Immutable.ImmutableQueue.CreateRange<T>(ValuesGenerator.ArrayOfUniqueValues<T>(Count));
+
+        [Benchmark]
+        public void ImmutableQueue()
+        {
+            _immutableQueue = _immutableQueue.Dequeue(out T item).Enqueue(item);
+        }
+
+        [GlobalSetup(Target = nameof(ImmutableStack))]
+        public void SetupImmutableStack() => _immutableStack = Immutable.ImmutableStack.CreateRange<T>(ValuesGenerator.ArrayOfUniqueValues<T>(Count));
+
+        [Benchmark]
+        public void ImmutableStack()
+        {
+            _immutableStack = _immutableStack.Pop(out T item).Push(item);
+        }
     }
 }

src/benchmarks/micro/libraries/System.Collections/CreateAddAndClear.cs

@@ -7,6 +7,7 @@
 using MicroBenchmarks;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Collections.Immutable;
 using System.Runtime.CompilerServices;
 
 namespace System.Collections
@@ -237,5 +238,93 @@ public ConcurrentBag<T> ConcurrentBag()
             return concurrentBag;
         }
 #endif
+
+        [Benchmark]
+        public ImmutableArray<T> ImmutableArray()
+        {
+            ImmutableArray<T> immutableArray = ImmutableArray<T>.Empty;
+            foreach (T value in _uniqueValues)
+            {
+                immutableArray = immutableArray.Add(value);
+            }
+            return immutableArray.Clear();
+        }
+
+        [Benchmark]
+        public ImmutableList<T> ImmutableList()
+        {
+            ImmutableList<T> immutableList = ImmutableList<T>.Empty;
+            foreach (T value in _uniqueValues)
+            {
+                immutableList = immutableList.Add(value);
+            }
+            return immutableList.Clear();
+        }
+
+        [Benchmark]
+        public ImmutableDictionary<T, T> ImmutableDictionary()
+        {
+            ImmutableDictionary<T, T> immutableDictionary = ImmutableDictionary<T, T>.Empty;
+            foreach (T value in _uniqueValues)
+            {
+                immutableDictionary = immutableDictionary.Add(value, value);
+            }
+            return immutableDictionary.Clear();
+        }
+
+        [Benchmark]
+        public ImmutableHashSet<T> ImmutableHashSet()
+        {
+            ImmutableHashSet<T> immutableHashSet = ImmutableHashSet<T>.Empty;
+            foreach (T value in _uniqueValues)
+            {
+                immutableHashSet = immutableHashSet.Add(value);
+            }
+            return immutableHashSet.Clear();
+        }
+
+        [Benchmark]
+        public ImmutableSortedDictionary<T, T> ImmutableSortedDictionary()
+        {
+            ImmutableSortedDictionary<T, T> immutableSortedDictionary = ImmutableSortedDictionary<T, T>.Empty;
+            foreach (T value in _uniqueValues)
+            {
+                immutableSortedDictionary = immutableSortedDictionary.Add(value, value);
+            }
+            return immutableSortedDictionary.Clear();
+        }
+
+        [Benchmark]
+        public ImmutableSortedSet<T> ImmutableSortedSet()
+        {
+            ImmutableSortedSet<T> immutableSortedSet = ImmutableSortedSet<T>.Empty;
+            foreach (T value in _uniqueValues)
+            {
+                immutableSortedSet = immutableSortedSet.Add(value);
+            }
+            return immutableSortedSet.Clear();
+        }
+
+        [Benchmark]
+        public ImmutableStack<T> ImmutableStack()
+        {
+            ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
+            foreach (T value in _uniqueValues)
+            {
+                immutableStack = immutableStack.Push(value);
+            }
+            return immutableStack.Clear();
+        }
+
+        [Benchmark]
+        public ImmutableQueue<T> ImmutableQueue()
+        {
+            ImmutableQueue<T> immutableQueue = ImmutableQueue<T>.Empty;
+            foreach (T value in _uniqueValues)
+            {
+                immutableQueue = immutableQueue.Enqueue(value);
+            }
+            return immutableQueue.Clear();
+        }
     }
 }