public AssumptionViolatedException(object value, Matcher matcher)
 {
   base.\u002Ector(!(value is Exception) ? (Exception) null : (Exception) value);
   AssumptionViolatedException violatedException = this;
   this.fValue = value;
   this.fMatcher = matcher;
 }

        public void FolderExclude()
        {
            var matcher = new Matcher();
            matcher.AddInclude(@"**/*.*");
            matcher.AddExclude(@"obj");
            matcher.AddExclude(@"bin");
            matcher.AddExclude(@".*");

            ExecuteAndVerify(matcher, @"src/project",
                "src/project/source1.cs",
                "src/project/sub/source2.cs",
                "src/project/sub/source3.cs",
                "src/project/sub2/source4.cs",
                "src/project/sub2/source5.cs",
                "src/project/compiler/preprocess/preprocess-source1.cs",
                "src/project/compiler/preprocess/sub/preprocess-source2.cs",
                "src/project/compiler/preprocess/sub/sub/preprocess-source3.cs",
                "src/project/compiler/preprocess/sub/sub/preprocess-source3.txt",
                "src/project/compiler/shared/shared1.cs",
                "src/project/compiler/shared/shared1.txt",
                "src/project/compiler/shared/sub/shared2.cs",
                "src/project/compiler/shared/sub/shared2.txt",
                "src/project/compiler/shared/sub/sub/sharedsub.cs",
                "src/project/compiler/resources/resource.res",
                "src/project/compiler/resources/sub/resource2.res",
                "src/project/compiler/resources/sub/sub/resource3.res",
                "src/project/content1.txt");
        }

 public static void That(object actual, Matcher matcher)
 {
     if (!matcher.Match(actual))
     {
         throw new ExpectationException(matcher.FailureMessage);
     }
 }

        public void IncludeCaseInsensitive(string root, string includePattern, string[] expectedFiles)
        {
            var matcher = new Matcher(StringComparison.OrdinalIgnoreCase);
            matcher.AddInclude(includePattern);

            ExecuteAndVerify(matcher, root, expectedFiles.Select(f => root + "/" + f).ToArray());
        }

        public void RegexCaseMatch()
        {
            var match = new Matcher<string, string>
            {
                { Case.Rx(new Regex("\\d{3}")), s => "Success" }
            }.ToFunc();

            Assert.Equal("Success", match("123"));
        }

 public static void assumeThat(object actual, Matcher matcher)
 {
   if (matcher.matches(actual))
     return;
   object obj = actual;
   Matcher matcher1 = matcher;
   Throwable.__\u003CsuppressFillInStackTrace\u003E();
   throw new AssumptionViolatedException(obj, matcher1);
 }

        public void EmptyCollectionWhenNoFilesPresent()
        {
            var matcher = new Matcher();
            var scenario = new FileSystemGlobbingTestContext(@"c:\files\", matcher)
                .Include("alpha.txt")
                .Execute();

            scenario.AssertExact();
        }

        public void DuplicatePatterns(string pattern1, string pattern2)
        {
            var matcher = new Matcher();
            matcher.AddInclude(pattern1);
            matcher.AddInclude(pattern2);

            ExecuteAndVerify(matcher, @"src/project",
                "src/project/sub/source2.cs");
        }

        public void RegexWithGroupMatchTest()
        {
            var match = new Matcher<string, string>
            {
                { Case.Rx(new Regex("this\\s(\\d{3})")), s => s }
            }.ToFunc();

            Assert.Equal("123", match("this 123"));
        }

        public void DoubleParentsWithRecursiveSearch()
        {
            var matcher = new Matcher();
            matcher.AddInclude(@"..\..\lib\**\*.cs");

            ExecuteAndVerify(matcher, @"src/project",
                "lib/source6.cs",
                "lib/sub3/source7.cs",
                "lib/sub4/source8.cs");
        }

		/// <summary>
		/// Initializes a new instance of the <see cref="BuildableExpectation"/> class.
		/// </summary>
		/// <param name="expectationDescription">The expectation description.</param>
		/// <param name="requiredCountMatcher">The required count matcher.</param>
		/// <param name="matchingCountMatcher">The matching count matcher.</param>
		public BuildableExpectation(string expectationDescription, Matcher requiredCountMatcher, Matcher matchingCountMatcher)
		{
			_expectationDescription = expectationDescription;
			_requiredCountMatcher = requiredCountMatcher;
			_matchingCountMatcher = matchingCountMatcher;

			ArgumentsMatcher = new ArgumentsMatcher();

			IsValid = false;
		}

        public void SlashPolarityIsIgnored(string includePattern, string filePath)
        {
            var matcher = new Matcher();
            var scenario = new FileSystemGlobbingTestContext(@"c:\files\", matcher)
                .Include(includePattern)
                .Files("one/two.txt", filePath, "three/four.txt")
                .Execute();

            scenario.AssertExact("beta/alpha.txt");
        }

        public void MismatchedFileIsIgnored()
        {
            var matcher = new Matcher();
            var scenario = new FileSystemGlobbingTestContext(@"c:\files\", matcher)
                .Include("alpha.txt")
                .Files("omega.txt")
                .Execute();

            scenario.AssertExact();
        }

        public void PatternMatchingWorks(string includePattern, string[] matchesExpected)
        {
            var matcher = new Matcher();
            var scenario = new FileSystemGlobbingTestContext(@"c:\files\", matcher)
                .Include(includePattern)
                .Files("alpha.txt", "beta.txt", "gamma.dat")
                .Execute();

            scenario.AssertExact(matchesExpected);
        }

        public void FolderNamesAreTraversed()
        {
            var matcher = new Matcher();
            var scenario = new FileSystemGlobbingTestContext(@"c:\files\", matcher)
                .Include("beta/alpha.txt")
                .Files("beta/alpha.txt")
                .Execute();

            scenario.AssertExact("beta/alpha.txt");
        }

        public void StringMatching()
        {
            var match = new Matcher<string, int>
            {
                {s => string.IsNullOrEmpty(s), (string _) => 0},
                {s => true, s => s.Length}
            }.ToFunc();

            Assert.Equal(0, match(null));
            Assert.Equal(4, match("test"));
        }

        public void ExcludeMayEndInDirectoryName()
        {
            var matcher = new Matcher();
            var scenario = new FileSystemGlobbingTestContext(@"c:\files\", matcher)
                .Include("*.cs", "*/*.cs", "*/*/*.cs")
                .Exclude("bin", "one/two")
                .Files("one/x.cs", "two/x.cs", "one/two/x.cs", "x.cs", "bin/x.cs", "bin/two/x.cs")
                .Execute();

            scenario.AssertExact("one/x.cs", "two/x.cs", "x.cs");
        }

        public void ExcludeCanHaveSurroundingRecursiveWildcards()
        {
            var matcher = new Matcher();
            var scenario = new FileSystemGlobbingTestContext(@"c:\files\", matcher)
                .Include("**")
                .Exclude("**/x/**")
                .Files("x/1", "1/x/2", "1/x", "x", "1", "1/2")
                .Execute();

            scenario.AssertExact("1/x", "x", "1", "1/2");
        }

        static void Main(string[] args)
        {
            var match = new Matcher<string, string>
            {
                { Case.Rx(new Regex("test\\s(\\d{3})")), a => a },
                { _ => true, (string _) => "nope" }
            }.ToFunc();

            Console.WriteLine(match("test 333"));
            Console.ReadKey();
        }

 public virtual CombinableMatcher or(Matcher matcher)
 {
   Matcher[] matcherArray = new Matcher[2];
   int index1 = 0;
   Matcher matcher1 = matcher;
   matcherArray[index1] = matcher1;
   int index2 = 1;
   Matcher matcher2 = this.fMatcher;
   matcherArray[index2] = matcher2;
   return new CombinableMatcher(CoreMatchers.anyOf(matcherArray));
 }