Testing Changes

Why Testing Matters

Atlas makes significant modifications to Windows that affect millions of users. Thorough testing ensures:

Changes work as intended across supported Windows builds
No unintended side effects or broken functionality
Performance, privacy, and usability goals are met
The user experience remains smooth and stable

All pull requests must be tested before submission. Untested PRs may be closed without merging.

Testing Environment

Recommended Setup

Best practice: Always test on a virtual machine (VM) or dedicated test system, never on your primary computer.

Test System Requirements

Fresh Windows installation

Start with a clean Windows 11 installation matching a supported build:

Build 26100 (24H2)
Build 26200 (25H2)

Check the playbook.conf file for the current list of supported builds.

System preparation

Before installing your test playbook:

Disable Windows Defender (required by AME Wizard)
Install all pending Windows updates
Connect to the internet
Plug in power (for laptops)
Create a VM snapshot for quick rollback

Install AME Wizard

Download the latest version from amelabs.net

Create a snapshot after preparing Windows but before installing Atlas. This allows you to quickly test multiple iterations.

What to Test

Depending on what you modified, focus your testing on relevant areas:

General Functionality Tests

These should be checked for every contribution:

Installation completes successfully

The playbook installs without errors
AME Wizard doesn’t crash or hang
System reboots successfully
No critical errors in the installation log

System boots and functions

Windows boots normally after installation
Desktop loads without errors
Start menu and taskbar work correctly
File Explorer opens and functions
Settings app is accessible

Core Windows features

Windows Update can check for updates
Microsoft Store opens (if not removed)
Windows Search functions
Task Manager works
Control Panel is accessible

Atlas-specific features

Atlas folder is present in C:\
Atlas scripts execute without errors
Configuration options work as expected
Atlas Desktop launches (if installed)

Category-Specific Tests

Focus on these areas based on your changes:

If you modified performance tweaks:

Check CPU usage at idle and under load
Monitor RAM usage
Test disk I/O performance
Verify startup time improvements
Check for any performance regressions
Test gaming performance (if relevant)

Performance monitoring

# Check running processes
Get-Process | Sort-Object CPU -Descending | Select-Object -First 10

# Monitor system resources
Get-Counter '\Processor(_Total)\% Processor Time'

If you modified privacy settings:

Verify telemetry services are disabled
Check scheduled tasks related to telemetry
Test with network monitoring tools
Verify registry keys are set correctly
Check that user data isn’t being sent

Check telemetry services

# List telemetry-related services
Get-Service | Where-Object { $_.Name -match 'Diag|Track|Telemetry' }

If you added or modified PowerShell scripts:

Run the script multiple times
Test with different user permissions
Verify error handling works
Check script output and logs
Test on both PowerShell 5.1 and 7+
Verify script rollback/undo (if applicable)

Test script execution

# Run with detailed error output
$ErrorActionPreference = 'Stop'
try {
    & 'C:\Atlas\path\to\script.ps1'
} catch {
    Write-Error $_.Exception.Message
}

If you modified registry settings:

Verify registry keys are created/modified correctly
Check registry values have correct data types
Test the effect of the registry changes
Ensure no conflicts with other tweaks
Verify changes persist after reboot

Verify registry changes

# Check specific registry value
Get-ItemProperty -Path 'HKLM:\SOFTWARE\Atlas' -Name 'YourSetting'

Testing Procedures

Step-by-Step Testing Workflow

Build your playbook

Follow the building playbooks guide to create your test .apbx file.

cd src/playbook
./build-playbook.cmd  # Windows
./build-playbook.sh   # Linux/macOS

Restore VM to clean state

Revert your test VM to the pre-Atlas snapshot to ensure a clean test environment.

Install the test playbook

Copy Atlas Test.apbx to your VM
Open AME Wizard
Drag the playbook file into AME Wizard
Follow the installation wizard
Note any errors or warnings during installation

Document observations

During and after installation:

Screenshot any errors
Note unexpected behavior
Record performance metrics if relevant
Check installation logs in C:\ProgramData\AME\Logs

Run verification tests

Execute the relevant tests from the What to Test section based on your changes.

Test edge cases

Test with different Windows language settings
Try with different hardware configurations (if using real hardware)
Test with minimal and maximal feature selections
Verify rollback/undo functionality (if applicable)

Multiple Build Testing

If Atlas supports multiple Windows builds, test on at least one build from each supported version.

Current supported builds (check playbook.conf for latest):

Windows 11 24H2 (Build 26100)
Windows 11 25H2 (Build 26200)

Verification Steps

After installation, verify your specific changes:

Registry Modifications

# Check if your registry changes applied
$path = 'HKLM:\SOFTWARE\Your\Path'
$value = 'YourValue'

if (Test-Path $path) {
    $result = Get-ItemProperty -Path $path -Name $value -ErrorAction SilentlyContinue
    if ($result) {
        Write-Host "✓ Registry value exists: $($result.$value)"
    } else {
        Write-Host "✗ Registry value not found"
    }
} else {
    Write-Host "✗ Registry path not found"
}

Service Status

# Verify service status changes
$serviceName = 'YourService'
$service = Get-Service -Name $serviceName -ErrorAction SilentlyContinue

if ($service) {
    Write-Host "Service: $serviceName"
    Write-Host "Status: $($service.Status)"
    Write-Host "Start Type: $($service.StartType)"
} else {
    Write-Host "✓ Service removed or doesn't exist"
}

Scheduled Tasks

# Check scheduled task modifications
$taskName = 'YourTask'
$task = Get-ScheduledTask -TaskName $taskName -ErrorAction SilentlyContinue

if ($task) {
    Write-Host "Task exists: $($task.State)"
} else {
    Write-Host "✓ Task removed successfully"
}

File Operations

# Verify file copy/deletion
$filePath = 'C:\Path\To\File.exe'

if (Test-Path $filePath) {
    Write-Host "✓ File exists at: $filePath"
    Get-Item $filePath | Select-Object Name, Length, LastWriteTime
} else {
    Write-Host "File not found (expected if removal was intended)"
}

Common Issues and Solutions

Installation fails or hangs

Symptoms: AME Wizard crashes, freezes, or shows errors during installation.Troubleshooting:

Check the live log window (enabled by default in test builds)
Review logs in C:\ProgramData\AME\Logs
Verify YAML syntax in modified configuration files
Check for PowerShell script errors
Ensure all required files are included in the playbook

Changes don't apply

Symptoms: Your modifications don’t take effect after installation.Troubleshooting:

Verify the build script included your changes
Check that file paths in YAML are correct
Ensure registry paths use correct hive names
Verify your changes aren’t being overridden by later actions
Check if a reboot is required for changes to take effect

System becomes unstable

Symptoms: Windows crashes, blue screens, or features stop working.Troubleshooting:

Revert to the pre-Atlas VM snapshot
Review what you changed - was anything critical disabled?
Test changes incrementally (disable some tweaks to isolate the issue)
Check if your changes conflict with other Atlas tweaks
Verify you’re not disabling essential Windows services

Performance regressions

Symptoms: System is slower after your changes.Troubleshooting:

Identify which specific change caused the regression
Test without your changes to establish a baseline
Monitor resource usage to find bottlenecks
Consider whether the tradeoff is acceptable
Document performance impact clearly in your PR

Documenting Test Results

When submitting your pull request, include:

Test Summary

## Testing

**Environment**:
- Windows version: Windows 11 Build 26100 (24H2)
- VM software: Hyper-V
- RAM: 8GB
- Atlas options: Default selections

**Tests performed**:
- ✓ Clean installation completed successfully
- ✓ System boots normally
- ✓ Modified registry keys verified
- ✓ Target service disabled correctly
- ✓ No errors in installation logs
- ✓ Performance impact: negligible

**Screenshots**: [Attach relevant screenshots]

**Logs**: [Include relevant log excerpts if there were any issues]

Before/After Comparisons

For measurable changes, provide before/after data:

**Memory usage at idle**:
- Before: 3.2 GB
- After: 2.8 GB
- Improvement: ~400 MB reduction

**Startup time**:
- Before: 42 seconds
- After: 38 seconds
- Improvement: ~4 seconds faster

Automated Testing

While manual testing is essential, consider:

Writing PowerShell validation scripts for complex changes
Using AME Wizard’s verification features
Creating checklists for repetitive test procedures
Documenting expected vs. actual behavior

Example validation script

# validation.ps1 - Test your changes automatically

$errors = @()

# Test 1: Registry key
if (-not (Test-Path 'HKLM:\SOFTWARE\Atlas\Setting')) {
    $errors += "Registry key not found"
}

# Test 2: Service status
$service = Get-Service 'ServiceName' -ErrorAction SilentlyContinue
if ($service -and $service.Status -eq 'Running') {
    $errors += "Service should be disabled"
}

# Test 3: File exists
if (-not (Test-Path 'C:\Atlas\file.txt')) {
    $errors += "Expected file not found"
}

if ($errors.Count -eq 0) {
    Write-Host "✓ All tests passed" -ForegroundColor Green
} else {
    Write-Host "✗ Tests failed:" -ForegroundColor Red
    $errors | ForEach-Object { Write-Host "  - $_" }
}

Additional Testing Resources

Building Playbooks

Learn how to build your test playbook.

Contribution Guidelines

Review the full contribution guidelines.

Atlas Documentation

Browse user-facing documentation for context.

AME Wizard Docs

Learn about AME Wizard’s capabilities and actions.

Remember: Thorough testing protects millions of Atlas users from issues. Take the time to test properly!

Getting Started

Features

Configuration

FAQ & Troubleshooting

Contributing

Testing Changes

Why Testing Matters

Testing Environment

Recommended Setup

Test System Requirements

What to Test

General Functionality Tests

Category-Specific Tests

Testing Procedures

Step-by-Step Testing Workflow

Multiple Build Testing

Verification Steps

Registry Modifications

Service Status

Scheduled Tasks

File Operations

Common Issues and Solutions

Documenting Test Results

Test Summary

Before/After Comparisons

Automated Testing

Additional Testing Resources

Building Playbooks

Contribution Guidelines

Atlas Documentation

AME Wizard Docs

Build docs developers (and LLMs) love

Getting Started

Features

Configuration

FAQ & Troubleshooting

Contributing

​Why Testing Matters

​Testing Environment

​Recommended Setup

​Test System Requirements

​What to Test

​General Functionality Tests

​Category-Specific Tests

​Testing Procedures

​Step-by-Step Testing Workflow

​Multiple Build Testing

​Verification Steps

​Registry Modifications

​Service Status

​Scheduled Tasks

​File Operations

​Common Issues and Solutions

​Documenting Test Results

​Test Summary

​Before/After Comparisons

​Automated Testing

​Additional Testing Resources

Building Playbooks

Contribution Guidelines

Atlas Documentation

AME Wizard Docs

Build docs developers (and LLMs) love

Why Testing Matters

Testing Environment

Recommended Setup

Test System Requirements

What to Test

General Functionality Tests

Category-Specific Tests

Testing Procedures

Step-by-Step Testing Workflow

Multiple Build Testing

Verification Steps

Registry Modifications

Service Status

Scheduled Tasks

File Operations

Common Issues and Solutions

Documenting Test Results

Test Summary

Before/After Comparisons

Automated Testing

Additional Testing Resources