We'll look at the basic approaches to refactoring in order to cover the legacy code with automated tests, and also consider their interaction. You will learn how to choose solutions that allow you to make reliable changes by creating a "reliability grid" around the modifiable module.

How to choose Static Application Security Testing system.

We'll cover the main tools from developers' armory and show how we can combine them to solve testing tasks. Together we'll go all the way from designing the Perfect Test till launching the cleanest and clearest test possible for the system of sources planning based on Kotlin.

In order to keep up testers' reputation and the image of the testing profession, we'll point the way towards developing technical skills, socials skills, and most importantly thinking skills that can build respect for testing and increase testers’ effectiveness.

A microscopic examination of common interface components and problems appearing and tested in responsive user interfaces.

In this talk we’ll share how we look for functional problems in the compiler of Zing Java machine, using automatic generator of test programs on Java.

We'll look at the new major version of Allure test report. This talk will be useful both for those who are not familiar with Allure and for active users.

This talk is about our approach to building new CI from scratch. What we tried, what didn't work, what types of issues we faced.

Come and learn how easy it is to run tests in parallel with tools like fbsimctl and how separating tests from infrastructure might ease adoption of your tests, maintenance, and scaling of infrastructure.

We’ll speak about the shortcomings of the first implementations of HtmlElements and why we refused to use any existing solutions and created our own. We’ll show the functionality on which Atlas is based, how it transformed old projects and how to use existing extension points for your own projects.

We'll look at our experience in setting up crowdtesting in Yandex and highlight major steps of this process: how to select and train performers; how to control quality; how to prepare the infrastructure for testing with a crowd; how to combine crowd force with highly qualified in-house QA specialists.

We'll cover the simple course of action that allows you to make your web application safer: how to search for vulnerabilities, what threats to users and services they may contain and so forth.

We'll look at the problems of generating, loading and cleaning test data; maintenance of multiple HTTP clients; verification that the whole cluster of microservices is ready for testing at the beginning and during the execution of tests.

We'll discuss how we write Java unit-tests for configuration, how we benefit from them, pitfalls and workarounds.

In this live-coding session, you'll learn the basics of Spock and you'll see how easily you can test a Java application.

Using real-life examples, we'll show you how we didn`t just replace the annotations but got rid of the first "A" in the "AAA" abbreviation (Arrange – Act – Assert).

Best kind of tests are ones that cost almost nothing, yet find defects. We’ll talk about two Java tools (EqualsVerifier library and ErrorProne) that are close to this ideal.

This is a story about building a dam against the never-ending flood of millions of tests which turned out to be not that scary. You are very welcome to join and see it for yourself.

We'll outline the logic of verification and ways in which we might be vulnerable to false premises and misleading conclusions about it. We’ll also identify ways that we can address those problems by embedding verification in a larger system of testing, experimentation and critical thinking.

Let’s see how with the help of open source solutions we can quickly organize E2E tests that will work both in the web and in mobile applications. The approach will be demonstrated on the Python stack, but can easily be transferred to another stack.

From practically writing code to test genuine production level scenarios with different approaches to incredibly optimising your tests cases, we will see what’s new in Android Test Support Library 1.0 and how to test on multiple devices.

This talk shows cases with many practical examples how test automation with Selenium boils down to being a full-blown software project, along with the major pitfalls that prevent teams to build a scalable and reliable automation solution with the Selenium tool family. You'll also learn how to apply a lean approach in making test automation with Selenium a full success.

We'll introduce you a few blockchain protocols, along with a brief description of Waves platform features. We'll also give you examples of issues which could be found and tools that we use for testing.

Come and learn about the mobile test automation tools, the reason why we love Cucumber (BDD), how we killed the flakiness of the tests, how we overcome the challenges of keeping releases' speed, and why involving manual QA in automation is the most important thing.

We'll discuss how containers can simplify the many different flavors of mobile app builds, how to utilize parallelization to speed up build and test execution time, and how the choice of a CI system can improve the efficiency of the entire CI/CD pipeline.

We'll discuss how to layer tests respectively in order to build a pyramid, multiple pyramids, application architecture choice, as well as which kinds of mocks aid in building good-quality testing and which don't.

We'll start with a basic introduction to JUnit 5 and the JPMS (Java Platform Module System) and then present the three approaches for executing tests when using the JPMS from the command line.

We’ll recast the software development lifecycle as a conversation about risk. We’ll discuss the position of testers in a team, the role of testing, and the place that automation has in the conversation that is software development as a mechanism for assuaging the fear of risk.

We'll look at the issues of using Appium default tools and gamescenes graphs for autotests implementation. Using real-life examples, we'll explain how it works in Zeptolab and how our expertise might be useful in other projects.

We'll touch on how we started moving from usual tests to model-based testing, what problems we faced during this transition, why we use Petri net instead of state and what we ended up with. The talk is illustrated with examples of Petri nets and plenty of Ruby code.

We'll look at how beta testing in VK started, how we test major updates and completely new products, our tools and platform, how to manage 12 thousand testers, handle tens of thousands of bug reports and effectively integrate beta testing into the product development process.