Common Infinite Loops in Quiz Apps: Causes and Fixes

In quiz apps the loop usually involves the question‑loading pipeline: fetch → parse → render → answer → repeat. Any break in that pipeline that fails to update the “finished” flag or the index pointer

1. What Causes Infinite Loops in Quiz Apps

In quiz apps the loop usually involves the question‑loading pipeline: fetch → parse → render → answer → repeat. Any break in that pipeline that fails to update the “finished” flag or the index pointer will cause the cycle to repeat forever.

---

2. Real‑World Impact

• User complaints – Users report “the app freezes on the first question” or “it keeps loading the same question”. Reviews on Google Play and the App Store often mention “stuck in a loop”, leading to a 2–5 ★ rating drop.
• Support cost – Each loop generates a support ticket. For a mid‑size quiz publisher, 200 tickets per month can translate to $4 k–$6 k in engineering time.
• Revenue loss – Monetization in quiz apps is usually ad‑based or via in‑app purchases (hints, extra lives). If users never reach the payoff screen, eCPM drops and conversion funnels break, cutting daily revenue by up to 30 % during the bug window.
• App store penalties – Repeated crash‑free but “unresponsive” reports trigger Google Play’s “Poor performance” warning and can lead to temporary removal.

---

3. Concrete Manifestations

---

4. How to Detect Infinite Loops

1. Automated UI exploration (SUSA)

• Upload the APK or web URL to SUSA. The platform runs a curious persona that clicks every tappable element and records flow verdicts.
• SUSA’s flow tracking will flag a step that never reaches a PASS state (e.g., question → submit → same question). The generated Appium script will contain a loop‑detected annotation.

1. Performance profiling

• Android Studio’s CPU Profiler or Chrome DevTools’ Performance tab show a long‑running call stack with repeated function entries (loadNextQuestion → setState → loadNextQuestion).

1. Log analysis

• Look for repeating log lines (e.g., Fetching question… appearing > 10 times within a second).
• Enable SUSA CLI (susatest-agent) in CI to capture JUnit XML with a custom section that records loop warnings.

1. Watchdog timers

• Insert a watchdog in test builds: if a screen stays longer than a threshold (e.g., 5 s) without a state change, log INFINITE_LOOP_DETECTED.

1. Static analysis

• Use detekt (Kotlin) or SonarQube rules that flag while (!condition) loops without a break statement inside an async context.

1. Accessibility testing

• Run WCAG 2.1 AA checks with SUSA’s accessibility persona. An endless live‑region update will be reported as an “ARIA live region not terminating”.

---

5. Fixing the Examples

Example 1 – Re‑loading the same question

// Bad
fun onSubmit(answer: String) {
    if (isCorrect(answer)) {
        loadQuestion(currentIndex)   // <-- should be +1
    } else {
        showError()
    }
}

Fix

fun onSubmit(answer: String) {
    if (isCorrect(answer)) {
        currentIndex++
        if (currentIndex < questions.size) {
            loadQuestion(currentIndex)
        } else {
            navigateToResult()
        }
    } else {
        showError()
    }
}

Add a bounds check and increment the index before loading.

Example 2 – Spinner never stops

let timer = setInterval(() => {
  if (quizFinished) clearInterval(timer);
}, 1000);

Fix

function finishQuiz() {
  quizFinished = true;
  clearInterval(timer); // immediate cancel
}

Set the flag before the timer starts or use setTimeout for a one‑off check.

Example 3 – Recursive setState

@override
Widget build(BuildContext context) {
  loadNextQuestion();   // <-- called on every rebuild
  return Scaffold(...);
}

Fix

@override
void initState() {
  super.initState();
  loadNextQuestion();   // called once
}

Move side‑effects out of build() into initState or a FutureBuilder.

Example 4 – Aggressive retry

async def fetch_question():
    try:
        return await api.get('/question')
    except NetworkError:
        await fetch_question()   # no back‑off, no limit

Fix

import asyncio

MAX_RETRIES = 3
async def fetch_question(attempt=1):
    try:
        return await api.get('/question')
    except NetworkError as e:
        if attempt < MAX_RETRIES:
            await asyncio.sleep(2 ** attempt)   # exponential back‑off
            return await fetch_question(attempt + 1)
        raise e

Introduce a retry limit and back‑off.

Example 5 – Navigation stack misuse

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.question);
    Navigator.push(this, QuestionActivity.class); // pushes itself
}

Fix

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.question);
    // No self‑push; only push when user explicitly taps “Next”.
}

Only navigate in response to user actions, not in onCreate.

Example 6 – Live‑region binding loop

<div aria-live="polite" id="questionLabel">{{question.text}}</div>
<script>
  model.onChange = (q) => {
    document.getElementById('questionLabel').innerText = q.text;
    model.current = q; // writes back to model -> triggers onChange again
  };
</script>

Fix

model.onChange = (q) => {
  const label = document.getElementById('questionLabel');
  if (label.innerText !== q.text) {
    label.innerText = q.text;
  }
  // Do NOT write back to model here
};

Guard against redundant updates and avoid two‑way writes.

Example 7 – Blocking while‑loop

while (!isQuizOver) {
    fetchNext()
}

Fix

fun startQuiz() = lifecycleScope.launch {
    while (isActive && !isQuizOver) {
        fetchNext()
        delay(500) // give UI thread a chance to render
    }
}

Run the loop in a coroutine with a delay, or better yet, drive progression via user events rather than a tight loop.

---

6. Prevention – Catch Infinite Loops Before Release

1. Integrate SUSA into CI/CD

• Add a GitHub Actions step that runs susatest-agent against the newly built APK.
• Fail the pipeline if any flow verdict stays in *Running* for longer than a configurable timeout (default 8 s).

1. Unit‑test the state machine

• Write exhaustive tests for every transition (givenAnswerWhenCorrectThenAdvance, givenLastQuestionWhenSubmitThenResult).
• Use property‑based testing (e.g., Kotlin kotest checkAll) to generate random answer sequences and assert the index never exceeds questions.size.

1. Static‑analysis rule set

• Enforce “no UI updates in render loops” and “no recursive calls without base case”.
• Add custom linters that detect while (!condition) without an await or delay inside.

1. Watchdog in production builds

• Ship a lightweight watchdog that logs a warning if any screen stays longer than a threshold.
• Pair with SUSA’s CLI to automatically upload these logs for post‑release analysis.

1. Persona‑driven exploratory testing

• Use SUSA’s impatient persona to hammer the “Next” button repeatedly; the platform will surface any UI that never progresses.
• The elderly persona slows down interactions, exposing loops that rely on rapid clicks to break.

1. Accessibility regression

• Run SUSA’s WCAG 2.1 AA suite on every PR. Infinite live‑region updates will be flagged as violations, preventing the loop from slipping into production.

1. Security‑oriented checks

• OWASP Top 10 scanning (included in SUSA) can reveal infinite‑loop‑like DoS patterns where an attacker triggers repeated API calls.

By making automated detection, static guarantees, and persona‑driven exploration part of the development pipeline, quiz apps can eliminate infinite loops early, protect user experience, and keep revenue streams flowing.