"""
end
defp get_skip_links do
GenServer.call(__MODULE__, :get_skip_links)
end
end
```
## Accessibility Testing
### Automated Accessibility Testing
```elixir
defmodule MyApp.AccessibilityTest do
@moduledoc """
Automated accessibility testing for Raxol components.
"""
use ExUnit.Case
describe "accessibility compliance" do
test "components have proper ARIA labels" do
html = render_component(MyApp.Components.Button, %{}, do: "Click me")
# Check for required ARIA attributes
assert html =~ ~r/aria-label|aria-labelledby/
assert html =~ ~r/role="button"/
# Verify button is focusable
assert html =~ ~r/tabindex="0"/
end
test "color contrast meets WCAG AA standards" do
theme = MyApp.AccessibilityTheme.get_theme(:default)
contrast_ratio = MyApp.AccessibilityTheme.calculate_contrast_ratio(
theme.foreground,
theme.background
)
# WCAG AA requires 4.5:1 for normal text
assert contrast_ratio >= 4.5
end
test "keyboard navigation works correctly" do
{:ok, nav_state} = MyApp.KeyboardNavigation.new()
# Add focusable elements
nav_state = add_focusable_elements(nav_state, [
%{id: "button1", type: :button, label: "First Button"},
%{id: "input1", type: :input, label: "Text Input"},
%{id: "button2", type: :button, label: "Second Button"}
])
# Test tab navigation
{:focus_moved, nav_state} = MyApp.KeyboardNavigation.handle_keypress(nav_state, :tab)
assert nav_state.focus_index == 1
{:focus_moved, nav_state} = MyApp.KeyboardNavigation.handle_keypress(nav_state, :tab)
assert nav_state.focus_index == 2
# Test wrap-around
{:focus_moved, nav_state} = MyApp.KeyboardNavigation.handle_keypress(nav_state, :tab)
assert nav_state.focus_index == 0
end
test "screen reader announcements work" do
# Start announcer
{:ok, _pid} = Raxol.Core.Accessibility.Announcer.start_link()
# Test announcement
Raxol.Core.Accessibility.Announcer.announce("Test announcement", priority: :polite)
# Verify announcement was processed (in real test, this would check output)
Process.sleep(100)
# Test interrupting announcement
Raxol.Core.Accessibility.Announcer.announce("Important message",
priority: :assertive,
interrupt: true
)
end
test "focus management handles trapping correctly" do
{:ok, _pid} = MyApp.FocusManager.start_link()
# Create modal with focus trap
:ok = MyApp.FocusManager.trap_focus("modal-dialog",
first_element: "modal-close-button"
)
# Verify focus is trapped within modal
# (In real implementation, this would test actual focus behavior)
# Release focus trap
:ok = MyApp.FocusManager.release_focus_trap()
end
end
describe "assistive technology compatibility" do
test "works with screen readers" do
# Test compatibility with major screen readers
for screen_reader <- [:nvda, :jaws, :voice_over, :orca] do
assert_screen_reader_compatible(screen_reader)
end
end
test "supports high contrast mode" do
high_contrast_theme = MyApp.AccessibilityTheme.get_theme(:high_contrast)
# Verify high contrast ratios
assert high_contrast_theme.contrast_ratio >= 21.0
# Test component rendering with high contrast
html = render_component_with_theme(MyApp.Components.Card, high_contrast_theme)
assert html =~ "high-contrast"
end
test "supports reduced motion preferences" do
# Test with reduced motion preference
preferences = %{reduce_motion: true}
component_html = render_component(MyApp.Components.AnimatedButton, %{
preferences: preferences
})
# Should not include animation classes when reduced motion is preferred
refute component_html =~ "animate-"
refute component_html =~ "transition-"
end
end
# Helper functions
defp render_component_with_theme(component, theme) do
assigns = %{theme: theme, content: "Test content"}
render_component(component, assigns)
end
defp assert_screen_reader_compatible(screen_reader) do
# Platform-specific screen reader compatibility tests
case screen_reader do
:nvda ->
assert System.find_executable("nvda-speak") != nil
:voice_over ->
assert :os.type() == {:unix, :darwin}
:orca ->
assert System.find_executable("orca") != nil
_ ->
:ok
end
end
end
```
### Manual Testing Checklist
```elixir
defmodule MyApp.AccessibilityChecklist do
@moduledoc """
Manual accessibility testing checklist and utilities.
"""
@keyboard_tests [
"Can navigate entire application using only keyboard",
"Tab order is logical and follows visual layout",
"All interactive elements are keyboard accessible",
"Focus indicators are clearly visible",
"Escape key works to close modals/dropdowns",
"Arrow keys work for grid/list navigation",
"Enter/Space activate buttons and links",
"Keyboard shortcuts don't conflict with assistive technology"
]
@screen_reader_tests [
"All images have appropriate alt text",
"Headings create logical document structure",
"Form fields have proper labels",
"Error messages are announced",
"Dynamic content changes are announced",
"Tables have proper headers and captions",
"Lists are properly marked up",
"Links have descriptive text"
]
@visual_tests [
"Text has sufficient color contrast (4.5:1 minimum)",
"UI works at 200% zoom level",
"High contrast mode is supported",
"Information isn't conveyed by color alone",
"Focus indicators are visible and clear",
"Text can be resized without horizontal scrolling",
"Interface works without custom fonts",
"Animation can be disabled/reduced"
]
@motor_tests [
"Large enough click targets (44px minimum)",
"Sufficient spacing between interactive elements",
"Drag and drop has keyboard alternatives",
"Time limits can be extended/disabled",
"No seizure-triggering flashing content",
"Gestures have single-point alternatives",
"Interface works with assistive pointing devices",
"Voice control compatible"
]
def run_checklist(category) do
tests = get_tests_for_category(category)
IO.puts("\n=== #{String.upcase(to_string(category))} ACCESSIBILITY TESTS ===\n")
Enum.with_index(tests, 1)
|> Enum.map(fn {test, index} ->
IO.puts("#{index}. #{test}")
case get_user_input(" Pass? (y/n/skip): ") do
"y" -> {:pass, test}
"n" ->
issue = get_user_input(" Describe issue: ")
{:fail, test, issue}
_ -> {:skip, test}
end
end)
|> generate_report(category)
end
defp get_tests_for_category(category) do
case category do
:keyboard -> @keyboard_tests
:screen_reader -> @screen_reader_tests
:visual -> @visual_tests
:motor -> @motor_tests
end
end
defp get_user_input(prompt) do
IO.gets(prompt) |> String.trim() |> String.downcase()
end
defp generate_report(results, category) do
passed = Enum.count(results, fn {status, _, _} -> status == :pass end)
failed = Enum.count(results, fn {status, _, _} -> status == :fail end)
skipped = Enum.count(results, fn {status, _, _} -> status == :skip end)
total = length(results)
IO.puts("\n=== #{String.upcase(to_string(category))} TEST RESULTS ===")
IO.puts("Passed: #{passed}/#{total}")
IO.puts("Failed: #{failed}/#{total}")
IO.puts("Skipped: #{skipped}/#{total}")
if failed > 0 do
IO.puts("\nISSUES TO FIX:")
results
|> Enum.filter(fn {status, _, _} -> status == :fail end)
|> Enum.each(fn {:fail, test, issue} ->
IO.puts("- #{test}: #{issue}")
end)
end
pass_rate = passed / total * 100
IO.puts("\nPass rate: #{:io_lib.format("~.1f", [pass_rate])}%")
if pass_rate >= 80 do
IO.puts("[OK] Good accessibility compliance")
else
IO.puts("[FAIL] Accessibility needs improvement")
end
%{
category: category,
passed: passed,
failed: failed,
skipped: skipped,
total: total,
pass_rate: pass_rate,
issues: Enum.filter(results, fn {status, _, _} -> status == :fail end)
}
end
end
```
## Accessibility Configuration
### User Preferences System
```elixir
defmodule MyApp.AccessibilityPreferences do
@moduledoc """
User accessibility preferences management.
"""
use GenServer
@default_preferences %{
# Visual preferences
high_contrast: false,
dark_mode: false,
font_size: :normal, # :small, :normal, :large, :extra_large
reduce_motion: false,
color_blindness_type: nil, # :protanopia, :deuteranopia, :tritanopia
# Audio preferences
screen_reader_enabled: false,
speech_rate: :normal, # :slow, :normal, :fast
sound_effects: true,
# Motor preferences
sticky_keys: false,
slow_keys: false,
mouse_keys: false,
click_assistance: false,
# Cognitive preferences
reading_guide: false,
simplified_ui: false,
extra_time: false,
focus_enhancement: false
}
def start_link(user_id) do
GenServer.start_link(__MODULE__, user_id, name: via_tuple(user_id))
end
def init(user_id) do
preferences = load_user_preferences(user_id) || @default_preferences
{:ok, %{user_id: user_id, preferences: preferences}}
end
def get_preferences(user_id) do
GenServer.call(via_tuple(user_id), :get_preferences)
end
def update_preference(user_id, key, value) do
GenServer.call(via_tuple(user_id), {:update_preference, key, value})
end
def apply_preferences(user_id, component_assigns) do
preferences = get_preferences(user_id)
apply_preferences_to_assigns(component_assigns, preferences)
end
def handle_call(:get_preferences, _from, state) do
{:reply, state.preferences, state}
end
def handle_call({:update_preference, key, value}, _from, state) do
new_preferences = Map.put(state.preferences, key, value)
# Save to persistent storage
save_user_preferences(state.user_id, new_preferences)
# Broadcast preference change
broadcast_preference_change(state.user_id, key, value)
new_state = %{state | preferences: new_preferences}
{:reply, :ok, new_state}
end
defp apply_preferences_to_assigns(assigns, preferences) do
assigns
|> apply_visual_preferences(preferences)
|> apply_motion_preferences(preferences)
|> apply_audio_preferences(preferences)
|> apply_motor_preferences(preferences)
end
defp apply_visual_preferences(assigns, preferences) do
assigns =
if preferences.high_contrast do
Map.put(assigns, :theme, :high_contrast)
else
assigns
end
assigns =
if preferences.font_size != :normal do
Map.put(assigns, :font_size_class, "font-size-#{preferences.font_size}")
else
assigns
end
assigns =
if preferences.color_blindness_type do
Map.put(assigns, :color_blind_theme, preferences.color_blindness_type)
else
assigns
end
assigns
end
defp apply_motion_preferences(assigns, preferences) do
if preferences.reduce_motion do
Map.update(assigns, :class, "", fn class ->
"#{class} reduce-motion"
end)
else
assigns
end
end
defp via_tuple(user_id) do
{:via, Registry, {MyApp.AccessibilityRegistry, user_id}}
end
defp load_user_preferences(user_id) do
# Load from database, file, or other persistent storage
case MyApp.UserPreferences.get(user_id) do
{:ok, preferences} -> preferences
{:error, :not_found} -> nil
end
end
defp save_user_preferences(user_id, preferences) do
MyApp.UserPreferences.save(user_id, preferences)
end
defp broadcast_preference_change(user_id, key, value) do
Phoenix.PubSub.broadcast(
MyApp.PubSub,
"user_preferences:#{user_id}",
{:preference_changed, key, value}
)
end
end
```
## Platform-Specific Accessibility
### macOS Accessibility Integration
```elixir
defmodule MyApp.MacOSAccessibility do
@moduledoc """
macOS-specific accessibility features and VoiceOver integration.
"""
def enable_accessibility_apis do
# Check if accessibility permissions are granted
case System.cmd("osascript", ["-e", "tell application \"System Events\" to get processes"]) do
{_output, 0} ->
{:ok, "Accessibility permissions granted"}
{_output, _exit_code} ->
{:error, "Accessibility permissions required. Please grant in System Preferences."}
end
end
def send_to_voiceover(text, options \\ []) do
priority = Keyword.get(options, :priority, :polite)
applescript = case priority do
:assertive ->
"""
tell application "VoiceOver Utility"
output "#{escape_applescript_string(text)}" with interrupt
end tell
"""
_ ->
"""
tell application "VoiceOver Utility"
output "#{escape_applescript_string(text)}"
end tell
"""
end
System.cmd("osascript", ["-e", applescript])
end
def get_voiceover_enabled do
applescript = """
tell application "System Preferences"
reveal pane "com.apple.preference.universalaccess"
delay 1
tell application "System Events"
tell process "System Preferences"
get value of checkbox "Enable VoiceOver" of tab group 1 of window "Accessibility"
end tell
end tell
end tell
"""
case System.cmd("osascript", ["-e", applescript]) do
{"true\n", 0} -> true
_ -> false
end
end
defp escape_applescript_string(text) do
text
|> String.replace("\"", "\\\"")
|> String.replace("\\", "\\\\")
end
end
```
### Windows Accessibility Integration
```elixir
defmodule MyApp.WindowsAccessibility do
@moduledoc """
Windows-specific accessibility features and screen reader integration.
"""
def detect_screen_reader do
cond do
System.get_env("NVDA_RUNNING") -> :nvda
System.get_env("JAWS_RUNNING") -> :jaws
System.get_env("DRAGON_RUNNING") -> :dragon
registry_check("NVDA") -> :nvda
registry_check("JAWS") -> :jaws
true -> nil
end
end
def send_to_nvda(text, options \\ []) do
interrupt = Keyword.get(options, :interrupt, false)
args = if interrupt do
["--interrupt", text]
else
[text]
end
case System.cmd("nvda-speak", args) do
{_output, 0} -> :ok
{error, _} -> {:error, error}
end
end
def send_to_jaws(text, _options \\ []) do
# JAWS integration via COM interface would go here
# For now, use a simple approach
temp_file = Path.join(System.tmp_dir!(), "jaws_speech.txt")
File.write!(temp_file, text)
System.cmd("jfw", ["/say", temp_file])
end
def get_high_contrast_enabled do
# Check Windows high contrast mode
case System.cmd("reg", ["query", "HKCU\\Control Panel\\Accessibility\\HighContrast", "/v", "Flags"]) do
{output, 0} ->
# Parse registry output to check if high contrast is enabled
String.contains?(output, "0x1")
_ ->
false
end
end
defp registry_check(program) do
case System.cmd("tasklist", ["/FI", "IMAGENAME eq #{program}.exe"]) do
{output, 0} -> String.contains?(output, "#{program}.exe")
_ -> false
end
end
end
```
## Best Practices Summary
### Accessibility Development Checklist
- [ ] **Semantic Markup**
- [ ] Use proper HTML elements (button, input, etc.)
- [ ] Include ARIA labels and roles where needed
- [ ] Maintain logical heading structure
- [ ] Provide alternative text for images
- [ ] **Keyboard Accessibility**
- [ ] All functionality available via keyboard
- [ ] Logical tab order
- [ ] Visible focus indicators
- [ ] Keyboard shortcuts don't conflict
- [ ] **Screen Reader Support**
- [ ] Meaningful announcements for state changes
- [ ] Proper form field labeling
- [ ] Error messages are announced
- [ ] Dynamic content changes communicated
- [ ] **Visual Accessibility**
- [ ] Sufficient color contrast (4.5:1 minimum)
- [ ] Information not conveyed by color alone
- [ ] Responsive to zoom levels up to 200%
- [ ] Support for high contrast modes
- [ ] **Motor Accessibility**
- [ ] Large enough touch targets (44px minimum)
- [ ] Sufficient spacing between elements
- [ ] Alternative input methods supported
- [ ] Timeout extensions available
- [ ] **Cognitive Accessibility**
- [ ] Clear and consistent navigation
- [ ] Simple language and instructions
- [ ] Error prevention and clear error messages
- [ ] Consistent UI patterns
## Further Resources
- [WCAG 2.1 Guidelines](https://www.w3.org/WAI/WCAG21/quickref/)
- [Accessible Rich Internet Applications (ARIA)](https://www.w3.org/WAI/ARIA/apg/)
- [Raxol Accessibility Testing](../../test/accessibility/)
- [Platform Accessibility APIs](./platform_accessibility.md)
- [Screen Reader Testing Guide](./screen_reader_testing.md)
---
*Accessibility is an ongoing commitment. This guide evolves with new standards, technologies, and user feedback. Contribute improvements and real-world accessibility patterns.*