Edge Cases, on Purpose

Warm-up: from Day 6

The last warm-up of the course, from memory first.

1. Predict both lines. Same three jobs, two ways of waiting for them.

import asyncio

async def job(name, delay):
    await asyncio.sleep(delay)
    return name

async def main():
    print(await asyncio.gather(job("a", 0.03), job("b", 0.01), job("c", 0.02)))
    order = []
    for next_done in asyncio.as_completed([job("a", 0.03), job("b", 0.01), job("c", 0.02)]):
        order.append(await next_done)
    print(order)

asyncio.run(main())

['a', 'b', 'c']
['b', 'c', 'a']

2. Fix. One source being down should be reported, not take the whole report with it. This should print ['web: ok', 'db: failed', 'api: ok'].

import asyncio

async def fetch(name):
    if name == "db":
        raise ConnectionError("db unreachable")
    return f"{name}: ok"

async def main():
    print(await asyncio.gather(fetch("web"), fetch("db"), fetch("api")))

asyncio.run(main())

import asyncio

async def fetch(name):
    if name == "db":
        raise ConnectionError("db unreachable")
    return f"{name}: ok"

async def safely(name):
    try:
        return await fetch(name)
    except ConnectionError:
        return f"{name}: failed"

async def main():
    print(await asyncio.gather(safely("web"), safely("db"), safely("api")))

asyncio.run(main())

['web: ok', 'db: failed', 'api: ok']

3. Explain. No code: fetch_safely catches TimeoutError and ConnectionError — why not every Exception?

Where Day 5 ended

The last day. Here’s where the analyzer stood at the end of Day 5:

Today it becomes a tool other people can run: a command line, proper logging, a README. But first, one more look at what it does with awkward input. A tool used by other people meets inputs its author never imagined, so the edge cases are worth finding on purpose, before they find you.

An inventory of the week

Most edge cases are already handled, because every bug hunt this week left a regression test behind. Listing them shows what’s covered, and where the gaps are:

What’s missing is the one edge nobody has looked at yet: the file itself. Every test so far starts from lines that are already strings. The bytes on disk, and how they become text, have never been tested.

Bug hunt: the first line is always bad

The billing team exports its logs with a Windows tool. Their file looks exactly like messy.log in any editor, but the report says one line more is bad:

Reproduce. Three bad lines instead of two, and the new one is line 1, which looks perfect.

Inspect. The error message shows the line with repr, which is exactly what you want here. Look at the start of it: '\ufeff2026-09-01 09:14:02 .... There’s a character before the date that no editor displays.

Your turn, before you open this. Write a test that reproduces the bug from raw bytes, without export.log, then fix read_lines. Read the reveal either way: it introduces the utf-8-sig encoding the rest of the lesson builds on.

print(open("export.log", "rb").read(12))

def test_a_marked_first_line_parses(self):
    lines = self.read("\ufeff2026-09-01 09:14:02 INFO auth: user=ada\n".encode())
    self.assertEqual(parse_record(lines[0]).source, "auth")

    with open(path, encoding="utf-8-sig", errors="replace") as file:

Bytes that aren’t text

The fix above has a second argument: errors="replace". A log file that isn’t valid UTF-8 at all, say one byte from an old Latin-1 system, makes a plain open raise UnicodeDecodeError halfway through the file, and the whole report is lost for one byte.

That’s the Day 2 decision again, one level down. Fail on the first bad byte, or carry on and let the damage show? errors="replace" turns each undecodable byte into U+FFFD, the replacement character �. The line usually still parses, the odd character shows up in the message, and one bad byte costs one character instead of the whole file.

Your turn

import os
import sys
import unittest


def read_lines(path):
    """Yield the lines of a text file one at a time, without line endings."""
    with open(path) as file:
        for line in file:
            yield line.rstrip("\n")


class TestReadLines(unittest.TestCase):
    def read(self, data):
        """Write data to a file as raw bytes, and read it back with read_lines."""
        with open("edge-case.log", "wb") as file:
            file.write(data)
        try:
            return list(read_lines("edge-case.log"))
        finally:
            os.remove("edge-case.log")

    def test_edge_cases(self):
        cases = {
            b"": [],
            b"one\ntwo": ["one", "two"],                       # no newline at the end
            b"one\r\ntwo\r\n": ["one", "two"],                 # Windows line endings
            b"\xef\xbb\xbfone\n": ["one"],                     # a byte-order mark
            b"caf\xe9\n": ["caf\ufffd"],                       # not UTF-8: replaced, not fatal
            "zoë\n".encode(): ["zoë"],               # UTF-8 is read as UTF-8
        }
        for data, lines in cases.items():
            with self.subTest(data=data):
                self.assertEqual(self.read(data), lines)


suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestReadLines)
unittest.TextTestRunner(stream=sys.stdout, verbosity=2).run(suite)

def read_lines(path):
    """Yield the lines of a text file one at a time, without line endings.

    A byte-order mark at the start is skipped, and bytes that aren't valid
    UTF-8 become U+FFFD instead of stopping the whole file.
    """
    with open(path, encoding="utf-8-sig", errors="replace") as file:
        for line in file:
            yield line.rstrip("\n")

What you can now do

• Take an inventory of a program’s edge cases, and see which have tests.
• Test file handling from raw bytes, including BOMs, bad bytes and line endings.
• Open text files with an explicit encoding, and choose what happens to bytes that can’t be decoded.

Next: replacing the analyzer’s scattered prints with logging.