Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   Copyright 2014 Red Hat, Inc. and/or its affiliates.
  
   This file is part of darcy.
  
   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation, either version 3 of the License, or
   (at your option) any later version.
 
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
 
  You should have received a copy of the GNU General Public License
  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package com.redhat.darcy.ui;
 
 
 import java.util.List;
A helper class with static factories for com.redhat.darcy.ui.api.Locators, inspired by Selenium's By class.
 
 public abstract class By {
     public static ById id(String id) {
         return new ById(id);
     }
 
     public static ByName name(String name) {
         return new ByName(name);
     }
     
     public static ByLinkText linkText(String linkText) {
         return new ByLinkText(linkText);
     }
     
     public static ByTextContent textContent(String textContent) {
         return new ByTextContent(textContent);
     }
     
     public static ByPartialTextContent partialTextContent(String partialTextContent) {
         return new ByPartialTextContent(partialTextContent);
     }
     
     public static ByXPath xpath(String xpath) {
         return new ByXPath(xpath);
     }
     
     public static ByView view(View view) {
         return new ByView(view);
     }
     
     public static ByChained chained(Locator... locators) {
         return new ByChained(locators);
     }
     
     public static ByNested nested(Element parentLocator childLocator... additional) {
         return new ByNested(parentchildadditional);
     }
 
     public static ByAttribute attribute(String attributeString value) {
         return new ByAttribute(attributevalue);
     }
     
     public static class ById implements Locator {
         private String id;
         
         public ById(String id) {
             this. = Objects.requireNonNull(id"id");
         }
         
         @Override
         public <T> List<T> findAll(Class<T> typeContext context) {
             try {
                 return ((FindsByIdcontext).findAllById(type);
             } catch (ClassCastException cce) {
                 throw new LocatorNotSupportedException(this);
             }
        }
        
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByIdcontext).findById(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public boolean equals(Object object) {
            if (!(object instanceof ById)) {
                return false;
            }
            ById other = (ByIdobject;
            return .equals(other.id);
        }
        @Override
        public String toString() {
            return "ById: {" +
                    "id='" +  + '\'' +
                    '}';
        }
    }
    public static class ByAttribute implements Locator {
        private String attribute;
        private String value;
        public ByAttribute(String attributeString value) {
            this. = Objects.requireNonNull(attribute"attribute");
            this. = Objects.requireNonNull(value"value");
        }
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            if (context instanceof FindsByAttribute) {
                return ((FindsByAttributecontext).findAllByAttribute(type);
            } else if (context instanceof FindsByXPath) {
                return ((FindsByXPathcontext).findAllByXPath(type".//*[@" +  + "='" +  + "']");
            }
            throw new LocatorNotSupportedException(this);
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            if (context instanceof FindsByAttribute) {
                return ((FindsByAttributecontext).findByAttribute(type);
            } else if (context instanceof FindsByXPath) {
                return ((FindsByXPathcontext).findByXPath(type".//*[@" +  + "='" +  + "']");
            }
            throw new LocatorNotSupportedException(this);
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            ByAttribute byAttribute = (ByAttributeo;
            return .equals(byAttribute.attribute)
                    && .equals(byAttribute.value);
        }
        @Override
        public String toString() {
            return "ByAttribute: {" +
                    "attribute='" +  + "', " +
                    "value='" +  + "'" +
                    '}';
        }
    }
    
    public static class ByName implements Locator {
        private String name;
        
        public ByName(String name) {
            this. = Objects.requireNonNull(name"name");
        }
        
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            try {
                return ((FindsByNamecontext).findAllByName(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByNamecontext).findByName(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            ByName byName = (ByNameo;
            return .equals(byName.name);
        }
        @Override
        public String toString() {
            return "ByName: {" +
                    "name='" +  + '\'' +
                    '}';
        }
    }
    
    public static class ByLinkText implements Locator {
        private String linkText;
        
        public ByLinkText(String linkText) {
            this. = Objects.requireNonNull(linkText"linkText");
        }
        
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            try {
                return ((FindsByLinkTextcontext).findAllByLinkText(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByLinkTextcontext).findByLinkText(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            ByLinkText that = (ByLinkTexto;
            return .equals(that.linkText);
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public String toString() {
            return "ByLinkText: {" +
                    "linkText='" +  + '\'' +
                    '}';
        }
    }
    
    public static class ByTextContent implements Locator {
        private String textContent;
        
        public ByTextContent(String textContent) {
            this. = Objects.requireNonNull(textContent"textContent");
        }
        
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            try {
                return ((FindsByTextContentcontext).findAllByTextContent(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByTextContentcontext).findByTextContent(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            ByTextContent that = (ByTextContento;
            return .equals(that.textContent);
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public String toString() {
            return "ByTextContent: {" +
                    "textContent='" +  + '\'' +
                    '}';
        }
    }
    
    public static class ByPartialTextContent implements Locator {
        private String partialTextContent;
        
        public ByPartialTextContent(String partialTextContent) {
            this. = Objects.requireNonNull(partialTextContent,
                    "partialTextContent");
        }
        
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            try {
                return ((FindsByPartialTextContentcontext)
                        .findAllByPartialTextContent(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByPartialTextContentcontext)
                        .findByPartialTextContent(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            ByPartialTextContent that = (ByPartialTextContento;
            return .equals(that.partialTextContent);
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public String toString() {
            return "ByPartialTextContent: {" +
                    "partialTextContent='" +  + '\'' +
                    '}';
        }
    }
    
    public static class ByXPath implements Locator {
        private String xpath;
        
        public ByXPath(String xpath) {
            this. = Objects.requireNonNull(xpath"xpath");
        }
        
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            try {
                return ((FindsByXPathcontext).findAllByXPath(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByXPathcontext).findByXPath(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            ByXPath that = (ByXPatho;
            return .equals(that.xpath);
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public String toString() {
            return "ByXPath: {" +
                    "xpath='" +  + '\'' +
                    '}';
        }
    }
    
    public static class ByView implements Locator {
        private final View view;
        
        public ByView(View view) {
            this. = Objects.requireNonNull(view"view");
        }
        
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            try {
                return ((FindsByViewcontext).findAllByView(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByViewcontext).findByView(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            ByView that = (ByViewo;
            return .equals(that.view);
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public String toString() {
            return "ByView: {" +
                    "view='" +  + '\'' +
                    '}';
        }
    }
    
    public static class ByChained implements Locator {
        private final Locator[] locators;
        
        public ByChained(Locator... locators) {
            this. = Objects.requireNonNull(locators"locators");
            if (locators.length == 0) {
                throw new IllegalArgumentException("Cannot chain 0 locators.");
            }
        }
        
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            try {
                return ((FindsByNestedcontext).findAllByChained(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByNestedcontext).findByChained(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public boolean equals(Object object) {
            if (this == object) {
                return true;
            }
            if (object == null || getClass() != object.getClass()) {
                return false;
            }
            ByChained other = (ByChainedobject;
            return Arrays.equals(other.locators);
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public String toString() {
            return "ByChained: {" +
                    "locators='" + Arrays.toString() + '\'' +
                    '}';
        }
    }
    
    public static class ByNested implements Locator {
        private final Element parent;
        private final Locator child;
        
        public ByNested(Element parentLocator childLocator... additional) {
            Objects.requireNonNull(child"child");
            Objects.requireNonNull(parent"parent");
            if (additional.length > 0) {
                Locator[] locators = new Locator[additional.length + 1];
                locators[0] = child;
                System.arraycopy(additional, 0, locators, 1, additional.length);
                this. = By.chained(locators);
            } else {
                this. = child;
            }
            this. = (parent instanceof WrapsElement)
                    ? ((WrapsElementparent).getWrappedElement()
                    : parent;
        }
        
        @Override
        public <T> List<T> findAll(Class<T> typeContext context) {
            try {
                return ((FindsByNestedcontext).findAllByNested(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public <T> T find(Class<T> typeContext context) {
            try {
                return ((FindsByNestedcontext).findByNested(type);
            } catch (ClassCastException cce) {
                throw new LocatorNotSupportedException(this);
            }
        }
        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            ByNested byNested = (ByNestedo;
            return .equals(byNested.child) && .equals(byNested.parent);
        }
        @Override
        public int hashCode() {
            return Objects.hash();
        }
        @Override
        public String toString() {
            return "ByNested: {" +
                    "parent=" +  +
                    ", child=" +  +
                    '}';
        }
    }
New to GrepCode? Check out our FAQ X