OpenTween.Tests/PostFilterRuleTest.cs

   1 // OpenTween - Client of Twitter
   2 // Copyright (c) 2013 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.Generic;
  24 using System.Linq;
  25 using System.Text;
  26 using Xunit;
  27 using Xunit.Extensions;
  28
  29 namespace OpenTween
  30 {
  31     public class PostFilterRuleTest
  32     {
  33         public PostFilterRuleTest()
  34         {
  35             PostFilterRule.AutoCompile = true;
  36         }
  37
  38         [Fact]
  39         public void EmptyRuleTest()
  40         {
  41             var filter = new PostFilterRule { };
  42             var post = new PostClass { ScreenName = "hogehoge" };
  43
  44             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
  45         }
  46
  47         [Fact]
  48         public void NullTest()
  49         {
  50             var filter = new PostFilterRule
  51             {
  52                 FilterName = null,
  53                 FilterSource = null,
  54                 ExFilterName = null,
  55                 ExFilterSource = null,
  56             };
  57             var post = new PostClass { ScreenName = "hogehoge" };
  58
  59             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
  60
  61             Assert.Throws<ArgumentNullException>(() => filter.FilterBody = null);
  62             Assert.Throws<ArgumentNullException>(() => filter.ExFilterBody = null);
  63         }
  64
  65         [Fact]
  66         public void MatchOnlyTest()
  67         {
  68             var filter = new PostFilterRule { FilterName = "hogehoge" };
  69             var post = new PostClass { ScreenName = "hogehoge" };
  70
  71             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
  72         }
  73
  74         [Fact]
  75         public void ExcludeOnlyTest()
  76         {
  77             var filter = new PostFilterRule { ExFilterName = "hogehoge" };
  78             var post = new PostClass { ScreenName = "hogehoge" };
  79
  80             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
  81         }
  82
  83         [Fact]
  84         public void MatchAndExcludeTest()
  85         {
  86             var filter = new PostFilterRule { FilterName = "hogehoge", ExFilterSource = "tetete" };
  87             var post = new PostClass { ScreenName = "hogehoge", Source = "tetete" };
  88
  89             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
  90         }
  91
  92         [Fact]
  93         public void PostMatchOptions_CopyTest()
  94         {
  95             var filter = new PostFilterRule { FilterName = "hogehoge" };
  96             var post = new PostClass { ScreenName = "hogehoge" };
  97
  98             filter.MoveMatches = false;
  99             filter.MarkMatches = false;
 100             Assert.Equal(MyCommon.HITRESULT.Copy, filter.ExecFilter(post));
 101         }
 102
 103         [Fact]
 104         public void PostMatchOptions_CopyAndMarkTest()
 105         {
 106             var filter = new PostFilterRule { FilterName = "hogehoge" };
 107             var post = new PostClass { ScreenName = "hogehoge" };
 108
 109             filter.MoveMatches = false;
 110             filter.MarkMatches = true;
 111             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 112         }
 113
 114         [Fact]
 115         public void PostMatchOptions_MoveTest()
 116         {
 117             var filter = new PostFilterRule { FilterName = "hogehoge" };
 118             var post = new PostClass { ScreenName = "hogehoge" };
 119
 120             filter.MoveMatches = true;
 121             filter.MarkMatches = false; // 無視される
 122             Assert.Equal(MyCommon.HITRESULT.Move, filter.ExecFilter(post));
 123
 124             filter.MoveMatches = true;
 125             filter.MarkMatches = true; // 無視される
 126             Assert.Equal(MyCommon.HITRESULT.Move, filter.ExecFilter(post));
 127         }
 128
 129         [Fact]
 130         public void FilterName_Test()
 131         {
 132             var filter = new PostFilterRule();
 133             PostClass post;
 134
 135             filter.FilterName = "hogehoge";
 136
 137             post = new PostClass { ScreenName = "hogehoge" };
 138             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 139
 140             post = new PostClass { ScreenName = "foo" };
 141             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 142
 143             // FilterName は RetweetedBy にもマッチする
 144             post = new PostClass { ScreenName = "foo", RetweetedBy = "hogehoge" };
 145             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 146
 147             post = new PostClass { ScreenName = "foo", RetweetedBy = "bar" };
 148             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 149
 150             // FilterName は完全一致 (UseRegex = false の場合)
 151             post = new PostClass { ScreenName = "_hogehoge_" };
 152             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 153
 154             // 大小文字を区別する
 155             filter.CaseSensitive = true;
 156
 157             post = new PostClass { ScreenName = "HogeHoge" };
 158             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 159
 160             // 大小文字を区別しない
 161             filter.CaseSensitive = false;
 162
 163             post = new PostClass { ScreenName = "HogeHoge" };
 164             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 165         }
 166
 167         [Fact]
 168         public void ExFilterName_Test()
 169         {
 170             var filter = new PostFilterRule();
 171             PostClass post;
 172
 173             filter.ExFilterName = "hogehoge";
 174
 175             post = new PostClass { ScreenName = "hogehoge" };
 176             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 177
 178             post = new PostClass { ScreenName = "foo" };
 179             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 180
 181             // ExFilterName は RetweetedBy にもマッチする
 182             post = new PostClass { ScreenName = "foo", RetweetedBy = "hogehoge" };
 183             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 184
 185             post = new PostClass { ScreenName = "foo", RetweetedBy = "bar" };
 186             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 187
 188             // ExFilterName は完全一致 (ExUseRegex = false の場合)
 189             post = new PostClass { ScreenName = "_hogehoge_" };
 190             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 191
 192             // 大小文字を区別する
 193             filter.ExCaseSensitive = true;
 194
 195             post = new PostClass { ScreenName = "HogeHoge" };
 196             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 197
 198             // 大小文字を区別しない
 199             filter.ExCaseSensitive = false;
 200
 201             post = new PostClass { ScreenName = "HogeHoge" };
 202             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 203         }
 204
 205         [Fact]
 206         public void FilterName_RegexTest()
 207         {
 208             var filter = new PostFilterRule();
 209             PostClass post;
 210
 211             filter.UseRegex = true;
 212             filter.FilterName = "(hoge){2}";
 213
 214             post = new PostClass { ScreenName = "hogehoge" };
 215             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 216
 217             post = new PostClass { ScreenName = "foo" };
 218             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 219
 220             // FilterName は RetweetedBy にもマッチする
 221             post = new PostClass { ScreenName = "foo", RetweetedBy = "hogehoge" };
 222             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 223
 224             post = new PostClass { ScreenName = "foo", RetweetedBy = "bar" };
 225             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 226
 227             // FilterName は部分一致 (UseRegex = true の場合)
 228             post = new PostClass { ScreenName = "_hogehoge_" };
 229             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 230
 231             // 大小文字を区別する
 232             filter.CaseSensitive = true;
 233
 234             post = new PostClass { ScreenName = "HogeHoge" };
 235             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 236
 237             // 大小文字を区別しない
 238             filter.CaseSensitive = false;
 239
 240             post = new PostClass { ScreenName = "HogeHoge" };
 241             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 242         }
 243
 244         [Fact]
 245         public void ExFilterName_RegexTest()
 246         {
 247             var filter = new PostFilterRule();
 248             PostClass post;
 249
 250             filter.ExUseRegex = true;
 251             filter.ExFilterName = "(hoge){2}";
 252
 253             post = new PostClass { ScreenName = "hogehoge" };
 254             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 255
 256             post = new PostClass { ScreenName = "foo" };
 257             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 258
 259             // ExFilterName は RetweetedBy にもマッチする
 260             post = new PostClass { ScreenName = "foo", RetweetedBy = "hogehoge" };
 261             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 262
 263             post = new PostClass { ScreenName = "foo", RetweetedBy = "bar" };
 264             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 265
 266             // ExFilterName は部分一致 (ExUseRegex = true の場合)
 267             post = new PostClass { ScreenName = "_hogehoge_" };
 268             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 269
 270             // 大小文字を区別する
 271             filter.ExCaseSensitive = true;
 272
 273             post = new PostClass { ScreenName = "HogeHoge" };
 274             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 275
 276             // 大小文字を区別しない
 277             filter.ExCaseSensitive = false;
 278
 279             post = new PostClass { ScreenName = "HogeHoge" };
 280             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 281         }
 282
 283         [Fact]
 284         public void FilterBody_Test()
 285         {
 286             var filter = new PostFilterRule();
 287             PostClass post;
 288
 289             filter.FilterBody = new[] { "aaa", "bbb" };
 290
 291             post = new PostClass { TextFromApi = "test" };
 292             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 293
 294             // 片方だけではマッチしない
 295             post = new PostClass { TextFromApi = "aaa" };
 296             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 297
 298             // FilterBody の文字列が全て含まれている
 299             post = new PostClass { TextFromApi = "123aaa456bbb" };
 300             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 301
 302             // ScreenName にはマッチしない (UseNameField = true の場合)
 303             post = new PostClass { ScreenName = "aaabbb", TextFromApi = "test" };
 304             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 305
 306             // 大小文字を区別する
 307             filter.CaseSensitive = true;
 308
 309             post = new PostClass { TextFromApi = "AaaBbb" };
 310             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 311
 312             // 大小文字を区別しない
 313             filter.CaseSensitive = false;
 314
 315             post = new PostClass { TextFromApi = "AaaBbb" };
 316             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 317         }
 318
 319         [Fact]
 320         public void ExFilterBody_Test()
 321         {
 322             var filter = new PostFilterRule();
 323             PostClass post;
 324
 325             filter.ExFilterBody = new[] { "aaa", "bbb" };
 326
 327             post = new PostClass { TextFromApi = "test" };
 328             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 329
 330             // 片方だけではマッチしない
 331             post = new PostClass { TextFromApi = "aaa" };
 332             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 333
 334             // ExFilterBody の文字列が全て含まれている
 335             post = new PostClass { TextFromApi = "123aaa456bbb" };
 336             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 337
 338             // ScreenName にはマッチしない (ExUseNameField = true の場合)
 339             post = new PostClass { ScreenName = "aaabbb", TextFromApi = "test" };
 340             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 341
 342             // 大小文字を区別する
 343             filter.ExCaseSensitive = true;
 344
 345             post = new PostClass { TextFromApi = "AaaBbb" };
 346             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 347
 348             // 大小文字を区別しない
 349             filter.ExCaseSensitive = false;
 350
 351             post = new PostClass { TextFromApi = "AaaBbb" };
 352             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 353         }
 354
 355         [Fact]
 356         public void FilterBody_RegexTest()
 357         {
 358             var filter = new PostFilterRule();
 359             PostClass post;
 360
 361             filter.UseRegex = true;
 362             filter.FilterBody = new[] { "a{3}", "b{3}" };
 363
 364             post = new PostClass { TextFromApi = "test" };
 365             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 366
 367             // 片方だけではマッチしない
 368             post = new PostClass { TextFromApi = "aaa" };
 369             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 370
 371             // FilterBody の文字列が全て含まれている
 372             post = new PostClass { TextFromApi = "123aaa456bbb" };
 373             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 374
 375             // ScreenName にはマッチしない (UseNameField = true の場合)
 376             post = new PostClass { ScreenName = "aaabbb", TextFromApi = "test" };
 377             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 378
 379             // 大小文字を区別する
 380             filter.CaseSensitive = true;
 381
 382             post = new PostClass { TextFromApi = "AaaBbb" };
 383             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 384
 385             // 大小文字を区別しない
 386             filter.CaseSensitive = false;
 387
 388             post = new PostClass { TextFromApi = "AaaBbb" };
 389             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 390         }
 391
 392         [Fact]
 393         public void ExFilterBody_RegexTest()
 394         {
 395             var filter = new PostFilterRule();
 396             PostClass post;
 397
 398             filter.ExUseRegex = true;
 399             filter.ExFilterBody = new[] { "a{3}", "b{3}" };
 400
 401             post = new PostClass { TextFromApi = "test" };
 402             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 403
 404             // 片方だけではマッチしない
 405             post = new PostClass { TextFromApi = "aaa" };
 406             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 407
 408             // ExFilterBody の文字列が全て含まれている
 409             post = new PostClass { TextFromApi = "123aaa456bbb" };
 410             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 411
 412             // ScreenName にはマッチしない (ExUseNameField = true の場合)
 413             post = new PostClass { ScreenName = "aaabbb", TextFromApi = "test" };
 414             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 415
 416             // 大小文字を区別する
 417             filter.ExCaseSensitive = true;
 418
 419             post = new PostClass { TextFromApi = "AaaBbb" };
 420             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 421
 422             // 大小文字を区別しない
 423             filter.ExCaseSensitive = false;
 424
 425             post = new PostClass { TextFromApi = "AaaBbb" };
 426             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 427         }
 428
 429         [Fact]
 430         public void FilterBody_ByUrlTest()
 431         {
 432             var filter = new PostFilterRule();
 433             PostClass post;
 434
 435             // FilterByUrl = true の場合は TextFromApi ではなく Text がマッチ対象になる
 436             filter.FilterByUrl = true;
 437
 438             filter.FilterBody = new[] { "aaa", "bbb" };
 439
 440             post = new PostClass { Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 441             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 442
 443             // 片方だけではマッチしない
 444             post = new PostClass { Text = "<a href='http://example.com/aaa'>t.co/hoge</a>" };
 445             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 446
 447             // FilterBody の文字列が全て含まれている
 448             post = new PostClass { Text = "<a href='http://example.com/aaabbb'>t.co/hoge</a>" };
 449             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 450
 451             // ScreenName にはマッチしない (UseNameField = true の場合)
 452             post = new PostClass { ScreenName = "aaabbb", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 453             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 454
 455             // 大小文字を区別する
 456             filter.CaseSensitive = true;
 457
 458             post = new PostClass { Text = "<a href='http://example.com/AaaBbb'>t.co/hoge</a>" };
 459             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 460
 461             // 大小文字を区別しない
 462             filter.CaseSensitive = false;
 463
 464             post = new PostClass { Text = "<a href='http://example.com/AaaBbb'>t.co/hoge</a>" };
 465             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 466         }
 467
 468         [Fact]
 469         public void ExFilterBody_ByUrlTest()
 470         {
 471             var filter = new PostFilterRule();
 472             PostClass post;
 473
 474             // ExFilterByUrl = true の場合は TextFromApi ではなく Text がマッチ対象になる
 475             filter.ExFilterByUrl = true;
 476
 477             filter.ExFilterBody = new[] { "aaa", "bbb" };
 478
 479             post = new PostClass { Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 480             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 481
 482             // 片方だけではマッチしない
 483             post = new PostClass { Text = "<a href='http://example.com/aaa'>t.co/hoge</a>" };
 484             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 485
 486             // ExFilterBody の文字列が全て含まれている
 487             post = new PostClass { Text = "<a href='http://example.com/aaabbb'>t.co/hoge</a>" };
 488             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 489
 490             // ScreenName にはマッチしない (ExUseNameField = true の場合)
 491             post = new PostClass { ScreenName = "aaabbb", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 492             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 493
 494             // 大小文字を区別する
 495             filter.ExCaseSensitive = true;
 496
 497             post = new PostClass { Text = "<a href='http://example.com/AaaBbb'>t.co/hoge</a>" };
 498             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 499
 500             // 大小文字を区別しない
 501             filter.ExCaseSensitive = false;
 502
 503             post = new PostClass { Text = "<a href='http://example.com/AaaBbb'>t.co/hoge</a>" };
 504             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 505         }
 506
 507         [Fact]
 508         public void FilterBody_ByUrlRegexTest()
 509         {
 510             var filter = new PostFilterRule();
 511             PostClass post;
 512
 513             // FilterByUrl = true の場合は TextFromApi ではなく Text がマッチ対象になる
 514             filter.FilterByUrl = true;
 515
 516             filter.UseRegex = true;
 517             filter.FilterBody = new[] { "a{3}", "b{3}" };
 518
 519             post = new PostClass { Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 520             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 521
 522             // 片方だけではマッチしない
 523             post = new PostClass { Text = "<a href='http://example.com/aaa'>t.co/hoge</a>" };
 524             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 525
 526             // FilterBody の文字列が全て含まれている
 527             post = new PostClass { Text = "<a href='http://example.com/aaabbb'>t.co/hoge</a>" };
 528             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 529
 530             // ScreenName にはマッチしない (UseNameField = true の場合)
 531             post = new PostClass { ScreenName = "aaabbb", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 532             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 533
 534             // 大小文字を区別する
 535             filter.CaseSensitive = true;
 536
 537             post = new PostClass { Text = "<a href='http://example.com/AaaBbb'>t.co/hoge</a>" };
 538             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 539
 540             // 大小文字を区別しない
 541             filter.CaseSensitive = false;
 542
 543             post = new PostClass { Text = "<a href='http://example.com/AaaBbb'>t.co/hoge</a>" };
 544             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 545         }
 546
 547         [Fact]
 548         public void ExFilterBody_ByUrlRegexTest()
 549         {
 550             var filter = new PostFilterRule();
 551             PostClass post;
 552
 553             // ExFilterByUrl = true の場合は TextFromApi ではなく Text がマッチ対象になる
 554             filter.ExFilterByUrl = true;
 555
 556             filter.ExUseRegex = true;
 557             filter.ExFilterBody = new[] { "a{3}", "b{3}" };
 558
 559             post = new PostClass { Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 560             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 561
 562             // 片方だけではマッチしない
 563             post = new PostClass { Text = "<a href='http://example.com/aaa'>t.co/hoge</a>" };
 564             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 565
 566             // ExFilterBody の文字列が全て含まれている
 567             post = new PostClass { Text = "<a href='http://example.com/aaabbb'>t.co/hoge</a>" };
 568             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 569
 570             // ScreenName にはマッチしない (ExUseNameField = true の場合)
 571             post = new PostClass { ScreenName = "aaabbb", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 572             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 573
 574             // 大小文字を区別する
 575             filter.ExCaseSensitive = true;
 576
 577             post = new PostClass { Text = "<a href='http://example.com/AaaBbb'>t.co/hoge</a>" };
 578             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 579
 580             // 大小文字を区別しない
 581             filter.ExCaseSensitive = false;
 582
 583             post = new PostClass { Text = "<a href='http://example.com/AaaBbb'>t.co/hoge</a>" };
 584             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 585         }
 586
 587         [Fact]
 588         public void FilterBodyAndName_Test()
 589         {
 590             var filter = new PostFilterRule();
 591             PostClass post;
 592
 593             // UseNameField = false の場合は FilterBody のマッチ対象が TextFromApi と ScreenName の両方になる
 594             filter.UseNameField = false;
 595
 596             filter.FilterBody = new[] { "aaa", "bbb" };
 597
 598             post = new PostClass { ScreenName = "hoge", TextFromApi = "test" };
 599             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 600
 601             // FilterBody の片方だけではマッチしない
 602             post = new PostClass { ScreenName = "hoge", TextFromApi = "aaa" };
 603             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 604
 605             // FilterBody の片方だけではマッチしない
 606             post = new PostClass { ScreenName = "aaa", TextFromApi = "test" };
 607             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 608
 609             // TextFromApi に FilterBody の文字列が全て含まれている
 610             post = new PostClass { ScreenName = "hoge", TextFromApi = "123aaa456bbb" };
 611             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 612
 613             // TextFromApi と ScreenName に FilterBody の文字列がそれぞれ含まれている
 614             post = new PostClass { ScreenName = "aaa", TextFromApi = "bbb" };
 615             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 616
 617             // TextFromApi と RetweetedBy に FilterBody の文字列がそれぞれ含まれている
 618             post = new PostClass { ScreenName = "hoge", TextFromApi = "bbb", RetweetedBy = "aaa" };
 619             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 620
 621             // RetweetedBy が null でなくても依然として ScreenName にはマッチする
 622             post = new PostClass { ScreenName = "aaa", TextFromApi = "bbb", RetweetedBy = "hoge" };
 623             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 624
 625             // ScreenName に対しては完全一致 (UseRegex = false の場合)
 626             post = new PostClass { ScreenName = "_aaa_", TextFromApi = "bbb" };
 627             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 628
 629             // TextFromApi に対しては UseRegex に関わらず常に部分一致
 630             post = new PostClass { ScreenName = "aaa", TextFromApi = "_bbb_" };
 631             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 632
 633             // 大小文字を区別する
 634             filter.CaseSensitive = true;
 635
 636             post = new PostClass { ScreenName = "Aaa", TextFromApi = "Bbb" };
 637             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 638
 639             post = new PostClass { ScreenName = "hoge", TextFromApi = "Bbb", RetweetedBy = "Aaa" };
 640             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 641
 642             // 大小文字を区別しない
 643             filter.CaseSensitive = false;
 644
 645             post = new PostClass { ScreenName = "Aaa", TextFromApi = "Bbb" };
 646             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 647
 648             post = new PostClass { ScreenName = "hoge", TextFromApi = "Bbb", RetweetedBy = "Aaa" };
 649             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 650         }
 651
 652         [Fact]
 653         public void ExFilterBodyAndName_Test()
 654         {
 655             var filter = new PostFilterRule();
 656             PostClass post;
 657
 658             // ExUseNameField = false の場合は ExFilterBody のマッチ対象が TextFromApi と ScreenName の両方になる
 659             filter.ExUseNameField = false;
 660
 661             filter.ExFilterBody = new[] { "aaa", "bbb" };
 662
 663             post = new PostClass { ScreenName = "hoge", TextFromApi = "test" };
 664             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 665
 666             // ExFilterBody の片方だけではマッチしない
 667             post = new PostClass { ScreenName = "hoge", TextFromApi = "aaa" };
 668             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 669
 670             // ExFilterBody の片方だけではマッチしない
 671             post = new PostClass { ScreenName = "aaa", TextFromApi = "test" };
 672             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 673
 674             // TextFromApi に ExFilterBody の文字列が全て含まれている
 675             post = new PostClass { ScreenName = "hoge", TextFromApi = "123aaa456bbb" };
 676             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 677
 678             // TextFromApi と ScreenName に ExFilterBody の文字列がそれぞれ含まれている
 679             post = new PostClass { ScreenName = "aaa", TextFromApi = "bbb" };
 680             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 681
 682             // TextFromApi と RetweetedBy に ExFilterBody の文字列がそれぞれ含まれている
 683             post = new PostClass { ScreenName = "hoge", TextFromApi = "bbb", RetweetedBy = "aaa" };
 684             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 685
 686             // RetweetedBy が null でなくても依然として ScreenName にはマッチする
 687             post = new PostClass { ScreenName = "aaa", TextFromApi = "bbb", RetweetedBy = "hoge" };
 688             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 689
 690             // ScreenName に対しては完全一致 (ExUseRegex = false の場合)
 691             post = new PostClass { ScreenName = "_aaa_", TextFromApi = "bbb" };
 692             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 693
 694             // TextFromApi に対しては ExUseRegex に関わらず常に部分一致
 695             post = new PostClass { ScreenName = "aaa", TextFromApi = "_bbb_" };
 696             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 697
 698             // 大小文字を区別する
 699             filter.ExCaseSensitive = true;
 700
 701             post = new PostClass { ScreenName = "Aaa", TextFromApi = "Bbb" };
 702             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 703
 704             post = new PostClass { ScreenName = "hoge", TextFromApi = "Bbb", RetweetedBy = "Aaa" };
 705             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 706
 707             // 大小文字を区別しない
 708             filter.ExCaseSensitive = false;
 709
 710             post = new PostClass { ScreenName = "Aaa", TextFromApi = "Bbb" };
 711             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 712
 713             post = new PostClass { ScreenName = "hoge", TextFromApi = "Bbb", RetweetedBy = "Aaa" };
 714             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 715         }
 716
 717         [Fact]
 718         public void FilterBodyAndName_RegexTest()
 719         {
 720             var filter = new PostFilterRule();
 721             PostClass post;
 722
 723             // UseNameField = false の場合は FilterBody のマッチ対象が TextFromApi と ScreenName の両方になる
 724             filter.UseNameField = false;
 725
 726             filter.UseRegex = true;
 727             filter.FilterBody = new[] { "a{3}", "b{3}" };
 728
 729             post = new PostClass { ScreenName = "hoge", TextFromApi = "test" };
 730             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 731
 732             // FilterBody の片方だけではマッチしない
 733             post = new PostClass { ScreenName = "hoge", TextFromApi = "aaa" };
 734             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 735
 736             // FilterBody の片方だけではマッチしない
 737             post = new PostClass { ScreenName = "aaa", TextFromApi = "test" };
 738             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 739
 740             // TextFromApi に FilterBody の文字列が全て含まれている
 741             post = new PostClass { ScreenName = "hoge", TextFromApi = "123aaa456bbb" };
 742             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 743
 744             // TextFromApi と ScreenName に FilterBody の文字列がそれぞれ含まれている
 745             post = new PostClass { ScreenName = "aaa", TextFromApi = "bbb" };
 746             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 747
 748             // TextFromApi と RetweetedBy に FilterBody の文字列がそれぞれ含まれている
 749             post = new PostClass { ScreenName = "hoge", TextFromApi = "bbb", RetweetedBy = "aaa" };
 750             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 751
 752             // RetweetedBy が null でなくても依然として ScreenName にはマッチする
 753             post = new PostClass { ScreenName = "aaa", TextFromApi = "bbb", RetweetedBy = "hoge" };
 754             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 755
 756             // ScreenName に対しても部分一致 (UseRegex = true の場合)
 757             post = new PostClass { ScreenName = "_aaa_", TextFromApi = "bbb" };
 758             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 759
 760             // TextFromApi に対しては UseRegex に関わらず常に部分一致
 761             post = new PostClass { ScreenName = "aaa", TextFromApi = "_bbb_" };
 762             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 763
 764             // 大小文字を区別する
 765             filter.CaseSensitive = true;
 766
 767             post = new PostClass { ScreenName = "Aaa", TextFromApi = "Bbb" };
 768             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 769
 770             post = new PostClass { ScreenName = "hoge", TextFromApi = "Bbb", RetweetedBy = "Aaa" };
 771             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 772
 773             // 大小文字を区別しない
 774             filter.CaseSensitive = false;
 775
 776             post = new PostClass { ScreenName = "Aaa", TextFromApi = "Bbb" };
 777             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 778
 779             post = new PostClass { ScreenName = "hoge", TextFromApi = "Bbb", RetweetedBy = "Aaa" };
 780             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 781         }
 782
 783         [Fact]
 784         public void ExFilterBodyAndName_RegexTest()
 785         {
 786             var filter = new PostFilterRule();
 787             PostClass post;
 788
 789             // ExUseNameField = false の場合は ExFilterBody のマッチ対象が TextFromApi と ScreenName の両方になる
 790             filter.ExUseNameField = false;
 791
 792             filter.ExUseRegex = true;
 793             filter.ExFilterBody = new[] { "a{3}", "b{3}" };
 794
 795             post = new PostClass { ScreenName = "hoge", TextFromApi = "test" };
 796             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 797
 798             // ExFilterBody の片方だけではマッチしない
 799             post = new PostClass { ScreenName = "hoge", TextFromApi = "aaa" };
 800             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 801
 802             // ExFilterBody の片方だけではマッチしない
 803             post = new PostClass { ScreenName = "aaa", TextFromApi = "test" };
 804             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 805
 806             // TextFromApi に ExFilterBody の文字列が全て含まれている
 807             post = new PostClass { ScreenName = "hoge", TextFromApi = "123aaa456bbb" };
 808             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 809
 810             // TextFromApi と ScreenName に ExFilterBody の文字列がそれぞれ含まれている
 811             post = new PostClass { ScreenName = "aaa", TextFromApi = "bbb" };
 812             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 813
 814             // TextFromApi と RetweetedBy に ExFilterBody の文字列がそれぞれ含まれている
 815             post = new PostClass { ScreenName = "hoge", TextFromApi = "bbb", RetweetedBy = "aaa" };
 816             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 817
 818             // RetweetedBy が null でなくても依然として ScreenName にはマッチする
 819             post = new PostClass { ScreenName = "aaa", TextFromApi = "bbb", RetweetedBy = "hoge" };
 820             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 821
 822             // ScreenName に対しても部分一致 (ExUseRegex = true の場合)
 823             post = new PostClass { ScreenName = "_aaa_", TextFromApi = "bbb" };
 824             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 825
 826             // TextFromApi に対しては ExUseRegex に関わらず常に部分一致
 827             post = new PostClass { ScreenName = "aaa", TextFromApi = "_bbb_" };
 828             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 829
 830             // 大小文字を区別する
 831             filter.ExCaseSensitive = true;
 832
 833             post = new PostClass { ScreenName = "Aaa", TextFromApi = "Bbb" };
 834             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 835
 836             post = new PostClass { ScreenName = "hoge", TextFromApi = "Bbb", RetweetedBy = "Aaa" };
 837             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 838
 839             // 大小文字を区別しない
 840             filter.ExCaseSensitive = false;
 841
 842             post = new PostClass { ScreenName = "Aaa", TextFromApi = "Bbb" };
 843             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 844
 845             post = new PostClass { ScreenName = "hoge", TextFromApi = "Bbb", RetweetedBy = "Aaa" };
 846             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 847         }
 848
 849         [Fact]
 850         public void FilterBodyAndName_ByUrlTest()
 851         {
 852             var filter = new PostFilterRule();
 853             PostClass post;
 854
 855             // FilterByUrl = true の場合は TextFromApi ではなく Text がマッチ対象になる
 856             filter.FilterByUrl = true;
 857
 858             // UseNameField = false の場合は FilterBody のマッチ対象が Text と ScreenName の両方になる
 859             filter.UseNameField = false;
 860
 861             filter.FilterBody = new[] { "aaa", "bbb" };
 862
 863             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 864             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 865
 866             // FilterBody の片方だけではマッチしない
 867             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/aaa'>t.co/hoge</a>" };
 868             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 869
 870             // FilterBody の片方だけではマッチしない
 871             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 872             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 873
 874             // Text に FilterBody の文字列が全て含まれている
 875             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/aaabbb'>t.co/hoge</a>" };
 876             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 877
 878             // Text と ScreenName に FilterBody の文字列がそれぞれ含まれている
 879             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>" };
 880             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 881
 882             // Text と ScreenName に FilterBody の文字列がそれぞれ含まれている
 883             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>", RetweetedBy = "aaa" };
 884             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 885
 886             // RetweetedBy が null でなくても依然として ScreenName にはマッチする
 887             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>", RetweetedBy = "hoge" };
 888             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 889
 890             // ScreenName に対しては完全一致 (UseRegex = false の場合)
 891             post = new PostClass { ScreenName = "_aaa_", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>" };
 892             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 893
 894             // Text に対しては UseRegex に関わらず常に部分一致
 895             post = new PostClass { ScreenName = "aaa", Text = "_bbb_" };
 896             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 897
 898             // 大小文字を区別する
 899             filter.CaseSensitive = true;
 900
 901             post = new PostClass { ScreenName = "Aaa", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>" };
 902             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 903
 904             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>", RetweetedBy = "Aaa" };
 905             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 906
 907             // 大小文字を区別しない
 908             filter.CaseSensitive = false;
 909
 910             post = new PostClass { ScreenName = "Aaa", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>" };
 911             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 912
 913             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>", RetweetedBy = "Aaa" };
 914             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
 915         }
 916
 917         [Fact]
 918         public void ExFilterBodyAndName_ByUrlTest()
 919         {
 920             var filter = new PostFilterRule();
 921             PostClass post;
 922
 923             // ExFilterByUrl = true の場合は TextFromApi ではなく Text がマッチ対象になる
 924             filter.ExFilterByUrl = true;
 925
 926             // ExUseNameField = false の場合は ExFilterBody のマッチ対象が Text と ScreenName の両方になる
 927             filter.ExUseNameField = false;
 928
 929             filter.ExFilterBody = new[] { "aaa", "bbb" };
 930
 931             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 932             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 933
 934             // ExFilterBody の片方だけではマッチしない
 935             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/aaa'>t.co/hoge</a>" };
 936             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 937
 938             // ExFilterBody の片方だけではマッチしない
 939             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
 940             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 941
 942             // Text に ExFilterBody の文字列が全て含まれている
 943             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/aaabbb'>t.co/hoge</a>" };
 944             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 945
 946             // Text と ScreenName に ExFilterBody の文字列がそれぞれ含まれている
 947             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>" };
 948             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 949
 950             // Text と ScreenName に ExFilterBody の文字列がそれぞれ含まれている
 951             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>", RetweetedBy = "aaa" };
 952             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 953
 954             // RetweetedBy が null でなくても依然として ScreenName にはマッチする
 955             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>", RetweetedBy = "hoge" };
 956             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 957
 958             // ScreenName に対しては完全一致 (ExUseRegex = false の場合)
 959             post = new PostClass { ScreenName = "_aaa_", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>" };
 960             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 961
 962             // Text に対しては ExUseRegex に関わらず常に部分一致
 963             post = new PostClass { ScreenName = "aaa", Text = "_bbb_" };
 964             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 965
 966             // 大小文字を区別する
 967             filter.ExCaseSensitive = true;
 968
 969             post = new PostClass { ScreenName = "Aaa", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>" };
 970             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 971
 972             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>", RetweetedBy = "Aaa" };
 973             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
 974
 975             // 大小文字を区別しない
 976             filter.ExCaseSensitive = false;
 977
 978             post = new PostClass { ScreenName = "Aaa", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>" };
 979             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 980
 981             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>", RetweetedBy = "Aaa" };
 982             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
 983         }
 984
 985         [Fact]
 986         public void FilterBodyAndName_ByUrlRegexTest()
 987         {
 988             var filter = new PostFilterRule();
 989             PostClass post;
 990
 991             // FilterByUrl = true の場合は TextFromApi ではなく Text がマッチ対象になる
 992             filter.FilterByUrl = true;
 993
 994             // UseNameField = false の場合は FilterBody のマッチ対象が Text と ScreenName の両方になる
 995             filter.UseNameField = false;
 996
 997             filter.UseRegex = true;
 998             filter.FilterBody = new[] { "a{3}", "b{3}" };
 999
1000             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
1001             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1002
1003             // FilterBody の片方だけではマッチしない
1004             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/aaa'>t.co/hoge</a>" };
1005             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1006
1007             // FilterBody の片方だけではマッチしない
1008             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
1009             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1010
1011             // Text に FilterBody の文字列が全て含まれている
1012             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/aaabbb'>t.co/hoge</a>" };
1013             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1014
1015             // Text と ScreenName に FilterBody の文字列がそれぞれ含まれている
1016             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>" };
1017             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1018
1019             // Text と ScreenName に FilterBody の文字列がそれぞれ含まれている
1020             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>", RetweetedBy = "aaa" };
1021             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1022
1023             // RetweetedBy が null でなくても依然として ScreenName にはマッチする
1024             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>", RetweetedBy = "hoge" };
1025             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1026
1027             // ScreenName に対しても部分一致 (UseRegex = true の場合)
1028             post = new PostClass { ScreenName = "_aaa_", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>" };
1029             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1030
1031             // Text に対しては UseRegex に関わらず常に部分一致
1032             post = new PostClass { ScreenName = "aaa", Text = "_bbb_" };
1033             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1034
1035             // 大小文字を区別する
1036             filter.CaseSensitive = true;
1037
1038             post = new PostClass { ScreenName = "Aaa", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>" };
1039             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1040
1041             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>", RetweetedBy = "Aaa" };
1042             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1043
1044             // 大小文字を区別しない
1045             filter.CaseSensitive = false;
1046
1047             post = new PostClass { ScreenName = "Aaa", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>" };
1048             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1049
1050             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>", RetweetedBy = "Aaa" };
1051             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1052         }
1053
1054         [Fact]
1055         public void ExFilterBodyAndName_ByUrlRegexTest()
1056         {
1057             var filter = new PostFilterRule();
1058             PostClass post;
1059
1060             // ExFilterByUrl = true の場合は TextFromApi ではなく Text がマッチ対象になる
1061             filter.ExFilterByUrl = true;
1062
1063             // ExUseNameField = false の場合は ExFilterBody のマッチ対象が Text と ScreenName の両方になる
1064             filter.ExUseNameField = false;
1065
1066             filter.ExUseRegex = true;
1067             filter.ExFilterBody = new[] { "a{3}", "b{3}" };
1068
1069             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
1070             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1071
1072             // ExFilterBody の片方だけではマッチしない
1073             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/aaa'>t.co/hoge</a>" };
1074             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1075
1076             // ExFilterBody の片方だけではマッチしない
1077             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/123'>t.co/hoge</a>" };
1078             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1079
1080             // Text に ExFilterBody の文字列が全て含まれている
1081             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/aaabbb'>t.co/hoge</a>" };
1082             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1083
1084             // Text と ScreenName に ExFilterBody の文字列がそれぞれ含まれている
1085             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>" };
1086             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1087
1088             // Text と ScreenName に ExFilterBody の文字列がそれぞれ含まれている
1089             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>", RetweetedBy = "aaa" };
1090             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1091
1092             // RetweetedBy が null でなくても依然として ScreenName にはマッチする
1093             post = new PostClass { ScreenName = "aaa", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>", RetweetedBy = "hoge" };
1094             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1095
1096             // ScreenName に対しても部分一致 (ExUseRegex = true の場合)
1097             post = new PostClass { ScreenName = "_aaa_", Text = "<a href='http://example.com/bbb'>t.co/hoge</a>" };
1098             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1099
1100             // Text に対しては ExUseRegex に関わらず常に部分一致
1101             post = new PostClass { ScreenName = "aaa", Text = "_bbb_" };
1102             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1103
1104             // 大小文字を区別する
1105             filter.ExCaseSensitive = true;
1106
1107             post = new PostClass { ScreenName = "Aaa", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>" };
1108             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1109
1110             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>", RetweetedBy = "Aaa" };
1111             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1112
1113             // 大小文字を区別しない
1114             filter.ExCaseSensitive = false;
1115
1116             post = new PostClass { ScreenName = "Aaa", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>" };
1117             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1118
1119             post = new PostClass { ScreenName = "hoge", Text = "<a href='http://example.com/Bbb'>t.co/hoge</a>", RetweetedBy = "Aaa" };
1120             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1121         }
1122
1123         [Fact]
1124         public void FilterSource_Test()
1125         {
1126             var filter = new PostFilterRule();
1127             PostClass post;
1128
1129             filter.FilterSource = "hogehoge";
1130
1131             post = new PostClass { Source = "hogehoge" };
1132             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1133
1134             post = new PostClass { Source = "foo" };
1135             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1136
1137             // FilterSource は完全一致 (UseRegex = false の場合)
1138             post = new PostClass { Source = "_hogehoge_" };
1139             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1140
1141             // 大小文字を区別する
1142             filter.CaseSensitive = true;
1143
1144             post = new PostClass { Source = "HogeHoge" };
1145             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1146
1147             // 大小文字を区別しない
1148             filter.CaseSensitive = false;
1149
1150             post = new PostClass { Source = "HogeHoge" };
1151             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1152         }
1153
1154         [Fact]
1155         public void ExFilterSource_Test()
1156         {
1157             var filter = new PostFilterRule();
1158             PostClass post;
1159
1160             filter.ExFilterSource = "hogehoge";
1161
1162             post = new PostClass { Source = "hogehoge" };
1163             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1164
1165             post = new PostClass { Source = "foo" };
1166             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1167
1168             // ExFilterSource は完全一致 (ExUseRegex = false の場合)
1169             post = new PostClass { Source = "_hogehoge_" };
1170             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1171
1172             // 大小文字を区別する
1173             filter.ExCaseSensitive = true;
1174
1175             post = new PostClass { Source = "HogeHoge" };
1176             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1177
1178             // 大小文字を区別しない
1179             filter.ExCaseSensitive = false;
1180
1181             post = new PostClass { Source = "HogeHoge" };
1182             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1183         }
1184
1185         [Fact]
1186         public void FilterSource_RegexTest()
1187         {
1188             var filter = new PostFilterRule();
1189             PostClass post;
1190
1191             filter.UseRegex = true;
1192             filter.FilterSource = "(hoge){2}";
1193
1194             post = new PostClass { Source = "hogehoge" };
1195             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1196
1197             post = new PostClass { Source = "foo" };
1198             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1199
1200             // FilterSource は部分一致 (UseRegex = true の場合)
1201             post = new PostClass { Source = "_hogehoge_" };
1202             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1203
1204             // 大小文字を区別する
1205             filter.CaseSensitive = true;
1206
1207             post = new PostClass { Source = "HogeHoge" };
1208             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1209
1210             // 大小文字を区別しない
1211             filter.CaseSensitive = false;
1212
1213             post = new PostClass { Source = "HogeHoge" };
1214             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1215         }
1216
1217         [Fact]
1218         public void ExFilterSource_RegexTest()
1219         {
1220             var filter = new PostFilterRule();
1221             PostClass post;
1222
1223             filter.ExUseRegex = true;
1224             filter.ExFilterSource = "(hoge){2}";
1225
1226             post = new PostClass { Source = "hogehoge" };
1227             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1228
1229             post = new PostClass { Source = "foo" };
1230             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1231
1232             // ExFilterSource は部分一致 (ExUseRegex = true の場合)
1233             post = new PostClass { Source = "_hogehoge_" };
1234             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1235
1236             // 大小文字を区別する
1237             filter.ExCaseSensitive = true;
1238
1239             post = new PostClass { Source = "HogeHoge" };
1240             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1241
1242             // 大小文字を区別しない
1243             filter.ExCaseSensitive = false;
1244
1245             post = new PostClass { Source = "HogeHoge" };
1246             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1247         }
1248
1249         [Fact]
1250         public void FilterSource_ByUrlTest()
1251         {
1252             var filter = new PostFilterRule();
1253             PostClass post;
1254
1255             // FilterByUrl = true の場合は Source ではなく SourceHtml がマッチ対象になる
1256             filter.FilterByUrl = true;
1257
1258             filter.FilterSource = "hogehoge";
1259
1260             // FilterSource は UseRegex の値に関わらず部分一致
1261             post = new PostClass { SourceHtml = "<a href='http://example.com/hogehoge'>****</a>" };
1262             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1263
1264             post = new PostClass { SourceHtml = "<a href='http://example.com/foo'>****</a>" };
1265             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1266
1267             // 大小文字を区別する
1268             filter.CaseSensitive = true;
1269
1270             post = new PostClass { SourceHtml = "<a href='http://example.com/HogeHoge'>****</a>" };
1271             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1272
1273             // 大小文字を区別しない
1274             filter.CaseSensitive = false;
1275
1276             post = new PostClass { SourceHtml = "<a href='http://example.com/HogeHoge'>****</a>" };
1277             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1278         }
1279
1280         [Fact]
1281         public void ExFilterSource_ByUrlTest()
1282         {
1283             var filter = new PostFilterRule();
1284             PostClass post;
1285
1286             // ExFilterByUrl = true の場合は Source ではなく SourceHtml がマッチ対象になる
1287             filter.ExFilterByUrl = true;
1288
1289             filter.ExFilterSource = "hogehoge";
1290
1291             // ExFilterSource は ExUseRegex の値に関わらず部分一致
1292             post = new PostClass { SourceHtml = "<a href='http://example.com/hogehoge'>****</a>" };
1293             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1294
1295             post = new PostClass { SourceHtml = "<a href='http://example.com/foo'>****</a>" };
1296             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1297
1298             // 大小文字を区別する
1299             filter.ExCaseSensitive = true;
1300
1301             post = new PostClass { SourceHtml = "<a href='http://example.com/HogeHoge'>****</a>" };
1302             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1303
1304             // 大小文字を区別しない
1305             filter.ExCaseSensitive = false;
1306
1307             post = new PostClass { SourceHtml = "<a href='http://example.com/HogeHoge'>****</a>" };
1308             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1309         }
1310
1311         [Fact]
1312         public void FilterSource_ByUrlRegexTest()
1313         {
1314             var filter = new PostFilterRule();
1315             PostClass post;
1316
1317             // FilterByUrl = true の場合は Source ではなく SourceHtml がマッチ対象になる
1318             filter.FilterByUrl = true;
1319
1320             filter.UseRegex = true;
1321             filter.FilterSource = "(hoge){2}";
1322
1323             // FilterSource は UseRegex の値に関わらず部分一致
1324             post = new PostClass { SourceHtml = "<a href='http://example.com/hogehoge'>****</a>" };
1325             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1326
1327             post = new PostClass { SourceHtml = "<a href='http://example.com/foo'>****</a>" };
1328             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1329
1330             // 大小文字を区別する
1331             filter.CaseSensitive = true;
1332
1333             post = new PostClass { SourceHtml = "<a href='http://example.com/HogeHoge'>****</a>" };
1334             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1335
1336             // 大小文字を区別しない
1337             filter.CaseSensitive = false;
1338
1339             post = new PostClass { SourceHtml = "<a href='http://example.com/HogeHoge'>****</a>" };
1340             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1341         }
1342
1343         [Fact]
1344         public void ExFilterSource_ByUrlRegexTest()
1345         {
1346             var filter = new PostFilterRule();
1347             PostClass post;
1348
1349             // ExFilterByUrl = true の場合は Source ではなく SourceHtml がマッチ対象になる
1350             filter.ExFilterByUrl = true;
1351
1352             filter.ExUseRegex = true;
1353             filter.ExFilterSource = "(hoge){2}";
1354
1355             // ExFilterSource は ExUseRegex の値に関わらず部分一致
1356             post = new PostClass { SourceHtml = "<a href='http://example.com/hogehoge'>****</a>" };
1357             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1358
1359             post = new PostClass { SourceHtml = "<a href='http://example.com/foo'>****</a>" };
1360             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1361
1362             // 大小文字を区別する
1363             filter.ExCaseSensitive = true;
1364
1365             post = new PostClass { SourceHtml = "<a href='http://example.com/HogeHoge'>****</a>" };
1366             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1367
1368             // 大小文字を区別しない
1369             filter.ExCaseSensitive = false;
1370
1371             post = new PostClass { SourceHtml = "<a href='http://example.com/HogeHoge'>****</a>" };
1372             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1373         }
1374
1375         [Fact]
1376         public void FilterRt_Test()
1377         {
1378             var filter = new PostFilterRule();
1379             PostClass post;
1380
1381             filter.FilterRt = true;
1382
1383             post = new PostClass { RetweetedBy = "hogehoge", RetweetedId = 123L };
1384             Assert.Equal(MyCommon.HITRESULT.CopyAndMark, filter.ExecFilter(post));
1385
1386             post = new PostClass { };
1387             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1388         }
1389
1390         [Fact]
1391         public void ExFilterRt_Test()
1392         {
1393             var filter = new PostFilterRule();
1394             PostClass post;
1395
1396             filter.ExFilterRt = true;
1397
1398             post = new PostClass { RetweetedBy = "hogehoge", RetweetedId = 123L };
1399             Assert.Equal(MyCommon.HITRESULT.Exclude, filter.ExecFilter(post));
1400
1401             post = new PostClass { };
1402             Assert.Equal(MyCommon.HITRESULT.None, filter.ExecFilter(post));
1403         }
1404     }
1405 }