public void TestMultipleElementSet()
        {
            var values = new[] { Generator.GetInt32().ToString(), Generator.GetInt32().ToString(), Generator.GetInt32().ToString() };

            // Construction using ImmutableSortedTreeSet.Create
            var set = ImmutableSortedTreeSet.Create(values);

            Assert.Equal(values.OrderBy(x => x, Comparer <string> .Default), set);

            set = ImmutableSortedTreeSet.Create <string>(comparer: null, values);
            Assert.Same(Comparer <string> .Default, set.KeyComparer);
            Assert.Equal(values.OrderBy(x => x, Comparer <string> .Default), set);

            set = ImmutableSortedTreeSet.Create(StringComparer.OrdinalIgnoreCase, values);
            Assert.Same(StringComparer.OrdinalIgnoreCase, set.KeyComparer);
            Assert.Equal(values.OrderBy(x => x, StringComparer.OrdinalIgnoreCase), set);

            // Construction using ImmutableSortedTreeSet.ToImmutableSortedTreeSet
            set = values.ToImmutableSortedTreeSet();
            Assert.Same(Comparer <string> .Default, set.KeyComparer);
            Assert.Equal(values.OrderBy(x => x, Comparer <string> .Default), set);

            set = values.ToImmutableSortedTreeSet(comparer: null);
            Assert.Same(Comparer <string> .Default, set.KeyComparer);
            Assert.Equal(values.OrderBy(x => x, Comparer <string> .Default), set);

            set = values.ToImmutableSortedTreeSet(StringComparer.OrdinalIgnoreCase);
            Assert.Same(StringComparer.OrdinalIgnoreCase, set.KeyComparer);
            Assert.Equal(values.OrderBy(x => x, StringComparer.OrdinalIgnoreCase), set);
        }
        public void TestEmptyImmutableSortedTreeSet()
        {
            var set = ImmutableSortedTreeSet.Create <int>();

            Assert.Same(ImmutableSortedTreeSet <int> .Empty, set);
            Assert.Empty(set);
        }
        public void TestUnsupportedISetOperations()
        {
            ISet <int> set = ImmutableSortedTreeSet.Create <int>();

            Assert.Throws <NotSupportedException>(() => set.Add(1));
            Assert.Throws <NotSupportedException>(() => set.UnionWith(Enumerable.Empty <int>()));
            Assert.Throws <NotSupportedException>(() => set.IntersectWith(Enumerable.Empty <int>()));
            Assert.Throws <NotSupportedException>(() => set.ExceptWith(Enumerable.Empty <int>()));
            Assert.Throws <NotSupportedException>(() => set.SymmetricExceptWith(Enumerable.Empty <int>()));
        }
        public void TestIListTInterface()
        {
            TestIListTInterfaceImpl(ImmutableSortedTreeSet.Create(600, 601), supportsNullValues: false);
            TestIListTInterfaceImpl(ImmutableSortedTreeSet.Create <int?>(600, 601), supportsNullValues: true);
            TestIListTInterfaceImpl(ImmutableSortedTreeSet.Create <object>(600, 601), supportsNullValues: true);

            // Run the same set of tests on List<T> to ensure consistent behavior
            TestIListTInterfaceImpl(ImmutableList.Create(600, 601), supportsNullValues: false);
            TestIListTInterfaceImpl(ImmutableList.Create <int?>(600, 601), supportsNullValues: true);
            TestIListTInterfaceImpl(ImmutableList.Create <object>(600, 601), supportsNullValues: true);
        }
        public void TestExplicitComparer()
        {
            var objComparer        = new ComparisonComparer <object>((x, y) => 0);
            var intComparer        = new ComparisonComparer <int>((x, y) => 0);
            var comparableComparer = new ComparisonComparer <IComparable>((x, y) => 0);

            Assert.Same(objComparer, ImmutableSortedTreeSet.Create <object>(comparer: objComparer).KeyComparer);
            Assert.Same(intComparer, ImmutableSortedTreeSet.Create <int>(comparer: intComparer).KeyComparer);
            Assert.Same(comparableComparer, ImmutableSortedTreeSet.Create <IComparable>(comparer: comparableComparer).KeyComparer);

            Assert.Same(objComparer, ImmutableSortedTreeSet.CreateRange <object>(comparer: objComparer, Enumerable.Empty <object>()).KeyComparer);
            Assert.Same(intComparer, ImmutableSortedTreeSet.CreateRange <int>(comparer: intComparer, Enumerable.Empty <int>()).KeyComparer);
            Assert.Same(comparableComparer, ImmutableSortedTreeSet.CreateRange <IComparable>(comparer: comparableComparer, Enumerable.Empty <IComparable>()).KeyComparer);
        }
        public void TestSingleElementSet()
        {
            var value = Generator.GetInt32().ToString();
            var set   = ImmutableSortedTreeSet.Create(value);

            Assert.Equal(new[] { value }, set);

            set = ImmutableSortedTreeSet.Create(comparer: null, value);
            Assert.Same(Comparer <string> .Default, set.KeyComparer);
            Assert.Equal(new[] { value }, set);

            set = ImmutableSortedTreeSet.Create(StringComparer.OrdinalIgnoreCase, value);
            Assert.Same(StringComparer.OrdinalIgnoreCase, set.KeyComparer);
            Assert.Equal(new[] { value }, set);
        }
        public void TestCollectionConstructorUsesCorrectComparer()
        {
            var instance1 = new StrongBox <int>(1);
            var instance2 = new StrongBox <int>(2);
            var comparer  = new ComparisonComparer <StrongBox <int> >((x, y) => Comparer <int> .Default.Compare(x.Value, y.Value));
            var objectSet = ImmutableSortedTreeSet.Create(comparer, new[] { instance1, instance2, instance1 }).ToBuilder();

            Assert.Same(comparer, objectSet.KeyComparer);
            Assert.Equal(2, objectSet.Count);
            Assert.Equal(new[] { instance1, instance2 }, objectSet);

            ImmutableSortedTreeSet <string?> .Builder stringSet = ImmutableSortedTreeSet.CreateBuilder <string?>();
            Assert.Same(Comparer <string> .Default, stringSet.KeyComparer);

            stringSet = ImmutableSortedTreeSet.CreateBuilder(StringComparer.OrdinalIgnoreCase);
            Assert.Same(StringComparer.OrdinalIgnoreCase, stringSet.KeyComparer);
        }
        public void TestICollectionInterface()
        {
            TestICollectionInterfaceImpl(ImmutableSortedTreeSet.Create <int>(600, 601).ToBuilder(), isOwnSyncRoot: true, supportsNullValues: false);
            TestICollectionInterfaceImpl(ImmutableSortedTreeSet.Create <int?>(600, 601).ToBuilder(), isOwnSyncRoot: true, supportsNullValues: true);
            TestICollectionInterfaceImpl(ImmutableSortedTreeSet.Create <object>(600, 601).ToBuilder(), isOwnSyncRoot: true, supportsNullValues: true);

            // Run the same set of tests on SortedSet<T> to ensure consistent behavior
            TestICollectionInterfaceImpl(new SortedSet <int> {
                600, 601
            }, isOwnSyncRoot: false, supportsNullValues: false);
            TestICollectionInterfaceImpl(new SortedSet <int?> {
                600, 601
            }, isOwnSyncRoot: false, supportsNullValues: true);
            TestICollectionInterfaceImpl(new SortedSet <object> {
                600, 601
            }, isOwnSyncRoot: false, supportsNullValues: true);
        }
        public void TestDefaultComparer()
        {
            Assert.Same(Comparer <object> .Default, ImmutableSortedTreeSet.Create <object>().KeyComparer);
            Assert.Same(Comparer <int> .Default, ImmutableSortedTreeSet.Create <int>().KeyComparer);
            Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeSet.Create <IComparable>().KeyComparer);

            Assert.Same(Comparer <object> .Default, ImmutableSortedTreeSet.CreateRange <object>(Enumerable.Empty <object>()).KeyComparer);
            Assert.Same(Comparer <int> .Default, ImmutableSortedTreeSet.CreateRange <int>(Enumerable.Empty <int>()).KeyComparer);
            Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeSet.CreateRange <IComparable>(Enumerable.Empty <IComparable>()).KeyComparer);

            Assert.Same(Comparer <object> .Default, ImmutableSortedTreeSet.Create <object>(comparer: null).KeyComparer);
            Assert.Same(Comparer <int> .Default, ImmutableSortedTreeSet.Create <int>(comparer: null).KeyComparer);
            Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeSet.Create <IComparable>(comparer: null).KeyComparer);

            Assert.Same(Comparer <object> .Default, ImmutableSortedTreeSet.CreateRange <object>(comparer: null, Enumerable.Empty <object>()).KeyComparer);
            Assert.Same(Comparer <int> .Default, ImmutableSortedTreeSet.CreateRange <int>(comparer: null, Enumerable.Empty <int>()).KeyComparer);
            Assert.Same(Comparer <IComparable> .Default, ImmutableSortedTreeSet.CreateRange <IComparable>(comparer: null, Enumerable.Empty <IComparable>()).KeyComparer);
        }
 public void TestImmutableSortedTreeSetCreateValidation()
 {
     Assert.Throws <ArgumentNullException>("other", () => ImmutableSortedTreeSet.Create(default(int[]) !));
     Assert.Throws <ArgumentNullException>("other", () => ImmutableSortedTreeSet.Create(Comparer <int> .Default, default(int[]) !));
 }
 public void TestIListInterface()
 {
     TestIListInterfaceImpl(ImmutableSortedTreeSet.Create <int>(600, 601), supportsNullValues: false);
     TestIListInterfaceImpl(ImmutableSortedTreeSet.Create <int?>(600, 601), supportsNullValues: true);
     TestIListInterfaceImpl(ImmutableSortedTreeSet.Create <ValueType>(600, 601), supportsNullValues: true);
 }