Web Accessibility Rules – Principles, Guidelines, Criteria, and Techniques

Use the AccessibilityRules class to access WCAG 2.0 principles, guidelines, success criteria, and techniques in Java. Retrieve rules by code and pass the selected list to WebAccessibility.createValidator() to run focused accessibility checks.

Accessibility rules describe requirements and techniques for making websites, applications, and digital content usable by people with visual, auditory, motor, and cognitive disabilities. Aspose.HTML for Java provides its WCAG 2.0 rules through the com.aspose.html.accessibility package.

WCAG 2.0 Rule Structure

WCAG 2.0 organizes its rules as principles, guidelines, and testable success criteria. Techniques describe ways to meet a criterion or identify common failures. The four top-level principles are Perceivable, Operable, Understandable, and Robust.

Access Web Accessibility Rules

Create a WebAccessibility instance and call getRules() to obtain an AccessibilityRules object. Its hierarchy corresponds to the WCAG 2.0 Quick Reference.

The AccessibilityRules class provides methods for retrieving the complete collection or individual entries by code:

Method	Description
getPrinciple(String code)	Returns a Principle with the specified WCAG code.
getPrinciples()	Returns the collection of principles.
getRules(String[] codes)	Returns a List<IRule> for the specified rule codes.

The rules are organized into four related types:

• Principle – a top-level accessibility foundation.
• Guideline – a goal organized under a principle.
• Criterion – a testable success criterion with conformance level A, AA, or AAA.
• Technique – a way to satisfy a criterion or identify a failure.

IRule Interface and Rule Base Class

All entries implement the IRule interface and inherit their shared behavior from the abstract Rule class.

Method	Description
getCode()	Returns the rule code used in the WCAG quick reference.
getDescription()	Returns the rule description.

Get Accessibility Rules by Code

Use AccessibilityRules.getRules() to retrieve different rule types in one list. The example requests three techniques, one guideline, and one success criterion, then prints each code and description.

// Retrieve and list accessibility rules by code with their descriptions from the rules repository

// Create a WebAccessibility instance
WebAccessibility webAccessibility = new WebAccessibility();

// List of rule codes can contain both technique codes and principles,
// guidelines and criteria - all rules that implement the interface IRule
String[] rulesCodes = new String[]{"H2", "H37", "H30", "1.1", "1.2.1"};

// Get a list of IRule objects; if a rule with the specified code is not found,
// it will not be in the list
List<IRule> rules = webAccessibility.getRules().getRules(rulesCodes);

// Get code and description of rule
for (IRule rule : rules) {
    System.out.println(String.format("%s: %s",
            rule.getCode(),
            rule.getDescription()
    ));
}

The program writes the following values to the console:

H2: Combining adjacent image and text links for the same resource
H37: Using alt attributes on img elements
H30: Providing link text that describes the purpose of a link for anchor elements
1.1: Text Alternatives
1.2.1: Audio-only and Video-only (Prerecorded)

Get a WCAG Principle

The Principle class represents the top level of the WCAG hierarchy and contains a collection of guidelines.

Method	Description
getGuideline(String code)	Returns the guideline with the specified code from this principle.
getGuidelines()	Returns the principle’s guidelines.

The example retrieves principle 1, Perceivable, and prints its code and description:

// Get accessibility principle by code from WCAG rules in Aspose.HTML for Java

// Create a WebAccessibility instance
WebAccessibility webAccessibility = new WebAccessibility();

// Get the principle by code
Principle rule = webAccessibility.getRules().getPrinciple("1");

// Get code and description of principle
System.out.println(String.format("%s: %s",
        rule.getCode(),
        rule.getDescription()
));
// @output: 1: Perceivable

Get a WCAG Guideline

The Guideline class represents the level below a principle and contains success criteria. Guidelines describe general accessibility goals; the criteria provide testable requirements.

Method	Description
getCriterion(String code)	Returns the success criterion with the specified code from this guideline.
getCriterions()	Returns the guideline’s collection of criteria.

The example obtains principle 1 and retrieves guideline 1.1, Text Alternatives:

// Get accessibility guideline by code from WCAG principle in Aspose.HTML for Java

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

// Get the principle by code 
Principle principle = webAccessibility.getRules().getPrinciple("1");

// Get guideline 1.1
Guideline guideline = principle.getGuideline("1.1");
if (guideline != null) {
    System.out.println(String.format("%s: %s, %s",
            guideline.getCode(),
            guideline.getDescription(),
            guideline
    ));
    // @output: 1.1: Text Alternatives
}

Get a Success Criterion and Its Techniques

The Criterion class represents a testable WCAG 2.0 success criterion. A criterion includes a conformance level and collections of sufficient techniques, advisory techniques, and failures.

Method	Description
getLevel()	Returns the criterion’s A, AA, or AAA conformance level.
getSufficientTechniques()	Returns techniques that describe sufficient ways to meet the criterion.
getAdvisoryTechniques()	Returns additional techniques that can improve accessibility.
getFailures()	Returns documented failures associated with the criterion.

WCAG conformance is determined by its success criteria, not by requiring authors to use a particular published technique. See Understanding Techniques for WCAG Success Criteria for that distinction.

The example retrieves criterion 1.1.1, prints its level, and lists its sufficient techniques:

// Get accessibility criterion and its sufficient techniques in Java

// Create a WebAccessibility instance
WebAccessibility webAccessibility = new WebAccessibility();

// Get the principle by code 
Principle principle = webAccessibility.getRules().getPrinciple("1");

// Get guideline 
Guideline guideline = principle.getGuideline("1.1");

// Get criterion by code
Criterion criterion = guideline.getCriterion("1.1.1");
if (criterion != null) {
    System.out.println(String.format("%s: %s - %s",
            criterion.getCode(),
            criterion.getDescription(),
            criterion.getLevel()
    ));
    // @output: 1.1.1: Non-text Content - A

    // Get all Sufficient Techniques and write to console
    for (IRule technique : criterion.getSufficientTechniques())
        System.out.println(String.format("%s: %s",
                technique.getCode(),
                technique.getDescription()
        ));
}

Validate HTML Against Selected Accessibility Rules

The following Java workflow validates an HTML document against a selected set of WCAG technique codes:

1. Create a WebAccessibility instance to access the rules and validator factory.
2. Define the rule codes required for the accessibility check.
3. Pass the codes to getRules() to obtain a List<IRule>.
4. Create an AccessibilityValidator with the selected rules and ValidationBuilder.getAll() settings.
5. Load the HTML source into an HTMLDocument.
6. Call validate() and format the returned ValidationResult with saveToString().

// Validate an HTML document using specific rule codes with Java

String htmlPath = "input.html";

// Create a WebAccessibility instance
WebAccessibility webAccessibility = new WebAccessibility();

// List of necessary rules for checking (rule code according to the specification) 
String[] rulesCode = new String[]{"H2", "H37", "H67", "H86"};

// Get the required IList<IRule> rules from the rules reference
List<IRule> rules = webAccessibility.getRules().getRules(rulesCode);

// Create an accessibility validator, pass the found rules as parameters,
// and specify the full validation settings
AccessibilityValidator validator = webAccessibility.createValidator(
        rules, ValidationBuilder.getAll());

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

// Return the result in string format
// SaveToString - return only errors and warnings
System.out.println(validationResult.saveToString());

The example prints the formatted validation result to the console. Selecting rule codes is useful for targeted checks; use the complete rule set when the workflow requires a broader automated audit.

FAQ

How do I get an accessibility rule by code?

Pass one or more codes to AccessibilityRules.getRules(String[]). To retrieve a top-level principle directly, use getPrinciple(String).

What is the difference between a success criterion and a technique?

A success criterion is a testable WCAG requirement. A technique describes a documented way to meet that criterion, while a failure describes a pattern that does not satisfy it.

Can I validate only selected accessibility rules?

Yes. Retrieve the required rules by code and pass the resulting List<IRule> to WebAccessibility.createValidator() together with the validation settings.

Related Articles

• Accessibility Validator – create validators and configure accessibility checks.
• Validation Results – inspect rule and technique results returned by validation.
• Web Accessibility Check – collect errors, warnings, and affected HTML or CSS targets.
• Color Contrast Accessibility – evaluate text and background color contrast.
• Screen Reader Accessibility – check alternative text and related document markup.

Try the Online Web Accessibility Checker

Use the free online Web Accessibility Checker for a quick page scan before selecting rules for a Java validation workflow. Automated results do not replace manual accessibility testing.