Web Accessibility Check – Errors and Warnings

How to Check Accessibility of Website

Checking a website for accessibility means ensuring that everyone, including people with disabilities, can use your website or app. This involves testing your content against guidelines like WCAG, which outline how to make digital experiences more inclusive. Using Aspose.HTML for Java, you can automate this process by scanning HTML and CSS for accessibility issues – either against the full WCAG set of standards or by focusing on specific criteria.

In this article, you will learn how to assess website accessibility for WCAG compliance using the classes and methods from the com.aspose.html.accessibility and com.aspose.html.accessibility.results packages. We will explore various classes and interfaces that help collect error and warning information while checking a website’s accessibility. Special attention will be given to the failure criteria and methods for reporting errors, along with a Java example that demonstrates how to retrieve web accessibility errors after validating an HTML document.

Let’s see a code snippet related to web accessibility validation. The following code checks the accessibility of a remote HTML page using all WCAG validation rules and prints details of any rules that were not successfully met:

1. Use the WebAccessibility() constructor to create an instance of the WebAccessibility class responsible for web accessibility validation.
2. Call the createValidator() method to create a validator object.
3. Load an HTML page using the HTMLDocument(Url) constructor.
4. Use the validate(document) method to check the web page for accessibility. The result is stored in the validationResult variable.
5. Check whether the validation was successful. For each accessibility issue, print information about the rule code, rule description, and whether the validation succeeded or failed.

// Check website for WCAG compliance in Java

// Initialize webAccessibility container
WebAccessibility webAccessibility = new WebAccessibility();

// Create an accessibility validator with static instance
// for all rules from repository that match the builder settings
AccessibilityValidator validator = webAccessibility.createValidator(ValidationBuilder.getAll());

// Initialize an HTMLDocument object
final HTMLDocument document = new HTMLDocument("https://products.aspose.com/html/net/generators/video/");
ValidationResult validationResult = validator.validate(document);

// Checking for success
if (!validationResult.getSuccess()) {
    // Get a list of Details
    for (RuleValidationResult detail : validationResult.getDetails()) {
        System.out.println(String.format("%s: %s = %s",
                detail.getRule().getCode(),
                detail.getRule().getDescription(),
                detail.getSuccess()
        ));
    }
}

Errors and Warnings

Detecting errors helps identify barriers that may prevent people with disabilities from using and interacting with web content effectively. Errors and warnings guide what must be addressed to improve web accessibility. They serve as a roadmap for developers and designers to make necessary changes.

IError

The IError is a public interface containing information about the validation error. This means an erroneous check, i.e., the rule was not passed – and its result does not match Accessibility.

The IError interface describes the details of a validation problem encountered during accessibility checks. It provides key information about the error, including a human-readable message via getErrorMessage(), the result status with getSuccess(), and the error type as a numeric value (getErrorType()) and a descriptive name (getErrorTypeName()), such as Error or Warning. Additionally, getTarget() returns the specific HTML or CSS element in which the problem was encountered, allowing accessibility issues to be accurately identified and corrected. This interface is essential for effectively interpreting and reporting accessibility check results.

IError object has such meanings:

* ErrorType = 1 and Success = false – this means that the error is critical, and the result of the check is not performed.
* ErrorType = 2 and Success = true – this means that the error is not critical but has an informational character and displays hints for possible improvement. 

The type of error is determined by the type of technique:

• If a technique fails to meet a required success criterion, and that criterion is required to meet it, the result will be marked as a critical failure, resulting in ErrorType=1 and Success=false, and it is an Error.
• If a technique is not strictly required, or if the issue is more of a best practice or improvement suggestion than a hard violation of the rules, it will be marked as ErrorType=2 and Success=true, and it is a Warning.

Target

The Target class represents a specific HTML or CSS element where an accessibility error or warning was detected during validation. It provides two key properties: Item, which returns the actual object (such as an HTML tag or CSS rule) that caused the problem, and TargetType, which determines whether the source of the problem is an HTML element or a CSS component.

TargetTypes

The TargetTypes enumeration defines the possible types of objects in an HTML document where an accessibility error or warning might be found. It helps classify the source of the problem, making it easier to identify and resolve. The enumeration includes three values:

Name	Value	Description
HTMLElement	0	The element containing the HTMLElement from a document: standard HTML elements such as <img> or <button>.
CSSStyleRule	1	The element containing the CSSStyleRule from a document: specific CSS rules in stylesheets.
CSSStyleSheet	2	The element containing the CSSStyleSheet from a document: entire CSS stylesheets.

This enumeration works in conjunction with the Target class to indicate exactly what type of element caused the validation result.

Generate Full Accessibility Report

Let’s look at the Java code for iterating through the web accessibility check results, paying particular attention to the failure criteria and the details of the methods that report errors. Example of getting errors details and elements of an HTML document:

1. Use the RuleValidationResult class and iterate through the ruleResult objects contained within validationResult.getDetails(). These represent different accessibility criteria.
2. Print the code and description of the criterion and whether it was successful or not. For this, use the Code and Description properties of the IRule interface.
3. Use the getSuccess() method to check the criteria.
4. Use the ITechniqueResult objects – ruleDetail contained within ruleResult.getErrors(). The ITechniqueResult objects represent individual rule results for the criterion that reported errors.
5. Print the information about the method, including the method code, success status, and description.
6. Use the IError property to obtain the error object from the ruleDetail. The ruleDetail represents a specific accessibility issue, and the error object contains information about that issue.
7. Use getTarget() to retrieve the target object associated with the error. The target object typically represents the specific HTML element, CSS rule, or other content that triggered the accessibility error.
8. Print information about the error. It includes the error type error.getErrorTypeName() and the error message error.getErrorMessage().
9. Use the getTargetType() method of the Target class to check the type of the target object. Depending on the type of the target object, specific information is extracted and printed to the console.

// Check HTML for WCAG compliance and output failed rule codes and error messages

// Initialize a webAccessibility container
WebAccessibility webAccessibility = new WebAccessibility();

// Create an accessibility validator with static instance
// for all rules from repository that match the builder settings
AccessibilityValidator validator = webAccessibility.createValidator(ValidationBuilder.getAll());

String documentPath = "input.html";

// Initialize an object of the HTMLDocument class
final HTMLDocument document = new HTMLDocument(documentPath);
ValidationResult validationResult = validator.validate(document);

for (RuleValidationResult ruleResult : validationResult.getDetails()) {
    //  list only unsuccessful rule
    if (!ruleResult.getSuccess()) {
        // print the code and description of the rule
        System.out.println(String.format("%s: %s = %s",
                ruleResult.getRule().getCode(),
                ruleResult.getRule().getDescription(),
                ruleResult.getSuccess()
        ));

        // print the results of methods with errors
        for (ITechniqueResult ruleDetail : ruleResult.getErrors()) {
            // print the code and description of the method
            StringBuilder str = new StringBuilder(String.format("\n{0}: {1} - {2}",
                    ruleDetail.getRule().getCode(),
                    ruleDetail.getSuccess(),
                    ruleDetail.getRule().getDescription()
            ));
            // get an error object
            IError error = ruleDetail.getError();
            // get a target object
            Target target = error.getTarget();
            // get error type and message
            str.append(String.format("\n\n\t%s : %s",
                    error.getErrorTypeName(),
                    error.getErrorMessage()
            ));

            if (target != null) {
                // Checking the type of the contained object for casting and working with it
                if (target.getTargetType() == TargetTypes.CSSStyleRule) {
                    ICSSStyleRule cssRule = (ICSSStyleRule) target.getItem();
                    str.append(String.format("\n\n\t%s",
                            cssRule.getCSSText()
                    ));
                }
                if (ruleDetail.getError().getTarget().getTargetType() == TargetTypes.CSSStyleSheet) {
                    str.append(String.format("\n\n\t%s",
                            ((ICSSStyleSheet) target.getItem()).getTitle()
                    ));
                }
                if (ruleDetail.getError().getTarget().getTargetType() == TargetTypes.HTMLElement) {
                    str.append(String.format("\n\n\t%s",
                            ((HTMLElement) target.getItem()).getOuterHTML()
                    ));
                }
            }
            System.out.println(str);
        }
    }
}

For each failed criterion, the code lists rule descriptions, failed methods, error messages, and highlights the exact HTML or CSS element where the issue was found. This approach is ideal for generating a complete and accurate accessibility report, including error context and technical diagnostics for developers.

See Also

• You will find helpful tips on evaluating and improving text visibility in the article Color Contrast Accessibility, which covers contrast checking based on WCAG using Aspose.HTML for Java.
• For instructions on checking web content is compatible with screen readers, you will find in the article Screen Reader Accessibility. You will learn how to check alt text and other key elements.
• If you want to learn how to view validation results and identify web accessibility issues, see the Validation Results article.
  

Aspose.HTML offers a free online Color Contrast Checker to check the contrast ratios in your web designs. This tool provides feedback on whether your color choices meet accessibility standards.