[ios] Adds unittests for blocks and NSRegularExpression.

ios/chrome/common/ns_regular_expression_unittest.mm

+// Copyright 2013 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/strings/sys_string_conversions.h"
+#import "testing/gtest_mac.h"
+#include "testing/platform_test.h"
+
+// Chromium code relies on NSRegularExpression class to match regular
+// expressions.  Any subtle changes in behavior can lead to hard to diagnose
+// problems.  This files tests how NSRegularExpression handles various regular
+// expression features.
+
+namespace {
+
+// Checks that capture groups from |testString| substituted into
+// |templateString| matches |expected|.
+void ExpectRegexMatched(NSRegularExpression* regex,
+                        NSString* testString,
+                        NSString* templateString,
+                        NSString* expected) {
+  NSRange testRange = NSMakeRange(0, [testString length]);
+  NSString* outputString =
+      [regex stringByReplacingMatchesInString:testString
+                                      options:0
+                                        range:testRange
+                                 withTemplate:templateString];
+  EXPECT_TRUE(outputString && [outputString isEqualToString:expected])
+      << "ExpectRegexMatched: '" << base::SysNSStringToUTF8(expected) << "' != "
+      << (!outputString ? "(nil)"
+                        : "'" + base::SysNSStringToUTF8(outputString) + "'");
+}
+
+// Checks that |testString| is not matched by |regex|.
+void ExpectRegexNotMatched(NSRegularExpression* regex, NSString* testString) {
+  __block BOOL matched = NO;
+  NSRange testRange = NSMakeRange(0, [testString length]);
+  [regex enumerateMatchesInString:testString
+                          options:0
+                            range:testRange
+                       usingBlock:^(NSTextCheckingResult* result,
+                                    NSMatchingFlags flags, BOOL* stop) {
+                         if (NSEqualRanges([result range], testRange)) {
+                           *stop = YES;
+                           matched = YES;
+                         }
+                       }];
+  EXPECT_FALSE(matched) << "ExpectRegexNotMatched: '"
+                        << base::SysNSStringToUTF8(testString) << "' "
+                        << "pattern:"
+                        << base::SysNSStringToUTF8([regex pattern]);
+}
+
+// Returns an autoreleased NSRegularExpression object from the regular
+// expression |pattern|.
+NSRegularExpression* MakeRegularExpression(NSString* pattern) {
+  NSError* error;

[sdefresne, 2016/11/07 13:54:57]

nit: NSError* error = nil;

[rohitrao (ping after 24h), 2016/11/07 14:04:05]

Done.

+  return [NSRegularExpression regularExpressionWithPattern:pattern
+                                                   options:0
+                                                     error:&error];
+}
+
+TEST(NSRegularExpressionTest, TestSimpleRegex) {
+  NSRegularExpression* regex = MakeRegularExpression(@"foo(.*)bar(.*)");
+  ExpectRegexMatched(regex, @"fooONEbarTWO", @"first $1, second $2",
+                     @"first ONE, second TWO");
+}
+
+TEST(NSRegularExpressionTest, TestComplexRegex) {
+  NSString* expression = @"^http[s]?://"
+                          "(?:"
+                          "(?:youtu\\.be/)|"
+                          "(?:.*\\.youtube\\.com/watch\\?v=)|"
+                          "(?:.*\\.youtube\\.com/index\\?)"
+                          ")"
+                          "([^&]*)[\\&]?(?:.*)$";
+  NSString* templateString = @"vnd.youtube://$1";
+  NSString* expectedOutput = @"vnd.youtube://ndRXe3tTnsA";
+  NSRegularExpression* regex = MakeRegularExpression(expression);
+  ExpectRegexMatched(regex, @"http://youtu.be/ndRXe3tTnsA", templateString,
+                     expectedOutput);
+  ExpectRegexMatched(regex, @"http://www.youtube.com/watch?v=ndRXe3tTnsA",
+                     templateString, expectedOutput);
+  ExpectRegexNotMatched(regex, @"http://www.google.com");
+  ExpectRegexNotMatched(regex, @"http://www.youtube.com/embed/GkOZ8DfO248");
+}
+
+TEST(NSRegularExpressionTest, TestSimpleAlternation) {
+  // This test verifies how NSRegularExpression works.
+  // Regex 'ab|c' matches 'ab' or 'c'. Does not match 'ac'.
+  NSRegularExpression* regex = MakeRegularExpression(@"^ab|c$");
+  ExpectRegexMatched(regex, @"ab", @"$0", @"ab");
+  ExpectRegexMatched(regex, @"c", @"$0", @"c");
+  ExpectRegexMatched(regex, @"ac", @"$0", @"ac");

[sdefresne, 2016/11/07 13:54:57]

This seems to contradict the comment above. Am I missing something?

Comment say that it should match "ab" or "c" but not "ac" but the test check
that it match "ab", "c" and "ac" but not "abc" nor "a" nor "b".

Can you fix the comment?

+  ExpectRegexNotMatched(regex, @"abc");
+  ExpectRegexNotMatched(regex, @"a");
+  ExpectRegexNotMatched(regex, @"b");
+
+  // Regex 'ab|c' behaves the same as '(?:ab)|(?:c)'
+  regex = MakeRegularExpression(@"^(?:ab)|(?:c)$");
+  ExpectRegexMatched(regex, @"ab", @"$0", @"ab");
+  ExpectRegexMatched(regex, @"c", @"$0", @"c");
+  ExpectRegexNotMatched(regex, @"ac");
+  ExpectRegexNotMatched(regex, @"abc");
+
+  // This other regex: 'a(b|c)' matches either 'ab' or 'ac'.
+  regex = MakeRegularExpression(@"^a(?:b|c)$");
+  ExpectRegexMatched(regex, @"ab", @"$0", @"ab");
+  ExpectRegexMatched(regex, @"ac", @"$0", @"ac");
+  ExpectRegexNotMatched(regex, @"a");
+  ExpectRegexNotMatched(regex, @"abc");
+}
+
+TEST(NSRegularExpressionTest, TestUberCaptureGroup) {
+  // The absence of an uber-capture group caused NSRegularExpression to crash on
+  // iOS 5.x. This tests to make sure that it is not happening on iOS 6+
+  // environments.
+  NSRegularExpression* regex = MakeRegularExpression(@"^(ab|cd|ef)ghij$");
+  ExpectRegexMatched(regex, @"abghij", @"$0", @"abghij");
+  ExpectRegexMatched(regex, @"cdghij", @"$0", @"cdghij");
+  ExpectRegexMatched(regex, @"efghij", @"$0", @"efghij");
+  ExpectRegexNotMatched(regex, @"abcdefghij");
+
+  regex = MakeRegularExpression(@"^ab|cd|efghij$");
+  ExpectRegexMatched(regex, @"ab", @"$0", @"ab");
+  ExpectRegexMatched(regex, @"cd", @"$0", @"cd");
+  ExpectRegexMatched(regex, @"efghij", @"$0", @"efghij");
+  ExpectRegexNotMatched(regex, @"abcdefghij");
+  ExpectRegexNotMatched(regex, @"abghij");
+  ExpectRegexNotMatched(regex, @"cdghij");
+}
+
+}  // namespace