HmLibTest/Models/IgnoreCaseSetTest.cs

   1 // ================================================================================================
   2 // <summary>
   3 //      IgnoreCaseSetのテストクラスソース。</summary>
   4 //
   5 // <copyright file="IgnoreCaseSetTest.cs" company="honeplusのメモ帳">
   6 //      Copyright (C) 2012 Honeplus. All rights reserved.</copyright>
   7 // <author>
   8 //      Honeplus</author>
   9 // ================================================================================================
  10
  11 namespace Honememo.Models
  12 {
  13     using System;
  14     using System.Collections.Generic;
  15     using Microsoft.VisualStudio.TestTools.UnitTesting;
  16
  17     /// <summary>
  18     /// <see cref="IgnoreCaseSet"/>のテストクラスです。
  19     /// </summary>
  20     [TestClass]
  21     public class IgnoreCaseSetTest
  22     {
  23         #region コンストラクタテストケース
  24
  25         /// <summary>
  26         /// コンストラクタテストケース（引数なし）。
  27         /// </summary>
  28         [TestMethod]
  29         public void TestConstructor()
  30         {
  31             IgnoreCaseSet set = new IgnoreCaseSet();
  32             Assert.AreEqual(0, set.Set.Count);
  33         }
  34
  35         /// <summary>
  36         /// コンストラクタテストケース（引数Set）。
  37         /// </summary>
  38         [TestMethod]
  39         public void TestConstructorSet()
  40         {
  41             ISet<string> inner = new HashSet<string>();
  42             inner.Add("TestValue");
  43             IgnoreCaseSet set = new IgnoreCaseSet(inner);
  44             Assert.AreEqual(inner, set.Set);
  45             Assert.IsTrue(set.Contains("TESTValue"));
  46         }
  47
  48         /// <summary>
  49         /// コンストラクタテストケース（引数Enumerable）。
  50         /// </summary>
  51         [TestMethod]
  52         public void TestConstructorEnumerable()
  53         {
  54             IList<string> other = new List<string>();
  55             other.Add("TestValue");
  56             IgnoreCaseSet set = new IgnoreCaseSet(other);
  57             Assert.IsTrue(set.Contains("TESTValue"));
  58         }
  59
  60         /// <summary>
  61         /// コンストラクタテストケース（null値）。
  62         /// </summary>
  63         [TestMethod]
  64         [ExpectedException(typeof(ArgumentNullException))]
  65         public void TestConstructorSetNull()
  66         {
  67             new IgnoreCaseSet(null);
  68         }
  69
  70         #endregion
  71
  72         #region 独自実装公開プロパティテストケース
  73
  74         /// <summary>
  75         /// Setプロパティテストケース（正常系）。
  76         /// </summary>
  77         [TestMethod]
  78         public void TestSet()
  79         {
  80             IgnoreCaseSet set = new IgnoreCaseSet();
  81             ISet<string> inner = new HashSet<string>();
  82             inner.Add("TestValue");
  83             set.Set = inner;
  84             Assert.AreSame(inner, set.Set);
  85             Assert.IsTrue(set.Contains("TESTvalue"));
  86         }
  87
  88         /// <summary>
  89         /// Setプロパティテストケース（null値）。
  90         /// </summary>
  91         [TestMethod]
  92         [ExpectedException(typeof(ArgumentNullException))]
  93         public void TestSetNull()
  94         {
  95             IgnoreCaseSet set = new IgnoreCaseSet();
  96             set.Set = null;
  97         }
  98
  99         #endregion
 100
 101         #region ラップするインスタンスを参照するプロパティテストケース
 102
 103         /// <summary>
 104         /// Countプロパティテストケース。
 105         /// </summary>
 106         [TestMethod]
 107         public void TestCount()
 108         {
 109             // ラップするISetと同じ値であること
 110             ISet<string> inner = new HashSet<string>();
 111             inner.Add("TestValue");
 112             IgnoreCaseSet set = new IgnoreCaseSet(inner);
 113             Assert.AreEqual(inner.Count, set.Count);
 114         }
 115
 116         /// <summary>
 117         /// IsReadOnlyプロパティテストケース。
 118         /// </summary>
 119         [TestMethod]
 120         public void TestIsReadOnly()
 121         {
 122             // ラップするISetと同じ値であること
 123             ISet<string> inner = new HashSet<string>();
 124             inner.Add("TestValue");
 125             IgnoreCaseSet set = new IgnoreCaseSet(inner);
 126             Assert.AreEqual(inner.IsReadOnly, set.IsReadOnly);
 127         }
 128
 129         #endregion
 130
 131         #region 独自実装メソッドテストケース
 132
 133         /// <summary>
 134         /// Addメソッドテストケース（正常系）。
 135         /// </summary>
 136         [TestMethod]
 137         public void TestAdd()
 138         {
 139             IgnoreCaseSet set = new IgnoreCaseSet();
 140             Assert.AreEqual(0, set.Count);
 141             set.Add("TestValue");
 142             Assert.AreEqual(1, set.Count);
 143             Assert.IsTrue(set.Contains("TESTvalue"));
 144             Assert.IsTrue(set.Set.Contains("TestValue"));
 145             Assert.IsFalse(set.Set.Contains("TESTvalue"));
 146             set.Add("tESTvALUE2");
 147             Assert.AreEqual(2, set.Count);
 148             Assert.IsTrue(set.Contains("TESTvalue2"));
 149             Assert.IsTrue(set.Set.Contains("tESTvALUE2"));
 150         }
 151
 152         /// <summary>
 153         /// Addメソッドテストケース（null値）。
 154         /// </summary>
 155         [TestMethod]
 156         [ExpectedException(typeof(ArgumentNullException))]
 157         public void TestAddNull()
 158         {
 159             new IgnoreCaseSet().Add(null);
 160         }
 161
 162         /// <summary>
 163         /// Containsメソッドテストケース（正常系）。
 164         /// </summary>
 165         [TestMethod]
 166         public void TestContains()
 167         {
 168             IgnoreCaseSet set = new IgnoreCaseSet();
 169             Assert.IsFalse(set.Contains("TestValue"));
 170             set.Add("TestValue");
 171             Assert.IsTrue(set.Contains("TestValue"));
 172             Assert.IsTrue(set.Contains("tESTvALue"));
 173             Assert.IsFalse(set.Contains("TestValue2"));
 174         }
 175
 176         /// <summary>
 177         /// Containsメソッドテストケース（null値）。
 178         /// </summary>
 179         [TestMethod]
 180         [ExpectedException(typeof(ArgumentNullException))]
 181         public void TestContainsNull()
 182         {
 183             new IgnoreCaseSet().Contains(null);
 184         }
 185
 186         /// <summary>
 187         /// Clearメソッドテストケース。
 188         /// </summary>
 189         [TestMethod]
 190         public void TestClear()
 191         {
 192             // 全データが削除されること、またラップしているオブジェクトは維持されること
 193             ISet<string> inner = new HashSet<string>();
 194             IgnoreCaseSet set = new IgnoreCaseSet(inner);
 195             set.Add("TestValue");
 196             set.Add("tESTVAlue2");
 197             Assert.AreEqual(2, set.Count);
 198             Assert.AreSame(inner, set.Set);
 199
 200             set.Clear();
 201             Assert.AreEqual(0, set.Count);
 202             Assert.AreSame(inner, set.Set);
 203         }
 204
 205         /// <summary>
 206         /// CopyToメソッドテストケース（正常系）。
 207         /// </summary>
 208         [TestMethod]
 209         public void TestCopyTo()
 210         {
 211             IgnoreCaseSet set = new IgnoreCaseSet();
 212             set.Add("TestValue");
 213             set.Add("tESTvAlue2");
 214             string[] array = new string[5];
 215             set.CopyTo(array, 3);
 216             Assert.IsNull(array[0]);
 217             Assert.IsNull(array[1]);
 218             Assert.IsNull(array[2]);
 219             Assert.AreEqual("TestValue", array[3]);
 220             Assert.AreEqual("tESTvAlue2", array[4]);
 221         }
 222
 223         /// <summary>
 224         /// CopyToメソッドテストケース（null値）。
 225         /// </summary>
 226         [TestMethod]
 227         [ExpectedException(typeof(ArgumentNullException))]
 228         public void TestCopyToNull()
 229         {
 230             new IgnoreCaseSet().CopyTo(null, 0);
 231         }
 232
 233         /// <summary>
 234         /// CopyToメソッドテストケース（インデックスがマイナス値）。
 235         /// </summary>
 236         [TestMethod]
 237         [ExpectedException(typeof(ArgumentOutOfRangeException))]
 238         public void TestCopyToOutOfRange()
 239         {
 240             new IgnoreCaseSet().CopyTo(new string[5], -1);
 241         }
 242
 243         /// <summary>
 244         /// CopyToメソッドテストケース（領域不足）。
 245         /// </summary>
 246         [TestMethod]
 247         [ExpectedException(typeof(ArgumentException))]
 248         public void TestCopyToOverflow()
 249         {
 250             IgnoreCaseSet set = new IgnoreCaseSet();
 251             set.Add("TestValue");
 252             set.Add("tESTvAlue2");
 253             set.CopyTo(new string[5], 4);
 254         }
 255
 256         /// <summary>
 257         /// ExceptWithメソッドテストケース（正常系）。
 258         /// </summary>
 259         [TestMethod]
 260         public void TestExceptWith()
 261         {
 262             IgnoreCaseSet set = new IgnoreCaseSet();
 263             set.Add("TestValue");
 264             set.Add("tESTvAlue2");
 265             set.Add("testvalue3");
 266             set.ExceptWith(new string[] { "TestValue", "testvalUE2", "TestValue4" });
 267             Assert.AreEqual(1, set.Count);
 268             Assert.IsTrue(set.Set.Contains("testvalue3"));
 269         }
 270
 271         /// <summary>
 272         /// ExceptWithメソッドテストケース（null値）。
 273         /// </summary>
 274         [TestMethod]
 275         [ExpectedException(typeof(ArgumentNullException))]
 276         public void TestExceptWithNull()
 277         {
 278             new IgnoreCaseSet().ExceptWith(null);
 279         }
 280
 281         /// <summary>
 282         /// IntersectWithメソッドテストケース（正常系）。
 283         /// </summary>
 284         [TestMethod]
 285         public void TestIntersectWith()
 286         {
 287             IgnoreCaseSet set = new IgnoreCaseSet();
 288             set.Add("TestValue");
 289             set.Add("tESTvAlue2");
 290             set.Add("testvalue3");
 291             set.IntersectWith(new string[] { "TestValue", "testvalUE2", "TestValue4" });
 292             Assert.AreEqual(2, set.Count);
 293             Assert.IsTrue(set.Set.Contains("TestValue"));
 294             Assert.IsTrue(set.Set.Contains("tESTvAlue2"));
 295         }
 296
 297         /// <summary>
 298         /// IntersectWithメソッドテストケース（null値）。
 299         /// </summary>
 300         [TestMethod]
 301         [ExpectedException(typeof(ArgumentNullException))]
 302         public void TestIntersectWithNull()
 303         {
 304             new IgnoreCaseSet().IntersectWith(null);
 305         }
 306
 307         /// <summary>
 308         /// IsProperSubsetOfメソッドテストケース（正常系）。
 309         /// </summary>
 310         [TestMethod]
 311         public void TestIsProperSubsetOf()
 312         {
 313             IgnoreCaseSet set = new IgnoreCaseSet();
 314             set.Add("TestValue");
 315             set.Add("tESTvAlue2");
 316             set.Add("testvalue3");
 317             Assert.IsFalse(set.IsProperSubsetOf(new string[0]));
 318             Assert.IsFalse(set.IsProperSubsetOf(new string[] { "TestValue", "testvalUE2" }));
 319             Assert.IsFalse(set.IsProperSubsetOf(new string[] { "TestValue", "testvalUE2", "TestValue4" }));
 320             Assert.IsFalse(set.IsProperSubsetOf(new string[] { "TestValue", "testvalUE2", "TestValue3" }));
 321             Assert.IsTrue(set.IsProperSubsetOf(new string[] { "TestValue", "testvalUE2", "TestValue3", "TestValue4" }));
 322             Assert.IsFalse(set.IsProperSubsetOf(new string[] { "TestValue4" }));
 323         }
 324
 325         /// <summary>
 326         /// IsProperSubsetOfメソッドテストケース（null値）。
 327         /// </summary>
 328         [TestMethod]
 329         [ExpectedException(typeof(ArgumentNullException))]
 330         public void TestIsProperSubsetOfNull()
 331         {
 332             new IgnoreCaseSet().IsProperSubsetOf(null);
 333         }
 334
 335         /// <summary>
 336         /// IsProperSupersetOfメソッドテストケース（正常系）。
 337         /// </summary>
 338         [TestMethod]
 339         public void TestIsProperSupersetOf()
 340         {
 341             IgnoreCaseSet set = new IgnoreCaseSet();
 342             set.Add("TestValue");
 343             set.Add("tESTvAlue2");
 344             set.Add("testvalue3");
 345             Assert.IsTrue(set.IsProperSupersetOf(new string[0]));
 346             Assert.IsTrue(set.IsProperSupersetOf(new string[] { "TestValue", "testvalUE2" }));
 347             Assert.IsFalse(set.IsProperSupersetOf(new string[] { "TestValue", "testvalUE2", "TestValue4" }));
 348             Assert.IsFalse(set.IsProperSupersetOf(new string[] { "TestValue", "testvalUE2", "TestValue3" }));
 349             Assert.IsFalse(set.IsProperSupersetOf(new string[] { "TestValue", "testvalUE2", "TestValue3", "TestValue4" }));
 350             Assert.IsFalse(set.IsProperSupersetOf(new string[] { "TestValue4" }));
 351         }
 352
 353         /// <summary>
 354         /// IsProperSupersetOfメソッドテストケース（null値）。
 355         /// </summary>
 356         [TestMethod]
 357         [ExpectedException(typeof(ArgumentNullException))]
 358         public void TestIsProperSupersetOfNull()
 359         {
 360             new IgnoreCaseSet().IsProperSupersetOf(null);
 361         }
 362
 363         /// <summary>
 364         /// IsSubsetOfメソッドテストケース（正常系）。
 365         /// </summary>
 366         [TestMethod]
 367         public void TestIsSubsetOf()
 368         {
 369             IgnoreCaseSet set = new IgnoreCaseSet();
 370             set.Add("TestValue");
 371             set.Add("tESTvAlue2");
 372             set.Add("testvalue3");
 373             Assert.IsFalse(set.IsSubsetOf(new string[0]));
 374             Assert.IsFalse(set.IsSubsetOf(new string[] { "TestValue", "testvalUE2" }));
 375             Assert.IsFalse(set.IsSubsetOf(new string[] { "TestValue", "testvalUE2", "TestValue4" }));
 376             Assert.IsTrue(set.IsSubsetOf(new string[] { "TestValue", "testvalUE2", "TestValue3" }));
 377             Assert.IsTrue(set.IsSubsetOf(new string[] { "TestValue", "testvalUE2", "TestValue3", "TestValue4" }));
 378             Assert.IsFalse(set.IsSubsetOf(new string[] { "TestValue4" }));
 379         }
 380
 381         /// <summary>
 382         /// IsSubsetOfメソッドテストケース（null値）。
 383         /// </summary>
 384         [TestMethod]
 385         [ExpectedException(typeof(ArgumentNullException))]
 386         public void TestIsSubsetOfNull()
 387         {
 388             new IgnoreCaseSet().IsSubsetOf(null);
 389         }
 390
 391         /// <summary>
 392         /// IsSupersetOfメソッドテストケース（正常系）。
 393         /// </summary>
 394         [TestMethod]
 395         public void TestIsSupersetOf()
 396         {
 397             IgnoreCaseSet set = new IgnoreCaseSet();
 398             set.Add("TestValue");
 399             set.Add("tESTvAlue2");
 400             set.Add("testvalue3");
 401             Assert.IsTrue(set.IsSupersetOf(new string[0]));
 402             Assert.IsTrue(set.IsSupersetOf(new string[] { "TestValue", "testvalUE2" }));
 403             Assert.IsFalse(set.IsSupersetOf(new string[] { "TestValue", "testvalUE2", "TestValue4" }));
 404             Assert.IsTrue(set.IsSupersetOf(new string[] { "TestValue", "testvalUE2", "TestValue3" }));
 405             Assert.IsFalse(set.IsSupersetOf(new string[] { "TestValue", "testvalUE2", "TestValue3", "TestValue4" }));
 406             Assert.IsFalse(set.IsSupersetOf(new string[] { "TestValue4" }));
 407         }
 408
 409         /// <summary>
 410         /// IsSupersetOfメソッドテストケース（null値）。
 411         /// </summary>
 412         [TestMethod]
 413         [ExpectedException(typeof(ArgumentNullException))]
 414         public void TestIsSupersetOfNull()
 415         {
 416             new IgnoreCaseSet().IsSupersetOf(null);
 417         }
 418
 419         /// <summary>
 420         /// Overlapsメソッドテストケース（正常系）。
 421         /// </summary>
 422         [TestMethod]
 423         public void TestOverlaps()
 424         {
 425             IgnoreCaseSet set = new IgnoreCaseSet();
 426             set.Add("TestValue");
 427             set.Add("tESTvAlue2");
 428             set.Add("testvalue3");
 429             Assert.IsFalse(set.Overlaps(new string[0]));
 430             Assert.IsTrue(set.Overlaps(new string[] { "TestValue", "testvalUE2" }));
 431             Assert.IsTrue(set.Overlaps(new string[] { "TestValue", "testvalUE2", "TestValue4" }));
 432             Assert.IsTrue(set.Overlaps(new string[] { "TestValue", "testvalUE2", "TestValue3" }));
 433             Assert.IsTrue(set.Overlaps(new string[] { "TestValue", "testvalUE2", "TestValue3", "TestValue4" }));
 434             Assert.IsFalse(set.Overlaps(new string[] { "TestValue4" }));
 435         }
 436
 437         /// <summary>
 438         /// Overlapsメソッドテストケース（null値）。
 439         /// </summary>
 440         [TestMethod]
 441         [ExpectedException(typeof(ArgumentNullException))]
 442         public void TestOverlapsNull()
 443         {
 444             new IgnoreCaseSet().Overlaps(null);
 445         }
 446
 447         /// <summary>
 448         /// Removeメソッドテストケース（正常系）。
 449         /// </summary>
 450         [TestMethod]
 451         public void TestRemove()
 452         {
 453             IgnoreCaseSet set = new IgnoreCaseSet();
 454             set.Add("TestValue");
 455             set.Add("tESTvAlUe2");
 456             Assert.AreEqual(2, set.Count);
 457             Assert.IsTrue(set.Contains("TestValue"));
 458             Assert.IsTrue(set.Contains("tESTvAlUe2"));
 459
 460             Assert.IsTrue(set.Remove("tEstValue"));
 461             Assert.AreEqual(1, set.Count);
 462             Assert.IsFalse(set.Contains("TestValue"));
 463             Assert.IsTrue(set.Contains("tESTvAlUe2"));
 464
 465             Assert.IsFalse(set.Remove("tESTvAlUe3"));
 466             Assert.AreEqual(1, set.Count);
 467             Assert.IsTrue(set.Contains("tESTvAlUe2"));
 468
 469             Assert.IsTrue(set.Remove("tESTvAlUe2"));
 470             Assert.AreEqual(0, set.Count);
 471             Assert.IsFalse(set.Contains("tESTvAlUe2"));
 472         }
 473
 474         /// <summary>
 475         /// Removeメソッドテストケース（null値）。
 476         /// </summary>
 477         [TestMethod]
 478         [ExpectedException(typeof(ArgumentNullException))]
 479         public void TestRemoveNull()
 480         {
 481             new IgnoreCaseSet().Remove(null);
 482         }
 483
 484         /// <summary>
 485         /// SetEqualsメソッドテストケース（正常系）。
 486         /// </summary>
 487         [TestMethod]
 488         public void TestSetEquals()
 489         {
 490             IgnoreCaseSet set = new IgnoreCaseSet();
 491             set.Add("TestValue");
 492             set.Add("tESTvAlue2");
 493             set.Add("testvalue3");
 494             Assert.IsFalse(set.SetEquals(new string[0]));
 495             Assert.IsFalse(set.SetEquals(new string[] { "TestValue", "testvalUE2" }));
 496             Assert.IsFalse(set.SetEquals(new string[] { "TestValue", "testvalUE2", "TestValue4" }));
 497             Assert.IsTrue(set.SetEquals(new string[] { "TestValue", "testvalUE2", "TestValue3" }));
 498             Assert.IsFalse(set.SetEquals(new string[] { "TestValue", "testvalUE2", "TestValue3", "TestValue4" }));
 499             Assert.IsFalse(set.SetEquals(new string[] { "TestValue4" }));
 500         }
 501
 502         /// <summary>
 503         /// SetEqualsメソッドテストケース（null値）。
 504         /// </summary>
 505         [TestMethod]
 506         [ExpectedException(typeof(ArgumentNullException))]
 507         public void TestSetEqualsNull()
 508         {
 509             new IgnoreCaseSet().SetEquals(null);
 510         }
 511
 512         /// <summary>
 513         /// SymmetricExceptWithメソッドテストケース（正常系）。
 514         /// </summary>
 515         [TestMethod]
 516         public void TestSymmetricExceptWith()
 517         {
 518             IgnoreCaseSet set = new IgnoreCaseSet();
 519             set.Add("TestValue");
 520             set.Add("tESTvAlue2");
 521             set.Add("testvalue3");
 522             set.SymmetricExceptWith(new string[] { "TestValue", "testvalUE2", "TestValue4" });
 523             Assert.AreEqual(2, set.Count);
 524             Assert.IsTrue(set.Set.Contains("testvalue3"));
 525             Assert.IsTrue(set.Set.Contains("TestValue4"));
 526         }
 527
 528         /// <summary>
 529         /// SymmetricExceptWithメソッドテストケース（null値）。
 530         /// </summary>
 531         [TestMethod]
 532         [ExpectedException(typeof(ArgumentNullException))]
 533         public void TestSymmetricExceptWithNull()
 534         {
 535             new IgnoreCaseSet().SymmetricExceptWith(null);
 536         }
 537
 538         /// <summary>
 539         /// UnionWithメソッドテストケース（正常系）。
 540         /// </summary>
 541         [TestMethod]
 542         public void TestUnionWith()
 543         {
 544             // 両方の値が格納される、重複するものは後の値で上書き
 545             IgnoreCaseSet set = new IgnoreCaseSet();
 546             set.Add("TestValue");
 547             set.Add("tESTvAlue2");
 548             set.Add("testvalue3");
 549             set.UnionWith(new string[] { "TestValue", "testvalUE2", "TestValue4" });
 550             Assert.AreEqual(4, set.Count);
 551             Assert.IsTrue(set.Set.Contains("TestValue"));
 552             Assert.IsTrue(set.Set.Contains("testvalUE2"));
 553             Assert.IsTrue(set.Set.Contains("testvalue3"));
 554             Assert.IsTrue(set.Set.Contains("TestValue4"));
 555         }
 556
 557         /// <summary>
 558         /// UnionWithメソッドテストケース（null値）。
 559         /// </summary>
 560         [TestMethod]
 561         [ExpectedException(typeof(ArgumentNullException))]
 562         public void TestUnionWithNull()
 563         {
 564             new IgnoreCaseSet().UnionWith(null);
 565         }
 566
 567         #endregion
 568
 569         #region ラップするインスタンスを参照するメソッドテストケース
 570
 571         /// <summary>
 572         /// GetEnumeratorメソッドテストケース。
 573         /// </summary>
 574         [TestMethod]
 575         public void TestGetEnumerator()
 576         {
 577             // ラップするISetと同じ値であること
 578             ISet<string> inner = new HashSet<string>();
 579             inner.Add("TestValue");
 580             IgnoreCaseSet set = new IgnoreCaseSet(inner);
 581             Assert.AreEqual(inner.GetEnumerator(), set.GetEnumerator());
 582         }
 583
 584         #endregion
 585     }
 586 }