VOOZH about

URL: https://www.coursera.org/learn/introduction-software-testing?specialization=software-testing-automation

⇱ Introduction to Software Testing | Coursera

Introduction to Software Testing

Keep adding new skills with 10,000+ programs for $239 (usually $399). Save now.

Introduction to Software Testing

132,985 already enrolled

Included with

Ask Coursera

Gain insight into a topic and learn the fundamentals.
4.3

832 reviews

Intermediate level

Recommended experience

Flexible schedule
3 weeks at 10 hours a week
Learn at your own pace
91%
Most learners liked this course
Gain insight into a topic and learn the fundamentals.
4.3

832 reviews

Intermediate level

Recommended experience

Flexible schedule
3 weeks at 10 hours a week
Learn at your own pace
91%
Most learners liked this course

What you'll learn

  • You will gain an understanding of the theory of testing.

  • You will practice writing tests for a variety of quality intent, including code coverage, defect finding, and statistical testing.

  • You will develop test plans to guide the testing stage of the software development lifecycle.

  • You will create defect reports to provide transparency and understanding to supervisors, colleagues, and users.

Details to know

Shareable certificate

Add to your LinkedIn profile

Assessments

26 assignments¹

AI Graded see disclaimer
Taught in English

Build your subject-matter expertise

This course is part of the Software Testing and Automation Specialization
When you enroll in this course, you'll also be enrolled in this Specialization.
  • Learn new concepts from industry experts
  • Gain a foundational understanding of a subject or tool
  • Develop job-relevant skills with hands-on projects
  • Earn a shareable career certificate

There are 4 modules in this course

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.

In this module, you will be introduced to the basics of testing, especially the variety of terminology to be used through the rest of the course.

What's included

6 videos1 reading5 assignments1 programming assignment2 discussion prompts

6 videos•Total 66 minutes
  • Welcome to the Software Testing and Automation! •3 minutes
  • Introduction•12 minutes
  • Why is software testing challenging?•12 minutes
  • What is a Test?•6 minutes
  • Automation: Using a test framework•11 minutes
  • Automation: Writing JUnit tests•22 minutes
1 reading•Total 5 minutes
  • Welcome to the course!•5 minutes
5 assignments•Total 150 minutes
  • Overview•30 minutes
  • On the difficulty of software testing•30 minutes
  • What is a Test?•30 minutes
  • Automation: Using a Test Framework•30 minutes
  • Automation: Writing JUnit Tests•30 minutes
1 programming assignment•Total 180 minutes
  • Building Unit Tests•180 minutes
2 discussion prompts•Total 20 minutes
  • On coverage testing•10 minutes
  • On Test-Driven Development•10 minutes

In this module, you will investigate a variety of testing principles, models of testing, and types of systematic testing strategies.

What's included

8 videos8 assignments2 discussion prompts

8 videos•Total 57 minutes
  • Dependability Definitions•15 minutes
  • Testing Principles•6 minutes
  • Testing Principles: Where•13 minutes
  • Testing Principles: How•9 minutes
  • The "V Model" of Software Development•4 minutes
  • Validation and Verification in the "V Model"•4 minutes
  • Structural Testing•4 minutes
  • Mutation Testing•3 minutes
8 assignments•Total 218 minutes
  • On Basic Testing Terminology, Dependability, and Testing Principles•30 minutes
  • Dependability Quiz•30 minutes
  • Testing Principles: Where•30 minutes
  • Testing Principles: How•30 minutes
  • The V-Model Quiz•8 minutes
  • Validation and Verification in the "V-Model" Quiz•30 minutes
  • Structural Testing•30 minutes
  • Mutation Testing•30 minutes
2 discussion prompts•Total 20 minutes
  • Testing Principles: Why?•10 minutes
  • Testing: Commonality vs. Specificity•10 minutes

In this module, you will learn about the social aspects of testing. We will learn about test plans, testing status reports, and defect reporting.

What's included

10 videos10 assignments1 peer review

10 videos•Total 49 minutes
  • What is a test plan?•5 minutes
  • Importance of a Good Test Plan•5 minutes
  • Stages of Software Testing Process•2 minutes
  • Test (Status) Reports•3 minutes
  • Risk-based Test Planning•6 minutes
  • Software Defect Reports•2 minutes
  • Software Defect Reports: Analysis•4 minutes
  • Software Defect Reports: Reporting•4 minutes
  • Software Defect Reports: Report Content•15 minutes
  • Software Defect Reports: Track, Retest, and Close•3 minutes
10 assignments•Total 240 minutes
  • What is a Test Plan?•30 minutes
  • Importance of a Good Test Plan•30 minutes
  • Stages of Software Testing Process•30 minutes
  • Test (Status) Reports•0 minutes
  • Risk Based Test Planning•0 minutes
  • Software Defect Reports•30 minutes
  • Software Defect Reports: Analysis•30 minutes
  • Software Defect Reports: Reporting•30 minutes
  • Software Defect Reports: Report Content•30 minutes
  • Software Defect Reports: Track, Retest, and Close•30 minutes
1 peer review•Total 180 minutes
  • Building a test plan•180 minutes

In this module, you will learn about writing unit tests and gain practice in writing these tests through three coding assignments, each with additional testing sophistication.

What's included

5 videos3 assignments3 programming assignments

5 videos•Total 77 minutes
  • Test Doubles: Introduction•11 minutes
  • Test Doubles: Input•19 minutes
  • Test Doubles: Output•15 minutes
  • Assessing Adequacy and Code Coverage Analysis with JaCoCo•10 minutes
  • Flakey Tests and How to Avoid Them•23 minutes
3 assignments
  • Test Doubles: Introduction•0 minutes
  • Test Doubles: Input•0 minutes
  • Test Doubles: Output•0 minutes
3 programming assignments•Total 540 minutes
  • Writing Unit Tests for the Coffee Maker•180 minutes
  • Checking Coverage with JaCoCo•180 minutes
  • Adding Mocks and Stubs•180 minutes

Earn a career certificate

Add this credential to your LinkedIn profile, resume, or CV. Share it on social media and in your performance review.

Instructors

Instructor ratings
4.5 (283 ratings)
University of Minnesota
2 Courses•142,749 learners

Explore more from Software Development

Why people choose Coursera for their career

👁 Image

Felipe M.

Learner since 2018
"To be able to take courses at my own pace and rhythm has been an amazing experience. I can learn whenever it fits my schedule and mood."
👁 Image

Jennifer J.

Learner since 2020
"I directly applied the concepts and skills I learned from my courses to an exciting new project at work."
👁 Image

Larry W.

Learner since 2021
"When I need courses on topics that my university doesn't offer, Coursera is one of the best places to go."
👁 Image

Chaitanya A.

"Learning isn't just about being better at your job: it's so much more than that. Coursera allows me to learn without limits."

Learner reviews

  • 5 stars

    62.62%

  • 4 stars

    21.87%

  • 3 stars

    7.21%

  • 2 stars

    2.64%

  • 1 star

    5.64%

Showing 3 of 832

BS
·

Reviewed on Sep 7, 2021

Quite challenging yet very educating course. The practice assignments are very good hands-on example and provides insight into testing

WM
·

Reviewed on Jan 2, 2021

Expected knowledge of programming and use of Eclipse is more than I expect for this course. I cannot find where I can donwload the sources mentioned in the week 4 videos.

AZ
·

Reviewed on Jan 19, 2022

Course itself is very good. Minus one star for assignments where without forum help you are not capable to gain 10/10, even though tests are successful on your Pc

Frequently asked questions

You'll learn how to think about software quality and test software in a systematic way, not just how to run a few checks. It starts with core ideas like verification and validation, then builds into test design, white-box and black-box testing, and where testing fits in the development process. You'll apply that by writing test cases for small Java programs, automating some of them, and judging whether those tests are actually strong enough.

Yes, some Java experience is expected, or at least a similar object-oriented language plus the ability to pick up Java syntax quickly. The course moves into writing and automating tests rather than teaching programming basics, and it also assumes some familiarity with the software development lifecycle. If you're comfortable reading small classes and methods, you'll be in good shape.

It can be beginner-friendly if you're new to software testing but not new to programming. The ideas are introduced clearly, but the course is intermediate and expects you to work with Java code and development process concepts fairly early. If you're completely new to coding, this will probably feel like too big a jump.

Plan on about 30 hours in total, or roughly 3 weeks if you study around 10 hours a week. That gives you time to move through the lessons steadily and still make room for quizzes and coding practice. The course includes lessons, quizzes, programming assignments, a peer-reviewed test plan, and discussion prompts.

Yes, there is hands-on work, but it's mostly guided assignment work rather than a large open-ended project. You'll write and improve unit tests for small Java programs, including a buggy coffee maker class, and practice using test doubles to isolate behavior. That makes the course useful if you want to apply each testing idea as you learn it.

It covers the main ideas behind software testing, how testing supports the development lifecycle, and how to communicate results clearly. You'll learn white-box and black-box testing, test plans, defect reports, and ways to judge whether a test suite is thorough enough. By the end, you should have a clearer sense of how to design, evaluate, and explain a testing approach.

After finishing, you should be able to write stronger unit and integration tests, assess whether a test suite is finding meaningful faults, and report defects clearly. For example, you could take a small Java class, create test cases with expected outcomes, automate them, and check how well the suite covers the code. You'll also be able to contribute to a basic test plan and communicate test results in a more structured way.

It's more concept-first with guided practice than project-heavy. The course spends a lot of time explaining how testing works and where it fits in development, then reinforces those ideas with structured coding assignments and quizzes.

This course is a strong choice if you want software testing taught as both an engineering skill and a team process. Instead of stopping at unit test syntax, it connects core testing ideas with test planning, risk, status reporting, and defect reporting, while still giving you guided Java-based practice. If you want to understand why testing decisions matter and also practice writing better tests, this course is likely a better fit than a narrower tool-only option.

Financial aid available,

¹ Some assignments in this course are AI-graded. For these assignments, your data will be used in accordance with Coursera's Privacy Notice.