org.spearce.jgit.test/tst/org/spearce/jgit/fnmatch/FileNameMatcherTest.java

   1 /*
   2  * Copyright (C) 2008, Florian Köberle <florianskarten@web.de>
   3  *
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or
   7  * without modification, are permitted provided that the following
   8  * conditions are met:
   9  *
  10  * - Redistributions of source code must retain the above copyright
  11  *   notice, this list of conditions and the following disclaimer.
  12  *
  13  * - Redistributions in binary form must reproduce the above
  14  *   copyright notice, this list of conditions and the following
  15  *   disclaimer in the documentation and/or other materials provided
  16  *   with the distribution.
  17  *
  18  * - Neither the name of the Git Development Community nor the
  19  *   names of its contributors may be used to endorse or promote
  20  *   products derived from this software without specific prior
  21  *   written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
  24  * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  25  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  26  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  28  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  30  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  31  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  32  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  33  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  34  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  35  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  */
  37
  38 package org.spearce.jgit.fnmatch;
  39
  40 import org.spearce.jgit.errors.InvalidPatternException;
  41 import org.spearce.jgit.fnmatch.FileNameMatcher;
  42
  43 import junit.framework.TestCase;
  44
  45 public class FileNameMatcherTest extends TestCase {
  46
  47         private void assertMatch(final String pattern, final String input,
  48                         final boolean matchExpected, final boolean appendCanMatchExpected)
  49                         throws InvalidPatternException {
  50                 final FileNameMatcher matcher = new FileNameMatcher(pattern, null);
  51                 matcher.append(input);
  52                 assertEquals(matchExpected, matcher.isMatch());
  53                 assertEquals(appendCanMatchExpected, matcher.canAppendMatch());
  54         }
  55
  56         private void assertFileNameMatch(final String pattern, final String input,
  57                         final char excludedCharacter, final boolean matchExpected,
  58                         final boolean appendCanMatchExpected)
  59                         throws InvalidPatternException {
  60                 final FileNameMatcher matcher = new FileNameMatcher(pattern,
  61                                 new Character(excludedCharacter));
  62                 matcher.append(input);
  63                 assertEquals(matchExpected, matcher.isMatch());
  64                 assertEquals(appendCanMatchExpected, matcher.canAppendMatch());
  65         }
  66
  67         public void testVerySimplePatternCase0() throws Exception {
  68                 assertMatch("", "", true, false);
  69         }
  70
  71         public void testVerySimplePatternCase1() throws Exception {
  72                 assertMatch("ab", "a", false, true);
  73         }
  74
  75         public void testVerySimplePatternCase2() throws Exception {
  76                 assertMatch("ab", "ab", true, false);
  77         }
  78
  79         public void testVerySimplePatternCase3() throws Exception {
  80                 assertMatch("ab", "ac", false, false);
  81         }
  82
  83         public void testVerySimplePatternCase4() throws Exception {
  84                 assertMatch("ab", "abc", false, false);
  85         }
  86
  87         public void testVerySimpleWirdcardCase0() throws Exception {
  88                 assertMatch("?", "a", true, false);
  89         }
  90
  91         public void testVerySimpleWildCardCase1() throws Exception {
  92                 assertMatch("??", "a", false, true);
  93         }
  94
  95         public void testVerySimpleWildCardCase2() throws Exception {
  96                 assertMatch("??", "ab", true, false);
  97         }
  98
  99         public void testVerySimpleWildCardCase3() throws Exception {
 100                 assertMatch("??", "abc", false, false);
 101         }
 102
 103         public void testVerySimpleStarCase0() throws Exception {
 104                 assertMatch("*", "", true, true);
 105         }
 106
 107         public void testVerySimpleStarCase1() throws Exception {
 108                 assertMatch("*", "a", true, true);
 109         }
 110
 111         public void testVerySimpleStarCase2() throws Exception {
 112                 assertMatch("*", "ab", true, true);
 113         }
 114
 115         public void testSimpleStarCase0() throws Exception {
 116                 assertMatch("a*b", "a", false, true);
 117         }
 118
 119         public void testSimpleStarCase1() throws Exception {
 120                 assertMatch("a*c", "ac", true, true);
 121         }
 122
 123         public void testSimpleStarCase2() throws Exception {
 124                 assertMatch("a*c", "ab", false, true);
 125         }
 126
 127         public void testSimpleStarCase3() throws Exception {
 128                 assertMatch("a*c", "abc", true, true);
 129         }
 130
 131         public void testManySolutionsCase0() throws Exception {
 132                 assertMatch("a*a*a", "aaa", true, true);
 133         }
 134
 135         public void testManySolutionsCase1() throws Exception {
 136                 assertMatch("a*a*a", "aaaa", true, true);
 137         }
 138
 139         public void testManySolutionsCase2() throws Exception {
 140                 assertMatch("a*a*a", "ababa", true, true);
 141         }
 142
 143         public void testManySolutionsCase3() throws Exception {
 144                 assertMatch("a*a*a", "aaaaaaaa", true, true);
 145         }
 146
 147         public void testManySolutionsCase4() throws Exception {
 148                 assertMatch("a*a*a", "aaaaaaab", false, true);
 149         }
 150
 151         public void testVerySimpleGroupCase0() throws Exception {
 152                 assertMatch("[ab]", "a", true, false);
 153         }
 154
 155         public void testVerySimpleGroupCase1() throws Exception {
 156                 assertMatch("[ab]", "b", true, false);
 157         }
 158
 159         public void testVerySimpleGroupCase2() throws Exception {
 160                 assertMatch("[ab]", "ab", false, false);
 161         }
 162
 163         public void testVerySimpleGroupRangeCase0() throws Exception {
 164                 assertMatch("[b-d]", "a", false, false);
 165         }
 166
 167         public void testVerySimpleGroupRangeCase1() throws Exception {
 168                 assertMatch("[b-d]", "b", true, false);
 169         }
 170
 171         public void testVerySimpleGroupRangeCase2() throws Exception {
 172                 assertMatch("[b-d]", "c", true, false);
 173         }
 174
 175         public void testVerySimpleGroupRangeCase3() throws Exception {
 176                 assertMatch("[b-d]", "d", true, false);
 177         }
 178
 179         public void testVerySimpleGroupRangeCase4() throws Exception {
 180                 assertMatch("[b-d]", "e", false, false);
 181         }
 182
 183         public void testVerySimpleGroupRangeCase5() throws Exception {
 184                 assertMatch("[b-d]", "-", false, false);
 185         }
 186
 187         public void testTwoGroupsCase0() throws Exception {
 188                 assertMatch("[b-d][ab]", "bb", true, false);
 189         }
 190
 191         public void testTwoGroupsCase1() throws Exception {
 192                 assertMatch("[b-d][ab]", "ca", true, false);
 193         }
 194
 195         public void testTwoGroupsCase2() throws Exception {
 196                 assertMatch("[b-d][ab]", "fa", false, false);
 197         }
 198
 199         public void testTwoGroupsCase3() throws Exception {
 200                 assertMatch("[b-d][ab]", "bc", false, false);
 201         }
 202
 203         public void testTwoRangesInOneGroupCase0() throws Exception {
 204                 assertMatch("[b-ce-e]", "a", false, false);
 205         }
 206
 207         public void testTwoRangesInOneGroupCase1() throws Exception {
 208                 assertMatch("[b-ce-e]", "b", true, false);
 209         }
 210
 211         public void testTwoRangesInOneGroupCase2() throws Exception {
 212                 assertMatch("[b-ce-e]", "c", true, false);
 213         }
 214
 215         public void testTwoRangesInOneGroupCase3() throws Exception {
 216                 assertMatch("[b-ce-e]", "d", false, false);
 217         }
 218
 219         public void testTwoRangesInOneGroupCase4() throws Exception {
 220                 assertMatch("[b-ce-e]", "e", true, false);
 221         }
 222
 223         public void testTwoRangesInOneGroupCase5() throws Exception {
 224                 assertMatch("[b-ce-e]", "f", false, false);
 225         }
 226
 227         public void testIncompleteRangesInOneGroupCase0() throws Exception {
 228                 assertMatch("a[b-]", "ab", true, false);
 229         }
 230
 231         public void testIncompleteRangesInOneGroupCase1() throws Exception {
 232                 assertMatch("a[b-]", "ac", false, false);
 233         }
 234
 235         public void testIncompleteRangesInOneGroupCase2() throws Exception {
 236                 assertMatch("a[b-]", "a-", true, false);
 237         }
 238
 239         public void testCombinedRangesInOneGroupCase0() throws Exception {
 240                 assertMatch("[a-c-e]", "b", true, false);
 241         }
 242
 243         /**
 244          * The c belongs to the range a-c. "-e" is no valid range so d should not
 245          * match.
 246          *
 247          * @throws Exception
 248          *             for some reasons
 249          */
 250         public void testCombinedRangesInOneGroupCase1() throws Exception {
 251                 assertMatch("[a-c-e]", "d", false, false);
 252         }
 253
 254         public void testCombinedRangesInOneGroupCase2() throws Exception {
 255                 assertMatch("[a-c-e]", "e", true, false);
 256         }
 257
 258         public void testInversedGroupCase0() throws Exception {
 259                 assertMatch("[!b-c]", "a", true, false);
 260         }
 261
 262         public void testInversedGroupCase1() throws Exception {
 263                 assertMatch("[!b-c]", "b", false, false);
 264         }
 265
 266         public void testInversedGroupCase2() throws Exception {
 267                 assertMatch("[!b-c]", "c", false, false);
 268         }
 269
 270         public void testInversedGroupCase3() throws Exception {
 271                 assertMatch("[!b-c]", "d", true, false);
 272         }
 273
 274         public void testAlphaGroupCase0() throws Exception {
 275                 assertMatch("[[:alpha:]]", "d", true, false);
 276         }
 277
 278         public void testAlphaGroupCase1() throws Exception {
 279                 assertMatch("[[:alpha:]]", ":", false, false);
 280         }
 281
 282         public void testAlphaGroupCase2() throws Exception {
 283                 // \u00f6 = 'o' with dots on it
 284                 assertMatch("[[:alpha:]]", "\u00f6", true, false);
 285         }
 286
 287         public void test2AlphaGroupsCase0() throws Exception {
 288                 // \u00f6 = 'o' with dots on it
 289                 assertMatch("[[:alpha:]][[:alpha:]]", "a\u00f6", true, false);
 290                 assertMatch("[[:alpha:]][[:alpha:]]", "a1", false, false);
 291         }
 292
 293         public void testAlnumGroupCase0() throws Exception {
 294                 assertMatch("[[:alnum:]]", "a", true, false);
 295         }
 296
 297         public void testAlnumGroupCase1() throws Exception {
 298                 assertMatch("[[:alnum:]]", "1", true, false);
 299         }
 300
 301         public void testAlnumGroupCase2() throws Exception {
 302                 assertMatch("[[:alnum:]]", ":", false, false);
 303         }
 304
 305         public void testBlankGroupCase0() throws Exception {
 306                 assertMatch("[[:blank:]]", " ", true, false);
 307         }
 308
 309         public void testBlankGroupCase1() throws Exception {
 310                 assertMatch("[[:blank:]]", "\t", true, false);
 311         }
 312
 313         public void testBlankGroupCase2() throws Exception {
 314                 assertMatch("[[:blank:]]", "\r", false, false);
 315         }
 316
 317         public void testBlankGroupCase3() throws Exception {
 318                 assertMatch("[[:blank:]]", "\n", false, false);
 319         }
 320
 321         public void testBlankGroupCase4() throws Exception {
 322                 assertMatch("[[:blank:]]", "a", false, false);
 323         }
 324
 325         public void testCntrlGroupCase0() throws Exception {
 326                 assertMatch("[[:cntrl:]]", "a", false, false);
 327         }
 328
 329         public void testCntrlGroupCase1() throws Exception {
 330                 assertMatch("[[:cntrl:]]", String.valueOf((char) 7), true, false);
 331         }
 332
 333         public void testDigitGroupCase0() throws Exception {
 334                 assertMatch("[[:digit:]]", "0", true, false);
 335         }
 336
 337         public void testDigitGroupCase1() throws Exception {
 338                 assertMatch("[[:digit:]]", "5", true, false);
 339         }
 340
 341         public void testDigitGroupCase2() throws Exception {
 342                 assertMatch("[[:digit:]]", "9", true, false);
 343         }
 344
 345         public void testDigitGroupCase3() throws Exception {
 346                 // \u06f9 = EXTENDED ARABIC-INDIC DIGIT NINE
 347                 assertMatch("[[:digit:]]", "\u06f9", true, false);
 348         }
 349
 350         public void testDigitGroupCase4() throws Exception {
 351                 assertMatch("[[:digit:]]", "a", false, false);
 352         }
 353
 354         public void testDigitGroupCase5() throws Exception {
 355                 assertMatch("[[:digit:]]", "]", false, false);
 356         }
 357
 358         public void testGraphGroupCase0() throws Exception {
 359                 assertMatch("[[:graph:]]", "]", true, false);
 360         }
 361
 362         public void testGraphGroupCase1() throws Exception {
 363                 assertMatch("[[:graph:]]", "a", true, false);
 364         }
 365
 366         public void testGraphGroupCase2() throws Exception {
 367                 assertMatch("[[:graph:]]", ".", true, false);
 368         }
 369
 370         public void testGraphGroupCase3() throws Exception {
 371                 assertMatch("[[:graph:]]", "0", true, false);
 372         }
 373
 374         public void testGraphGroupCase4() throws Exception {
 375                 assertMatch("[[:graph:]]", " ", false, false);
 376         }
 377
 378         public void testGraphGroupCase5() throws Exception {
 379                 // \u00f6 = 'o' with dots on it
 380                 assertMatch("[[:graph:]]", "\u00f6", true, false);
 381         }
 382
 383         public void testLowerGroupCase0() throws Exception {
 384                 assertMatch("[[:lower:]]", "a", true, false);
 385         }
 386
 387         public void testLowerGroupCase1() throws Exception {
 388                 assertMatch("[[:lower:]]", "h", true, false);
 389         }
 390
 391         public void testLowerGroupCase2() throws Exception {
 392                 assertMatch("[[:lower:]]", "A", false, false);
 393         }
 394
 395         public void testLowerGroupCase3() throws Exception {
 396                 assertMatch("[[:lower:]]", "H", false, false);
 397         }
 398
 399         public void testLowerGroupCase4() throws Exception {
 400                 // \u00e4 = small 'a' with dots on it
 401                 assertMatch("[[:lower:]]", "\u00e4", true, false);
 402         }
 403
 404         public void testLowerGroupCase5() throws Exception {
 405                 assertMatch("[[:lower:]]", ".", false, false);
 406         }
 407
 408         public void testPrintGroupCase0() throws Exception {
 409                 assertMatch("[[:print:]]", "]", true, false);
 410         }
 411
 412         public void testPrintGroupCase1() throws Exception {
 413                 assertMatch("[[:print:]]", "a", true, false);
 414         }
 415
 416         public void testPrintGroupCase2() throws Exception {
 417                 assertMatch("[[:print:]]", ".", true, false);
 418         }
 419
 420         public void testPrintGroupCase3() throws Exception {
 421                 assertMatch("[[:print:]]", "0", true, false);
 422         }
 423
 424         public void testPrintGroupCase4() throws Exception {
 425                 assertMatch("[[:print:]]", " ", true, false);
 426         }
 427
 428         public void testPrintGroupCase5() throws Exception {
 429                 // \u00f6 = 'o' with dots on it
 430                 assertMatch("[[:print:]]", "\u00f6", true, false);
 431         }
 432
 433         public void testPunctGroupCase0() throws Exception {
 434                 assertMatch("[[:punct:]]", ".", true, false);
 435         }
 436
 437         public void testPunctGroupCase1() throws Exception {
 438                 assertMatch("[[:punct:]]", "@", true, false);
 439         }
 440
 441         public void testPunctGroupCase2() throws Exception {
 442                 assertMatch("[[:punct:]]", " ", false, false);
 443         }
 444
 445         public void testPunctGroupCase3() throws Exception {
 446                 assertMatch("[[:punct:]]", "a", false, false);
 447         }
 448
 449         public void testSpaceGroupCase0() throws Exception {
 450                 assertMatch("[[:space:]]", " ", true, false);
 451         }
 452
 453         public void testSpaceGroupCase1() throws Exception {
 454                 assertMatch("[[:space:]]", "\t", true, false);
 455         }
 456
 457         public void testSpaceGroupCase2() throws Exception {
 458                 assertMatch("[[:space:]]", "\r", true, false);
 459         }
 460
 461         public void testSpaceGroupCase3() throws Exception {
 462                 assertMatch("[[:space:]]", "\n", true, false);
 463         }
 464
 465         public void testSpaceGroupCase4() throws Exception {
 466                 assertMatch("[[:space:]]", "a", false, false);
 467         }
 468
 469         public void testUpperGroupCase0() throws Exception {
 470                 assertMatch("[[:upper:]]", "a", false, false);
 471         }
 472
 473         public void testUpperGroupCase1() throws Exception {
 474                 assertMatch("[[:upper:]]", "h", false, false);
 475         }
 476
 477         public void testUpperGroupCase2() throws Exception {
 478                 assertMatch("[[:upper:]]", "A", true, false);
 479         }
 480
 481         public void testUpperGroupCase3() throws Exception {
 482                 assertMatch("[[:upper:]]", "H", true, false);
 483         }
 484
 485         public void testUpperGroupCase4() throws Exception {
 486                 // \u00c4 = 'A' with dots on it
 487                 assertMatch("[[:upper:]]", "\u00c4", true, false);
 488         }
 489
 490         public void testUpperGroupCase5() throws Exception {
 491                 assertMatch("[[:upper:]]", ".", false, false);
 492         }
 493
 494         public void testXDigitGroupCase0() throws Exception {
 495                 assertMatch("[[:xdigit:]]", "a", true, false);
 496         }
 497
 498         public void testXDigitGroupCase1() throws Exception {
 499                 assertMatch("[[:xdigit:]]", "d", true, false);
 500         }
 501
 502         public void testXDigitGroupCase2() throws Exception {
 503                 assertMatch("[[:xdigit:]]", "f", true, false);
 504         }
 505
 506         public void testXDigitGroupCase3() throws Exception {
 507                 assertMatch("[[:xdigit:]]", "0", true, false);
 508         }
 509
 510         public void testXDigitGroupCase4() throws Exception {
 511                 assertMatch("[[:xdigit:]]", "5", true, false);
 512         }
 513
 514         public void testXDigitGroupCase5() throws Exception {
 515                 assertMatch("[[:xdigit:]]", "9", true, false);
 516         }
 517
 518         public void testXDigitGroupCase6() throws Exception {
 519                 assertMatch("[[:xdigit:]]", "۹", false, false);
 520         }
 521
 522         public void testXDigitGroupCase7() throws Exception {
 523                 assertMatch("[[:xdigit:]]", ".", false, false);
 524         }
 525
 526         public void testWordroupCase0() throws Exception {
 527                 assertMatch("[[:word:]]", "g", true, false);
 528         }
 529
 530         public void testWordroupCase1() throws Exception {
 531                 // \u00f6 = 'o' with dots on it
 532                 assertMatch("[[:word:]]", "\u00f6", true, false);
 533         }
 534
 535         public void testWordroupCase2() throws Exception {
 536                 assertMatch("[[:word:]]", "5", true, false);
 537         }
 538
 539         public void testWordroupCase3() throws Exception {
 540                 assertMatch("[[:word:]]", "_", true, false);
 541         }
 542
 543         public void testWordroupCase4() throws Exception {
 544                 assertMatch("[[:word:]]", " ", false, false);
 545         }
 546
 547         public void testWordroupCase5() throws Exception {
 548                 assertMatch("[[:word:]]", ".", false, false);
 549         }
 550
 551         public void testMixedGroupCase0() throws Exception {
 552                 assertMatch("[A[:lower:]C3-5]", "A", true, false);
 553         }
 554
 555         public void testMixedGroupCase1() throws Exception {
 556                 assertMatch("[A[:lower:]C3-5]", "C", true, false);
 557         }
 558
 559         public void testMixedGroupCase2() throws Exception {
 560                 assertMatch("[A[:lower:]C3-5]", "e", true, false);
 561         }
 562
 563         public void testMixedGroupCase3() throws Exception {
 564                 assertMatch("[A[:lower:]C3-5]", "3", true, false);
 565         }
 566
 567         public void testMixedGroupCase4() throws Exception {
 568                 assertMatch("[A[:lower:]C3-5]", "4", true, false);
 569         }
 570
 571         public void testMixedGroupCase5() throws Exception {
 572                 assertMatch("[A[:lower:]C3-5]", "5", true, false);
 573         }
 574
 575         public void testMixedGroupCase6() throws Exception {
 576                 assertMatch("[A[:lower:]C3-5]", "B", false, false);
 577         }
 578
 579         public void testMixedGroupCase7() throws Exception {
 580                 assertMatch("[A[:lower:]C3-5]", "2", false, false);
 581         }
 582
 583         public void testMixedGroupCase8() throws Exception {
 584                 assertMatch("[A[:lower:]C3-5]", "6", false, false);
 585         }
 586
 587         public void testMixedGroupCase9() throws Exception {
 588                 assertMatch("[A[:lower:]C3-5]", ".", false, false);
 589         }
 590
 591         public void testSpecialGroupCase0() throws Exception {
 592                 assertMatch("[[]", "[", true, false);
 593         }
 594
 595         public void testSpecialGroupCase1() throws Exception {
 596                 assertMatch("[]]", "]", true, false);
 597         }
 598
 599         public void testSpecialGroupCase2() throws Exception {
 600                 assertMatch("[]a]", "]", true, false);
 601         }
 602
 603         public void testSpecialGroupCase3() throws Exception {
 604                 assertMatch("[a[]", "[", true, false);
 605         }
 606
 607         public void testSpecialGroupCase4() throws Exception {
 608                 assertMatch("[a[]", "a", true, false);
 609         }
 610
 611         public void testSpecialGroupCase5() throws Exception {
 612                 assertMatch("[!]]", "]", false, false);
 613         }
 614
 615         public void testSpecialGroupCase6() throws Exception {
 616                 assertMatch("[!]]", "x", true, false);
 617         }
 618
 619         public void testSpecialGroupCase7() throws Exception {
 620                 assertMatch("[:]]", ":]", true, false);
 621         }
 622
 623         public void testSpecialGroupCase8() throws Exception {
 624                 assertMatch("[:]]", ":", false, true);
 625         }
 626
 627         public void testSpecialGroupCase9() throws Exception {
 628                 try {
 629                         assertMatch("[[:]", ":", true, true);
 630                         fail("InvalidPatternException expected");
 631                 } catch (InvalidPatternException e) {
 632                         // expected
 633                 }
 634         }
 635
 636         public void testUnsupportedGroupCase0() throws Exception {
 637                 try {
 638                         assertMatch("[[=a=]]", "b", false, false);
 639                         fail("InvalidPatternException expected");
 640                 } catch (InvalidPatternException e) {
 641                         assertTrue(e.getMessage().contains("[=a=]"));
 642                 }
 643         }
 644
 645         public void testUnsupportedGroupCase1() throws Exception {
 646                 try {
 647                         assertMatch("[[.a.]]", "b", false, false);
 648                         fail("InvalidPatternException expected");
 649                 } catch (InvalidPatternException e) {
 650                         assertTrue(e.getMessage().contains("[.a.]"));
 651                 }
 652         }
 653
 654         public void testFilePathSimpleCase() throws Exception {
 655                 assertFileNameMatch("a/b", "a/b", '/', true, false);
 656         }
 657
 658         public void testFilePathCase0() throws Exception {
 659                 assertFileNameMatch("a*b", "a/b", '/', false, false);
 660         }
 661
 662         public void testFilePathCase1() throws Exception {
 663                 assertFileNameMatch("a?b", "a/b", '/', false, false);
 664         }
 665
 666         public void testFilePathCase2() throws Exception {
 667                 assertFileNameMatch("a*b", "a\\b", '\\', false, false);
 668         }
 669
 670         public void testFilePathCase3() throws Exception {
 671                 assertFileNameMatch("a?b", "a\\b", '\\', false, false);
 672         }
 673
 674         public void testReset() throws Exception {
 675                 final String pattern = "helloworld";
 676                 final FileNameMatcher matcher = new FileNameMatcher(pattern, null);
 677                 matcher.append("helloworld");
 678                 assertEquals(true, matcher.isMatch());
 679                 assertEquals(false, matcher.canAppendMatch());
 680                 matcher.reset();
 681                 matcher.append("hello");
 682                 assertEquals(false, matcher.isMatch());
 683                 assertEquals(true, matcher.canAppendMatch());
 684                 matcher.append("world");
 685                 assertEquals(true, matcher.isMatch());
 686                 assertEquals(false, matcher.canAppendMatch());
 687                 matcher.append("to much");
 688                 assertEquals(false, matcher.isMatch());
 689                 assertEquals(false, matcher.canAppendMatch());
 690                 matcher.reset();
 691                 matcher.append("helloworld");
 692                 assertEquals(true, matcher.isMatch());
 693                 assertEquals(false, matcher.canAppendMatch());
 694         }
 695
 696         public void testCreateMatcherForSuffix() throws Exception {
 697                 final String pattern = "helloworld";
 698                 final FileNameMatcher matcher = new FileNameMatcher(pattern, null);
 699                 matcher.append("hello");
 700                 final FileNameMatcher childMatcher = matcher.createMatcherForSuffix();
 701                 assertEquals(false, matcher.isMatch());
 702                 assertEquals(true, matcher.canAppendMatch());
 703                 assertEquals(false, childMatcher.isMatch());
 704                 assertEquals(true, childMatcher.canAppendMatch());
 705                 matcher.append("world");
 706                 assertEquals(true, matcher.isMatch());
 707                 assertEquals(false, matcher.canAppendMatch());
 708                 assertEquals(false, childMatcher.isMatch());
 709                 assertEquals(true, childMatcher.canAppendMatch());
 710                 childMatcher.append("world");
 711                 assertEquals(true, matcher.isMatch());
 712                 assertEquals(false, matcher.canAppendMatch());
 713                 assertEquals(true, childMatcher.isMatch());
 714                 assertEquals(false, childMatcher.canAppendMatch());
 715                 childMatcher.reset();
 716                 assertEquals(true, matcher.isMatch());
 717                 assertEquals(false, matcher.canAppendMatch());
 718                 assertEquals(false, childMatcher.isMatch());
 719                 assertEquals(true, childMatcher.canAppendMatch());
 720                 childMatcher.append("world");
 721                 assertEquals(true, matcher.isMatch());
 722                 assertEquals(false, matcher.canAppendMatch());
 723                 assertEquals(true, childMatcher.isMatch());
 724                 assertEquals(false, childMatcher.canAppendMatch());
 725         }
 726
 727         public void testCopyConstructor() throws Exception {
 728                 final String pattern = "helloworld";
 729                 final FileNameMatcher matcher = new FileNameMatcher(pattern, null);
 730                 matcher.append("hello");
 731                 final FileNameMatcher copy = new FileNameMatcher(matcher);
 732                 assertEquals(false, matcher.isMatch());
 733                 assertEquals(true, matcher.canAppendMatch());
 734                 assertEquals(false, copy.isMatch());
 735                 assertEquals(true, copy.canAppendMatch());
 736                 matcher.append("world");
 737                 assertEquals(true, matcher.isMatch());
 738                 assertEquals(false, matcher.canAppendMatch());
 739                 assertEquals(false, copy.isMatch());
 740                 assertEquals(true, copy.canAppendMatch());
 741                 copy.append("world");
 742                 assertEquals(true, matcher.isMatch());
 743                 assertEquals(false, matcher.canAppendMatch());
 744                 assertEquals(true, copy.isMatch());
 745                 assertEquals(false, copy.canAppendMatch());
 746                 copy.reset();
 747                 assertEquals(true, matcher.isMatch());
 748                 assertEquals(false, matcher.canAppendMatch());
 749                 assertEquals(false, copy.isMatch());
 750                 assertEquals(true, copy.canAppendMatch());
 751                 copy.append("helloworld");
 752                 assertEquals(true, matcher.isMatch());
 753                 assertEquals(false, matcher.canAppendMatch());
 754                 assertEquals(true, copy.isMatch());
 755                 assertEquals(false, copy.canAppendMatch());
 756         }
 757 }