Example #1
0
        public void testBasic()
        {
            Pattern pat0 = RegularPattern.compile("^$");

            Assert.IsTrue(SimpleMatcher.matches(pat0, ""));
            Assert.IsFalse(SimpleMatcher.matches(pat0, "notEmpty"));

            Pattern pat = RegularPattern.compile("^aa$");

            Assert.IsTrue(SimpleMatcher.matches(pat, "aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat, "a"));
            Assert.IsFalse(SimpleMatcher.matches(pat, "aaa"));
            Assert.IsFalse(SimpleMatcher.matches(pat, "bb"));

            Pattern pat2 = RegularPattern.compile("^(aa)(bb)$");

            Assert.IsTrue(SimpleMatcher.matches(pat2, "aa bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "aa bb cc"));

            Pattern pat3 = RegularPattern.compile("^(aa)bb(cc)$");

            Assert.IsTrue(SimpleMatcher.matches(pat3, "aa bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat3, "aa bb cc dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat3, "aa cc dd"));

            Pattern pat4 = RegularPattern.compile("^aa(bb)cc$");

            Assert.IsTrue(SimpleMatcher.matches(pat4, "aa bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat4, "aa bb cc dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat4, "aa cc dd"));
        }
Example #2
0
        public void testDot()
        {
            Pattern pat0 = RegularPattern.compile("^.$");

            Assert.IsTrue(SimpleMatcher.matches(pat0, "aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat0, "bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat0, ""));
            Assert.IsFalse(SimpleMatcher.matches(pat0, "aa bb"));

            Pattern pat0a = RegularPattern.compile("^.?$");

            Assert.IsTrue(SimpleMatcher.matches(pat0a, "aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat0a, "bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat0a, ""));
            Assert.IsFalse(SimpleMatcher.matches(pat0a, "aa bb"));

            // "aa" "bb cc aa"
            Pattern pat = RegularPattern.compile("^.*aa$");

            Assert.IsTrue(SimpleMatcher.matches(pat, "aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat, "aa aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat, "bb aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat, "bb cc aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat, "bb cc dd aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat, "bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat, "aa bb"));

            // "bb aa" "bb cc dd aa"
            Pattern pat2 = RegularPattern.compile("^.+aa$");

            Assert.IsTrue(SimpleMatcher.matches(pat2, "aa aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "bb aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "bb cc aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "bb cc dd aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "aa bb"));

            Pattern pat3 = RegularPattern.compile("^aa.*aa$");

            Assert.IsTrue(SimpleMatcher.matches(pat3, "aa aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "aa bb aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "aa aa aa aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat3, "bb aa"));

            Pattern pat4 = RegularPattern.compile("^aa.+aa$");

            Assert.IsTrue(SimpleMatcher.matches(pat4, "aa bb aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat4, "aa aa aa aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat4, "aa aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat4, "bb aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat4, "bb bb aa"));

            Pattern pat5 = RegularPattern.compile("^aa.?aa$");

            Assert.IsTrue(SimpleMatcher.matches(pat5, "aa aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat5, "aa bb aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat5, "aa aa aa aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat5, "bb aa"));
        }
Example #3
0
        public void testNeq()
        {
            // "bb" "cc" "dd"
            Pattern pat = RegularPattern.compile("^![aa]$");

            Assert.IsTrue(SimpleMatcher.matches(pat, "bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat, "bb aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat, "aa"));

            // "cc" "dd"
            Pattern pat2 = RegularPattern.compile("^![aa,bb]$");

            Assert.IsTrue(SimpleMatcher.matches(pat2, "cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "aa bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "bb"));

            // "aa" "cc" "dd"
            Pattern pat3 = RegularPattern.compile("^aa|![bb]$");

            Assert.IsTrue(SimpleMatcher.matches(pat3, "aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat3, "bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat3, "aa bb"));

            // "aa dd dd" "aa aa dd"
            Pattern pat6 = RegularPattern.compile("^(aa)![bb,cc](dd)$");

            Assert.IsTrue(SimpleMatcher.matches(pat6, "aa dd dd"));
            Assert.IsTrue(SimpleMatcher.matches(pat6, "aa aa dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat6, "aa bb dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat6, "aa cc dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat6, "aa dd"));
        }
Example #4
0
        static async Task Main(string[] args)
        {
            var argsAreProvided = args.Count() == 2;
            var recordsPath     = argsAreProvided ? args[0] : "https://s3.amazonaws.com/idt-code-challenge/records.txt";
            var queriesPath     = argsAreProvided ? args[1] : "https://s3.amazonaws.com/idt-code-challenge/queries.txt";

            var records = new List <IEnumerable <string> >();
            var queries = new List <ISet <string> >();

            using (var client = new HttpClient())
            {
                Console.WriteLine("Downloading records");
                using (var response = await client.GetAsync(recordsPath))
                {
                    if (response.IsSuccessStatusCode)
                    {
                        using (var stream = await response.Content.ReadAsStreamAsync())
                            using (var reader = new StreamReader(stream))
                            {
                                string line;
                                while ((line = reader.ReadLine()) != null)
                                {
                                    records.Add(line.Split(","));
                                }
                            }
                    }
                }

                Console.WriteLine("Downloading queries");
                using (var response = await client.GetAsync(queriesPath))
                {
                    if (response.IsSuccessStatusCode)
                    {
                        using (var stream = await response.Content.ReadAsStreamAsync())
                            using (var reader = new StreamReader(stream))
                            {
                                string line;
                                while ((line = reader.ReadLine()) != null)
                                {
                                    queries.Add(new HashSet <string>(line.Split(",")));
                                }
                            }
                    }
                }
            }

            Console.WriteLine("Matching");
            var result = new SimpleMatcher().Match(records, queries).ToList();

            for (var i = 0; i < queries.Count; i++)
            {
                Console.WriteLine("=========================================================");
                Console.WriteLine($"Query: {JsonConvert.SerializeObject(queries[i])}");
                foreach (var matchedRecord in result[i])
                {
                    Console.WriteLine($"Matched record result: {JsonConvert.SerializeObject(matchedRecord)}");
                }
            }
        }
Example #5
0
        public void TestSimpleNoMatch()
        {
            var matcher = new SimpleMatcher("Not present", false);
            var content = new StringContentProvider("Simple test text content.");

            var matches = matcher.GetMatches(content).Result;

            Assert.Equal(0, matches.Count);
        }
Example #6
0
        public void TestSimpleMatch()
        {
            var matcher = new SimpleMatcher("text", false);
            var content = new StringContentProvider("Simple test text content.");

            var matches = matcher.GetMatches(content).Result;

            Assert.Equal(1, matches.Count);
            Assert.Equal(13, matches[0].Index);
        }
Example #7
0
        public void testAdv()
        {
            Pattern rw = RegularPattern.compile("^(write)(![write,read]*(write)![write,read]*)+(read)$");

            Assert.IsTrue(SimpleMatcher.matches(rw, "write write read"));
            Assert.IsTrue(SimpleMatcher.matches(rw, "write write write read"));
            Assert.IsTrue(SimpleMatcher.matches(rw, "write foo write read"));
            Assert.IsTrue(SimpleMatcher.matches(rw, "write foo foo write read"));
            Assert.IsTrue(SimpleMatcher.matches(rw, "write foo foo write foo read"));
            Assert.IsFalse(SimpleMatcher.matches(rw, "write read"));
        }
Example #8
0
        public void testMult()
        {
            // "bb" or ""
            Pattern pat1 = RegularPattern.compile("^(bb)?$");

            Assert.IsTrue(SimpleMatcher.matches(pat1, ""));
            Assert.IsTrue(SimpleMatcher.matches(pat1, "bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat1, "aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat1, "bb bb"));

            // "aa bb cc" or "aa cc"
            Pattern pat1a = RegularPattern.compile("^aa(bb)?cc$");

            Assert.IsTrue(SimpleMatcher.matches(pat1a, "aa cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat1a, "aa bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat1a, "aa bb bb cc"));

            // "bb bb" "bb" ""
            Pattern pat2 = RegularPattern.compile("^(bb)*$");

            Assert.IsTrue(SimpleMatcher.matches(pat2, ""));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "bb bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "bb bb bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "bb aa"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "bb aa bb"));

            // "aa bb bb cc" "aa bb cc" "aa cc"
            Pattern pat2a = RegularPattern.compile("^aa(bb)*cc$");

            Assert.IsTrue(SimpleMatcher.matches(pat2a, "aa cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2a, "aa bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2a, "aa bb bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2a, "aa cc bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat2a, "aa cc bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2a, "aa dd cc"));

            // "bb bb" "bb"
            Pattern pat3 = RegularPattern.compile("^(bb)+$");

            Assert.IsTrue(SimpleMatcher.matches(pat3, "bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "bb bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "bb bb bb"));

            // "aa bb bb bb cc" "aa bb cc"
            Pattern pat3a = RegularPattern.compile("^aa(bb)+cc$");

            Assert.IsTrue(SimpleMatcher.matches(pat3a, "aa bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat3a, "aa bb bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat3a, "aa cc bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat3a, "aa cc bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat3a, "aa dd cc"));
        }
Example #9
0
        public void testAlts()
        {
            // pat1 == pat2 == pat3 == pat4
            // "aa" "bb" "cc" "dd"
            Pattern pat = RegularPattern.compile("^aa|bb|cc|dd$");

            Assert.IsTrue(SimpleMatcher.matches(pat, "aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat, "bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat, "cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat, "dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat, "aa bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat, ""));
            Assert.IsFalse(SimpleMatcher.matches(pat, "ee"));

            Pattern pat2 = RegularPattern.compile("^(aa)|(bb)|(cc)|(dd)$");

            Assert.IsTrue(SimpleMatcher.matches(pat2, "aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2, "dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "aa bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat2, ""));
            Assert.IsFalse(SimpleMatcher.matches(pat2, "ee"));

            Pattern pat3 = RegularPattern.compile("^aa|(bb|cc|dd)$");

            Assert.IsTrue(SimpleMatcher.matches(pat3, "aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat3, "dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat3, "aa bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat3, ""));
            Assert.IsFalse(SimpleMatcher.matches(pat3, "ee"));

            Pattern pat4 = RegularPattern.compile("^aa|(bb|(cc|dd))$");

            Assert.IsTrue(SimpleMatcher.matches(pat4, "aa"));
            Assert.IsTrue(SimpleMatcher.matches(pat4, "bb"));
            Assert.IsTrue(SimpleMatcher.matches(pat4, "cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat4, "dd"));
            Assert.IsFalse(SimpleMatcher.matches(pat4, "aa bb"));
            Assert.IsFalse(SimpleMatcher.matches(pat4, ""));
            Assert.IsFalse(SimpleMatcher.matches(pat4, "ee"));

            // "aa bb cc ee" "aa bb dd ee"
            Pattern pat5 = RegularPattern.compile("^(aa)(bb)(cc|dd)(ee)$");

            Assert.IsTrue(SimpleMatcher.matches(pat5, "aa bb cc ee"));
            Assert.IsTrue(SimpleMatcher.matches(pat5, "aa bb dd ee"));
            Assert.IsFalse(SimpleMatcher.matches(pat5, "aa bb cc dd ee"));
            Assert.IsFalse(SimpleMatcher.matches(pat5, "aa bb ee"));
        }
        private static void GenerateFastMappersBenchmarkCode()
        {
            MappingConfiguration config = new MappingConfiguration();

            var matcher = new SimpleMatcher();
            var customerSpec = new MappingSpecification<BenchmarkFastMapper.Classes.Customer, BenchmarkFastMapper.Classes.CustomerDTO>();
            customerSpec.AddMapsBasedOnMatches(matcher);
            customerSpec.AddMap(source => source.Address.City, target => target.AddressCity);

            var addressSpec = new MappingSpecification<BenchmarkFastMapper.Classes.Address, BenchmarkFastMapper.Classes.AddressDTO>();
            addressSpec.AddMapsBasedOnMatches(matcher);

            config.AddMappingSpecification(customerSpec);
            config.AddMappingSpecification(addressSpec);

            CheckConfigAndGenCode(config, "FastMapper");
        }
        private static MappingConfiguration SetupFlatteningMapOneLayered()
        {
            var matcher = new SimpleMatcher();
            matcher.AddPossibleTargetSuffix("ProperName");
            MappingConfiguration config = new MappingConfiguration();
            var map1 = new MappingSpecification<Model1, Dto1>();
            var map2 = new MappingSpecification<Model2, Dto2>();
            var map3 = new MappingSpecification<Model3, Dto3>();
            var map4 = new MappingSpecification<Model4, Dto4>();
            var map5 = new MappingSpecification<Model5, Dto5>();
            var map6 = new MappingSpecification<Model6, Dto6>();
            var map7 = new MappingSpecification<Model7, Dto7>();
            var map8 = new MappingSpecification<Model8, Dto8>();
            var map9 = new MappingSpecification<Model9, Dto9>();
            var map10 = new MappingSpecification<Model10, Dto10>();
            var mapObject = new MappingSpecification<ModelObject, ModelDto>();
            map1.AddMapsBasedOnMatches(matcher);
            map2.AddMapsBasedOnMatches(matcher);
            map3.AddMapsBasedOnMatches(matcher);
            map4.AddMapsBasedOnMatches(matcher);
            map5.AddMapsBasedOnMatches(matcher);
            map6.AddMapsBasedOnMatches(matcher);
            map7.AddMapsBasedOnMatches(matcher);
            map8.AddMapsBasedOnMatches(matcher);
            map9.AddMapsBasedOnMatches(matcher);
            map10.AddMapsBasedOnMatches(matcher);
            mapObject.AddMap(source => source.BaseDate, target => target.BaseDate);
            mapObject.AddMap(source => source.Sub.ProperName, target => target.SubProperName);
            mapObject.AddMap(source => source.Sub2.ProperName, target => target.Sub2ProperName);
            mapObject.AddMap(source => source.SubWithExtraName.ProperName, target => target.SubWithExtraNameProperName);
            mapObject.AddMap(source => source.Sub.SubSub.IAmACoolProperty, target => target.SubSubSubIAmACoolProperty);
            config.AddMappingSpecification(map1);
            config.AddMappingSpecification(map2);
            config.AddMappingSpecification(map3);
            config.AddMappingSpecification(map4);
            config.AddMappingSpecification(map5);
            config.AddMappingSpecification(map6);
            config.AddMappingSpecification(map7);
            config.AddMappingSpecification(map8);
            config.AddMappingSpecification(map9);
            config.AddMappingSpecification(map10);
            config.AddMappingSpecification(mapObject);

            return config;
        }
Example #12
0
 /// <summary>
 /// Returns true when the operation sequences violates this rule.
 /// </summary>
 /// <returns></returns>
 public bool violatesRule(IList <string> sequence)
 {
     return(SimpleMatcher.matches(_pattern, sequence) == _constraint);
 }
Example #13
0
        public void testMultEx()
        {
            // "aa bb dd cc" "aa cc"
            Pattern pat1b = RegularPattern.compile("^aa((bb)(dd))?cc$");

            Assert.IsTrue(SimpleMatcher.matches(pat1b, "aa cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat1b, "aa bb dd cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat1b, "aa dd cc"));

            // "aa bb cc" "aa dd cc" "aa cc"
            Pattern pat1c = RegularPattern.compile("^aa((bb)|(dd))?cc$");

            Assert.IsTrue(SimpleMatcher.matches(pat1c, "aa cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat1c, "aa bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat1c, "aa dd cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat1c, "aa bb dd cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat1c, "aa dd dd cc"));

            // "aa bb dd bb dd cc" "aa bb dd cc" "aa cc"
            Pattern pat2b = RegularPattern.compile("^aa((bb)(dd))*cc$");

            Assert.IsTrue(SimpleMatcher.matches(pat2b, "aa cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2b, "aa bb dd cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2b, "aa bb dd bb dd cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2b, "aa dd cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2b, "aa bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2b, "aa bb dd bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2b, "aa bb bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2b, "aa dd bb cc"));
            Assert.IsFalse(SimpleMatcher.matches(pat2b, "aa bb dd dd bb cc"));

            // "aa bb bb dd cc" "aa dd cc" "aa bb cc" "aa dd bb dd cc"
            Pattern pat2c = RegularPattern.compile("^aa((bb)|(dd))*cc$");

            Assert.IsTrue(SimpleMatcher.matches(pat2c, "aa cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2c, "aa bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2c, "aa dd cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2c, "aa bb dd cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2c, "aa dd bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2c, "aa bb bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2c, "aa bb bb dd bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(pat2c, "aa dd bb dd dd bb cc"));

            Pattern patextr1 = RegularPattern.compile("^bb|(dd)*$");

            Assert.IsTrue(SimpleMatcher.matches(patextr1, "bb"));
            Assert.IsTrue(SimpleMatcher.matches(patextr1, "dd"));
            Assert.IsTrue(SimpleMatcher.matches(patextr1, "dd dd"));
            Assert.IsTrue(SimpleMatcher.matches(patextr1, "dd dd dd"));
            Assert.IsFalse(SimpleMatcher.matches(patextr1, "bb dd"));
            Assert.IsFalse(SimpleMatcher.matches(patextr1, "dd bb"));

            // "aa bb cc" "aa dd dd cc" "aa dd dd bb dd bb cc"
            Pattern patextr2 = RegularPattern.compile("^aa(bb|(dd)*)+cc$");

            Assert.IsTrue(SimpleMatcher.matches(patextr2, "aa cc"));
            Assert.IsTrue(SimpleMatcher.matches(patextr2, "aa bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(patextr2, "aa dd cc"));
            Assert.IsTrue(SimpleMatcher.matches(patextr2, "aa dd dd cc"));
            Assert.IsTrue(SimpleMatcher.matches(patextr2, "aa bb dd dd bb cc"));
            Assert.IsTrue(SimpleMatcher.matches(patextr2, "aa bb bb cc"));
        }