Spécialisation Software Testing and Automation

After completing this course, you will have an understanding of the fundamental principles and processes of software testing. You will have actively created test cases and run them using an automated testing tool. You will being writing and recognizing good test cases, including input data and expected outcomes.

After completing this course, you will be able to… - Describe the difference between verification and validation. - Explain the goal of testing. - Use appropriate test terminology in communication; specifically: test fixture, logical test case, concrete test case, test script, test oracle, and fault. - Describe the motivations for white and black box testing. - Compare and contrast test-first and test-last development techniques. - Measure test adequacy using statement and branch coverage. - Reason about the causes and acceptability of and poor coverage - Assess the fault-finding effectiveness of a functional test suite using mutation testing. - Critique black-box and white-box testing, describing the benefits and use of each within the greater development effort. - Distinguish among the expected-value (true), heuristic, consistency (as used in A/B regression), and probability test oracles and select the one best-suited to the testing objective. - Craft unit and integration test cases to detect defects within code and automate these tests using JUnit. To achieve this, students will employ test doubles to support their tests, including stubs (for state verification) and mocks (for behavioral verification) (https://martinfowler.com/articles/mocksArentStubs.html). This course is primarily aimed at those learners interested in any of the following roles: Software Engineer, Software Engineer in Test, Test Automation Engineer, DevOps Engineer, Software Developer, Programmer, Computer Enthusiast. We expect that you should have an understanding of the Java programming language (or any similar object-oriented language and the ability to pick up Java syntax quickly) and some knowledge of the Software Development Lifecycle.

After completing this course, learners will have an understanding of a variety of black-box and white-box testing techniques. The learner will have put this understanding into practice, creating effective sets of test cases (called a test suite) to properly exercise software for defect finding. The learner will have examined requirements for testability, created an oracle for automated testing, assessed fault-finding effectiveness of test suites, and generated inputs using a variety of techniques.

After completing this course, you will be able to: - evaluate testability of requirements - define testable units within a program specification - apply black-box test input selection methods - specifically boundary-value analysis, fuzzing, and random selection - and select the method most-suited to achieve the given testing objective - assess the fault-finding effectiveness of a functional test suite using mutation testing - use category partitioning to develop automated functional tests (with Cucumber) based on a given software specification - create an expected-value oracle from a program description to use within the generated tests In order to do well in this course, you should have experience with an OOP language (like Java), have an IDE installed (e.g., Eclipse), and be familiar with testing terminology (see Intro to Software Testing course within this specialization). we also expect a familiarity with the Software Development Lifecycle and the context in which the testing stage sits. This course is primarily aimed at those learners interested in any of the following roles: Software Engineer, Software Engineer in Test, Test Automation Engineer, DevOps Engineer, Software Developer, Programmer, Computer Enthusiast.

This course introduces state-of-the-art techniques for automated analysis. Automated analysis encompasses both approaches to automatically generate a very large number of tests to check whether programs meet requirements, and also means by which it is possible to *prove* that software meets requirements and that it is free from certain commonly-occurring defects, such as divide-by-zero, overflow/underflow, deadlock, race-condition freedom, buffer/array overflow, uncaught exceptions, and several other commonly-occurring bugs that can lead to program failures or security problems. The learner will become familiar with the fundamental theory and applications of such approaches, and apply a variety of automated analysis techniques on example programs.

After completing this course, a learner will be able to: - Understand the foundations of automated verification: randomization and symbolic representations - Distinguish the strengths and weaknesses of random testing, symbolic analysis, static analysis, and model checking - Use a variety of state-of-the-art static analysis and automated testing tools for automated verification - Create executable requirements as an oracle suitable for automated testing and symbolic analysis - Understand how the choice of oracle affects fault-finding for automated analysis strategies. - Use automated testing to achieve full mutation coverage - Create a test plan that utilizes both manually-written tests and automated tests towards maximizing rigor, minimizing effort and time, and minimizing test costs. This course is intended for learners interested in understanding the principles of automation and the application of tools for analysis and testing of software This knowledge would benefit several typical roles: Software Engineer, Software Engineer in Test, Test Automation Engineer, DevOps Engineer, Software Developer, Programmer, Computer Enthusiast. We expect that you have some familiarity with the Software development Life-Cycle, an understanding of the fundamentals of software testing, similar to what is covered in the Introduction to Software Testing and Black-box and White-Box Testing Courses. Familiarity with an object-oriented language such as Java or ability to pick-up Java syntax quickly to write and modify code, and willingness to use tools and IDEs are assumed.