public void EqualsTest()
        {
            var t0 = new DateTime(2013, 7, 28, 0, 0, 0); // UTC
            var d0 = TimeSpan.FromSeconds(10d);
            var d1 = TimeSpan.FromSeconds(11d);

            var x = new MondaiResult("id0", t0, d0, Difficulty.Hard);
            var y = new MondaiResult("id0", t0, d0, Difficulty.Hard);
            var z = new MondaiResult("id0", t0, d0, Difficulty.Hard);

            // 反射律
            Assert.True(x.Equals(x));

            // 対象律
            Assert.True(x.Equals(y));
            Assert.True(y.Equals(x));

            // 推移律
            Assert.True(y.Equals(z));
            Assert.True(z.Equals(x));

            Assert.False(x.Equals(null));
            Assert.False(x.Equals(new object()));

            Assert.AreEqual(x.GetHashCode(), y.GetHashCode());

            // 等しくないデータ同士を比較
            {
                var zz = new MondaiResult("id0", t0, d1, Difficulty.Hard);
                Assert.False(zz.Equals(x));
                Assert.AreNotEqual(zz.GetHashCode(), x.GetHashCode());
            }
            {
                var zzz = new MondaiResult("id0", t0, d0, Difficulty.Normal);
                Assert.False(zzz.Equals(x));
                Assert.AreNotEqual(zzz.GetHashCode(), x.GetHashCode());
            }
        }
        public void 分表示がおかしい不具合()
        {
            using (var test = new EPuzzleTestManager())
            {
                test.AddFile(@"mondai\MondaiDocument.xml", TestResources.Mondai03);
                test.AddFile(@"help\HelpDocument.xml", TestResources.HelpDocumentXml);
                test.Initialize();
                var window = test.Window;
                var userInfo = window.EPuzzleData.CurrentUserInfo;
                var mondaiDocument = window.EPuzzleData.CurrentMondaiDocument;
                var chumon = (Chumon)mondaiDocument.GetItem("chumon1");
                var t0 = new DateTime(2013, 1, 18, 17, 3, 0, DateTimeKind.Local);
                var t1 = new DateTime(2013, 1, 18, 18, 19, 0, DateTimeKind.Local);
                var now = new DateTime(2013, 1, 19, 17, 0, 0, DateTimeKind.Local);
                test.Now = now;

                {
                    var mondaiResult = new MondaiResult(chumon.Id, t0, TimeSpan.FromSeconds(70d), userInfo.Difficulty);
                    Assert.AreEqual(
            @"(1日前)
            2013/01/18(金) 17:04
            01:10 (F)", KirokuInfoBox.GetString(mondaiResult, chumon, userInfo));

                }
                {
                    var mondaiResult = new MondaiResult(chumon.Id, t0, TimeSpan.FromSeconds(110d), userInfo.Difficulty);
                    Assert.AreEqual(
            @"(1日前)
            2013/01/18(金) 17:04
            01:50 (F)", KirokuInfoBox.GetString(mondaiResult, chumon, userInfo));

                }
                {
                    var mondaiResult = new MondaiResult(chumon.Id, t0, TimeSpan.FromMinutes(100d), userInfo.Difficulty);
                    Assert.AreEqual(
            @"(1日前)
            2013/01/18(金) 18:43
            100:00 (F)", KirokuInfoBox.GetString(mondaiResult, chumon, userInfo));

                }
            }
        }
        public void MondaiResultsThatAreReturnedFromGetItemsMethodDependOnDifficultyProperty()
        {
            var t0 = new DateTime(2013, 10, 2, 0, 0, 0); // UTC
            var t1 = t0 + TimeSpan.FromDays(2d);
            EPuzzleTime.Now = t1;
            var userInfo = new EPuzzleUserInfo();

            userInfo.Difficulty = Difficulty.Hard;

            Assert.AreEqual(Difficulty.Hard, userInfo.Difficulty);
            var mondaiResult0 = new MondaiResult("id50", t0, TimeSpan.FromSeconds(8d), Difficulty.Normal);
            var mondaiResult1 = new MondaiResult("id50", t1, TimeSpan.FromSeconds(8d), Difficulty.Hard);
            userInfo.MondaiResults.Add(mondaiResult0);
            userInfo.MondaiResults.Add(mondaiResult1);

            CollectionAssert.AreEqual(new [] { mondaiResult1, }, userInfo.MondaiResults.GetItems("id50"));

            var mondaiResult2 = userInfo.CreateMondaiResult("id50", t1, TimeSpan.FromSeconds(8d));
            Assert.AreEqual(Difficulty.Hard, mondaiResult2.Difficulty);
        }
        public void IgnoreDifficultyTest()
        {
            using (var test = new EPuzzleTestManager())
            {
                test.AddFile(@"mondai\MondaiDocument.xml", TestResources.Mondai03);
                test.AddFile(@"help\HelpDocument.xml", TestResources.HelpDocumentXml);
                test.Initialize();
                var window = test.Window;
                var userInfo = window.EPuzzleData.CurrentUserInfo;
                var mondaiDocument = window.EPuzzleData.CurrentMondaiDocument;

                userInfo.IgnoreDifficultyWhenGettingMondaiResults = false;
                Assert.False(userInfo.IgnoreDifficultyWhenGettingMondaiResults);

                var t0 = new DateTime(2013, 11, 29, 0, 0, 0); // UTC
                var now = t0 + TimeSpan.FromMinutes(1d);
                EPuzzleTime.Now = now;

                var id = "id0";
                var mondaiResult1 = new MondaiResult(id, t0, TimeSpan.FromSeconds(10d), Difficulty.Hard);
                var mondaiResult2 = new MondaiResult(id, now, TimeSpan.FromSeconds(10d), Difficulty.Normal);

                userInfo.MondaiResults.Add(mondaiResult1);
                userInfo.MondaiResults.Add(mondaiResult2);

                userInfo.Difficulty = Difficulty.Normal;
                userInfo.IgnoreDifficultyWhenGettingMondaiResults = false;

                CollectionAssert.AreEqual(new []
                {
                    mondaiResult2,
                }, userInfo.MondaiResults.GetItems(id));
                CollectionAssert.AreEqual(new []
                {
                    mondaiResult2,
            //				}, userInfo.MondaiResults.GetItemsThatHaveBeenDoneWithin(TimeSpan.FromDays(1d)));
                }, (IEnumerable<MondaiResult>)TestUtility.Invoke(userInfo, "GetMondaiResultsThatYouHaveDoneWithin", TimeSpan.FromDays(1d)));

                userInfo.IgnoreDifficultyWhenGettingMondaiResults = true;

                CollectionAssert.AreEqual(new []
                {
                    mondaiResult1, mondaiResult2,
                }, userInfo.MondaiResults.GetItems(id));
                CollectionAssert.AreEqual(new []
                {
                    mondaiResult1, mondaiResult2,
            //				}, userInfo.MondaiResults.GetItemsThatHaveBeenDoneWithin(TimeSpan.FromDays(1d)));
                }, (IEnumerable<MondaiResult>)TestUtility.Invoke(userInfo, "GetMondaiResultsThatYouHaveDoneWithin", TimeSpan.FromDays(1d)));
            }
        }
        public void GetLastMondaiResultTest()
        {
            using (var test = new EPuzzleTestManager())
            {
                test.AddFile(@"mondai\MondaiDocument.xml", TestResources.Mondai02);
                test.AddFile(@"help\HelpDocument.xml", TestResources.HelpDocumentXml);
                test.Initialize();
                var window = test.Window;
                var userInfo = window.EPuzzleData.CurrentUserInfo;
                var mondaiDocument = window.EPuzzleData.CurrentMondaiDocument;
                var chumon = (Chumon)mondaiDocument.GetItem("d1_chumon1");
                var t0 = new DateTime(2012, 12, 6, 0, 0, 0, DateTimeKind.Local);
                var t1 = new DateTime(2012, 12, 7, 0, 0, 0, DateTimeKind.Local);

                CollectionAssert.IsEmpty(userInfo.MondaiResults.GetOrderedItems(chumon.Id));
            //				Assert.Null(userInfo.MondaiResults.GetLast(chumon.Id));
                Assert.Null(userInfo.MondaiResults.GetNewest(chumon.Id));
                Assert.Null(userInfo.MondaiResults.GetBest(chumon.Id));

                var mondaiResult0 = new MondaiResult(chumon.Id, t0, chumon.GetTimeLimit(userInfo), userInfo.Difficulty);
                userInfo.MondaiResults.Add(mondaiResult0);

                var mondaiResult1 = new MondaiResult(chumon.Id, t1, chumon.GetTimeLimit(userInfo) + TimeSpan.FromSeconds(1d), userInfo.Difficulty);
                userInfo.MondaiResults.Add(mondaiResult1);

            //				chumon.GradeProcessor = GradeProcessorB.Instance;
                userInfo.GradeProcessor = GradeProcessorB.Instance;
            //				Assert.AreSame(mondaiResult1, userInfo.MondaiResults.GetLast(chumon.Id));
                Assert.AreSame(mondaiResult1, userInfo.MondaiResults.GetNewest(chumon.Id));
                Assert.AreSame(mondaiResult0, userInfo.MondaiResults.GetBest(chumon.Id));
                Assert.AreSame(mondaiResult0, userInfo.MondaiResults.GetOldest(chumon.Id));
                Assert.AreSame(mondaiResult1, userInfo.MondaiResults.GetNewest(chumon.Id));

                var items = userInfo.MondaiResults.GetOrderedItems(chumon.Id);
                CollectionAssert.AreEqual(new []
                {
                    mondaiResult1,
                    mondaiResult0,
                }, items);
            }
        }
        public void GetItemsThatHaveBeenDoneWithinTest()
        {
            var t0 = new DateTime(2013, 10, 2, 0, 0, 0); // UTC
            var t1 = t0 + TimeSpan.FromDays(2d);
            EPuzzleTime.Now = t1;
            var userInfo = new EPuzzleUserInfo();

            Assert.AreEqual(Difficulty.Normal, userInfo.Difficulty);
            var mondaiResult0 = new MondaiResult("id50", t0, TimeSpan.FromSeconds(8d), userInfo.Difficulty);
            var mondaiResult1 = new MondaiResult("id60", t1, TimeSpan.FromSeconds(8d), userInfo.Difficulty);
            var mondaiResult2 = new MondaiResult("id70", t1, TimeSpan.FromSeconds(8d), Difficulty.Hard);

            userInfo.MondaiResults.Add(mondaiResult0);
            userInfo.MondaiResults.Add(mondaiResult1);
            userInfo.MondaiResults.Add(mondaiResult2);

            {
            //				var mondaiResults = userInfo.MondaiResults.GetItemsThatHaveBeenDoneWithin(TimeSpan.FromHours(24d));
                var mondaiResults = (IEnumerable<MondaiResult>)TestUtility.Invoke(userInfo, "GetMondaiResultsThatYouHaveDoneWithin", TimeSpan.FromHours(24d));
                Assert.AreEqual(1, mondaiResults.Count());
                Assert.AreSame(mondaiResult1, mondaiResults.Single());
            }
            {
            //				var mondaiResults = userInfo.MondaiResults.GetItemsThatHaveBeenDoneWithin(TimeSpan.FromDays(3d));
                var mondaiResults = (IEnumerable<MondaiResult>)TestUtility.Invoke(userInfo, "GetMondaiResultsThatYouHaveDoneWithin", TimeSpan.FromDays(3d));
                Assert.AreEqual(2, mondaiResults.Count());
                CollectionAssert.AreEquivalent(new [] { mondaiResult0, mondaiResult1, }, mondaiResults);
            }
        }
        public void SortChumonsByDateYouDidThem_Test()
        {
            using (var test = new EPuzzleTestManager())
            {
                test.AddFile(@"mondai\mondai.xml", @"<?xml version=""1.0"" encoding=""utf-8""?>
            <mondai-document id=""doc1"" title=""DocumentB"">
            <daimon id=""d1"" title=""基礎I"">
            <chumon id=""c1"" title=""This is a pen."">
            <shomon id=""s1"">
                <mondaibun>[英訳] これはボールです。</mondaibun>
                <seikai>This is a ball.</seikai>
                <word>This is</word>
                <word>a ball.</word>
            </shomon>
            </chumon>
            <chumon id=""c2"" title=""This is a pen."">
            <shomon id=""s2"">
                <mondaibun>[英訳] これはボールです。</mondaibun>
                <seikai>This is a ball.</seikai>
                <word>This is</word>
                <word>a ball.</word>
            </shomon>
            </chumon>
            <chumon id=""c3"" title=""This is a pen."">
            <shomon id=""s3"">
                <mondaibun>[英訳] これはボールです。</mondaibun>
                <seikai>This is a ball.</seikai>
                <word>This is</word>
                <word>a ball.</word>
            </shomon>
            </chumon>
            </daimon>
            </mondai-document>");
                test.Initialize();
                var window = test.Window;
                var userInfo = window.EPuzzleData.CurrentUserInfo;
                var mondaiDocuments = window.EPuzzleData.MondaiDocuments;
                var mondaiDocument = mondaiDocuments.First();

                userInfo.UseNewMethodThatGetsChumonsThatYouHaveDoneToday = true;
                userInfo.DoesNotShowChumonsYouHaveNeverDone = false;
                userInfo.TimeToChangeDay = new TimeSpan(3, 0, 0);
                userInfo.HideChumonsYouHaveGotGradeAToday = false;
                userInfo.Difficulty = Difficulty.Normal;

                // 期間における復習猶予期間の最大値を書き換える
                ((GradeProcessorB)userInfo.GradeProcessor).期間における復習猶予期間の最大値 = new []
                {
                    new Pair<TimeSpan, TimeSpan>(TimeSpan.FromHours(12d), TimeSpan.FromHours(12d)),
                };

                var tutor = new EPuzzleTutor(userInfo, mondaiDocuments, TimeSpan.FromHours(12d), 10);
                CollectionAssert.AreEqual(mondaiDocuments, tutor.MondaiDocuments);
                Assert.AreEqual(10, tutor.NumberOfQuestionsThatYouHaveToDoToday);
                Assert.AreEqual(TimeSpan.FromHours(12f), tutor.この時間以内の問題は無視する);

                var t0 = new DateTime(2014, 1, 21, 15, 0, 0, DateTimeKind.Local);
                var t1 = t0 + TimeSpan.FromMinutes(5d);
                var t2 = t1 + TimeSpan.FromMinutes(5d);
            //				var t3 = t2 + TimeSpan.FromMinutes(5d);
                EPuzzleTime.Now = t2 + TimeSpan.FromHours(3d);

                var mondaiResult = new MondaiResult("c1", t0, TimeSpan.FromSeconds(1d), Difficulty.Normal);
                userInfo.MondaiResults.Add(mondaiResult);

                CollectionAssert.AreEqual(new []
                {
                    "c1",
                }, GetIds(tutor.SortChumonsByDateYouDidThem()));

                userInfo.MondaiResults.AddNew("c2", t1, TimeSpan.FromSeconds(1d));

                CollectionAssert.AreEqual(new []
                {
                    "c2", "c1",
                }, GetIds(tutor.SortChumonsByDateYouDidThem()));

                userInfo.MondaiResults.AddNew("c1", t2, TimeSpan.FromSeconds(1d));

                CollectionAssert.AreEqual(new []
                {
                    "c1", "c2",
                }, GetIds(tutor.SortChumonsByDateYouDidThem()));

                // 難易度についてのテストは今回は行わない。難易度制度を残さない可能性があるため。
            }
        }
        public void 同時刻のStartTimeを最短記録で一つに圧縮するテスト()
        {
            var t0 = new DateTime(2013, 7, 28, 0, 0, 0); // UTC
            var t1 = t0 + TimeSpan.FromMinutes(1d);
            var t2 = t1 + TimeSpan.FromMinutes(1d);
            var d0 = TimeSpan.FromSeconds(10d);
            var d1 = TimeSpan.FromSeconds(11d);
            var array = new []
            {
                new MondaiResult("id0", t1, d0, Difficulty.Normal),
                new MondaiResult("id0", t2, d1, Difficulty.Normal),
                new MondaiResult("id0", t2, d0, Difficulty.Normal),
                new MondaiResult("id0", t1, d1, Difficulty.Normal),
                new MondaiResult("id0", t0, d1, Difficulty.Normal),
                new MondaiResult("id0", t0, d0, Difficulty.Normal),
            };

            CollectionAssert.AreEquivalent(new []
            {
                new MondaiResult("id0", t2, d0, Difficulty.Normal),
                new MondaiResult("id0", t0, d0, Difficulty.Normal),
                new MondaiResult("id0", t1, d0, Difficulty.Normal),

            }, MondaiResult.同時刻のStartTimeを最短記録で一つに圧縮する(array));

            // StartTimeが重複していなければ、引数をそのまま返す
            var array2 = new []
            {
                new MondaiResult("id0", t0, d0, Difficulty.Normal),
                new MondaiResult("id0", t1, d0, Difficulty.Normal),
                new MondaiResult("id0", t2, d0, Difficulty.Normal),
            };
            Assert.AreSame(array2, MondaiResult.同時刻のStartTimeを最短記録で一つに圧縮する(array2));

            // 空のコレクションはそのまま返す
            var array4 = new MondaiResult[0];
            Assert.AreSame(array4, MondaiResult.同時刻のStartTimeを最短記録で一つに圧縮する(array4));

            // 異なるIDが混じっていたら例外
            var array3 = new []
            {
                new MondaiResult("id0", t0, d0, Difficulty.Normal),
                new MondaiResult("id1", t1, d0, Difficulty.Normal),
                new MondaiResult("id0", t2, d0, Difficulty.Normal),
            };
            Assert.Throws<ArgumentException>(() =>
            {
                MondaiResult.同時刻のStartTimeを最短記録で一つに圧縮する(array3);
            });
        }