FC0-U71 Software Development Concepts Practice Question
During a sprint retrospective, the team identifies that too many bugs are being discovered late in the development cycle. They decide to introduce a practice where developers write tests for individual functions before coding the functions themselves. This approach is an example of:
⚠ Common exam trap
FC0-U71 often tests the confusion between unit testing (individual functions, done early, often TDD) and integration/system/UAT testing (later, broader scope), so candidates pick the broader test type when the question emphasizes 'individual functions.'
Answer choices
Why each option matters
Answer the question above first, then reveal the full breakdown to understand why each option is right or wrong.
Correct answer & explanation
✓
Unit testing
Writing tests for individual functions before writing the functions themselves is the definition of unit testing, and doing so before coding is specifically test-driven development (TDD). Unit tests isolate the smallest testable pieces of code (functions, methods) to verify correctness. This matches the scenario's focus on individual functions and early bug detection.
Answer analysis
Option-by-option breakdown
For each option: why learners choose it and why it is or isn't the right answer here.
- ✗
User acceptance testing
Why it's wrong here
User acceptance testing confirms the delivered system meets business needs and is performed by end users near release, long after functions are coded. It is the right choice for validating fitness for purpose against real workflows, not for developers writing function-level tests before implementation.
- ✗
Integration testing
Why it's wrong here
Integration testing verifies interactions between combined modules or services, so it runs after units exist and cannot be written before the functions themselves. It is the right choice when validating interfaces, data flow and contracts between components, not for test-first development of individual functions.
- ✗
System testing
Why it's wrong here
System testing exercises the complete integrated application against end-to-end requirements, which necessarily happens once all components are built. It is correct for validating the whole system's behaviour and performance, but writing tests for individual functions before coding them is unit-level, test-first practise.
- ✓
Unit testing
Why this is correct
Unit testing exercises individual functions in isolation, so writing those tests before implementation — test-driven development — forces developers to define expected behaviour up front. That early verification catches defects at the function level during the sprint, directly addressing the stem's constraint of bugs being discovered late in the development cycle.
About these practice questions
This FC0-U71 question is part of Courseiva's 988-question bank — original exam-style content with full explanations and wrong-answer analysis, never real exam questions or exam dumps. Learn why practice questions differ from exam dumps →
JA
Written and reviewed by Johnson Ajibi, MSc IT Security
Senior Network & Security Engineer · founder of Courseiva
Last reviewed September 2026 · checked against the official CompTIA exam blueprint
This FC0-U71 practice question is part of Courseiva's free CompTIA certification practice question bank. Courseiva provides original exam-style practice questions with explanations, topic-based practice, mock exams, readiness tracking, and study analytics to help learners prepare for the FC0-U71 exam.