In recent years, we have witnessed the growing importance of software test automation. In particular, the creation of automated test scripts has seen an increasing emphasis and interest in industry. Automated test scripts provide many benefits, such as repeatable, predictable, and efficient test executions. To achieve a high level of automation, test engineers write programs using scripting languages (e.g., JavaScript and VBScript); these programs (or test scripts) mimic users by performing actions on the application user interface, using an underlying testing framework. The extra effort put in writing test scripts is paid off when these scripts are run repeatedly during regression test cycles. However, creating automated scripts from manual test cases can be tedious and can require significant up-front investment. Currently, testing frameworks are used to generate skeleton code of test scripts, e.g., using record-and-replay techniques. However, adding customization code to these skeleton scripts still requires significant manual effort. In addition, using these frameworks leads to monolithic test scripts, which are difficult to maintain and evolve.

Moreover, after the initial development, like any software system, the test scripts require continuous maintenance. For example, the scripts created using commonly used methods, such as record-replay and keyword-driven frameworks, are extremely fragile: simple changes in the application user interface can cause the scripts to break. Test scripts routinely use test data, which are often maintained and evolved separately. Thus, test scripts have a lifecycle---involving different development, maintenance, and validation activities---and must co-evolve with the application. To perform such activities efficiently (especially when the test suite of an application grows over time to consist of tens of thousands of scripts), the development of appropriate tools, techniques, and methods that encompass the entire test-script lifecycle is essential.

More generally, aspects of software engineering that are pertinent for general applications can be significant for test scripts too. For example, modularity and reuse, which are important tenets in software engineering, are equally relevant in test-script development: test scripts can contain common actions and, therefore, extracting these actions into reusable subroutines can simplify maintenance. Similarly, like a general application, a complex test script may require adequate validation to ensure that it performs the intended actions. Thus, could "testing a test" be an important aspect that requires the development of appropriate techniques? The goal of this workshop is to explore such questions and take a holistic view of the problems related to test-script engineering. The main topics of interest include, but are not limited to:

• Novel models, languages, and implementation techniques for test scripts
• Maintenance aspects of test scripts such as reuse, modularization, and parametrization of test scripts
• Formal aspects of addressing correctness of test scripts (semantics, reasoning, verification)
• Fault localization and repair for test scripts
• Test automation frameworks
• Capture-replay techniques
• Mining large repositories of test scripts for maintenance and evolution
• Applications of software test automation technologies in different domains
• Industrial points of view: experiences, applications in different domains, open issues

ETSE 2012 with be co-located with the 2012 International Symposium on Software Testing and Analysis (ISSTA 2012). The official homepage has more information, including submission details.