ElementProperties (DollarX - Java version 0.63 API)

java.lang.Object
- com.github.loyada.jdollarx.ElementProperties

```
public final class ElementProperties
extends Object
```
Various constrains on Path instances, that are used with the methods Path.that(com.github.loyada.jdollarx.ElementProperty...) and Path.and(com.github.loyada.jdollarx.ElementProperty...).

Field Summary

Fields
Modifier and Type	Field and Description
`static ElementProperty`	`hasChildren` The element has 1 or more children (the opposite from hasNoChildren).
`static ElementProperty`	`hasNoChildren` The element has no children.
`static ElementProperty`	`hasSomeText` Element has non-empty text
`static ElementProperty`	`isChecked` The element is checked
`static ElementProperty`	`isDisabled` The element is diabled
`static ElementProperty`	`isEnabled` The element is enabled
`static ElementProperty`	`isHidden` Element that is hidden.
`static ElementProperty`	`isLastSibling` The element is the last sibling (ie: last child) of its parent.
`static ElementProperty`	`isOnlyChild` The element is the only direct child of its parent.
`static ElementProperty`	`isSelected` The element is selected

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static ElementProperty`	`contains(Path... paths)` The given elements in the parameters list are contained in the current element
`static ElementProperty`	`hasAggregatedCaseSensitiveTextContaining(String txt)` When aggregating all the text under this element, it contains the given substring.
`static ElementProperty`	`hasAggregatedCaseSensitiveTextEqualTo(String txt)` When aggregating all the text under this element, it equals to the given parameter.
`static ElementProperty`	`hasAggregatedTextContaining(String txt)` When aggregating all the text under this element, it contains the given substring (ignoring case)
`static ElementProperty`	`hasAggregatedTextEndingWith(String txt)` When aggregating all the text under this element, it ends with the given substring (ignoring case)
`static ElementProperty`	`hasAggregatedTextEqualTo(String txt)` When aggregating all the text under this element, it equals to the given parameter.
`static ElementProperty`	`hasAggregatedTextStartingWith(String txt)` When aggregating all the text under this element, it starts with the given substring (ignoring case)
`static ElementProperty`	`hasAncesctor(Path path)` Element is inside the given parameter
`static ElementProperty`	`hasAnyOfClasses(String... cssClasses)` Element that has at least one of the classes given
`static ElementProperty`	`hasAttribute(String attribute, String value)`
`static ElementProperty`	`hasCaseSensitiveText(String txt)` Element has text equals to the given string parameter.
`static ElementProperty`	`hasCaseSensitiveTextContaining(String txt)` The text in the element contains the given parameter.
`static ElementProperty`	`hasChild(Path... paths)` Element is the parent of the given list of elements
`static ElementProperty`	`hasClass(String className)` Has the class given in the parameter
`static ElementProperty`	`hasClassContaining(String classSubString)` Element that has a class with name that contain the given parameter
`static ElementProperty`	`hasClasses(String... cssClasses)` Element that has all of the given classes
`static ElementProperty`	`hasDescendant(Path... paths)` The given elements in the parameters list are contained in the current element
`static ElementProperty`	`hasId(String id)` Element has ID equals to the given parameter
`static ElementProperty`	`hasName(String name)` Element with a "name" attribute equal to the given parameter.
`static ElementPropertyWithNumericalBoundaries`	`hasNChildren(Integer n)` The element has n direct children
`static ElementProperty`	`hasNonOfTheClasses(String... cssClasses)` Element that has none of the given classes
`static ElementProperty`	`hasParent(Path path)` Element is direct child of the element matched by the given parameter
`static ElementProperty`	`hasRawXpathProperty(String rawXpathProps, String rawExplanation)` Custom property that allows to state the raw expath of a property, and give a string description of it.
`static ElementProperty`	`hasRole(String role)` Element with a "role" attribute equal to the given role.
`static ElementProperty`	`hasSource(String src)` Element with a "src" attribute equal to the given parameter.
`static ElementProperty`	`hasText(String txt)` Element has text equals to the given string parameter, ignoring case.
`static ElementProperty`	`hasTextContaining(String txt)` The text in the element contains the given parameter, ignoring case
`static ElementProperty`	`hasTextEndingWith(String txt)` Element has text that ends with the given parameter
`static ElementProperty`	`hasTextStartingWith(String txt)` Element has text that starts with the given parameter
`static ElementProperty`	`isAfter(NPath nPath)` Element is after at-least/at-most/exactly the given number of the given element.
`static ElementProperty`	`isAfter(Path... paths)` Element appears after all the given parameters in the document
`static ElementProperty`	`isAfterSibling(NPath nPath)` Element is a sibling of the at-least/at-most/exactly n elements given, and appears after them.
`static ElementProperty`	`isAfterSibling(Path... paths)` Element is a sibling of all the elements defined by the given paths, AND is after all those siblings
`static ElementProperty`	`isAncestorOf(Path... paths)` The given elements in the parameters list are contained in the current element
`static ElementProperty`	`isBefore(NPath nPath)` Element is before at-least/at-most/exactly the given number of the given element.
`static ElementProperty`	`isBefore(Path... paths)` Element is before all the elements given in the parameters
`static ElementProperty`	`isBeforeSibling(NPath nPath)` Element is a sibling of the at-least/at-most/exactly n elements given, and appears before them.
`static ElementProperty`	`isBeforeSibling(Path... paths)` Element is a sibling of all the elements defined by the given paths, AND is before all those siblings
`static ElementProperty`	`isChildOf(Path path)` Element is direct child of the element matched by the given parameter
`static ElementProperty`	`isContainedIn(Path path)`
`static ElementProperty`	`isDescendantOf(Path path)` Element is inside the given parameter
`static ElementProperty`	`isInside(Path path)` Element is inside the given parameter
`static ElementProperty`	`isNthFromLastSibling(Integer reverseIndex)` The element is the nth-from-last sibling.
`static ElementProperty`	`isNthSibling(Integer index)` The element is the nth sibling.
`static ElementProperty`	`isParentOf(Path... paths)` Element is the parent of the given list of elements
`static ElementProperty`	`isSiblingOf(Path... paths)` Element is a sibling of all the elements defined by the given paths
`static ElementProperty`	`isWithIndex(Integer index)` Element that is the nth sibling of its parent
`static ElementProperty`	`not(ElementProperty prop)` Element does NOT have the given property.
`static ElementProperty`	`withIndexInRange(int first, int last)` The index among its siblings is between first and last parameters.

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - isLastSibling
```
public static final ElementProperty isLastSibling
```
    The element is the last sibling (ie: last child) of its parent.
  - isDisabled
```
public static final ElementProperty isDisabled
```
    The element is diabled
  - isEnabled
```
public static final ElementProperty isEnabled
```
    The element is enabled
  - isChecked
```
public static final ElementProperty isChecked
```
    The element is checked
  - isSelected
```
public static final ElementProperty isSelected
```
    The element is selected
  - hasNoChildren
```
public static final ElementProperty hasNoChildren
```
    The element has no children. Examples where it might be useful: an empty list, empty table, etc.
  - hasChildren
```
public static final ElementProperty hasChildren
```
    The element has 1 or more children (the opposite from hasNoChildren). Examples where it might be useful: an non-empty list, non-empty table, etc.
  - isOnlyChild
```
public static final ElementProperty isOnlyChild
```
    The element is the only direct child of its parent. It has no siblings. For example: a table with a single row.
  - isHidden
```
public static ElementProperty isHidden
```
    Element that is hidden. This is limited to only examine embeded css style, so it not useful in some cases.
  - hasSomeText
```
public static ElementProperty hasSomeText
```
    Element has non-empty text
- Method Detail
  - hasNChildren
```
public static ElementPropertyWithNumericalBoundaries hasNChildren(Integer n)
```
    The element has n direct children
    
    Parameters:
    
    n - the number of children
    
    Returns:
    
    a element property that can be applied with Path::that
  - isNthFromLastSibling
```
public static ElementProperty isNthFromLastSibling(Integer reverseIndex)
```
    The element is the nth-from-last sibling. Example usage: find the element before the last one in a list.
    
    Parameters:
    
    reverseIndex - - the place from last, starting at 0 for the last sibling.
    
    Returns:
    
    a element property that can be applied with Path::that
  - isNthSibling
```
public static ElementProperty isNthSibling(Integer index)
```
    The element is the nth sibling. Example usage: find the 4th element in a list.
    
    Parameters:
    
    index - - starting at 0 for the first one
    
    Returns:
    
    a element property that can be applied with Path::that
  - withIndexInRange
```
public static ElementProperty withIndexInRange(int first,
                                               int last)
```
    The index among its siblings is between first and last parameters. For example: taking a row from a table, which we know is between row number 2 and 4.
    
    Parameters:
    
    first - - lower index (inclusive, starting at 0)
    
    last - - upper index (inclusive, starting at 0)
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasRawXpathProperty
```
public static ElementProperty hasRawXpathProperty(String rawXpathProps,
                                                  String rawExplanation)
```
    Custom property that allows to state the raw expath of a property, and give a string description of it. Example:
```
 

  Path el = span.that(hasRawXpathProperty("string(.)='x'", "is awesome"), isOnlyChild);
  assertThat(el.getXPath().get(), equalTo("span[string(.)='x'][count(preceding-sibling::*)=0" +
                                                "and count(following-sibling::*)=0]"));
  assertThat(el.toString(), is(equalTo("span, that is awesome, and is only child")));
 
 
```
    Parameters:
    
    rawXpathProps - - the xpath property condition string. Will be wrapped with [] in the xpath
    
    rawExplanation - - a textual readable description of this property
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasText
```
public static ElementProperty hasText(String txt)
```
    Element has text equals to the given string parameter, ignoring case.
    
    Parameters:
    
    txt - - the text to match to
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasCaseSensitiveText
```
public static ElementProperty hasCaseSensitiveText(String txt)
```
    Element has text equals to the given string parameter. The equality is case-sensitive.
    
    Parameters:
    
    txt - - the text to match to (case sensitive)
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasTextStartingWith
```
public static ElementProperty hasTextStartingWith(String txt)
```
    Element has text that starts with the given parameter
    
    Parameters:
    
    txt - - the text to match to
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasTextEndingWith
```
public static ElementProperty hasTextEndingWith(String txt)
```
    Element has text that ends with the given parameter
    
    Parameters:
    
    txt - - the text to match to
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasId
```
public static ElementProperty hasId(String id)
```
    Element has ID equals to the given parameter
    
    Parameters:
    
    id - - the ID to match to
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasName
```
public static ElementProperty hasName(String name)
```
    Element with a "name" attribute equal to the given parameter. Useful for input elements.
    
    Parameters:
    
    name - the value of the name property
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasSource
```
public static ElementProperty hasSource(String src)
```
    Element with a "src" attribute equal to the given parameter. Useful for images.
    
    Parameters:
    
    src - the URI of the image
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasRole
```
public static ElementProperty hasRole(String role)
```
    Element with a "role" attribute equal to the given role.
    
    Parameters:
    
    role - the value of the role property
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasAttribute
```
public static ElementProperty hasAttribute(String attribute,
                                           String value)
```
  - hasAnyOfClasses
```
public static ElementProperty hasAnyOfClasses(String... cssClasses)
```
    Element that has at least one of the classes given
    
    Parameters:
    
    cssClasses - - the class names to match to
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasClasses
```
public static ElementProperty hasClasses(String... cssClasses)
```
    Element that has all of the given classes
    
    Parameters:
    
    cssClasses - - the class names to match to
    
    Returns:
    
    a element property that can be applied with Path::that
  - hasClassContaining
```
public static ElementProperty hasClassContaining(String classSubString)
```
    Element that has a class with name that contain the given parameter
    
    Parameters:
    
    classSubString - a string that should be contained in the class
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasNonOfTheClasses
```
public static ElementProperty hasNonOfTheClasses(String... cssClasses)
```
    Element that has none of the given classes
    
    Parameters:
    
    cssClasses - - a list of class names, none of which is present in element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isWithIndex
```
public static ElementProperty isWithIndex(Integer index)
```
    Element that is the nth sibling of its parent
    
    Parameters:
    
    index - - the index of the element among its sibling, starting with 0
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasTextContaining
```
public static ElementProperty hasTextContaining(String txt)
```
    The text in the element contains the given parameter, ignoring case
    
    Parameters:
    
    txt - - the substring to match to
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasCaseSensitiveTextContaining
```
public static ElementProperty hasCaseSensitiveTextContaining(String txt)
```
    The text in the element contains the given parameter. This condition is case=sensitive.
    
    Parameters:
    
    txt - - the substring to match to (case sensitive)
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasClass
```
public static ElementProperty hasClass(String className)
```
    Has the class given in the parameter
    
    Parameters:
    
    className - the class the element has
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasAggregatedTextEqualTo
```
public static ElementProperty hasAggregatedTextEqualTo(String txt)
```
    When aggregating all the text under this element, it equals to the given parameter. This condition is not case sensitive.
    
    Parameters:
    
    txt - the aggregated, case insensitive, text inside the element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasAggregatedCaseSensitiveTextEqualTo
```
public static ElementProperty hasAggregatedCaseSensitiveTextEqualTo(String txt)
```
    When aggregating all the text under this element, it equals to the given parameter. This condition is case sensitive.
    
    Parameters:
    
    txt - the aggregated, case insensitive, text inside the element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasAggregatedTextStartingWith
```
public static ElementProperty hasAggregatedTextStartingWith(String txt)
```
    When aggregating all the text under this element, it starts with the given substring (ignoring case)
    
    Parameters:
    
    txt - the prefix of the aggregated, case insensitive, text inside the element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasAggregatedTextEndingWith
```
public static ElementProperty hasAggregatedTextEndingWith(String txt)
```
    When aggregating all the text under this element, it ends with the given substring (ignoring case)
    
    Parameters:
    
    txt - the suffix of the aggregated, case insensitive, text inside the element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasAggregatedTextContaining
```
public static ElementProperty hasAggregatedTextContaining(String txt)
```
    When aggregating all the text under this element, it contains the given substring (ignoring case)
    
    Parameters:
    
    txt - a substring of the aggregated, case insensitive, text inside the element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasAggregatedCaseSensitiveTextContaining
```
public static ElementProperty hasAggregatedCaseSensitiveTextContaining(String txt)
```
    When aggregating all the text under this element, it contains the given substring. This condition is case sensitive.
    
    Parameters:
    
    txt - a substring of the aggregated, case sensitive, text inside the element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isChildOf
```
public static ElementProperty isChildOf(Path path)
```
    Element is direct child of the element matched by the given parameter
    
    Parameters:
    
    path - - the parent of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasParent
```
public static ElementProperty hasParent(Path path)
```
    Element is direct child of the element matched by the given parameter
    
    Parameters:
    
    path - - the parent of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isParentOf
```
public static ElementProperty isParentOf(Path... paths)
```
    Element is the parent of the given list of elements
    
    Parameters:
    
    paths - - a list of elements that are children of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasChild
```
public static ElementProperty hasChild(Path... paths)
```
    Element is the parent of the given list of elements
    
    Parameters:
    
    paths - - a list of elements that are children of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - contains
```
public static ElementProperty contains(Path... paths)
```
    The given elements in the parameters list are contained in the current element
    
    Parameters:
    
    paths - - a list of elements that are descendants of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isAncestorOf
```
public static ElementProperty isAncestorOf(Path... paths)
```
    The given elements in the parameters list are contained in the current element
    
    Parameters:
    
    paths - - a list of elements that are descendants of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasDescendant
```
public static ElementProperty hasDescendant(Path... paths)
```
    The given elements in the parameters list are contained in the current element
    
    Parameters:
    
    paths - - a list of elements that are descendants of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - hasAncesctor
```
public static ElementProperty hasAncesctor(Path path)
```
    Element is inside the given parameter
    
    Parameters:
    
    path - the ancestor of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isDescendantOf
```
public static ElementProperty isDescendantOf(Path path)
```
    Element is inside the given parameter
    
    Parameters:
    
    path - the ancestor of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isInside
```
public static ElementProperty isInside(Path path)
```
    Element is inside the given parameter
    
    Parameters:
    
    path - the ancestor of the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isContainedIn
```
public static ElementProperty isContainedIn(Path path)
```
  - isAfter
```
public static ElementProperty isAfter(Path... paths)
```
    Element appears after all the given parameters in the document
    
    Parameters:
    
    paths - - elements that precede the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isAfter
```
public static ElementProperty isAfter(NPath nPath)
```
    Element is after at-least/at-most/exactly the given number of the given element. Example use: import static com.github.loyada.jdollarx.atLeast; input.that(isAfter(atLeast(2).occurrencesOf(div)));
    
    Parameters:
    
    nPath - - at-least/at-most/exactly the given number of the given element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isBefore
```
public static ElementProperty isBefore(Path... paths)
```
    Element is before all the elements given in the parameters
    
    Parameters:
    
    paths - - all the elements that appear after the current element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isBefore
```
public static ElementProperty isBefore(NPath nPath)
```
    Element is before at-least/at-most/exactly the given number of the given element. Example use:
```
    import static com.github.loyada.jdollarx.isBefore;
    input.that(isBefore(atLeast(2).occurrencesOf(div)));
 
```
    Parameters:
    
    nPath - - at-least/at-most/exactly the given number of the given element
    
    Returns:
    
    An element property that can be applied with Path::that
  - isSiblingOf
```
public static ElementProperty isSiblingOf(Path... paths)
```
    Element is a sibling of all the elements defined by the given paths
    
    Parameters:
    
    paths - a list of paths referring to elements
    
    Returns:
    
    An element property that can be applied with Path::that
  - isAfterSibling
```
public static ElementProperty isAfterSibling(Path... paths)
```
    Element is a sibling of all the elements defined by the given paths, AND is after all those siblings
    
    Parameters:
    
    paths - a list of paths referring to elements
    
    Returns:
    
    An element property that can be applied with Path::that
  - isAfterSibling
```
public static ElementProperty isAfterSibling(NPath nPath)
```
    Element is a sibling of the at-least/at-most/exactly n elements given, and appears after them. Example:
```
   Path el = element.that(isAfterSibling(exactly(2).occurrencesOf(div)));
   assertThat(el.toString(), is(equalTo("any element, that is after 2 siblings of type: div")));
 
```
    Parameters:
    
    nPath - a count of elements that are siblings appearing before current elements.
    
    Returns:
    
    An element property that can be applied with Path::that
  - isBeforeSibling
```
public static ElementProperty isBeforeSibling(Path... paths)
```
    Element is a sibling of all the elements defined by the given paths, AND is before all those siblings
    
    Parameters:
    
    paths - a list of paths referring to elements
    
    Returns:
    
    An element property that can be applied with Path::that
  - isBeforeSibling
```
public static ElementProperty isBeforeSibling(NPath nPath)
```
    Element is a sibling of the at-least/at-most/exactly n elements given, and appears before them. Example:
```
   Path el = element.that(isBeforeSibling(exactly(2).occurrencesOf(div)));
   assertThat(el.toString(), is(equalTo("any element, that is before 2 siblings of type: div")));
 
```
    Parameters:
    
    nPath - a count of elements that are siblings appearing after current elements.
    
    Returns:
    
    An element property that can be applied with Path::that
  - not
```
public static ElementProperty not(ElementProperty prop)
```
    Element does NOT have the given property.
    
    Parameters:
    
    prop - - the property which the element must not have
    
    Returns:
    
    An element property that can be applied with Path::that

Class ElementProperties

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

isLastSibling

isDisabled

isEnabled

isChecked

isSelected

hasNoChildren

hasChildren

isOnlyChild

isHidden

hasSomeText

Method Detail

hasNChildren

isNthFromLastSibling

isNthSibling

withIndexInRange

hasRawXpathProperty

hasText

hasCaseSensitiveText

hasTextStartingWith

hasTextEndingWith

hasId

hasName

hasSource

hasRole

hasAttribute

hasAnyOfClasses

hasClasses

hasClassContaining

hasNonOfTheClasses

isWithIndex

hasTextContaining

hasCaseSensitiveTextContaining

hasClass

hasAggregatedTextEqualTo

hasAggregatedCaseSensitiveTextEqualTo

hasAggregatedTextStartingWith

hasAggregatedTextEndingWith

hasAggregatedTextContaining

hasAggregatedCaseSensitiveTextContaining

isChildOf

hasParent

isParentOf

hasChild

contains

isAncestorOf

hasDescendant

hasAncesctor

isDescendantOf

isInside

isContainedIn

isAfter

isAfter

isBefore

isBefore

isSiblingOf

isAfterSibling

isAfterSibling

isBeforeSibling

isBeforeSibling

not