Platforms
Automating browsers, desktop applications, iOS, Android, Flutter, Avalonia and APIs — what each platform makes easy, what it makes hard, and what the tooling looks like.
8 articles · updated 19 September 2026
The practices are portable. The tooling is not. What "click the button" costs, how you find the button in the first place, and whether you can run a hundred of them at once varies enormously depending on what the application is made of.
#The thing that varies
Every platform has an accessibility tree or an equivalent, and the quality of your automation is very nearly a function of how good that tree is and how much of it the framework exposes.
- The browser has the best one in existence. The DOM is queryable, roles and names are standardised, and three mature drivers compete to expose it.
- iOS and
Android have good ones —
XCUITestandUIAutomatorrespectively — reachable in one API through Appium, or natively if you can live inside one platform. - Flutter renders to a canvas and has no native tree at all, so it supplies its own finder API and its own test harness. Nothing from the browser world applies.
- Avalonia is the interesting case: a cross-platform .NET UI framework with a headless test platform, which means desktop UI tests that run in CI in milliseconds with no display server.
- Desktop generally — WinAppDriver, WinUI, WPF, Electron — is where automation is hardest, because the tree is often an afterthought and there is no equivalent of the browser's tooling.
#Below the UI
API testing belongs here too, and is the level most teams under-invest in relative to its value: the same behaviour, tested an order of magnitude faster and more reliably, with none of the rendering. A great deal of what teams write at the end-to-end level is a slow, flaky restatement of an API assertion.
#Browsers plural
Cross-browser testing has changed shape: the engine count is down to three and the differences that break real applications are mostly in layout, fonts and input handling rather than JavaScript semantics. Running your entire suite on three engines is usually the wrong trade — the article covers what to run where.
Everything in Platforms
Browser Testing
foundationWhat a browser test can prove that nothing below it can, the three engines that matter, headless versus headed, and the cost model that should shape your suite.
Cross-Browser Testing
practicalWhich browsers actually need testing in 2026, what still differs between engines, and a strategy that catches real defects without tripling your pipeline.
API Testing
foundationTesting HTTP and message interfaces directly — the level most teams under-invest in relative to its value, and how it replaces most slow end-to-end tests.
Desktop Application Testing
practicalAutomating WPF, WinUI, WinForms, Electron and native desktop apps — the accessibility trees, the tooling, and why desktop UI automation is harder than the web.
Testing Avalonia Applications
advancedAvalonia's headless test platform runs real UI tests in CI in milliseconds with no display server — the most testable desktop stack in .NET.
iOS App Testing
practicalXCTest, Swift Testing, XCUITest and the accessibility identifiers that make UI automation possible — plus what to run on a simulator and what needs a device.
Android App Testing
practicalJUnit and Robolectric for local tests, Espresso and Compose for instrumented UI, and the emulator strategy that keeps an Android suite affordable in CI.
Flutter Testing
practicalFlutter renders to a canvas with no native accessibility tree, so it brings its own three-layer test harness — unit, widget and integration — plus golden files.