PCET™ – Certified Entry-Level Tester with Python: EXAM SYLLABUS

Objectives covered by the block (6 exam items)

1.1 Understand the Definition and Purpose of Software Testing

• Define software testing as the process of verifying that software meets its intended requirements.
• Explain why software testing is critical for identifying defects and improving software quality.
• Explore key traits of testing, such as defect detection, failure prevention, and quality feedback.
• Discuss the limitations of testing, including the impossibility of proving the absence of all defects.

1.2 Understand the Relationship Between Errors, Defects, and Failures

• Explain the chain of issues: errors (human mistakes), defects (bugs), and failures (incorrect software behavior).
• Use real-world examples to demonstrate how defects can cause failures in software systems.
• Examine how testing breaks the chain by detecting defects early, preventing failures.

1.3 Understand the Role of Testing in the Software Development Lifecycle

• Evaluate the risks of not testing software, including financial loss, damage to customer trust, loss of reputation, legal liabilities, and potential safety risks.
• Explain how software testing, particularly automated testing, improves development efficiency and product quality.
• Discuss the long-term cost benefits of early defect detection in reducing support costs after release.
• Compare how testing is handled in different development methodologies: Waterfall (late-stage testing), Agile (continuous testing), and DevOps (automated testing throughout).
• Apply the concept of Shift-Left Testing, where testing is introduced early to catch issues before they become costly to fix.
• Assess the advantages and challenges of continuous testing in fast-paced Agile and DevOps environments.
• Explore challenges faced by testers, including limited time, resources, and constantly changing project requirements.
• Discuss the importance of close collaboration between analysts, designers, testers, developers, and product owners to ensure software quality.
• Evaluate how testers contribute to the development process by writing automated tests, performing manual tests, and identifying high-risk areas of code.

1.4 Understand Key Software Testing Principles and Apply Them to Real-World Scenarios

• Describe how testing helps identify defects but cannot ensure perfection.
• Discuss why it’s important to focus testing on critical and high-risk areas.
• Analyze how focusing on specific areas of the software during testing can lead to more efficient defect detection.
• Examine how evolving test cases and strategies over time ensures that tests remain effective in identifying issues.
• Assess whether the testing strategy incorporates early detection of defects, risk-based prioritization, and appropriate resource allocation.
• Determine if the testing strategy is adaptable to different contexts and software types.
• Design a testing workflow that prioritizes early testing and focuses on the areas most likely to contain defects.
• Update testing procedures regularly to ensure that defects are consistently identified and addressed.

Objectives covered by the block (8 exam items)

2.1 Understand the Types of Software Testing and Apply Them Appropriately

• Define manual and automated testing, explaining when each is appropriate based on the project's needs, goals, and resources.
• Differentiate between functional testing and non-functional testing.
• Apply manual testing for exploratory, creative tasks and automated testing for repetitive, high-volume tasks like regression testing or frequent validation.
• Evaluate how different types of testing contribute to ensuring software quality throughout the development lifecycle.

2.2 Understand and Apply the Levels of Testing

• Explain the levels of testing, including unit testing, integration testing, system testing, and acceptance testing.
• Apply each level of testing in scenarios such as verifying a module in isolation (unit testing) or ensuring end-to-end functionality across the entire application (system testing).
• Analyze the importance of these levels in catching defects early and preventing issues in later stages of the development cycle.

2.3 Understand the Test Pyramid and its Role in Efficient Test Strategy

• Define the Test Pyramid and explain how it guides an efficient testing strategy by emphasizing more unit tests (fast and inexpensive), fewer integration tests, and the least number of end-to-end tests (slower, more costly).
• Apply the Test Pyramid approach to prioritize testing activities based on cost and efficiency, ensuring that the majority of tests focus on small, fast units.
• Analyze real-world applications of the Test Pyramid in agile development, where continuous testing is critical.

2.4 Understand the Testing Process and Apply Structured Approaches

• Define the key phases of the testing process: Test Planning, Test Design, Test Environment Setup, Test Execution, Test Reporting, and Test Closure.
• Apply the steps of the testing process to plan and execute comprehensive test strategies for software projects.
• Evaluate how following a structured process ensures that tests are comprehensive, that defects are identified early, and that testing efforts are well-documented for future reference.

2.5 Understand and Create Effective Test Documentation

• Define and explain the purpose of core test documentation: test plans, test cases, test scenarios, and test reports.
• Demonstrate the ability to create a detailed test plan that outlines scope, objectives, schedule, and resources.
• Develop and execute test cases that include steps, expected results, and actual outcomes to ensure thorough testing.
• Analyze test reports to communicate testing results, highlighting any defects, coverage, and recommendations for improvements.

2.6 Understand and Utilize Test Doubles in Isolated Testing

• Define test doubles (e.g., dummies, stubs, fakes, spies, and mocks) and explain their importance in isolating units of code during testing.
• Apply test doubles to simulate dependencies, such as replacing a database with a stub, to make unit tests faster and more reliable.
• Analyze the appropriate use of test doubles in different types of testing, such as unit testing versus integration testing, to ensure isolation and accurate test results.

Objectives covered by the block (10 exam items)

3.1 Understand and Apply Static Testing Techniques

• Define static testing and explain its purpose in identifying issues early in the development lifecycle without executing code.
• Differentiate between various static testing techniques, such as code reviews, walkthroughs, and inspections.
• Use static analysis tools, such as linters, to detect syntax errors, security vulnerabilities, and adherence to coding standards (e.g., PEP 8 in Python).
• Analyze the benefits of static testing in terms of improving code quality and catching issues early in the development process.

3.2 Understand and Apply Dynamic Testing Techniques

• Define dynamic testing and explain its role in validating the functionality of the software during execution.
• Differentiate between levels of dynamic testing, including unit testing, integration testing, system testing, and acceptance testing.
• Apply dynamic testing methods in various scenarios, such as verifying individual units of code (unit testing) or testing the integration of components (integration testing).
• Evaluate how dynamic testing contributes to identifying defects that may only arise during code execution.

3.3 Understand the Role of Code Quality and Standards in Static Testing

• Define code quality and explain the importance of maintaining high-quality code through adherence to standards like PEP 8.
• Apply PEP 8 guidelines to ensure consistency and readability in Python code, including proper use of indentation, naming conventions, and line length.
• Use tools like linters to automate the enforcement of coding standards and improve code quality.
• Analyze how maintaining good code quality leads to easier maintenance, fewer bugs, and better collaboration among development teams.

3.4 Perform Static Analysis to Improve Code Quality

• Explain the purpose of static analysis in identifying potential issues in code without executing it.
• Apply static analysis tools, such as Pylint or Flake8, to detect dead code, unused variables, formatting issues, and potential bugs.
• Refactor code based on static analysis results, improving its readability, maintainability, and performance.
• Evaluate the role of static analysis in preventing defects and reducing the time spent on debugging during dynamic testing.

3.5 Understand and Apply Test Coverage and Metrics

• Define test coverage and explain its importance in measuring the effectiveness of testing efforts.
• Differentiate between types of test coverage, such as line coverage, branch coverage, and method coverage.
• Apply tools to measure test coverage and ensure that the most critical parts of the code are thoroughly tested.
• Analyze how achieving high test coverage helps reduce the risk of undetected bugs and improves software reliability.

3.6 Understand and Implement Effective Code Refactoring

• Define code refactoring and explain its role in improving the internal structure of the code without changing its external behavior.
• Implement code refactoring techniques to simplify complex functions, improve readability, and ensure the code adheres to best practices.
• Understand and apply the AAA pattern in unit testing.
• Apply the DRY (Don't Repeat Yourself) principle to reduce duplication and improve code maintainability.
• Follow the KISS principle to keep code simple and focused on solving the problem at hand without adding unnecessary complexity.
• Analyze the benefits of code refactoring in terms of reducing technical debt and making the code easier to extend and maintain over time.

Objectives covered by the block (11 exam items)

4.1 Understand and Apply Debugging Techniques

• Define debugging and explain its role in identifying and fixing issues in a program.
• Apply print debugging to trace variables and understand the program flow, using simple print statements for small-scale problems.
• Use advanced debugging tools like an IDE debugger, breakpoints, and step-by-step execution to handle more complex scenarios where print debugging becomes overwhelming.
• Evaluate the role of debugging in improving code quality and software functionality by identifying issues early.

4.2 Understand and Apply Assertions in Code

• Define assertions and explain their role in verifying that a program behaves as expected.
• Apply assertions to automatically check code conditions and trigger errors when conditions are not met.
• Work with multiple assertions, handling different return values or conditions to improve debugging effectiveness.
• Analyze the role of assertions as self-documenting code that makes the program’s expectations clear and improves maintenance.

4.3 Understand and Apply Logging for Debugging and Testing

• Define logging and its importance in tracking program behavior during execution.
• Apply logging using print statements, assertions, and Python's logging module for different levels of logging (DEBUG, INFO, WARNING, ERROR, CRITICAL).
• Analyze how logging helps identify errors, track the execution flow, and understand program behavior in complex systems.

4.4 Understand and Apply White Box Testing Techniques

• Define white box testing and explain its focus on testing internal logic and structure.
• Apply white box testing techniques like statement coverage, branch coverage, path coverage, and loop testing to ensure every part of the code is tested thoroughly.
• Analyze how white box testing contributes to identifying potential issues in code logic, paths, and data flow.

4.5 Understand and Apply Black Box Testing Techniques

• Define black box testing and explain its focus on testing software functionality without knowledge of internal code or implementation details.
• Apply black box testing techniques such as equivalence partitioning, boundary value analysis, decision table testing, and state transition testing to ensure external behavior meets requirements.
• Analyze how black box testing verifies that the system functions correctly across a range of inputs and scenarios.

4.6 Understand and Apply Experience-Based Testing Techniques

• Define experience-based testing and explain how testers rely on their knowledge and intuition to explore the system.
• Apply experience-based testing techniques such as error guessing, exploratory testing, and checklist-based testing to identify potential risks and defects.
• Analyze how experience-based testing helps testers discover hidden defects by using their past experience with similar systems.