{"abstract":"Coalesced free blocks swallow live objects that sit between them.","category":"Garbage collector invariants","checks":6,"contract":"blocks are [address, size, marked] covering the heap in any order. Sweep in address order: unmarked blocks become free and physically adjacent free blocks coalesce. Then serve requests first-fit in address order: round the request up to 8 bytes; split the chosen block when the remainder is at least 16 bytes (the allocation takes the low end), otherwise hand out the whole block; no fit yields None. Return the swept free list (as it was right after sweeping), the allocation addresses and the final free list.","evaluation_group":"w2-garbage-collector-invariants-sweep-free-list","failed_approach":"Using the current block's size to test adjacency fails whenever neighbouring sizes differ.","family":"w2-garbage-collector-invariants-sweep-free-list-coalescing-adjacency","id":"FA-90456","implementations":{"attempt":{"sha256":"36701a9363eded7343044ddfa9e6c866ad0909da61d73d8014e4f302c00b8022","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(blocks, requests):\n    free = []\n    for addr, size, marked in sorted(blocks):\n        if marked:\n            continue\n        if free and free[-1][0] + size == addr:\n            free[-1][1] += size\n        else:\n            free.append([addr, size])\n    swept = [list(b) for b in free]\n    got = []\n    for req in requests:\n        need = (req + 7) // 8 * 8\n        choice = None\n        for b in free:\n            if b[1] >= need:\n                choice = b\n                break\n        if choice is None:\n            got.append(None)\n            continue\n        got.append(choice[0])\n        rem = choice[1] - need\n        if rem >= 16:\n            choice[0] += need\n            choice[1] = rem\n        else:\n            free.remove(choice)\n    return {'swept': swept, 'alloc': got, 'free': free}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = [[('regression: sweep, split and exhaust',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [1040, 1064, 1096, 1136, None], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('exact fit uses the first block',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [48, 64]),\n   {'alloc': [1040, 1096], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [32, 40]),\n   {'alloc': [1040, 1096], 'free': [[1072, 16], [1136, 24]], 'swept': [[1040, 48], [1096, 64]]}),\n  ('remainder too small to split',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [1040, 1096, None], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [1]),\n   {'alloc': [1040], 'free': [[1048, 40], [1096, 64]], 'swept': [[1040, 48], [1096, 64]]}),\n  ('control: fully marked heap',\n   ([[1024, 32, True], [1056, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [2064, 2088, 2120, 2160, None], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('exact fit uses the first block',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [48, 64]),\n   {'alloc': [2064, 2120], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [32, 40]),\n   {'alloc': [2064, 2120], 'free': [[2096, 16], [2160, 24]], 'swept': [[2064, 48], [2120, 64]]}),\n  ('remainder too small to split',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [2064, 2120, None], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [1]),\n   {'alloc': [2064], 'free': [[2072, 40], [2120, 64]], 'swept': [[2064, 48], [2120, 64]]}),\n  ('control: fully marked heap',\n   ([[2048, 32, True], [2080, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [3088, 3112, 3144, 3184, None], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('exact fit uses the first block',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [48, 64]),\n   {'alloc': [3088, 3144], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [32, 40]),\n   {'alloc': [3088, 3144], 'free': [[3120, 16], [3184, 24]], 'swept': [[3088, 48], [3144, 64]]}),\n  ('remainder too small to split',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [3088, 3144, None], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [1]),\n   {'alloc': [3088], 'free': [[3096, 40], [3144, 64]], 'swept': [[3088, 48], [3144, 64]]}),\n  ('control: fully marked heap',\n   ([[3072, 32, True], [3104, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [4112, 4136, 4168, 4208, None], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('exact fit uses the first block',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [48, 64]),\n   {'alloc': [4112, 4168], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [32, 40]),\n   {'alloc': [4112, 4168], 'free': [[4144, 16], [4208, 24]], 'swept': [[4112, 48], [4168, 64]]}),\n  ('remainder too small to split',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [4112, 4168, None], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [1]),\n   {'alloc': [4112], 'free': [[4120, 40], [4168, 64]], 'swept': [[4112, 48], [4168, 64]]}),\n  ('control: fully marked heap',\n   ([[4096, 32, True], [4128, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [5136, 5160, 5192, 5232, None], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('exact fit uses the first block',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [48, 64]),\n   {'alloc': [5136, 5192], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [32, 40]),\n   {'alloc': [5136, 5192], 'free': [[5168, 16], [5232, 24]], 'swept': [[5136, 48], [5192, 64]]}),\n  ('remainder too small to split',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [5136, 5192, None], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [1]),\n   {'alloc': [5136], 'free': [[5144, 40], [5192, 64]], 'swept': [[5136, 48], [5192, 64]]}),\n  ('control: fully marked heap',\n   ([[5120, 32, True], [5152, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})]]\nfor label, args, expected in cases[N - 1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"},"broken":{"sha256":"796ccecbb9cfe5259a1d6badc54c4069699c8320b3706383562e36c50a599ef5","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(blocks, requests):\n    free = []\n    for addr, size, marked in sorted(blocks):\n        if marked:\n            continue\n        if free and free[-1][0] + free[-1][1] <= addr:\n            free[-1][1] += size\n        else:\n            free.append([addr, size])\n    swept = [list(b) for b in free]\n    got = []\n    for req in requests:\n        need = (req + 7) // 8 * 8\n        choice = None\n        for b in free:\n            if b[1] >= need:\n                choice = b\n                break\n        if choice is None:\n            got.append(None)\n            continue\n        got.append(choice[0])\n        rem = choice[1] - need\n        if rem >= 16:\n            choice[0] += need\n            choice[1] = rem\n        else:\n            free.remove(choice)\n    return {'swept': swept, 'alloc': got, 'free': free}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = [[('regression: sweep, split and exhaust',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [1040, 1064, 1096, 1136, None], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('exact fit uses the first block',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [48, 64]),\n   {'alloc': [1040, 1096], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [32, 40]),\n   {'alloc': [1040, 1096], 'free': [[1072, 16], [1136, 24]], 'swept': [[1040, 48], [1096, 64]]}),\n  ('remainder too small to split',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [1040, 1096, None], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [1]),\n   {'alloc': [1040], 'free': [[1048, 40], [1096, 64]], 'swept': [[1040, 48], [1096, 64]]}),\n  ('control: fully marked heap',\n   ([[1024, 32, True], [1056, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [2064, 2088, 2120, 2160, None], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('exact fit uses the first block',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [48, 64]),\n   {'alloc': [2064, 2120], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [32, 40]),\n   {'alloc': [2064, 2120], 'free': [[2096, 16], [2160, 24]], 'swept': [[2064, 48], [2120, 64]]}),\n  ('remainder too small to split',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [2064, 2120, None], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [1]),\n   {'alloc': [2064], 'free': [[2072, 40], [2120, 64]], 'swept': [[2064, 48], [2120, 64]]}),\n  ('control: fully marked heap',\n   ([[2048, 32, True], [2080, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [3088, 3112, 3144, 3184, None], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('exact fit uses the first block',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [48, 64]),\n   {'alloc': [3088, 3144], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [32, 40]),\n   {'alloc': [3088, 3144], 'free': [[3120, 16], [3184, 24]], 'swept': [[3088, 48], [3144, 64]]}),\n  ('remainder too small to split',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [3088, 3144, None], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [1]),\n   {'alloc': [3088], 'free': [[3096, 40], [3144, 64]], 'swept': [[3088, 48], [3144, 64]]}),\n  ('control: fully marked heap',\n   ([[3072, 32, True], [3104, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [4112, 4136, 4168, 4208, None], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('exact fit uses the first block',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [48, 64]),\n   {'alloc': [4112, 4168], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [32, 40]),\n   {'alloc': [4112, 4168], 'free': [[4144, 16], [4208, 24]], 'swept': [[4112, 48], [4168, 64]]}),\n  ('remainder too small to split',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [4112, 4168, None], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [1]),\n   {'alloc': [4112], 'free': [[4120, 40], [4168, 64]], 'swept': [[4112, 48], [4168, 64]]}),\n  ('control: fully marked heap',\n   ([[4096, 32, True], [4128, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [5136, 5160, 5192, 5232, None], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('exact fit uses the first block',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [48, 64]),\n   {'alloc': [5136, 5192], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [32, 40]),\n   {'alloc': [5136, 5192], 'free': [[5168, 16], [5232, 24]], 'swept': [[5136, 48], [5192, 64]]}),\n  ('remainder too small to split',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [5136, 5192, None], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [1]),\n   {'alloc': [5136], 'free': [[5144, 40], [5192, 64]], 'swept': [[5136, 48], [5192, 64]]}),\n  ('control: fully marked heap',\n   ([[5120, 32, True], [5152, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})]]\nfor label, args, expected in cases[N - 1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"},"fixed":{"sha256":"85d9ca4ce9716863a5678dcbf1a69f329730cd6e642031ef6b9b9cf2f63f8138","source":"\"\"\"Failure Map reference implementation. Python standard library only.\"\"\"\nimport json\n\nN = 1\nobservations = []\ndef solve(blocks, requests):\n    free = []\n    for addr, size, marked in sorted(blocks):\n        if marked:\n            continue\n        if free and free[-1][0] + free[-1][1] == addr:\n            free[-1][1] += size\n        else:\n            free.append([addr, size])\n    swept = [list(b) for b in free]\n    got = []\n    for req in requests:\n        need = (req + 7) // 8 * 8\n        choice = None\n        for b in free:\n            if b[1] >= need:\n                choice = b\n                break\n        if choice is None:\n            got.append(None)\n            continue\n        got.append(choice[0])\n        rem = choice[1] - need\n        if rem >= 16:\n            choice[0] += need\n            choice[1] = rem\n        else:\n            free.remove(choice)\n    return {'swept': swept, 'alloc': got, 'free': free}\ndef check(label, actual, expected):\n    observations.append({\"check\": label, \"actual\": actual, \"expected\": expected, \"passed\": actual == expected})\ncases = [[('regression: sweep, split and exhaust',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [1040, 1064, 1096, 1136, None], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('exact fit uses the first block',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [48, 64]),\n   {'alloc': [1040, 1096], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [32, 40]),\n   {'alloc': [1040, 1096], 'free': [[1072, 16], [1136, 24]], 'swept': [[1040, 48], [1096, 64]]}),\n  ('remainder too small to split',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [1040, 1096, None], 'free': [], 'swept': [[1040, 48], [1096, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[1088, 8, True],\n     [1040, 32, False],\n     [1024, 16, True],\n     [1072, 16, False],\n     [1096, 24, False],\n     [1120, 40, False],\n     [1160, 16, True]],\n    [1]),\n   {'alloc': [1040], 'free': [[1048, 40], [1096, 64]], 'swept': [[1040, 48], [1096, 64]]}),\n  ('control: fully marked heap',\n   ([[1024, 32, True], [1056, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [2064, 2088, 2120, 2160, None], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('exact fit uses the first block',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [48, 64]),\n   {'alloc': [2064, 2120], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [32, 40]),\n   {'alloc': [2064, 2120], 'free': [[2096, 16], [2160, 24]], 'swept': [[2064, 48], [2120, 64]]}),\n  ('remainder too small to split',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [2064, 2120, None], 'free': [], 'swept': [[2064, 48], [2120, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[2112, 8, True],\n     [2064, 32, False],\n     [2048, 16, True],\n     [2096, 16, False],\n     [2120, 24, False],\n     [2144, 40, False],\n     [2184, 16, True]],\n    [1]),\n   {'alloc': [2064], 'free': [[2072, 40], [2120, 64]], 'swept': [[2064, 48], [2120, 64]]}),\n  ('control: fully marked heap',\n   ([[2048, 32, True], [2080, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [3088, 3112, 3144, 3184, None], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('exact fit uses the first block',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [48, 64]),\n   {'alloc': [3088, 3144], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [32, 40]),\n   {'alloc': [3088, 3144], 'free': [[3120, 16], [3184, 24]], 'swept': [[3088, 48], [3144, 64]]}),\n  ('remainder too small to split',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [3088, 3144, None], 'free': [], 'swept': [[3088, 48], [3144, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[3136, 8, True],\n     [3088, 32, False],\n     [3072, 16, True],\n     [3120, 16, False],\n     [3144, 24, False],\n     [3168, 40, False],\n     [3208, 16, True]],\n    [1]),\n   {'alloc': [3088], 'free': [[3096, 40], [3144, 64]], 'swept': [[3088, 48], [3144, 64]]}),\n  ('control: fully marked heap',\n   ([[3072, 32, True], [3104, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [4112, 4136, 4168, 4208, None], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('exact fit uses the first block',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [48, 64]),\n   {'alloc': [4112, 4168], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [32, 40]),\n   {'alloc': [4112, 4168], 'free': [[4144, 16], [4208, 24]], 'swept': [[4112, 48], [4168, 64]]}),\n  ('remainder too small to split',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [4112, 4168, None], 'free': [], 'swept': [[4112, 48], [4168, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[4160, 8, True],\n     [4112, 32, False],\n     [4096, 16, True],\n     [4144, 16, False],\n     [4168, 24, False],\n     [4192, 40, False],\n     [4232, 16, True]],\n    [1]),\n   {'alloc': [4112], 'free': [[4120, 40], [4168, 64]], 'swept': [[4112, 48], [4168, 64]]}),\n  ('control: fully marked heap',\n   ([[4096, 32, True], [4128, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})],\n [('regression: sweep, split and exhaust',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [20, 24, 40, 10, 8]),\n   {'alloc': [5136, 5160, 5192, 5232, None], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('exact fit uses the first block',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [48, 64]),\n   {'alloc': [5136, 5192], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('remainder of exactly the minimum block size',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [32, 40]),\n   {'alloc': [5136, 5192], 'free': [[5168, 16], [5232, 24]], 'swept': [[5136, 48], [5192, 64]]}),\n  ('remainder too small to split',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [44, 50, 1]),\n   {'alloc': [5136, 5192, None], 'free': [], 'swept': [[5136, 48], [5192, 64]]}),\n  ('sweep snapshot is independent of allocation',\n   ([[5184, 8, True],\n     [5136, 32, False],\n     [5120, 16, True],\n     [5168, 16, False],\n     [5192, 24, False],\n     [5216, 40, False],\n     [5256, 16, True]],\n    [1]),\n   {'alloc': [5136], 'free': [[5144, 40], [5192, 64]], 'swept': [[5136, 48], [5192, 64]]}),\n  ('control: fully marked heap',\n   ([[5120, 32, True], [5152, 16, True]], [8]),\n   {'alloc': [None], 'free': [], 'swept': []})]]\nfor label, args, expected in cases[N - 1]:\n    check(label, solve(*args), expected)\nprint(json.dumps({\"observations\": observations, \"passed\": all(x[\"passed\"] for x in observations)}, ensure_ascii=False))\nraise SystemExit(0 if all(x[\"passed\"] for x in observations) else 1)\n"}},"limitations":"A deterministic, bounded teaching model of one garbage-collector mechanism with stipulated rules; it is not a production collector and claims no conformance to any particular runtime. This reproducer isolates one failure mechanism. Results cover the supplied fixtures. Variants within a family share a test contract and should remain grouped when constructing evaluation splits. Related mechanisms with a shared evaluation_group must also remain together; these controlled models are not independent production incidents.","method":"Deterministic executable model with adversarial boundary fixtures.","provenance":{"created_by":"Failure Map","dependencies":"Python standard library","family":"w2-garbage-collector-invariants-sweep-free-list-coalescing-adjacency","generated_at":"2026-09-29T14:51:26.987430+00:00","license":"CC0-1.0","python":"3.12.14","seed":1,"split":"open-access"},"relevance":"Sweepers and free-list allocators must keep block boundaries exact or they hand out overlapping memory.","repair":"Merge only when the previous free block ends exactly where this block starts.","root_cause":"Coalescing only checks that the previous free block ends at or before the current block.","sha256":"4ee1882c33f1e968c3d9f91cf44a042b7819bc8bf8f59e8f8998968218a4287e","title":"Free-list sweep: free blocks merged across live blocks · case 01","variant":1,"variant_policy":"Five numbered records share a model and may reuse boundary fixtures.","verification":{"attempt":{"elapsed_ms":42.0,"exit_code":1,"observations":[{"actual":{"alloc":[1040,1072,1120,1096,null],"free":[],"swept":[[1040,32],[1072,40],[1120,40]]},"check":"regression: sweep, split and exhaust","expected":{"alloc":[1040,1064,1096,1136,null],"free":[],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[null,null],"free":[[1040,32],[1072,40],[1120,40]],"swept":[[1040,32],[1072,40],[1120,40]]},"check":"exact fit uses the first block","expected":{"alloc":[1040,1096],"free":[],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[1040,1072],"free":[[1120,40]],"swept":[[1040,32],[1072,40],[1120,40]]},"check":"remainder of exactly the minimum block size","expected":{"alloc":[1040,1096],"free":[[1072,16],[1136,24]],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[null,null,1040],"free":[[1048,24],[1072,40],[1120,40]],"swept":[[1040,32],[1072,40],[1120,40]]},"check":"remainder too small to split","expected":{"alloc":[1040,1096,null],"free":[],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[1040],"free":[[1048,24],[1072,40],[1120,40]],"swept":[[1040,32],[1072,40],[1120,40]]},"check":"sweep snapshot is independent of allocation","expected":{"alloc":[1040],"free":[[1048,40],[1096,64]],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[null],"free":[],"swept":[]},"check":"control: fully marked heap","expected":{"alloc":[null],"free":[],"swept":[]},"passed":true}],"passed":false,"stderr":"","stdout":"{\"observations\": [{\"check\": \"regression: sweep, split and exhaust\", \"actual\": {\"swept\": [[1040, 32], [1072, 40], [1120, 40]], \"alloc\": [1040, 1072, 1120, 1096, null], \"free\": []}, \"expected\": {\"alloc\": [1040, 1064, 1096, 1136, null], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"exact fit uses the first block\", \"actual\": {\"swept\": [[1040, 32], [1072, 40], [1120, 40]], \"alloc\": [null, null], \"free\": [[1040, 32], [1072, 40], [1120, 40]]}, \"expected\": {\"alloc\": [1040, 1096], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"remainder of exactly the minimum block size\", \"actual\": {\"swept\": [[1040, 32], [1072, 40], [1120, 40]], \"alloc\": [1040, 1072], \"free\": [[1120, 40]]}, \"expected\": {\"alloc\": [1040, 1096], \"free\": [[1072, 16], [1136, 24]], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"remainder too small to split\", \"actual\": {\"swept\": [[1040, 32], [1072, 40], [1120, 40]], \"alloc\": [null, null, 1040], \"free\": [[1048, 24], [1072, 40], [1120, 40]]}, \"expected\": {\"alloc\": [1040, 1096, null], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"sweep snapshot is independent of allocation\", \"actual\": {\"swept\": [[1040, 32], [1072, 40], [1120, 40]], \"alloc\": [1040], \"free\": [[1048, 24], [1072, 40], [1120, 40]]}, \"expected\": {\"alloc\": [1040], \"free\": [[1048, 40], [1096, 64]], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"control: fully marked heap\", \"actual\": {\"swept\": [], \"alloc\": [null], \"free\": []}, \"expected\": {\"alloc\": [null], \"free\": [], \"swept\": []}, \"passed\": true}], \"passed\": false}\n"},"broken":{"elapsed_ms":40.99,"exit_code":1,"observations":[{"actual":{"alloc":[1040,1064,1088,1128,null],"free":[],"swept":[[1040,112]]},"check":"regression: sweep, split and exhaust","expected":{"alloc":[1040,1064,1096,1136,null],"free":[],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[1040,1088],"free":[],"swept":[[1040,112]]},"check":"exact fit uses the first block","expected":{"alloc":[1040,1096],"free":[],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[1040,1072],"free":[[1112,40]],"swept":[[1040,112]]},"check":"remainder of exactly the minimum block size","expected":{"alloc":[1040,1096],"free":[[1072,16],[1136,24]],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[1040,1088,null],"free":[],"swept":[[1040,112]]},"check":"remainder too small to split","expected":{"alloc":[1040,1096,null],"free":[],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[1040],"free":[[1048,104]],"swept":[[1040,112]]},"check":"sweep snapshot is independent of allocation","expected":{"alloc":[1040],"free":[[1048,40],[1096,64]],"swept":[[1040,48],[1096,64]]},"passed":false},{"actual":{"alloc":[null],"free":[],"swept":[]},"check":"control: fully marked heap","expected":{"alloc":[null],"free":[],"swept":[]},"passed":true}],"passed":false,"stderr":"","stdout":"{\"observations\": [{\"check\": \"regression: sweep, split and exhaust\", \"actual\": {\"swept\": [[1040, 112]], \"alloc\": [1040, 1064, 1088, 1128, null], \"free\": []}, \"expected\": {\"alloc\": [1040, 1064, 1096, 1136, null], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"exact fit uses the first block\", \"actual\": {\"swept\": [[1040, 112]], \"alloc\": [1040, 1088], \"free\": []}, \"expected\": {\"alloc\": [1040, 1096], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"remainder of exactly the minimum block size\", \"actual\": {\"swept\": [[1040, 112]], \"alloc\": [1040, 1072], \"free\": [[1112, 40]]}, \"expected\": {\"alloc\": [1040, 1096], \"free\": [[1072, 16], [1136, 24]], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"remainder too small to split\", \"actual\": {\"swept\": [[1040, 112]], \"alloc\": [1040, 1088, null], \"free\": []}, \"expected\": {\"alloc\": [1040, 1096, null], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"sweep snapshot is independent of allocation\", \"actual\": {\"swept\": [[1040, 112]], \"alloc\": [1040], \"free\": [[1048, 104]]}, \"expected\": {\"alloc\": [1040], \"free\": [[1048, 40], [1096, 64]], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": false}, {\"check\": \"control: fully marked heap\", \"actual\": {\"swept\": [], \"alloc\": [null], \"free\": []}, \"expected\": {\"alloc\": [null], \"free\": [], \"swept\": []}, \"passed\": true}], \"passed\": false}\n"},"fixed":{"elapsed_ms":43.761,"exit_code":0,"observations":[{"actual":{"alloc":[1040,1064,1096,1136,null],"free":[],"swept":[[1040,48],[1096,64]]},"check":"regression: sweep, split and exhaust","expected":{"alloc":[1040,1064,1096,1136,null],"free":[],"swept":[[1040,48],[1096,64]]},"passed":true},{"actual":{"alloc":[1040,1096],"free":[],"swept":[[1040,48],[1096,64]]},"check":"exact fit uses the first block","expected":{"alloc":[1040,1096],"free":[],"swept":[[1040,48],[1096,64]]},"passed":true},{"actual":{"alloc":[1040,1096],"free":[[1072,16],[1136,24]],"swept":[[1040,48],[1096,64]]},"check":"remainder of exactly the minimum block size","expected":{"alloc":[1040,1096],"free":[[1072,16],[1136,24]],"swept":[[1040,48],[1096,64]]},"passed":true},{"actual":{"alloc":[1040,1096,null],"free":[],"swept":[[1040,48],[1096,64]]},"check":"remainder too small to split","expected":{"alloc":[1040,1096,null],"free":[],"swept":[[1040,48],[1096,64]]},"passed":true},{"actual":{"alloc":[1040],"free":[[1048,40],[1096,64]],"swept":[[1040,48],[1096,64]]},"check":"sweep snapshot is independent of allocation","expected":{"alloc":[1040],"free":[[1048,40],[1096,64]],"swept":[[1040,48],[1096,64]]},"passed":true},{"actual":{"alloc":[null],"free":[],"swept":[]},"check":"control: fully marked heap","expected":{"alloc":[null],"free":[],"swept":[]},"passed":true}],"passed":true,"stderr":"","stdout":"{\"observations\": [{\"check\": \"regression: sweep, split and exhaust\", \"actual\": {\"swept\": [[1040, 48], [1096, 64]], \"alloc\": [1040, 1064, 1096, 1136, null], \"free\": []}, \"expected\": {\"alloc\": [1040, 1064, 1096, 1136, null], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": true}, {\"check\": \"exact fit uses the first block\", \"actual\": {\"swept\": [[1040, 48], [1096, 64]], \"alloc\": [1040, 1096], \"free\": []}, \"expected\": {\"alloc\": [1040, 1096], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": true}, {\"check\": \"remainder of exactly the minimum block size\", \"actual\": {\"swept\": [[1040, 48], [1096, 64]], \"alloc\": [1040, 1096], \"free\": [[1072, 16], [1136, 24]]}, \"expected\": {\"alloc\": [1040, 1096], \"free\": [[1072, 16], [1136, 24]], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": true}, {\"check\": \"remainder too small to split\", \"actual\": {\"swept\": [[1040, 48], [1096, 64]], \"alloc\": [1040, 1096, null], \"free\": []}, \"expected\": {\"alloc\": [1040, 1096, null], \"free\": [], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": true}, {\"check\": \"sweep snapshot is independent of allocation\", \"actual\": {\"swept\": [[1040, 48], [1096, 64]], \"alloc\": [1040], \"free\": [[1048, 40], [1096, 64]]}, \"expected\": {\"alloc\": [1040], \"free\": [[1048, 40], [1096, 64]], \"swept\": [[1040, 48], [1096, 64]]}, \"passed\": true}, {\"check\": \"control: fully marked heap\", \"actual\": {\"swept\": [], \"alloc\": [null], \"free\": []}, \"expected\": {\"alloc\": [null], \"free\": [], \"swept\": []}, \"passed\": true}], \"passed\": true}\n"}},"verified":true,"visibility":"public"}