Why Study with PlanetCert?
The Latest Questions
Practice questions and exam topics aligned with the current exam objectives.
Detailed Explanations
Go beyond the answer. Master the material with comprehensive learning and professional explanations for every concept.
AI-Powered Insights
Personalized preparation guidance that adapts to your performance and identifies weak spots automatically.
Exam Information
Official specifications published by Python Institute
Exam Format
Registration
Validity
Skills this practice test covers
- Trace how a human error leads to a defect and then to a failure in running code.
- Place unit, integration, system and acceptance tests on the Test Pyramid.
- Check Python code against PEP 8 with linters such as Pylint and Flake8.
- Measure line, branch and method coverage, then refactor code with the DRY principle.
- Debug Python code with breakpoints, assert statements and the logging module.
- Design black box tests with equivalence partitioning and boundary value analysis.
Explore related topics
PCET-30-01 exam content
4 domains · 23 topics · 150 questions
Core Software Testing Concepts17.1%26 questions
This block explains why software is tested and what testing cannot prove. Candidates trace how a human error creates a defect that later causes a failure, and compare testing in Waterfall, Agile and DevOps.
Skills tested
- Explain why testing cannot prove that software is free of defects.
- Trace an error, the defect it creates and the failure that follows.
- Compare late-stage testing in Waterfall with continuous testing in Agile and automated testing in DevOps.
- Focus testing effort on critical and high-risk areas of the code.
Questions by topic
- Definition and purpose of software testing5
- Limitations of testing4
- Errors, defects, and failures6
- Testing in the SDLC6
- Risk-based testing strategy5
Software Testing Types, Levels, and Processes22.9%34 questions
This block sorts testing by type, by level and by process. Candidates choose manual or automated testing, use the Test Pyramid to balance the levels, write test documentation and isolate code with test doubles.
Skills tested
- Choose manual testing for exploratory work and automated testing for regression testing.
- Explain unit, integration, system and acceptance testing and where each sits on the Test Pyramid.
- Follow the testing process from Test Planning to Test Closure.
- Write a test plan, test cases and a test report.
- Replace a database or another dependency with a stub, a fake or a mock.
Questions by topic
- Types of software testing6
- Levels of testing6
- Test Pyramid6
- Testing process phases6
- Test documentation5
- Test doubles5
Static Analysis, Dynamic Testing, and Code Refactoring28.6%42 questions
Static testing looks for problems without running the code. Dynamic testing finds the problems that only appear when it runs. Candidates use code reviews, linters and PEP 8, measure test coverage and refactor code without changing what it does.
Skills tested
- Run Pylint or Flake8 to find dead code, unused variables and formatting issues.
- Apply PEP 8 rules for indentation, naming conventions and line length.
- Compare line, branch and method coverage.
- Refactor a function with the DRY principle and keep its behavior the same.
- Lay out a unit test with the AAA pattern.
Questions by topic
- Static testing techniques7
- Dynamic testing techniques6
- Code quality and standards8
- Static analysis tools7
- Test coverage and metrics6
- Code refactoring8
Debugging, Assertions, and Testing Techniques31.4%48 questions
This block carries the most weight. It covers print debugging and IDE debuggers, assertions and Python's logging module, and three families of test design: white box, black box and experience-based testing.
Skills tested
- Set breakpoints and step through code in an IDE debugger.
- Write assert statements that stop a program when a condition fails.
- Log events with the logging module at the DEBUG, INFO, WARNING, ERROR and CRITICAL levels.
- Design tests with equivalence partitioning, boundary value analysis, decision tables and state transitions.
- Use error guessing and exploratory testing to find defects that scripted tests miss.
Questions by topic
- Debugging techniques7
- Assertions in Code11
- Logging for Debugging and Testing8
- White Box Testing Techniques7
- Black Box Testing Techniques9
- Experience-Based Testing Techniques6
Requirements
- No formal prerequisites: anyone can book the exam.
- Recommended: basic knowledge of Python programming and of software testing.
- Recommended: PCEP – Certified Entry-Level Python Programmer, which the Python Institute's roadmap lists as prior experience.
- Recommended: ISTQB Certified Tester Foundation Level as an alternative grounding in testing.
About the PCET-30-01 exam
PCET-30-01 shows that a newcomer to software testing understands core testing ideas and can apply them to Python code. The Python Institute's syllabus has four blocks, which run from why software is tested to static analysis, debugging, assertions and test design techniques. The two code-focused blocks, on static analysis and on debugging, carry most of the weight. Passing earns the PCET™ – Certified Entry-Level Tester with Python certification, which is valid for seven years.
The PlanetCert practice test gives the debugging block the most questions, and assertions are its largest single topic. Static analysis and refactoring come next. The explanations help most where options sound alike, such as an error, a defect and a failure, or a stub and a mock. Study Mode suits the black box techniques, where equivalence partitioning and boundary value analysis need worked examples. Brainy AI Assistant can explain a Pylint warning, or turn a vague assert statement into a clearer test.
How to earn the certification
- Earns
- PCET™ – Certified Entry-Level Tester with PythonEntry
The PCET certification is valid for seven years.
- Before
- PCEP-30-02 PCEP – Certified Entry-Level Python Programmer
Recommended prior experience on the Python Institute's roadmap. It builds the basic Python that the testing tasks use.
- CTFL ISTQB Certified Tester Foundation Level
A vendor-neutral testing certification that the Python Institute lists as associated with PCET and as an alternative grounding.
- PCEP-30-02 PCEP – Certified Entry-Level Python Programmer
How to prepare for PCET-30-01
- 1
Set up Pylint, Flake8 and a debugger
Install Python, an IDE with a debugger, Pylint and Flake8. The static analysis block expects candidates to read these tools' warnings and fix the code they point to.
- 2
Break a small script on purpose
Add a few defects to a short Python script and find them with print debugging, breakpoints and assert statements. Then add logging at each level and compare the output.
- 3
Draw a Test Pyramid for one app
Sketch unit, integration, system and acceptance tests for a small app. Mark where a stub or mock replaces a dependency, and which test documents each level needs.
- 4
Drill the black box techniques
Practise equivalence partitioning, boundary value analysis, decision tables and state transition testing on simple input rules, such as an age field. They belong to the heaviest block.
- 5
Close with timed practice
Take the PCET-30-01 practice test in Timed Mode, then read the explanation for every missed question. Brainy AI Assistant can rewrite a missed scenario with new values for another try.
Start a timed PCET-30-01run
The Python Institute aligns its free Python for Testing 101 (PT101) course on Edube Interactive with this exam.
Who PCET-30-01 is for
- Aspiring software testers who want to learn testing basics with Python.
- People preparing for entry-level roles such as software tester, QA engineer or test engineer.
- Programmers from other languages who want to run simple tests in Python.
- Project managers and product owners who work closely with test teams.
Typical job titles: Software tester · QA engineer · Test engineer · Junior Python developer
PCET-30-01 glossary
19 terms from the exam objectives and the vendor's official material, each defined in a sentence.
- AAA pattern
- Arrange, act, assert: a layout for a unit test that sets up the data, runs the code under test and then checks the result.
- assert statement
- A Python statement that checks a condition and stops the program with an error when the condition is false.
- Black box testing
- Testing what the software does from the outside, without knowledge of its code.
- Boundary value analysis
- A black box technique that tests the values at the edges of a valid range, where mistakes are common.
- Branch coverage
- A coverage measure that shows whether each possible branch of a decision, such as both sides of an if statement, has run in a test.
- Dynamic testing
- Testing software by running it and comparing what happens with what should happen.
- Equivalence partitioning
- A black box technique that splits inputs into groups the program should treat the same way, then tests one value from each group.
- Error guessing
- An experience-based technique in which a tester predicts likely mistakes and writes tests aimed at them.
- Flake8
- A Python tool that checks code against PEP 8 style rules and flags simple programming errors.
- Linters
- Tools that read source code without running it and report style problems, likely bugs and unused code.
- logging module
- Python's built-in library for recording program events at levels from DEBUG up to CRITICAL.
- Mocks
- Test doubles that record how the code under test called them, so the test can check those calls.
- PEP 8
- The style guide for Python code, with rules for indentation, naming conventions, line length and layout.
- Pylint
- A Python static analysis tool that reports errors, unused variables, dead code and breaks from coding standards.
- Regression testing
- Running tests again after a change to confirm that features which worked before still work.
- Static testing
- Checking code or documents without running the program, through code reviews, walkthroughs, inspections or linters.
- Test doubles
- Stand-ins for real dependencies in a test, such as dummies, stubs, fakes, spies and mocks.
- Test Pyramid
- A model of a test strategy with many fast unit tests at the base, fewer integration tests above them and few end-to-end tests at the top.
- White box testing
- Testing based on the internal structure of the code, such as making sure every statement, branch and loop runs.