OpenTween.Tests/IndexedSortedSetTest.cs

   1 // OpenTween - Client of Twitter
   2 // Copyright (c) 2015 kim_upsilon (@kim_upsilon) <https://upsilo.net/~upsilon/>
   3 // All rights reserved.
   4 //
   5 // This file is part of OpenTween.
   6 //
   7 // This program is free software; you can redistribute it and/or modify it
   8 // under the terms of the GNU General Public License as published by the Free
   9 // Software Foundation; either version 3 of the License, or (at your option)
  10 // any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful, but
  13 // WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14 // or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  15 // for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License along
  18 // with this program. If not, see <http://www.gnu.org/licenses/>, or write to
  19 // the Free Software Foundation, Inc., 51 Franklin Street - Fifth Floor,
  20 // Boston, MA 02110-1301, USA.
  21
  22 using System;
  23 using System.Collections;
  24 using System.Collections.Generic;
  25 using System.Linq;
  26 using System.Text;
  27 using System.Threading.Tasks;
  28 using Xunit;
  29
  30 namespace OpenTween
  31 {
  32     public class IndexedSortedSetTest
  33     {
  34         [Fact]
  35         public void IndexedSortedSet_Test()
  36         {
  37             var set = new IndexedSortedSet<int>();
  38             set.Add(100);
  39             set.Add(20);
  40             set.Add(600);
  41
  42             Assert.Equal(3, set.Count);
  43             Assert.Equal(20, set[0]);
  44             Assert.Equal(100, set[1]);
  45             Assert.Equal(600, set[2]);
  46
  47             set.Remove(100);
  48             set.Add(5);
  49
  50             Assert.Equal(3, set.Count);
  51             Assert.Equal(5, set[0]);
  52             Assert.Equal(20, set[1]);
  53             Assert.Equal(600, set[2]);
  54         }
  55
  56         [Fact]
  57         public void Constructor_Test()
  58         {
  59             var set = new IndexedSortedSet<int>();
  60             Assert.Empty(set);
  61
  62             set.Add(2);
  63             set.Add(1);
  64             set.Add(3);
  65             Assert.Equal(new[] { 1, 2, 3 }, set);
  66         }
  67
  68         [Fact]
  69         public void Constructor_WithComparerTest()
  70         {
  71             // 逆順にソートする Comparer
  72             var comparer = Comparer<int>.Create((x, y) => -x.CompareTo(y));
  73             var set = new IndexedSortedSet<int>(comparer);
  74             Assert.Empty(set);
  75
  76             set.Add(2);
  77             set.Add(1);
  78             set.Add(3);
  79             Assert.Equal(new[] { 3, 2, 1 }, set);
  80         }
  81
  82         [Fact]
  83         public void Constructor_WithEnumerableTest()
  84         {
  85             var set = new IndexedSortedSet<int>(new[] { 2, 1, 3 });
  86
  87             Assert.Equal(new[] { 1, 2, 3 }, set);
  88         }
  89
  90         [Fact]
  91         public void Constructor_WithEnumerableAndComparerTest()
  92         {
  93             // 逆順にソートする Comparer
  94             var comparer = Comparer<int>.Create((x, y) => -x.CompareTo(y));
  95             var set = new IndexedSortedSet<int>(new[] { 2, 1, 3 }, comparer);
  96
  97             Assert.Equal(new[] { 3, 2, 1 }, set);
  98         }
  99
 100         [Fact]
 101         public void Count_Test()
 102         {
 103             var set = new IndexedSortedSet<int>();
 104
 105             Assert.Empty(set);
 106
 107             set.Add(1);
 108             Assert.Single(set);
 109         }
 110
 111         [Fact]
 112         public void IsReadOnly_Test()
 113         {
 114             var set = new IndexedSortedSet<int>();
 115             Assert.False(set.IsReadOnly);
 116         }
 117
 118         [Fact]
 119         public void Getter_Test()
 120         {
 121             var set = new IndexedSortedSet<int> { 1, 2, 3 };
 122
 123             Assert.Equal(1, set[0]);
 124             Assert.Equal(2, set[1]);
 125             Assert.Equal(3, set[2]);
 126
 127             Assert.Throws<ArgumentOutOfRangeException>(() => set[-1]);
 128             Assert.Throws<ArgumentOutOfRangeException>(() => set[99]);
 129         }
 130
 131         [Fact]
 132         public void Add_Test()
 133         {
 134             var set = new IndexedSortedSet<int>();
 135
 136             Assert.True(set.Add(3));
 137             Assert.True(set.Add(1));
 138             Assert.True(set.Add(2));
 139             Assert.Equal(new[] { 1, 2, 3 }, set);
 140
 141             Assert.False(set.Add(1));
 142             Assert.Equal(new[] { 1, 2, 3 }, set);
 143         }
 144
 145         [Fact]
 146         public void Add_ICollectionTest()
 147         {
 148             var set = new IndexedSortedSet<int>();
 149             var collection = (ICollection<int>)set;
 150
 151             collection.Add(3);
 152             collection.Add(1);
 153             collection.Add(2);
 154             Assert.Equal(new[] { 1, 2, 3 }, set);
 155
 156             collection.Add(1);
 157             Assert.Equal(new[] { 1, 2, 3 }, set);
 158         }
 159
 160         [Fact]
 161         public void Remove_Test()
 162         {
 163             var set = new IndexedSortedSet<int> { 1, 2, 3 };
 164
 165             Assert.True(set.Remove(2));
 166             Assert.Equal(new[] { 1, 3 }, set);
 167
 168             Assert.False(set.Remove(999));
 169             Assert.Equal(new[] { 1, 3 }, set);
 170         }
 171
 172         [Fact]
 173         public void Clear_Test()
 174         {
 175             var set = new IndexedSortedSet<int> { 1, 2, 3 };
 176
 177             set.Clear();
 178             Assert.Empty(set);
 179         }
 180
 181         [Fact]
 182         public void Contains_Test()
 183         {
 184             var set = new IndexedSortedSet<int> { 1, 2, 3 };
 185
 186             Assert.True(set.Contains(2));
 187             Assert.False(set.Contains(999));
 188         }
 189
 190         [Fact]
 191         public void IndexOf_Test()
 192         {
 193             var set = new IndexedSortedSet<int> { 10, 15, 20 };
 194
 195             Assert.Equal(0, set.IndexOf(10));
 196             Assert.Equal(1, set.IndexOf(15));
 197             Assert.Equal(2, set.IndexOf(20));
 198
 199             Assert.Equal(-1, set.IndexOf(0));
 200             Assert.Equal(-1, set.IndexOf(12));
 201             Assert.Equal(-1, set.IndexOf(50));
 202         }
 203
 204         [Fact]
 205         public void RemoveAt_Test()
 206         {
 207             var set = new IndexedSortedSet<int> { 1, 2, 3 };
 208
 209             set.RemoveAt(1);
 210             Assert.Equal(new[] { 1, 3 }, set);
 211
 212             Assert.Throws<ArgumentOutOfRangeException>(() => set.RemoveAt(-1));
 213             Assert.Throws<ArgumentOutOfRangeException>(() => set.RemoveAt(99));
 214         }
 215
 216         [Fact]
 217         public void CopyTo_Test()
 218         {
 219             var set = new IndexedSortedSet<string> { "aaa", "bbb", "ccc" };
 220
 221             var array = new string[5];
 222             set.CopyTo(array, 0);
 223
 224             Assert.Equal("aaa", array[0]);
 225             Assert.Equal("bbb", array[1]);
 226             Assert.Equal("ccc", array[2]);
 227             Assert.Null(array[3]);
 228             Assert.Null(array[4]);
 229
 230             array = new string[5];
 231             set.CopyTo(array, 1);
 232
 233             Assert.Null(array[0]);
 234             Assert.Equal("aaa", array[1]);
 235             Assert.Equal("bbb", array[2]);
 236             Assert.Equal("ccc", array[3]);
 237             Assert.Null(array[4]);
 238
 239             array = new string[5];
 240
 241             Assert.Throws<ArgumentException>(() => set.CopyTo(array, 3));
 242             Assert.Throws<ArgumentException>(() => set.CopyTo(array, 5));
 243             Assert.Throws<ArgumentOutOfRangeException>(() => set.CopyTo(array, -1));
 244             Assert.Throws<ArgumentNullException>(() => set.CopyTo(null, 0));
 245         }
 246
 247         [Fact]
 248         public void Enumerator_Test()
 249         {
 250             var set = new IndexedSortedSet<string> { "aaa", "bbb", "ccc" };
 251
 252             var enumerator = set.GetEnumerator();
 253
 254             Assert.True(enumerator.MoveNext());
 255             Assert.Equal("aaa", enumerator.Current);
 256             Assert.True(enumerator.MoveNext());
 257             Assert.Equal("bbb", enumerator.Current);
 258             Assert.True(enumerator.MoveNext());
 259             Assert.Equal("ccc", enumerator.Current);
 260             Assert.False(enumerator.MoveNext());
 261         }
 262
 263         [Fact]
 264         public void Enumerator_NonGenericTest()
 265         {
 266             var set = new IndexedSortedSet<string> { "aaa", "bbb", "ccc" };
 267
 268             var enumerator = ((IEnumerable)set).GetEnumerator();
 269
 270             Assert.True(enumerator.MoveNext());
 271             Assert.Equal("aaa", enumerator.Current);
 272             Assert.True(enumerator.MoveNext());
 273             Assert.Equal("bbb", enumerator.Current);
 274             Assert.True(enumerator.MoveNext());
 275             Assert.Equal("ccc", enumerator.Current);
 276             Assert.False(enumerator.MoveNext());
 277         }
 278
 279         [Fact]
 280         public void UnionWith_Test()
 281         {
 282             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 283
 284             // 和集合
 285             set.UnionWith(new[] { 6, 4, 3, 5 });
 286
 287             Assert.Equal(new[] { 1, 2, 3, 4, 5, 6 }, set);
 288         }
 289
 290         [Fact]
 291         public void IntersectWith_Test()
 292         {
 293             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 294
 295             // 積集合
 296             set.IntersectWith(new[] { 6, 4, 3, 5 });
 297
 298             Assert.Equal(new[] { 3, 4 }, set);
 299         }
 300
 301         [Fact]
 302         public void ExceptWith_Test()
 303         {
 304             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 305
 306             // 差集合
 307             set.ExceptWith(new[] { 6, 4, 3, 5 });
 308
 309             Assert.Equal(new[] { 1, 2 }, set);
 310         }
 311
 312         [Fact]
 313         public void SymmetricExceptWith_Test()
 314         {
 315             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 316
 317             // 対称差
 318             set.SymmetricExceptWith(new[] { 6, 4, 3, 5 });
 319
 320             Assert.Equal(new[] { 1, 2, 5, 6 }, set);
 321         }
 322
 323         [Fact]
 324         public void IsSubsetOf_Test()
 325         {
 326             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 327
 328             // 部分集合
 329             Assert.True(set.IsSubsetOf(new[] { 1, 2, 3, 4, 5, 6 }));
 330             Assert.True(set.IsSubsetOf(new[] { 1, 2, 3, 4 }));
 331             Assert.False(set.IsSubsetOf(new[] { 1, 3, 5, 7 }));
 332             Assert.False(set.IsSubsetOf(new[] { -1, -2, -3, -4 }));
 333         }
 334
 335         [Fact]
 336         public void IsSupersetOf_Test()
 337         {
 338             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 339
 340             // 上位集合
 341             Assert.True(set.IsSupersetOf(new[] { 2, 3 }));
 342             Assert.True(set.IsSupersetOf(new[] { 1, 2, 3, 4 }));
 343             Assert.False(set.IsSupersetOf(new[] { 1, 2, 3, 4, 5, 6 }));
 344             Assert.False(set.IsSupersetOf(new[] { -1, -2, -3, -4 }));
 345         }
 346
 347         [Fact]
 348         public void IsProperSubsetOf_Test()
 349         {
 350             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 351
 352             // 真部分集合
 353             Assert.True(set.IsProperSubsetOf(new[] { 1, 2, 3, 4, 5, 6 }));
 354             Assert.False(set.IsProperSubsetOf(new[] { 1, 2, 3, 4 }));
 355             Assert.False(set.IsProperSubsetOf(new[] { 1, 3, 5, 7 }));
 356             Assert.False(set.IsProperSubsetOf(new[] { -1, -2, -3, -4 }));
 357         }
 358
 359         [Fact]
 360         public void IsProperSupersetOf_Test()
 361         {
 362             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 363
 364             // 真上位集合
 365             Assert.True(set.IsProperSupersetOf(new[] { 2, 3 }));
 366             Assert.False(set.IsProperSupersetOf(new[] { 1, 2, 3, 4 }));
 367             Assert.False(set.IsProperSupersetOf(new[] { 1, 2, 3, 4, 5, 6 }));
 368             Assert.False(set.IsProperSupersetOf(new[] { -1, -2, -3, -4 }));
 369         }
 370
 371         [Fact]
 372         public void Overlaps_Test()
 373         {
 374             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 375
 376             // 共通する要素が存在するか
 377             Assert.True(set.Overlaps(new[] { 1, 10, 100, 1000 }));
 378             Assert.True(set.Overlaps(new[] { 1, 2, 3, 4 }));
 379             Assert.False(set.Overlaps(new[] { -1, -2, -3, -4 }));
 380         }
 381
 382         [Fact]
 383         public void SetEquals_Test()
 384         {
 385             var set = new IndexedSortedSet<int> { 1, 2, 3, 4 };
 386
 387             // 等しい集合であるか
 388             Assert.True(set.SetEquals(new[] { 1, 2, 3, 4 }));
 389             Assert.False(set.SetEquals(new[] { 1, 2 }));
 390             Assert.False(set.SetEquals(new[] { 1, 2, 3, 4, 5, 6 }));
 391             Assert.False(set.SetEquals(new[] { 8, 9 }));
 392
 393             // 重複は無視される
 394             Assert.True(set.SetEquals(new[] { 1, 2, 2, 3, 3, 4 }));
 395         }
 396     }
 397 }