void ReplaceUrlWithAbsoluteUrl(StringBuilder builder, Group matchedUrlGroup, string currentDirectory)
 {
     var relativeUrl = matchedUrlGroup.Value.Trim('"', '\'');
     var absoluteUrl = CreateAbsoluteUrl(relativeUrl, currentDirectory);
     builder.Remove(matchedUrlGroup.Index, matchedUrlGroup.Length);
     builder.Insert(matchedUrlGroup.Index, absoluteUrl);
 }

 private string GetPathThroughLastSlash(SourceText text, int position, Group quotedPathGroup)
 {
     return PathCompletionUtilities.GetPathThroughLastSlash(
         quotedPath: quotedPathGroup.Value,
         quotedPathStart: GetQuotedPathStart(text, position, quotedPathGroup),
         position: position);
 }

 private IEnumerable<Frame> CreateFrames(
     Group framesGroup)
 {
     return 
         from Capture capture in framesGroup.Captures
         select CreateFrame(capture.Value);
 }

 private TextSpan GetTextChangeSpan(SourceText text, int position, Group quotedPathGroup)
 {
     return PathCompletionUtilities.GetTextChangeSpan(
         quotedPath: quotedPathGroup.Value,
         quotedPathStart: GetQuotedPathStart(text, position, quotedPathGroup),
         position: position);
 }

    public static Group Synchronized(Group inner)
    {
      Contract.Ensures(Contract.Result<System.Text.RegularExpressions.Group>() != null);
      Contract.Ensures(Contract.Result<System.Text.RegularExpressions.Group>() == inner);

      return default(Group);
    }

 /// <summary>
 /// Concatenates the captures of <paramref name="group" /> to a string.
 /// </summary>
 /// <param name="group"><see cref="Group" /> containing the captures.</param>
 /// <returns>
 /// <see cref="string" /> containg the concatenated captures.
 /// </returns>
 /// <remarks>
 /// A named-group can captured multiple times, when the regular
 /// expression has a quantifier, e.g. (// (?'Text'.*) )* will match
 /// multiline comments with group <i>Text</i> having a capture for
 /// every line.
 /// </remarks>
 private string ConcatenateCaptures(Group group) {
     StringBuilder sb = new StringBuilder();
     foreach (Capture capture in group.Captures) {
         sb.Append(capture.Value);
     }
     return sb.ToString();
 }

    public static Group Synchronized(Group inner)
    {
      Contract.Requires(inner != null);
      Contract.Ensures(Contract.Result<Group>() != null);

      return default(Group);
    }

        private void AddSubNode(int parentNodeIndex, string caption, Group captureGroup, int groupIndex)
        {
            TreeNode newNode = makeCaptureNode(caption);

            Nodes[parentNodeIndex].Nodes.Add(newNode);
            Nodes[parentNodeIndex].Nodes[groupIndex - 1].Tag = captureGroup;
            Nodes[parentNodeIndex].Expand();
        }

        private static void DisplayCaptures(Group group, TreeNode groupRoot)
        {
            foreach (Capture capture in group.Captures)
            {
                TreeNode captureRoot = new TreeNode(capture.Value);
                groupRoot.Nodes.Add(captureRoot);

            }
        }

        public static double ParseDouble(Group @group)
        {
            if (@group.Captures.Count != 1)
            {
                throw new ArgumentException("Expected single capture");
            }

            return ParseDouble(@group.Value);
        }

 private static int GroupToInt(Group g)
 {
     int value;
     if (int.TryParse(g.ToString(), out value))
     {
         return value;
     }
     return -1;
 }

        public EditUserForm()
        {
            InitializeComponent();

            _userName = string.Empty;
            _password = string.Empty;
            GroupId = -1;
            Groups = new Group[0];
        }

        private static IReadOnlyList<UriParameter> ParseParameterGroup(Group group)
        {
            if (!group.Success)
                return new UriParameter[] { };

            var parameters = group.Value;
            var splitByAmpersand = parameters.Split('&');
            return splitByAmpersand.Select(ParseParameterPart).ToArray();
        }

 string GetImageFilename(Group matchedUrlGroup, string currentDirectory)
 {
     var originalUrl = matchedUrlGroup.Value.Trim('"', '\'');
     if (originalUrl.StartsWith("/"))
     {
         return PathUtilities.NormalizePath("~" + originalUrl);
     }
     return PathUtilities.NormalizePath(PathUtilities.CombineWithForwardSlashes(currentDirectory, originalUrl));
 }

 private static string GetDistinctCount(string @select, Group g, string @from)
 {
     var columns = g.ToString().Trim();
     if(columns == "DISTINCT")
     {
         throw new ArgumentException("Malformed SQL; DISTINCT queries must specify at least one column");
     }
     var distinct = string.Concat(@select, "COUNT(", columns,  ") ", @from);
     return distinct;
 }

 private IEnumerable<Ball> CreateBonusBalls(
     Group bonusBallsGroup)
 {
     return 
         from Capture capture in bonusBallsGroup.Captures
         let value = capture.Value[0]
         select value == 'X'
             ? Ball.CreateStrike()
             : CreateBall(capture.Value[0]);
 }

        void ExpandUrl(StringBuilder builder, Group matchedUrlGroup, string relativeFilename)
        {
            relativeFilename = RemoveFragment(relativeFilename);
            var file = application.RootDirectory.GetFile(relativeFilename.Substring(2));
            if (!file.Exists) return;

            var hash = HashFileContents(file);
            var absoluteUrl = application.UrlGenerator.CreateRawFileUrl(relativeFilename, hash);
            builder.Remove(matchedUrlGroup.Index, matchedUrlGroup.Length);
            builder.Insert(matchedUrlGroup.Index, absoluteUrl);
        }

        void ExpandUrl(StringBuilder builder, Group matchedUrlGroup, string relativeFilename)
        {
            relativeFilename = RemoveFragment(relativeFilename);
            var file = sourceDirectory.GetFile(relativeFilename.TrimStart('~', '/'));
            if (!file.Exists) return;

            var hash = HashFileContents(file);
            var absoluteUrl = urlGenerator.CreateRawFileUrl(relativeFilename, hash);
            builder.Remove(matchedUrlGroup.Index, matchedUrlGroup.Length);
            builder.Insert(matchedUrlGroup.Index, absoluteUrl);
        }

 public RegexGroup(Group group, string name)
 {
     foreach (Capture c in group.Captures)
     {
         _Captures.Add(new RegexCapture(c));
     }
     this._Name = name;
     this._Value = group.Value;
     this._Index = group.Index;
     this._Length = group.Length;
 }

		public void Deny_Unrestricted ()
		{
			Assert.AreEqual (1, coll.Count, "Count");
			Assert.IsTrue (coll.IsReadOnly, "IsReadOnly");
			Assert.IsFalse (coll.IsSynchronized, "IsSynchronized");
			Assert.IsNotNull (coll.SyncRoot, "SyncRoot");
			Assert.IsNotNull (coll[0], "this[int]");

			Assert.IsNotNull (coll.GetEnumerator (), "GetEnumerator");
			Group[] groups = new Group[1];
			coll.CopyTo (groups, 0);
		}