[1.4.2-documentation] - added java docs

Author: dzaiats

readme.md

@@ -79,7 +79,7 @@
             EXECUTOR=http://{host}:{port}/wd/hub
             DEVICE=Device name or ID
 
-### Possibilities ###
+### Responsive UI Validation ###
  - Responsive UI Validator allows to validate UI on web or mobile page using lots of criterias. Also it allows tu build thr HTMl report after validation.
 
             ResponsiveUIValidator uiValidator = new    ResponsiveUIValidator(driver);
@@ -106,7 +106,183 @@
 
 
             uiValidator.generateReport();
+            
+ - Description for each methods available in the framework:
+    
+    * Init method:
+    
+            init(); // Method that defines start of new validation. Needs to be called each time before calling findElement(), findElements()
+            
+            init("Scenario name"); // Method that defines start of new validation with specified name of scenario. Needs to be called each time before calling findElement(), findElements()
+            
+            setColorForRootElement(Color color); // Set color for main element. This color will be used for highlighting element in results
+            
+            setColorForHighlightedElements(Color color); // Set color for compared elements. This color will be used for highlighting elements in results
+            
+            setLinesColor(Color color); // Set color for grid lines. This color will be used for the lines of alignment grid in results
+            
+            findElement(WebElement element, String readableNameOfElement); // Main method to specify which element we want to validate (can be called only findElement() OR findElements() for single validation)
+            
+            findElements(List<WebElement> elements); // Main method to specify the list of elements that we want to validate (can be called only findElement() OR findElements() for single validation)
+    
+    * For single element findElement({element}, "name"):
+        
+            insideOf(WebElement containerElement, String readableContainerName); // Verify that element is located inside of specified element
+            
+            withLeftElement(WebElement element); // Verify that element which located left to is correct
+        
+            
+            withLeftElement(WebElement element, int minMargin, int maxMargin); // Verify that element which located left to is correct with specified margins
+        
+            
+            withRightElement(WebElement element); // Verify that element which located right to is correct
+        
+            
+            withRightElement(WebElement element, int minMargin, int maxMargin); // Verify that element which located right to is correct with specified margins
+        
+            
+            withTopElement(WebElement element); // Verify that element which located top to is correct
+        
+            
+            withTopElement(WebElement element, int minMargin, int maxMargin); // Verify that element which located top to is correct with specified margins
+        
+            
+            withBottomElement(WebElement element); // Verify that element which located bottom to is correct
+        
+            
+            withBottomElement(WebElement element, int minMargin, int maxMargin); // Verify that element which located bottom to is correct with specified margins
+        
+            
+            notOverlapWith(WebElement element, String readableName); // Verify that element is NOT overlapped with specified element
+        
+            
+            overlapWith(WebElement element, String readableName); // Verify that element is overlapped with specified element
+        
+            
+            notOverlapWith(List<WebElement> elements); // Verify that element is NOT overlapped with every element is the list
+        
+            
+            sameOffsetLeftAs(WebElement element, String readableName); // Verify that element has the same left offset as specified element
+        
+            
+            sameOffsetLeftAs(List<WebElement> elements); // Verify that element has the same left offset as every element is the list
+        
+            
+            sameOffsetRightAs(WebElement element, String readableName); // Verify that element has the same right offset as specified element
+        
+            
+            sameOffsetRightAs(List<WebElement> elements); // Verify that element has the same right offset as every element is the list
+        
+            
+            sameOffsetTopAs(WebElement element, String readableName); // Verify that element has the same top offset as specified element
+        
+            
+            sameOffsetTopAs(List<WebElement> elements); // Verify that element has the same top offset as every element is the list
+        
+            
+            sameOffsetBottomAs(WebElement element, String readableName); // Verify that element has the same bottom offset as specified element
+        
+            
+            sameOffsetBottomAs(List<WebElement> elements); // Verify that element has the same bottom offset as every element is the list
+        
+            
+            sameWidthAs(WebElement element, String readableName); // Verify that element has the same width as specified element
+        
+            
+            sameWidthAs(List<WebElement> elements); // Verify that element has the same width as every element in the list
+        
+            
+            minWidth(int width); // Verify that width of element is not less than specified
+        
+            
+            maxWidth(int width); // Verify that width of element is not bigger than specified
+        
+            
+            widthBetween(int min, int max); // Verify that width of element is in range
+        
+            
+            sameHeightAs(WebElement element, String readableName); // Verify that element has the same height as specified element
+        
+            
+            sameHeightAs(List<WebElement> elements); // Verify that element has the same height as every element in the list
+        
+            
+            minHeight(int height); // Verify that height of element is not less than specified
+        
+            
+            maxHeight(int height); // Verify that height of element is not bigger than specified
+        
+            
+            sameSizeAs(WebElement element, String readableName); // Verify that element has the same size as specified element
+        
+            
+            sameSizeAs(List<WebElement> elements); // Verify that element has the same size as every element in the list
+        
+            
+            heightBetween(int min, int max); // Verify that height of element is in range
+        
+            
+            minOffset(int top, int right, int bottom, int left); // Verify that min offset of element is not less than (min value is -10000)
+        
+            
+            maxOffset(int top, int right, int bottom, int left); // Verify that max offset of element is not bigger than (min value is -10000)
+        
+            
+            withCssValue(String cssProperty, String... args); // Verify that element has correct CSS values
+        
+            
+            withoutCssValue(String cssProperty, String... args); // Verify that concrete CSS values are absent for specified element
+        
+            
+            equalLeftRightOffset(); // Verify that element has equal left and right offsets (e.g. Bootstrap container)
+        
+            
+            equalTopBottomOffset(); // Verify that element has equal top and bottom offset (aligned vertically in center)
+         
+            
+            changeMetricsUnitsTo(ResponsiveUIValidator.Units units); // Change units to Pixels or % (Units.PX, Units.PERCENT)
+
+    * For list of elements findElements({element}):
+            
+            insideOf(WebElement containerElement, String readableContainerName); // Verify that elements are located inside of specified element
+            
+            alignedAsGrid(int horizontalGridSize); // Verify that elements are aligned in a grid view width specified amount of columns
+            
+            alignedAsGrid(int horizontalGridSize, int verticalGridSize); // Verify that elements are aligned in a grid view width specified amount of columns and rows
+            
+            areNotOverlappedWithEachOther(); // Verify that every element in the list is not overlapped with another element from this list
+            
+            withSameSize(); // Verify that elements in the list have the same size
+            
+            withSameWidth(); // Verify that elements in the list have the same width
+            
+            withSameHeight(); // Verify that elements in the list have the same height
+            
+            sameRightOffset(); // Verify that elements in the list have the right offset
+            
+            sameLeftOffset(); // Verify that elements in the list have the same left offset
+            
+            sameTopOffset(); // Verify that elements in the list have the same top offset
+            
+            sameBottomOffset(); // Verify that elements in the list have the same bottom offset
+            
+            equalLeftRightOffset(); // Verify that every element in the list have equal right and left offset (aligned horizontally in center)
+            
+            equalTopBottomOffset(); // Verify that every element in the list have equal top and bottom offset (aligned vertically in center)
+            
+            changeMetricsUnitsTo(ResponsiveUIValidator.Units units); // Change units to Pixels or % (Units.PX, Units.PERCENT)
+           
+    * Generating results:
+    
+            drawMap(); // Methods needs to be called to collect all the results in JSON file and screenshots
+            
+            validate(); // Call method to summarize and validate the results (can be called with drawMap(). In this case result will be only True or False)
+            
+            generateReport(); // Call method to generate HTML report
+            
+            generateReport("file report name"); // Call method to generate HTML report with specified file report name
 
+### Possibilities ###
  - Verification that elements are aligned correctly on the web or mobile page
     * Elements horizontally are aligned correctly:
 

src/main/java/util/validator/ResponsiveUIChunkValidator.java

@@ -5,9 +5,6 @@
 
 import java.util.List;
 
-import static environment.EnvironmentFactory.isChrome;
-import static util.general.SystemHelper.isRetinaDisplay;
-
 public class ResponsiveUIChunkValidator extends ResponsiveUIValidator implements ChunkValidator {
 
     ResponsiveUIChunkValidator(WebDriver driver, List<WebElement> elements) {
@@ -19,78 +16,147 @@ public class ResponsiveUIChunkValidator extends ResponsiveUIValidator implements
         startTime = System.currentTimeMillis();
     }
 
+    /**
+     * Change units to Pixels or % (Units.PX, Units.PERCENT)
+     *
+     * @param units
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator changeMetricsUnitsTo(Units units) {
         this.units = units;
         return this;
     }
 
+    /**
+     * Verify that elements are aligned in a grid view width specified amount of columns
+     *
+     * @param horizontalGridSize
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator alignedAsGrid(int horizontalGridSize) {
         validateGridAlignment(horizontalGridSize, 0);
         return this;
     }
 
+    /**
+     * Verify that elements are aligned in a grid view width specified amount of columns and rows
+     *
+     * @param horizontalGridSize
+     * @param verticalGridSize
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator alignedAsGrid(int horizontalGridSize, int verticalGridSize) {
         validateGridAlignment(horizontalGridSize, verticalGridSize);
         return this;
     }
 
+    /**
+     * Verify that every element in the list is not overlapped with another element from this list
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator areNotOverlappedWithEachOther() {
         validateElementsAreNotOverlapped(rootElements);
         return this;
     }
 
+    /**
+     * Verify that elements in the list have the same size
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator withSameSize() {
         validateSameSize(rootElements, 0);
         return this;
     }
 
+    /**
+     * Verify that elements in the list have the same width
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator withSameWidth() {
         validateSameSize(rootElements, 1);
         return this;
     }
 
+    /**
+     * Verify that elements in the list have the same height
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator withSameHeight() {
         validateSameSize(rootElements, 2);
         return this;
     }
 
+    /**
+     * Verify that elements in the list have the right offset
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator sameRightOffset() {
         validateRightOffsetForChunk(rootElements);
         return this;
     }
 
+    /**
+     * Verify that elements in the list have the same left offset
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator sameLeftOffset() {
         validateLeftOffsetForChunk(rootElements);
         return this;
     }
 
+    /**
+     * Verify that elements in the list have the same top offset
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator sameTopOffset() {
         validateTopOffsetForChunk(rootElements);
         return this;
     }
 
+    /**
+     * Verify that elements in the list have the same bottom offset
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator sameBottomOffset() {
         validateBottomOffsetForChunk(rootElements);
         return this;
     }
 
+    /**
+     * Verify that every element in the list have equal right and left offset (aligned horizontally in center)
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator equalLeftRightOffset() {
         validateEqualLeftRightOffset(rootElements);
         return this;
     }
 
+    /**
+     * Verify that every element in the list have equal top and bottom offset (aligned vertically in center)
+     *
+     * @return ResponsiveUIChunkValidator
+     */
     @Override
     public ResponsiveUIChunkValidator equalTopBottomOffset() {
         validateEqualTopBottomOffset(rootElements);