Why testing matters in Kotlin - Why It Works This Way

Overview - Why testing matters

What is it?

Testing in programming means checking if your code works correctly before using it for real. It helps find mistakes early so they can be fixed quickly. Testing can be done by running small pieces of code to see if they behave as expected. This makes sure the program does what it should and avoids surprises later.

Why it matters

Without testing, bugs and errors can go unnoticed until they cause problems for users or break important features. This can lead to wasted time, lost money, and unhappy users. Testing helps catch problems early, making software more reliable and easier to improve. It builds confidence that the code works well and saves effort in the long run.

Where it fits

Before learning testing, you should understand basic programming concepts like variables, functions, and control flow. After testing, you can learn about advanced topics like automated testing tools, test-driven development, and continuous integration. Testing fits in the software development process as a key step to ensure quality.

Mental Model

Core Idea

Testing is like checking your work step-by-step to catch mistakes before they cause bigger problems.

Think of it like...

Imagine writing a recipe and trying it out in your kitchen before sharing it with friends. Testing is like tasting the dish early to make sure it’s delicious and fixing the recipe if it’s not.

┌───────────────┐
│ Write Code    │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Run Tests     │
└──────┬────────┘
       │
  ┌────┴─────┐
  │ Pass?    │
  └────┬─────┘
       │Yes          No
       ▼             ▼
┌───────────────┐  ┌───────────────┐
│ Use Code     │  │ Fix Bugs      │
└───────────────┘  └───────────────┘

Build-Up - 6 Steps

1

Foundation

What is testing in programming

Concept: Introduce the basic idea of testing as checking code correctness.

Testing means running parts of your program to see if they do what you expect. For example, if you have a function that adds two numbers, testing checks if it really adds them correctly.

Result

You understand that testing is about checking if code works as planned.

Understanding testing as a simple check helps remove fear and shows it as a natural part of coding.

2

Foundation

Types of tests: manual vs automated

Concept: Explain the difference between testing by hand and using code to test automatically.

Manual testing means you run the program and check results yourself. Automated testing means writing code that runs tests for you, so you can check many cases quickly and often.

Result

You know there are two main ways to test and why automated testing saves time.

Knowing automated tests exist encourages writing repeatable checks that catch bugs early.

3

Intermediate

Writing simple unit tests in Kotlin

🤔Before reading on: do you think a unit test checks the whole program or just a small part? Commit to your answer.

Concept: Introduce unit tests that check small pieces of code independently.

In Kotlin, you can write a unit test to check a function. For example: fun add(a: Int, b: Int) = a + b @Test fun testAdd() { assert(add(2, 3) == 5) } This test checks if add(2, 3) returns 5.

Result

You can write a test that confirms a small function works correctly.

Understanding unit tests helps isolate problems and makes debugging easier.

4

Intermediate

Why tests prevent bugs from spreading

🤔Before reading on: do you think one bug can cause many problems or just one? Commit to your answer.

Concept: Explain how testing early stops bugs from causing bigger issues later.

If a function has a bug, it can cause wrong results in many parts of the program. Tests catch these bugs early, so you fix them before they affect other code. This keeps the program stable and easier to maintain.

Result

You see how testing acts like a safety net to catch errors early.

Knowing tests prevent bug spread saves time and frustration in large projects.

5

Advanced

Test-driven development basics

🤔Before reading on: do you think writing tests before code is helpful or a waste of time? Commit to your answer.

Concept: Introduce the idea of writing tests before writing the actual code.

Test-driven development (TDD) means you write a test first that fails because the code doesn’t exist yet. Then you write just enough code to pass the test. This cycle repeats to build reliable code step-by-step.

Result

You understand how TDD guides coding and improves design.

Knowing TDD helps write cleaner, well-tested code from the start.

6

Expert

Common pitfalls and test reliability

🤔Before reading on: do you think all tests always catch bugs? Commit to your answer.

Concept: Explain why some tests can give false confidence and how to avoid it.

Not all tests catch every bug. Some tests might pass even if the code is wrong because they don’t check all cases. Writing good tests means thinking about edge cases and avoiding tests that only check obvious things.

Result

You learn that tests must be well-designed to be trustworthy.

Understanding test reliability prevents wasting time on false positives and missed bugs.

Under the Hood

Testing works by running code with known inputs and comparing the output to expected results. The testing framework calls your test functions, captures any errors or failed checks, and reports them. Automated tests can run many times quickly, often integrated into development tools to give instant feedback.

Why designed this way?

Testing frameworks were designed to automate repetitive checks and provide clear feedback to developers. Early software projects suffered from hidden bugs and manual testing was slow and error-prone. Automating tests made it easier to maintain code quality as projects grew larger.

┌───────────────┐
│ Test Runner   │
├──────┬────────┤
│ Calls│ Test   │
│ Code │ Functions
└──────┴────────┘
       │
       ▼
┌───────────────┐
│ Compare Output│
│ to Expected   │
└──────┬────────┘
       │
  ┌────┴─────┐
  │ Pass/Fail│
  └──────────┘

Myth Busters - 4 Common Misconceptions

Quick: Do you think testing guarantees your code is bug-free? Commit to yes or no before reading on.

Common Belief: If I write tests, my code will never have bugs.

Reality: Tests reduce bugs but cannot guarantee zero bugs because tests might miss some cases or have errors themselves.

Why it matters: Believing tests are perfect can lead to ignoring other quality practices and missing hidden bugs.

Quick: Do you think testing slows down development or speeds it up? Commit to your answer.

Common Belief: Testing takes too much time and slows down coding.

Reality: Testing saves time by catching bugs early and reducing costly fixes later, speeding up overall development.

Why it matters: Skipping tests to save time often causes more delays fixing unexpected bugs.

Quick: Do you think manual testing is enough for big projects? Commit to yes or no.

Common Belief: Manual testing is enough; automated tests are not necessary.

Reality: Manual testing is slow and error-prone for large projects; automated tests provide fast, repeatable checks.

Why it matters: Relying only on manual testing leads to missed bugs and slower releases.

Quick: Do you think tests only check if code runs without errors? Commit to yes or no.

Common Belief: Tests only check if the program crashes or not.

Reality: Tests check if the program produces correct results, not just if it runs without crashing.

Why it matters: Ignoring result correctness can let wrong outputs go unnoticed.

Expert Zone

1

Tests should be independent so one test failure doesn’t cause others to fail, making debugging easier.

2

Flaky tests that sometimes pass and sometimes fail cause mistrust and should be fixed or removed.

3

Code coverage is useful but 100% coverage doesn’t mean all bugs are caught; test quality matters more.

When NOT to use

Testing is less useful for quick throwaway scripts or prototypes where speed matters more than reliability. In such cases, manual checks or exploratory testing might be better. Also, some UI or hardware-dependent features require specialized testing tools beyond simple unit tests.

Production Patterns

In real projects, tests run automatically on every code change using continuous integration tools. Teams write unit tests for small parts, integration tests for combined parts, and end-to-end tests simulating user actions. Test-driven development is common in agile teams to improve code quality and design.

Connections

Quality Assurance (QA)

Testing is a core part of QA processes that ensure software meets standards.

Understanding testing helps grasp how QA teams systematically prevent defects and improve product quality.

Scientific Method

Testing code is like forming hypotheses and running experiments to confirm or reject them.

Seeing testing as experimentation clarifies why tests must be repeatable and objective.

Manufacturing Quality Control

Testing software is similar to checking products on an assembly line to catch defects early.

This connection shows how testing prevents faulty products from reaching customers, saving costs and reputation.

Common Pitfalls

#1 Writing tests that depend on each other causing confusing failures.

Wrong approach:

@Test
fun testA() {
// modifies shared state
}

@Test
fun testB() {
// expects state from testA
}

Correct approach:

@Test
fun testA() {
// independent setup
}

@Test
fun testB() {
// independent setup
}

Root cause:

Misunderstanding that tests should be isolated and independent to avoid cascading failures.

#2 Ignoring edge cases in tests leading to missed bugs.

Wrong approach:

@Test
fun testDivide() {
assert(divide(10, 2) == 5)
}

Correct approach:

@Test
fun testDivide() {
assert(divide(10, 2) == 5)
assertThrows { divide(10, 0) }
}

Root cause:

Not thinking about unusual or error cases that can break the code.

#3 Writing tests that only check if code runs without errors, not correctness.

Wrong approach:

@Test
fun testAdd() {
add(2, 3) // no assertion
}

Correct approach:

@Test
fun testAdd() {
assert(add(2, 3) == 5)
}

Root cause:

Confusing running code with verifying correct results.

Key Takeaways

Testing is essential to catch bugs early and ensure code works as expected.

Automated tests save time and improve reliability compared to manual checks.

Writing good tests requires thinking about all cases, including edge cases and errors.

Test-driven development helps build better code by writing tests before code.

Tests must be independent and reliable to be effective in real projects.