public void Count(ElementProxy element, int count)
 {
     Parallel.ForEach(element.Elements, e =>
     {
         this.BuildAssertProvider(e.Item1).Count(new ElementProxy(e.Item1, e.Item2), count);
     });
 }

 public void AppendText(ElementProxy element, string text)
 {
     this.RepackExceptions(() => Parallel.ForEach(element.Elements, e =>
     {
         e.Item1.AppendText(new ElementProxy(e.Item1, e.Item2), text);
     }));
 }

 public void Value(ElementProxy element, string value)
 {
     Parallel.ForEach(element.Elements, e =>
     {
         this.BuildAssertProvider(e.Item1).Value(new ElementProxy(e.Item1, e.Item2), value);
     });
 }

 public IActionSyntaxProvider RightClick(ElementProxy element)
 {
     this.commandProvider.RightClick(element);
     return this;
 }

 public void Text(ElementProxy element, string text)
 {
     Parallel.ForEach(element.Elements, e =>
     {
         this.BuildAssertProvider(e.Item1).Text(new ElementProxy(e.Item1, e.Item2), text);
     });
 }

            /// <summary>
            /// Specified <paramref name="element"/> that should have matching CSS class.
            /// </summary>
            /// <param name="element">IElement factory function.</param>
            public AssertSyntaxProvider On(ElementProxy element)
            {
                if (this.notMode)
                    this.assertProvider.NotCssProperty(element, this.propertyName, this.propertyValue);
                else
                    this.assertProvider.CssProperty(element, this.propertyName, this.propertyValue);

                return this.assertSyntaxProvider;
            }

 /// <summary>
 /// Assert the element specified does not exist.
 /// </summary>
 /// <param name="selector">Element reference.</param>
 public AssertSyntaxProvider Exists(ElementProxy element)
 {
     this.assertProvider.NotExists(element);
     return this.assertSyntaxProvider;
 }

 public void Attribute(ElementProxy element, string attributeName, string attributeValue)
 {
     Parallel.ForEach(this.providers, x => this.BuildAssertProvider(x.Key).Attribute(element, attributeName, attributeValue));
 }

 public IActionSyntaxProvider Upload(ElementProxy element, string fileName)
 {
     return this.Upload(element, 0, 0, fileName);
 }

            /// <summary>
            /// End Drag/Drop operation at specified <paramref name="targetElement"/>.
            /// </summary>
            /// <param name="targetElement">IElement factory function.</param>
            public IActionSyntaxProvider To(ElementProxy targetElement)
            {
                if (this.offsetX != 0 || this.offsetY != 0)
                {
                    this.syntaxProvider.commandProvider.DragAndDrop(this.sourceElement, offsetX, offsetY, targetElement, 0, 0);
                }
                else
                {
                    this.syntaxProvider.commandProvider.DragAndDrop(this.sourceElement, targetElement);
                }

                return this.syntaxProvider;
            }

 internal DragDropSyntaxProvider(ActionSyntaxProvider syntaxProvider, ElementProxy element)
 {
     this.syntaxProvider = syntaxProvider;
     this.sourceElement = element;
 }

 public void CssClass(ElementProxy element, string className)
 {
     Parallel.ForEach(element.Elements, e =>
     {
         this.BuildAssertProvider(e.Item1).CssClass(new ElementProxy(e.Item1, e.Item2), className);
     });
 }

 public void Visible(ElementProxy element)
 {
     Parallel.ForEach(this.providers, x => this.BuildAssertProvider(x.Key).Visible(element));
 }

            /// <summary>
            /// Select from specified <paramref name="element"/>.
            /// </summary>
            /// <param name="element">IElement factory function.</param>
            public IActionSyntaxProvider From(ElementProxy element)
            {
                if (this.mode == SelectionOption.Value)
                {
                    if (this.value is string)
                    {
                        this.syntaxProvider.commandProvider.SelectValue(element, this.value);
                    }
                    else if (this.value is string[])
                    {
                        this.syntaxProvider.commandProvider.MultiSelectValue(element, this.value);
                    }
                }
                else if (this.mode == SelectionOption.Text)
                {
                    if (this.value is string)
                    {
                        this.syntaxProvider.commandProvider.SelectText(element, this.value);
                    }
                    else if (this.value is string[])
                    {
                        this.syntaxProvider.commandProvider.MultiSelectText(element, this.value);
                    }
                }
                else if (this.value is int)
                {
                    this.syntaxProvider.commandProvider.SelectIndex(element, this.value);
                }
                else if (this.value is int[])
                {
                    this.syntaxProvider.commandProvider.MultiSelectIndex(element, this.value);
                }

                return this.syntaxProvider;
            }

 public IActionSyntaxProvider Scroll(ElementProxy element)
 {
     this.commandProvider.Hover(element);
     return this;
 }

 /// <summary>
 /// Switch focus to a previously selected frame/iframe
 /// </summary>
 /// <param name="frameElement"></param>
 /// <returns></returns>
 public IActionSyntaxProvider Frame(ElementProxy frameElement)
 {
     this.syntaxProvider.commandProvider.SwitchToFrame(frameElement);
     return this.syntaxProvider;
 }

            /// <summary>
            /// Specified <paramref name="elements"/> to be counted.
            /// </summary>
            /// <param name="elements">IElement collection factory function.</param>
            public AssertSyntaxProvider Of(ElementProxy elements)
            {
                if (this.notMode)
                    this.assertProvider.NotCount(elements, count);
                else
                    this.assertProvider.Count(elements, this.count);

                return this.assertSyntaxProvider;
            }

            /// <summary>
            /// Enter text into specified <paramref name="element"/>.
            /// </summary>
            /// <param name="element">IElement factory function.</param>
            public IActionSyntaxProvider In(ElementProxy element)
            {
                if (!element.Element.IsText)
                    throw new FluentException("Enter().In() is only supported on text elements (input, textarea, etc).");

                if (this.eventsEnabled)
                {
                    this.syntaxProvider.commandProvider.EnterText(element, text);
                }
                else
                {
                    this.syntaxProvider.commandProvider.EnterTextWithoutEvents(element, text);
                }

                return this.syntaxProvider;
            }

            /// <summary>
            /// Specified <paramref name="element"/> that should have a matching Value.
            /// </summary>
            /// <param name="element"></param>
            public AssertSyntaxProvider In(ElementProxy element)
            {
                if (!string.IsNullOrEmpty(this.value))
                {
                    if (this.notMode)
                        this.assertProvider.NotValue(element, this.value);
                    else
                        this.assertProvider.Value(element, this.value);
                }
                else if (this.matchFunc != null)
                {
                    if (this.notMode)
                        this.assertProvider.NotValue(element, this.matchFunc);
                    else
                        this.assertProvider.Value(element, this.matchFunc);
                }

                return this.assertSyntaxProvider;
            }

 public void NotCssProperty(ElementProxy element, string propertyName, string propertyValue)
 {
     Parallel.ForEach(this.providers, x => this.BuildAssertProvider(x.Key).NotCssProperty(element, propertyName, propertyValue));
 }